This is an archive of the discontinued LLVM Phabricator instance.

Differential D142921

[libc] Fix reusing/redefining `FPBits` symbols.
AbandonedPublic

Authored by lntue on Jan 30 2023, 11:21 AM.

Details

Reviewers
michaelrj
sivachandra
Summary

Change all of FPBits re-declaration to FPB instead.
See https://github.com/llvm/llvm-project/issues/57719#issuecomment-1333900338

Diff Detail

Event Timeline

lntue created this revision.Jan 30 2023, 11:21 AM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptJan 30 2023, 11:21 AM
Herald added subscribers: ecnelises, tschuett. · View Herald Transcript
lntue requested review of this revision.Jan 30 2023, 11:21 AM
Harbormaster completed remote builds in B210822: Diff 493364.Jan 30 2023, 11:40 AM
michaelrj accepted this revision.Jan 31 2023, 3:11 PM

LGTM

This revision is now accepted and ready to land.Jan 31 2023, 3:11 PM
sivachandra added a comment.Jan 31 2023, 5:03 PM

Can you please hold off on this change. I will update here when it is ready.

sivachandra added a comment.Jan 31 2023, 5:16 PM

Can you explain how some of the use cases here are different from https://godbolt.org/z/arvG69d79.

lntue added a comment.Jan 31 2023, 7:57 PM
In D142921#4095301, @sivachandra wrote:

Can you explain how some of the use cases here are different from https://godbolt.org/z/arvG69d79.

I'm not so sure why there were warnings by gcc in the github issue, but not in godbolt example. My guess is that they are from the constructors:

  • Without using FPBits = FPBits<float>, something like FPBits(1.0) will be understood as FPBits<double>(1.0)
  • With using FPBits = FPBits<float>, FPBits(1.0) now will be FPBits<float>(1.0) from implicit conversion.

These warnings seem to be inconsistent between different compilers and maybe different versions, but I think it's good to clean them up to prevent ambiguity.

sivachandra added a comment.EditedJan 31 2023, 9:32 PM

I think the best understanding of the problem comes from these two links:

clang allows it: https://godbolt.org/z/z5rWhzKET
gcc complains: https://godbolt.org/z/T6dvxTWKv

GCC's error message is actually very suggestive. IIUC, it is saying that we are changing the meaning of the type named S within the scope of the U (it is easy to see the problem if U were the global namespace). I think the older version of the code linked to in the bug had this problem: https://github.com/llvm/llvm-project/blob/d883a4ad02d867e7037bd4ec342016c402484148/libc/src/__support/FPUtil/except_value_utils.h

IMHO, it is very subtle. The problem code redefined the type names within the namespace __llvm_libc::fputil. But, I think the current code does not have any such instances - the renames are happening in the namespace __llvm_libc. So, my guess is that that is why we are not seeing similar errors with GCC anymore. Considering that we do have a GCC bot, do we really want to "fix"?

lntue added a comment.Feb 1 2023, 8:02 AM
In D142921#4095557, @sivachandra wrote:

I think the best understanding of the problem comes from these two links:

clang allows it: https://godbolt.org/z/z5rWhzKET
gcc complains: https://godbolt.org/z/T6dvxTWKv

GCC's error message is actually very suggestive. IIUC, it is saying that we are changing the meaning of the type named S within the scope of the U (it is easy to see the problem if U were the global namespace). I think the older version of the code linked to in the bug had this problem: https://github.com/llvm/llvm-project/blob/d883a4ad02d867e7037bd4ec342016c402484148/libc/src/__support/FPUtil/except_value_utils.h

IMHO, it is very subtle. The problem code redefined the type names within the namespace __llvm_libc::fputil. But, I think the current code does not have any such instances - the renames are happening in the namespace __llvm_libc. So, my guess is that that is why we are not seeing similar errors with GCC anymore. Considering that we do have a GCC bot, do we really want to "fix"?

I think you're right! As long as the gcc bot is not complaining, this patch is not needed.

lntue abandoned this revision.Feb 1 2023, 8:03 AM

Revision Contents

PathSize
libc/
src/
__support/
FPUtil/
18 lines
generic/
30 lines
x86_64/
24 lines
math/
generic/
7 lines
7 lines
6 lines
10 lines
11 lines
7 lines
10 lines
4 lines
10 lines
10 lines
10 lines
8 lines
8 lines
12 lines
13 lines
12 lines
15 lines
15 lines
15 lines
7 lines
13 lines
7 lines
12 lines
test/
src/
math/
2 lines
2 lines
2 lines
8 lines
2 lines
2 lines
2 lines
39 lines
4 lines
42 lines
22 lines
36 lines
4 lines
2 lines
32 lines
28 lines
22 lines
2 lines
26 lines
2 lines
2 lines
6 lines
2 lines
6 lines
6 lines
8 lines
12 lines
2 lines
8 lines
14 lines
differential_testing/
42 lines
18 lines
exhaustive/
4 lines
4 lines
4 lines
8 lines
8 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
6 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
8 lines
10 lines
18 lines
24 lines
30 lines
6 lines
8 lines
8 lines
6 lines
8 lines
8 lines
10 lines
2 lines
2 lines
8 lines
12 lines
18 lines
2 lines
8 lines
12 lines
utils/
FPUtil/
6 lines
utils/
MPFRWrapper/
12 lines
UnitTest/
14 lines

Diff 493364

libc/src/__support/FPUtil/Hypot.h

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
// //
// //
// Special cases: // Special cases:
// - HYPOT(x, y) is +Inf if x or y is +Inf or -Inf; else // - HYPOT(x, y) is +Inf if x or y is +Inf or -Inf; else
// - HYPOT(x, y) is NaN if x or y is NaN. // - HYPOT(x, y) is NaN if x or y is NaN.
// //
template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0> template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
LIBC_INLINE T hypot(T x, T y) { LIBC_INLINE T hypot(T x, T y) {
using FPBits_t = FPBits<T>; using FPB = FPBits<T>;
using UIntType = typename FPBits<T>::UIntType; using UIntType = typename FPBits<T>::UIntType;
using DUIntType = typename DoubleLength<UIntType>::Type; using DUIntType = typename DoubleLength<UIntType>::Type;
FPBits_t x_bits(x), y_bits(y); FPB x_bits(x), y_bits(y);
if (x_bits.is_inf() || y_bits.is_inf()) { if (x_bits.is_inf() || y_bits.is_inf()) {
return T(FPBits_t::inf()); return T(FPB::inf());
} }
if (x_bits.is_nan()) { if (x_bits.is_nan()) {
return x; return x;
} }
if (y_bits.is_nan()) { if (y_bits.is_nan()) {
return y; return y;
} }
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 LinesLIBC_INLINE T hypot(T x, T y) {
if (sum >= (DUIntType(1) << (2 * y_mant_width + 2))) { if (sum >= (DUIntType(1) << (2 * y_mant_width + 2))) {
// a^2 + b^2 >= 4* leading_one^2, so we will need an extra bit to the left. // a^2 + b^2 >= 4* leading_one^2, so we will need an extra bit to the left.
if (leading_one == ONE) { if (leading_one == ONE) {
// For normal result, we discard the last 2 bits of the sum and increase // For normal result, we discard the last 2 bits of the sum and increase
// the exponent. // the exponent.
sticky_bits = sticky_bits || ((sum & 0x3U) != 0); sticky_bits = sticky_bits || ((sum & 0x3U) != 0);
sum >>= 2; sum >>= 2;
++out_exp; ++out_exp;
if (out_exp >= FPBits_t::MAX_EXPONENT) { if (out_exp >= FPB::MAX_EXPONENT) {
if (int round_mode = get_round(); if (int round_mode = get_round();
round_mode == FE_TONEAREST || round_mode == FE_UPWARD) round_mode == FE_TONEAREST || round_mode == FE_UPWARD)
return T(FPBits_t::inf()); return T(FPB::inf());
return T(FPBits_t(FPBits_t::MAX_NORMAL)); return T(FPB(FPB::MAX_NORMAL));
} }
} else { } else {
// For denormal result, we simply move the leading bit of the result to // For denormal result, we simply move the leading bit of the result to
// the left by 1. // the left by 1.
leading_one <<= 1; leading_one <<= 1;
++y_mant_width; ++y_mant_width;
} }
} }
Show All 37 Lines case FE_UPWARD:
if (round_bit || sticky_bits || (r != 0)) if (round_bit || sticky_bits || (r != 0))
++y_new; ++y_new;
break; break;
} }
if (y_new >= (ONE >> 1)) { if (y_new >= (ONE >> 1)) {
y_new -= ONE >> 1; y_new -= ONE >> 1;
++out_exp; ++out_exp;
if (out_exp >= FPBits_t::MAX_EXPONENT) { if (out_exp >= FPB::MAX_EXPONENT) {
if (round_mode == FE_TONEAREST || round_mode == FE_UPWARD) if (round_mode == FE_TONEAREST || round_mode == FE_UPWARD)
return T(FPBits_t::inf()); return T(FPB::inf());
return T(FPBits_t(FPBits_t::MAX_NORMAL)); return T(FPB(FPB::MAX_NORMAL));
} }
} }
y_new |= static_cast<UIntType>(out_exp) << MantissaWidth<T>::VALUE; y_new |= static_cast<UIntType>(out_exp) << MantissaWidth<T>::VALUE;
return cpp::bit_cast<T>(y_new); return cpp::bit_cast<T>(y_new);
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_HYPOT_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_HYPOT_H

libc/src/__support/FPUtil/generic/FMA.h

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 LinesLIBC_INLINE bool shift_mantissa(int shift_length, UInt128 &mant) {
bool sticky_bits = (mant & mask) != 0; bool sticky_bits = (mant & mask) != 0;
mant >>= shift_length; mant >>= shift_length;
return sticky_bits; return sticky_bits;
} }
} // namespace internal } // namespace internal
template <> LIBC_INLINE double fma<double>(double x, double y, double z) { template <> LIBC_INLINE double fma<double>(double x, double y, double z) {
using FPBits = fputil::FPBits<double>; using FPB = fputil::FPBits<double>;
using FloatProp = fputil::FloatProperties<double>; using FloatProp = fputil::FloatProperties<double>;
if (unlikely(x == 0 || y == 0 || z == 0)) { if (unlikely(x == 0 || y == 0 || z == 0)) {
return x * y + z; return x * y + z;
} }
int x_exp = 0; int x_exp = 0;
int y_exp = 0; int y_exp = 0;
int z_exp = 0; int z_exp = 0;
// Normalize denormal inputs. // Normalize denormal inputs.
if (unlikely(FPBits(x).get_unbiased_exponent() == 0)) { if (unlikely(FPB(x).get_unbiased_exponent() == 0)) {
x_exp -= 52; x_exp -= 52;
x *= 0x1.0p+52; x *= 0x1.0p+52;
} }
if (unlikely(FPBits(y).get_unbiased_exponent() == 0)) { if (unlikely(FPB(y).get_unbiased_exponent() == 0)) {
y_exp -= 52; y_exp -= 52;
y *= 0x1.0p+52; y *= 0x1.0p+52;
} }
if (unlikely(FPBits(z).get_unbiased_exponent() == 0)) { if (unlikely(FPB(z).get_unbiased_exponent() == 0)) {
z_exp -= 52; z_exp -= 52;
z *= 0x1.0p+52; z *= 0x1.0p+52;
} }
FPBits x_bits(x), y_bits(y), z_bits(z); FPB x_bits(x), y_bits(y), z_bits(z);
bool x_sign = x_bits.get_sign(); bool x_sign = x_bits.get_sign();
bool y_sign = y_bits.get_sign(); bool y_sign = y_bits.get_sign();
bool z_sign = z_bits.get_sign(); bool z_sign = z_bits.get_sign();
bool prod_sign = x_sign != y_sign; bool prod_sign = x_sign != y_sign;
x_exp += x_bits.get_unbiased_exponent(); x_exp += x_bits.get_unbiased_exponent();
y_exp += y_bits.get_unbiased_exponent(); y_exp += y_bits.get_unbiased_exponent();
z_exp += z_bits.get_unbiased_exponent(); z_exp += z_bits.get_unbiased_exponent();
if (unlikely(x_exp == FPBits::MAX_EXPONENT || y_exp == FPBits::MAX_EXPONENT || if (unlikely(x_exp == FPB::MAX_EXPONENT || y_exp == FPB::MAX_EXPONENT ||
z_exp == FPBits::MAX_EXPONENT)) z_exp == FPB::MAX_EXPONENT))
return x * y + z; return x * y + z;
// Extract mantissa and append hidden leading bits. // Extract mantissa and append hidden leading bits.
UInt128 x_mant = x_bits.get_mantissa() | FPBits::MIN_NORMAL; UInt128 x_mant = x_bits.get_mantissa() | FPB::MIN_NORMAL;
UInt128 y_mant = y_bits.get_mantissa() | FPBits::MIN_NORMAL; UInt128 y_mant = y_bits.get_mantissa() | FPB::MIN_NORMAL;
UInt128 z_mant = z_bits.get_mantissa() | FPBits::MIN_NORMAL; UInt128 z_mant = z_bits.get_mantissa() | FPB::MIN_NORMAL;
// If the exponent of the product x*y > the exponent of z, then no extra // If the exponent of the product x*y > the exponent of z, then no extra
// precision beside the entire product x*y is needed. On the other hand, when // precision beside the entire product x*y is needed. On the other hand, when
// the exponent of z >= the exponent of the product x*y, the worst-case that // the exponent of z >= the exponent of the product x*y, the worst-case that
// we need extra precision is when there is cancellation and the most // we need extra precision is when there is cancellation and the most
// significant bit of the product is aligned exactly with the second most // significant bit of the product is aligned exactly with the second most
// significant bit of z: // significant bit of z:
// z : 10aa...a // z : 10aa...a
// - prod : 1bb...bb....b // - prod : 1bb...bb....b
// In that case, in order to store the exact result, we need at least // In that case, in order to store the exact result, we need at least
// (Length of prod) - (MantissaLength of z) = 2*(52 + 1) - 52 = 54. // (Length of prod) - (MantissaLength of z) = 2*(52 + 1) - 52 = 54.
// Overall, before aligning the mantissas and exponents, we can simply left- // Overall, before aligning the mantissas and exponents, we can simply left-
// shift the mantissa of z by at least 54, and left-shift the product of x*y // shift the mantissa of z by at least 54, and left-shift the product of x*y
// by (that amount - 52). After that, it is enough to align the least // by (that amount - 52). After that, it is enough to align the least
// significant bit, given that we keep track of the round and sticky bits // significant bit, given that we keep track of the round and sticky bits
// after the least significant bit. // after the least significant bit.
// We pick shifting z_mant by 64 bits so that technically we can simply use // We pick shifting z_mant by 64 bits so that technically we can simply use
// the original mantissa as high part when constructing 128-bit z_mant. So the // the original mantissa as high part when constructing 128-bit z_mant. So the
// mantissa of prod will be left-shifted by 64 - 54 = 10 initially. // mantissa of prod will be left-shifted by 64 - 54 = 10 initially.
UInt128 prod_mant = x_mant * y_mant << 10; UInt128 prod_mant = x_mant * y_mant << 10;
int prod_lsb_exp = int prod_lsb_exp =
x_exp + y_exp - x_exp + y_exp -
(FPBits::EXPONENT_BIAS + 2 * MantissaWidth<double>::VALUE + 10); (FPB::EXPONENT_BIAS + 2 * MantissaWidth<double>::VALUE + 10);
z_mant <<= 64; z_mant <<= 64;
int z_lsb_exp = z_exp - (MantissaWidth<double>::VALUE + 64); int z_lsb_exp = z_exp - (MantissaWidth<double>::VALUE + 64);
bool round_bit = false; bool round_bit = false;
bool sticky_bits = false; bool sticky_bits = false;
bool z_shifted = false; bool z_shifted = false;
// Align exponents. // Align exponents.
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines if (prod_mant != 0) {
} }
} else { } else {
// Return +0.0 when there is exact cancellation, i.e., x*y == -z exactly. // Return +0.0 when there is exact cancellation, i.e., x*y == -z exactly.
prod_sign = false; prod_sign = false;
} }
// Finalize the result. // Finalize the result.
int round_mode = fputil::get_round(); int round_mode = fputil::get_round();
if (unlikely(r_exp >= FPBits::MAX_EXPONENT)) { if (unlikely(r_exp >= FPB::MAX_EXPONENT)) {
if ((round_mode == FE_TOWARDZERO) || if ((round_mode == FE_TOWARDZERO) ||
(round_mode == FE_UPWARD && prod_sign) || (round_mode == FE_UPWARD && prod_sign) ||
(round_mode == FE_DOWNWARD && !prod_sign)) { (round_mode == FE_DOWNWARD && !prod_sign)) {
result = FPBits::MAX_NORMAL; result = FPB::MAX_NORMAL;
return prod_sign ? -cpp::bit_cast<double>(result) return prod_sign ? -cpp::bit_cast<double>(result)
: cpp::bit_cast<double>(result); : cpp::bit_cast<double>(result);
} }
return prod_sign ? static_cast<double>(FPBits::neg_inf()) return prod_sign ? static_cast<double>(FPB::neg_inf())
: static_cast<double>(FPBits::inf()); : static_cast<double>(FPB::inf());
} }
// Remove hidden bit and append the exponent field and sign bit. // Remove hidden bit and append the exponent field and sign bit.
result = (result & FloatProp::MANTISSA_MASK) | result = (result & FloatProp::MANTISSA_MASK) |
(static_cast<uint64_t>(r_exp) << FloatProp::MANTISSA_WIDTH); (static_cast<uint64_t>(r_exp) << FloatProp::MANTISSA_WIDTH);
if (prod_sign) { if (prod_sign) {
result |= FloatProp::SIGN_MASK; result |= FloatProp::SIGN_MASK;
} }
Show All 19 Lines

libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h

Show All 18 Lines
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
LIBC_INLINE long double nextafter(long double from, long double to) { LIBC_INLINE long double nextafter(long double from, long double to) {
using FPBits = FPBits<long double>; using FPB = FPBits<long double>;
FPBits from_bits(from); FPB from_bits(from);
if (from_bits.is_nan()) if (from_bits.is_nan())
return from; return from;
FPBits to_bits(to); FPB to_bits(to);
if (to_bits.is_nan()) if (to_bits.is_nan())
return to; return to;
if (from == to) if (from == to)
return to; return to;
// Convert pseudo subnormal number to normal number. // Convert pseudo subnormal number to normal number.
if (from_bits.get_implicit_bit() == 1 && if (from_bits.get_implicit_bit() == 1 &&
from_bits.get_unbiased_exponent() == 0) { from_bits.get_unbiased_exponent() == 0) {
from_bits.set_unbiased_exponent(1); from_bits.set_unbiased_exponent(1);
} }
using UIntType = FPBits::UIntType; using UIntType = FPB::UIntType;
constexpr UIntType SIGN_VAL = (UIntType(1) << 79); constexpr UIntType SIGN_VAL = (UIntType(1) << 79);
constexpr UIntType MANTISSA_MASK = constexpr UIntType MANTISSA_MASK =
(UIntType(1) << MantissaWidth<long double>::VALUE) - 1; (UIntType(1) << MantissaWidth<long double>::VALUE) - 1;
UIntType int_val = from_bits.uintval(); UIntType int_val = from_bits.uintval();
if (from < 0.0l) { if (from < 0.0l) {
if (from > to) { if (from > to) {
if (int_val == (SIGN_VAL + FPBits::MAX_SUBNORMAL)) { if (int_val == (SIGN_VAL + FPB::MAX_SUBNORMAL)) {
// We deal with normal/subnormal boundary separately to avoid // We deal with normal/subnormal boundary separately to avoid
// dealing with the implicit bit. // dealing with the implicit bit.
int_val = SIGN_VAL + FPBits::MIN_NORMAL; int_val = SIGN_VAL + FPB::MIN_NORMAL;
} else if ((int_val & MANTISSA_MASK) == MANTISSA_MASK) { } else if ((int_val & MANTISSA_MASK) == MANTISSA_MASK) {
from_bits.set_mantissa(0); from_bits.set_mantissa(0);
// Incrementing exponent might overflow the value to infinity, // Incrementing exponent might overflow the value to infinity,
// which is what is expected. Since NaNs are handling separately, // which is what is expected. Since NaNs are handling separately,
// it will never overflow "beyond" infinity. // it will never overflow "beyond" infinity.
from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() + 1); from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() + 1);
return from_bits; return from_bits;
} else { } else {
++int_val; ++int_val;
} }
} else { } else {
if (int_val == (SIGN_VAL + FPBits::MIN_NORMAL)) { if (int_val == (SIGN_VAL + FPB::MIN_NORMAL)) {
// We deal with normal/subnormal boundary separately to avoid // We deal with normal/subnormal boundary separately to avoid
// dealing with the implicit bit. // dealing with the implicit bit.
int_val = SIGN_VAL + FPBits::MAX_SUBNORMAL; int_val = SIGN_VAL + FPB::MAX_SUBNORMAL;
} else if ((int_val & MANTISSA_MASK) == 0) { } else if ((int_val & MANTISSA_MASK) == 0) {
from_bits.set_mantissa(MANTISSA_MASK); from_bits.set_mantissa(MANTISSA_MASK);
// from == 0 is handled separately so decrementing the exponent will not // from == 0 is handled separately so decrementing the exponent will not
// lead to underflow. // lead to underflow.
from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() - 1); from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() - 1);
return from_bits; return from_bits;
} else { } else {
--int_val; --int_val;
} }
} }
} else if (from == 0.0l) { } else if (from == 0.0l) {
if (from > to) if (from > to)
int_val = SIGN_VAL + 1; int_val = SIGN_VAL + 1;
else else
int_val = 1; int_val = 1;
} else { } else {
if (from > to) { if (from > to) {
if (int_val == FPBits::MIN_NORMAL) { if (int_val == FPB::MIN_NORMAL) {
int_val = FPBits::MAX_SUBNORMAL; int_val = FPB::MAX_SUBNORMAL;
} else if ((int_val & MANTISSA_MASK) == 0) { } else if ((int_val & MANTISSA_MASK) == 0) {
from_bits.set_mantissa(MANTISSA_MASK); from_bits.set_mantissa(MANTISSA_MASK);
// from == 0 is handled separately so decrementing the exponent will not // from == 0 is handled separately so decrementing the exponent will not
// lead to underflow. // lead to underflow.
from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() - 1); from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() - 1);
return from_bits; return from_bits;
} else { } else {
--int_val; --int_val;
} }
} else { } else {
if (int_val == FPBits::MAX_SUBNORMAL) { if (int_val == FPB::MAX_SUBNORMAL) {
int_val = FPBits::MIN_NORMAL; int_val = FPB::MIN_NORMAL;
} else if ((int_val & MANTISSA_MASK) == MANTISSA_MASK) { } else if ((int_val & MANTISSA_MASK) == MANTISSA_MASK) {
from_bits.set_mantissa(0); from_bits.set_mantissa(0);
// Incrementing exponent might overflow the value to infinity, // Incrementing exponent might overflow the value to infinity,
// which is what is expected. Since NaNs are handling separately, // which is what is expected. Since NaNs are handling separately,
// it will never overflow "beyond" infinity. // it will never overflow "beyond" infinity.
from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() + 1); from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() + 1);
return from_bits; return from_bits;
} else { } else {
Show All 13 Lines

libc/src/math/generic/acosf.cpp

Show All 30 Linesstatic constexpr fputil::ExceptValues<float, N_EXCEPTS> ACOSF_EXCEPTS = {{
{0xb28885a3, 0x3fc90fda, 1, 0, 1}, {0xb28885a3, 0x3fc90fda, 1, 0, 1},
// x = 0x1.04c444p-12, acosf(x) = 0x1.920f68p0 (RZ) // x = 0x1.04c444p-12, acosf(x) = 0x1.920f68p0 (RZ)
{0x39826222, 0x3fc907b4, 1, 0, 1}, {0x39826222, 0x3fc907b4, 1, 0, 1},
// x = -0x1.04c444p-12, acosf(x) = 0x1.923p0 (RZ) // x = -0x1.04c444p-12, acosf(x) = 0x1.923p0 (RZ)
{0xb9826222, 0x3fc91800, 1, 0, 1}, {0xb9826222, 0x3fc91800, 1, 0, 1},
}}; }};
LLVM_LIBC_FUNCTION(float, acosf, (float x)) { LLVM_LIBC_FUNCTION(float, acosf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
uint32_t x_uint = xbits.uintval(); uint32_t x_uint = xbits.uintval();
uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU; uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU;
uint32_t x_sign = x_uint >> 31; uint32_t x_sign = x_uint >> 31;
// |x| <= 0.5 // |x| <= 0.5
if (unlikely(x_abs <= 0x3f00'0000U)) { if (unlikely(x_abs <= 0x3f00'0000U)) {
// |x| < 0x1p-10 // |x| < 0x1p-10
if (unlikely(x_abs < 0x3a80'0000U)) { if (unlikely(x_abs < 0x3a80'0000U)) {
Show All 24 LinesLLVM_LIBC_FUNCTION(float, acosf, (float x)) {
} }
// |x| > 1, return NaNs. // |x| > 1, return NaNs.
if (unlikely(x_abs > 0x3f80'0000U)) { if (unlikely(x_abs > 0x3f80'0000U)) {
if (x_abs <= 0x7f80'0000U) { if (x_abs <= 0x7f80'0000U) {
errno = EDOM; errno = EDOM;
fputil::set_except(FE_INVALID); fputil::set_except(FE_INVALID);
} }
return x + return x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
// When 0.5 < |x| <= 1, we perform range reduction as follow: // When 0.5 < |x| <= 1, we perform range reduction as follow:
// //
// Assume further that 0.5 < x <= 1, and let: // Assume further that 0.5 < x <= 1, and let:
// y = acos(x) // y = acos(x)
// We use the double angle formula: // We use the double angle formula:
// x = cos(y) = 1 - 2 sin^2(y/2) // x = cos(y) = 1 - 2 sin^2(y/2)
Show All 27 Lines

libc/src/math/generic/asinf.cpp

Show All 36 Linesstatic constexpr fputil::ExceptValues<float, N_EXCEPTS> ASINF_EXCEPTS_HI = {{
// (inputs, RZ output, RU offset, RD offset, RN offset) // (inputs, RZ output, RU offset, RD offset, RN offset)
// x = 0x1.107434p-1, asinf(x) = 0x1.1f4b64p-1 (RZ) // x = 0x1.107434p-1, asinf(x) = 0x1.1f4b64p-1 (RZ)
{0x3f083a1a, 0x3f0fa5b2, 1, 0, 0}, {0x3f083a1a, 0x3f0fa5b2, 1, 0, 0},
// x = 0x1.ee836cp-1, asinf(x) = 0x1.4f0654p0 (RZ) // x = 0x1.ee836cp-1, asinf(x) = 0x1.4f0654p0 (RZ)
{0x3f7741b6, 0x3fa7832a, 1, 0, 0}, {0x3f7741b6, 0x3fa7832a, 1, 0, 0},
}}; }};
LLVM_LIBC_FUNCTION(float, asinf, (float x)) { LLVM_LIBC_FUNCTION(float, asinf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
uint32_t x_uint = xbits.uintval(); uint32_t x_uint = xbits.uintval();
uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU; uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU;
constexpr double SIGN[2] = {1.0, -1.0}; constexpr double SIGN[2] = {1.0, -1.0};
uint32_t x_sign = x_uint >> 31; uint32_t x_sign = x_uint >> 31;
// |x| <= 0.5-ish // |x| <= 0.5-ish
if (x_abs < 0x3f04'471dU) { if (x_abs < 0x3f04'471dU) {
// |x| < 0x1.d12edp-12 // |x| < 0x1.d12edp-12
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines#endif // LIBC_TARGET_HAS_FMA
} }
// |x| > 1, return NaNs. // |x| > 1, return NaNs.
if (unlikely(x_abs > 0x3f80'0000U)) { if (unlikely(x_abs > 0x3f80'0000U)) {
if (x_abs <= 0x7f80'0000U) { if (x_abs <= 0x7f80'0000U) {
errno = EDOM; errno = EDOM;
fputil::set_except(FE_INVALID); fputil::set_except(FE_INVALID);
} }
return x + return x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
// Check for exceptional values // Check for exceptional values
if (auto r = ASINF_EXCEPTS_HI.lookup_odd(x_abs, x_sign); if (auto r = ASINF_EXCEPTS_HI.lookup_odd(x_abs, x_sign);
unlikely(r.has_value())) unlikely(r.has_value()))
return r.value(); return r.value();
// When |x| > 0.5, we perform range reduction as follow: // When |x| > 0.5, we perform range reduction as follow:
Show All 35 Lines

libc/src/math/generic/asinhf.cpp

Show All 11 Lines
#include "src/__support/FPUtil/multiply_add.h" #include "src/__support/FPUtil/multiply_add.h"
#include "src/__support/FPUtil/sqrt.h" #include "src/__support/FPUtil/sqrt.h"
#include "src/math/generic/common_constants.h" #include "src/math/generic/common_constants.h"
#include "src/math/generic/explogxf.h" #include "src/math/generic/explogxf.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, asinhf, (float x)) { LLVM_LIBC_FUNCTION(float, asinhf, (float x)) {
using FPBits_t = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits_t xbits(x); FPB xbits(x);
uint32_t x_u = xbits.uintval(); uint32_t x_u = xbits.uintval();
uint32_t x_abs = x_u & FPBits_t::FloatProp::EXP_MANT_MASK; uint32_t x_abs = x_u & FPB::FloatProp::EXP_MANT_MASK;
// |x| <= 2^-3 // |x| <= 2^-3
if (unlikely(x_abs <= 0x3e80'0000U)) { if (unlikely(x_abs <= 0x3e80'0000U)) {
// |x| <= 2^-26 // |x| <= 2^-26
if (unlikely(x_abs <= 0x3280'0000U)) { if (unlikely(x_abs <= 0x3280'0000U)) {
return unlikely(x_abs == 0) ? x : (x - 0x1.5555555555555p-3 * x * x * x); return unlikely(x_abs == 0) ? x : (x - 0x1.5555555555555p-3 * x * x * x);
} }
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libc/src/math/generic/atanf.cpp

//===-- Single-precision atan function ------------------------------------===// //===-- Single-precision atan function ------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/atanf.h" #include "src/math/atanf.h"
#include "math_utils.h" #include "math_utils.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/generic/inv_trigf_utils.h" #include "src/math/generic/inv_trigf_utils.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, atanf, (float x)) { LLVM_LIBC_FUNCTION(float, atanf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
bool sign = xbits.get_sign(); bool sign = xbits.get_sign();
xbits.set_sign(false); xbits.set_sign(false);
if (unlikely(xbits.is_inf_or_nan())) { if (unlikely(xbits.is_inf_or_nan())) {
if (xbits.is_inf()) if (xbits.is_inf())
return opt_barrier(sign ? -M_MATH_PI_2 : M_MATH_PI_2); return opt_barrier(sign ? -M_MATH_PI_2 : M_MATH_PI_2);
else else
return x; return x;
} }
// |x| == 0.06905200332403183 // |x| == 0.06905200332403183
if (unlikely(xbits.uintval() == 0x3d8d6b23U)) { if (unlikely(xbits.uintval() == 0x3d8d6b23U)) {
if (fputil::get_round() == FE_TONEAREST) { if (fputil::get_round() == FE_TONEAREST) {
// 0.06894256919622421 // 0.06894256919622421
FPBits br(0x3d8d31c3U); FPB br(0x3d8d31c3U);
br.set_sign(sign); br.set_sign(sign);
return br.get_val(); return br.get_val();
} }
} }
// |x| == 1.8670953512191772 // |x| == 1.8670953512191772
if (unlikely(xbits.uintval() == 0x3feefcfbU)) { if (unlikely(xbits.uintval() == 0x3feefcfbU)) {
int rounding_mode = fputil::get_round(); int rounding_mode = fputil::get_round();
if (sign) { if (sign) {
if (rounding_mode == FE_DOWNWARD) { if (rounding_mode == FE_DOWNWARD) {
// -1.0790828466415405 // -1.0790828466415405
return FPBits(0xbf8a1f63U).get_val(); return FPB(0xbf8a1f63U).get_val();
} }
} else { } else {
if (rounding_mode == FE_UPWARD) { if (rounding_mode == FE_UPWARD) {
// 1.0790828466415405 // 1.0790828466415405
return FPBits(0x3f8a1f63U).get_val(); return FPB(0x3f8a1f63U).get_val();
} }
} }
} }
return atan_eval(x); return atan_eval(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/atanhf.cpp

//===-- Single-precision atanh function -----------------------------------===// //===-- Single-precision atanh function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/atanhf.h" #include "src/math/atanhf.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/generic/explogxf.h" #include "src/math/generic/explogxf.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, atanhf, (float x)) { LLVM_LIBC_FUNCTION(float, atanhf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
bool sign = xbits.get_sign(); bool sign = xbits.get_sign();
uint32_t x_abs = xbits.uintval() & FPBits::FloatProp::EXP_MANT_MASK; uint32_t x_abs = xbits.uintval() & FPB::FloatProp::EXP_MANT_MASK;
// |x| >= 1.0 // |x| >= 1.0
if (unlikely(x_abs >= 0x3F80'0000U)) { if (unlikely(x_abs >= 0x3F80'0000U)) {
if (xbits.is_nan()) { if (xbits.is_nan()) {
return x; return x;
} }
// |x| == 0 // |x| == 0
if (x_abs == 0x3F80'0000U) { if (x_abs == 0x3F80'0000U) {
fputil::set_except(FE_DIVBYZERO); fputil::set_except(FE_DIVBYZERO);
return with_errno(FPBits::inf(sign).get_val(), ERANGE); return with_errno(FPB::inf(sign).get_val(), ERANGE);
} else { } else {
fputil::set_except(FE_INVALID); fputil::set_except(FE_INVALID);
return with_errno( return with_errno(
FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1)), FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1)), EDOM);
EDOM);
} }
} }
// |x| < ~0.10 // |x| < ~0.10
if (unlikely(x_abs <= 0x3dcc'0000U)) { if (unlikely(x_abs <= 0x3dcc'0000U)) {
// |x| <= 2^-26 // |x| <= 2^-26
if (unlikely(x_abs <= 0x3280'0000U)) { if (unlikely(x_abs <= 0x3280'0000U)) {
return unlikely(x_abs == 0) ? x : (x + 0x1.5555555555555p-2 * x * x * x); return unlikely(x_abs == 0) ? x : (x + 0x1.5555555555555p-2 * x * x * x);
Show All 15 Lines

libc/src/math/generic/cosf.cpp

Show All 34 Linesstatic constexpr fputil::ExceptValues<float, N_EXCEPTS> COSF_EXCEPTS{{
{0x5f18b878, 0x3f7f14bb, 1, 0, 0}, {0x5f18b878, 0x3f7f14bb, 1, 0, 0},
// x = 0x1.2b9622p67, cos(x) = 0x1.f0285cp-1 (RZ) // x = 0x1.2b9622p67, cos(x) = 0x1.f0285cp-1 (RZ)
{0x6115cb11, 0x3f78142e, 1, 0, 1}, {0x6115cb11, 0x3f78142e, 1, 0, 1},
// x = 0x1.ddebdep120, cos(x) = 0x1.114438p-1 (RZ) // x = 0x1.ddebdep120, cos(x) = 0x1.114438p-1 (RZ)
{0x7beef5ef, 0x3f08a21c, 1, 0, 0}, {0x7beef5ef, 0x3f08a21c, 1, 0, 0},
}}; }};
LLVM_LIBC_FUNCTION(float, cosf, (float x)) { LLVM_LIBC_FUNCTION(float, cosf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
xbits.set_sign(false); xbits.set_sign(false);
uint32_t x_abs = xbits.uintval(); uint32_t x_abs = xbits.uintval();
double xd = static_cast<double>(xbits.get_val()); double xd = static_cast<double>(xbits.get_val());
// Range reduction: // Range reduction:
// For |x| > pi/16, we perform range reduction as follows: // For |x| > pi/16, we perform range reduction as follows:
// Find k and y such that: // Find k and y such that:
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines if (auto r = COSF_EXCEPTS.lookup(x_abs); unlikely(r.has_value()))
return r.value(); return r.value();
// x is inf or nan. // x is inf or nan.
if (unlikely(x_abs >= 0x7f80'0000U)) { if (unlikely(x_abs >= 0x7f80'0000U)) {
if (x_abs == 0x7f80'0000U) { if (x_abs == 0x7f80'0000U) {
errno = EDOM; errno = EDOM;
fputil::set_except(FE_INVALID); fputil::set_except(FE_INVALID);
} }
return x + return x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
// Combine the results with the sine of sum formula: // Combine the results with the sine of sum formula:
// cos(x) = cos((k + y)*pi/32) // cos(x) = cos((k + y)*pi/32)
// = cos(y*pi/32) * cos(k*pi/32) - sin(y*pi/32) * sin(k*pi/32) // = cos(y*pi/32) * cos(k*pi/32) - sin(y*pi/32) * sin(k*pi/32)
// = cosm1_y * cos_k + sin_y * sin_k // = cosm1_y * cos_k + sin_y * sin_k
// = (cosm1_y * cos_k + cos_k) + sin_y * sin_k // = (cosm1_y * cos_k + cos_k) + sin_y * sin_k
double sin_k, cos_k, sin_y, cosm1_y; double sin_k, cos_k, sin_y, cosm1_y;
sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y); sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y);
return fputil::multiply_add(sin_y, -sin_k, return fputil::multiply_add(sin_y, -sin_k,
fputil::multiply_add(cosm1_y, cos_k, cos_k)); fputil::multiply_add(cosm1_y, cos_k, cos_k));
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/coshf.cpp

//===-- Single-precision cosh function ------------------------------------===// //===-- Single-precision cosh function ------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/coshf.h" #include "src/math/coshf.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/multiply_add.h" #include "src/__support/FPUtil/multiply_add.h"
#include "src/math/generic/explogxf.h" #include "src/math/generic/explogxf.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, coshf, (float x)) { LLVM_LIBC_FUNCTION(float, coshf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
xbits.set_sign(false); xbits.set_sign(false);
x = xbits.get_val(); x = xbits.get_val();
uint32_t x_u = xbits.uintval(); uint32_t x_u = xbits.uintval();
// |x| <= 2^-26 // |x| <= 2^-26
if (unlikely(x_u <= 0x3280'0000U)) { if (unlikely(x_u <= 0x3280'0000U)) {
return 1.0f + x; return 1.0f + x;
} }
// When |x| >= 90, or x is inf or nan // When |x| >= 90, or x is inf or nan
if (unlikely(x_u >= 0x42b4'0000U)) { if (unlikely(x_u >= 0x42b4'0000U)) {
if (xbits.is_inf_or_nan()) if (xbits.is_inf_or_nan())
return x + FPBits::inf().get_val(); return x + FPB::inf().get_val();
int rounding = fputil::get_round(); int rounding = fputil::get_round();
if (unlikely(rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)) if (unlikely(rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO))
return FPBits(FPBits::MAX_NORMAL).get_val(); return FPB(FPB::MAX_NORMAL).get_val();
errno = ERANGE; errno = ERANGE;
return x + FPBits::inf().get_val(); return x + FPB::inf().get_val();
} }
// TODO: We should be able to reduce the latency and reciprocal throughput // TODO: We should be able to reduce the latency and reciprocal throughput
// further by using a low degree (maybe 3-7 ?) minimax polynomial for small // further by using a low degree (maybe 3-7 ?) minimax polynomial for small
// but not too small inputs, such as |x| < 2^-2, or |x| < 2^-3. // but not too small inputs, such as |x| < 2^-2, or |x| < 2^-3.
// cosh(x) = (e^x + e^(-x)) / 2. // cosh(x) = (e^x + e^(-x)) / 2.
return exp_pm_eval</*is_sinh*/ false>(x); return exp_pm_eval</*is_sinh*/ false>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/dp_trig.cpp

//===-- Utilities for double precision trigonometric functions ------------===// //===-- Utilities for double precision trigonometric functions ------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/FPUtil/UInt.h" #include "src/__support/FPUtil/UInt.h"
#include "src/__support/FPUtil/XFloat.h" #include "src/__support/FPUtil/XFloat.h"
using FPBits = __llvm_libc::fputil::FPBits<double>; using FPB = __llvm_libc::fputil::FPBits<double>;
namespace __llvm_libc { namespace __llvm_libc {
// Implementation is based on the Payne and Hanek range reduction algorithm. // Implementation is based on the Payne and Hanek range reduction algorithm.
// The caller should ensure that x is positive. // The caller should ensure that x is positive.
// Consider: // Consider:
// x/y = x * 1/y = I + F // x/y = x * 1/y = I + F
// I is the integral part and F the fractional part of the result of the // I is the integral part and F the fractional part of the result of the
// division operation. Then M = mod(x, y) = F * y. In order to compute M, we // division operation. Then M = mod(x, y) = F * y. In order to compute M, we
// first compute F. We do it by dropping bits from 1/y which would only // first compute F. We do it by dropping bits from 1/y which would only
// contribute integral results in the operation x * 1/y. This helps us get // contribute integral results in the operation x * 1/y. This helps us get
// accurate values of F even when x is a very large number. // accurate values of F even when x is a very large number.
// //
// Internal operations are performed at 192 bits of precision. // Internal operations are performed at 192 bits of precision.
static double mod_impl(double x, const uint64_t y_bits[3], static double mod_impl(double x, const uint64_t y_bits[3],
const uint64_t inv_y_bits[20], int y_exponent, const uint64_t inv_y_bits[20], int y_exponent,
int inv_y_exponent) { int inv_y_exponent) {
FPBits bits(x); FPB bits(x);
int exponent = bits.get_exponent(); int exponent = bits.get_exponent();
int bit_drop = (exponent - 52) + inv_y_exponent + 1; int bit_drop = (exponent - 52) + inv_y_exponent + 1;
bit_drop = bit_drop >= 0 ? bit_drop : 0; bit_drop = bit_drop >= 0 ? bit_drop : 0;
int word_drop = bit_drop / 64; int word_drop = bit_drop / 64;
bit_drop %= 64; bit_drop %= 64;
fputil::UInt<256> man4; fputil::UInt<256> man4;
for (size_t i = 0; i < 4; ++i) { for (size_t i = 0; i < 4; ++i) {
man4[3 - i] = inv_y_bits[word_drop + i]; man4[3 - i] = inv_y_bits[word_drop + i];
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libc/src/math/generic/exp10f.cpp

Show All 15 Lines
#include "src/__support/FPUtil/nearest_integer.h" #include "src/__support/FPUtil/nearest_integer.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include <errno.h> #include <errno.h>
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, exp10f, (float x)) { LLVM_LIBC_FUNCTION(float, exp10f, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
uint32_t x_u = xbits.uintval(); uint32_t x_u = xbits.uintval();
uint32_t x_abs = x_u & 0x7fff'ffffU; uint32_t x_abs = x_u & 0x7fff'ffffU;
// When |x| >= log10(2^128), or x is nan // When |x| >= log10(2^128), or x is nan
if (unlikely(x_abs >= 0x421a'209bU)) { if (unlikely(x_abs >= 0x421a'209bU)) {
// When x < log10(2^-150) or nan // When x < log10(2^-150) or nan
if (x_u > 0xc234'9e35U) { if (x_u > 0xc234'9e35U) {
// exp(-Inf) = 0 // exp(-Inf) = 0
if (xbits.is_inf()) if (xbits.is_inf())
return 0.0f; return 0.0f;
// exp(nan) = nan // exp(nan) = nan
if (xbits.is_nan()) if (xbits.is_nan())
return x; return x;
if (fputil::get_round() == FE_UPWARD) if (fputil::get_round() == FE_UPWARD)
return static_cast<float>(FPBits(FPBits::MIN_SUBNORMAL)); return static_cast<float>(FPB(FPB::MIN_SUBNORMAL));
errno = ERANGE; errno = ERANGE;
return 0.0f; return 0.0f;
} }
// x >= log10(2^128) or nan // x >= log10(2^128) or nan
if (!xbits.get_sign() && (x_u >= 0x421a'209bU)) { if (!xbits.get_sign() && (x_u >= 0x421a'209bU)) {
// x is finite // x is finite
if (x_u < 0x7f80'0000U) { if (x_u < 0x7f80'0000U) {
int rounding = fputil::get_round(); int rounding = fputil::get_round();
if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO) if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)
return static_cast<float>(FPBits(FPBits::MAX_NORMAL)); return static_cast<float>(FPB(FPB::MAX_NORMAL));
errno = ERANGE; errno = ERANGE;
} }
// x is +inf or nan // x is +inf or nan
return x + static_cast<float>(FPBits::inf()); return x + static_cast<float>(FPB::inf());
} }
} }
// When |x| <= log10(2)*2^-6 // When |x| <= log10(2)*2^-6
if (unlikely(x_abs <= 0x3b9a'209bU)) { if (unlikely(x_abs <= 0x3b9a'209bU)) {
if (unlikely(x_u == 0xb25e'5bd9U)) { // x = -0x1.bcb7b2p-27f if (unlikely(x_u == 0xb25e'5bd9U)) { // x = -0x1.bcb7b2p-27f
if (fputil::get_round() == FE_TONEAREST) if (fputil::get_round() == FE_TONEAREST)
return 0x1.fffffep-1f; return 0x1.fffffep-1f;
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libc/src/math/generic/exp2f.cpp

Show All 19 Lines
namespace __llvm_libc { namespace __llvm_libc {
constexpr uint32_t exval1 = 0x3b42'9d37U; constexpr uint32_t exval1 = 0x3b42'9d37U;
constexpr uint32_t exval2 = 0xbcf3'a937U; constexpr uint32_t exval2 = 0xbcf3'a937U;
constexpr uint32_t exval_mask = exval1 & exval2; constexpr uint32_t exval_mask = exval1 & exval2;
LLVM_LIBC_FUNCTION(float, exp2f, (float x)) { LLVM_LIBC_FUNCTION(float, exp2f, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
uint32_t x_u = xbits.uintval(); uint32_t x_u = xbits.uintval();
uint32_t x_abs = x_u & 0x7fff'ffffU; uint32_t x_abs = x_u & 0x7fff'ffffU;
// |x| < 2^-25 // |x| < 2^-25
if (unlikely(x_abs <= 0x3280'0000U)) { if (unlikely(x_abs <= 0x3280'0000U)) {
return 1.0f + x; return 1.0f + x;
} }
// // When |x| >= 128, or x is nan // // When |x| >= 128, or x is nan
if (unlikely(x_abs >= 0x4300'0000U)) { if (unlikely(x_abs >= 0x4300'0000U)) {
// x >= 128 // x >= 128
if (!xbits.get_sign()) { if (!xbits.get_sign()) {
// x is finite // x is finite
if (x_u < 0x7f80'0000U) { if (x_u < 0x7f80'0000U) {
int rounding = fputil::get_round(); int rounding = fputil::get_round();
if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO) if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)
return static_cast<float>(FPBits(FPBits::MAX_NORMAL)); return static_cast<float>(FPB(FPB::MAX_NORMAL));
errno = ERANGE; errno = ERANGE;
} }
// x is +inf or nan // x is +inf or nan
return x + FPBits::inf().get_val(); return x + FPB::inf().get_val();
} }
// x <= -150 // x <= -150
if (x_u >= 0xc316'0000U) { if (x_u >= 0xc316'0000U) {
// exp(-Inf) = 0 // exp(-Inf) = 0
if (xbits.is_inf()) if (xbits.is_inf())
return 0.0f; return 0.0f;
// exp(nan) = nan // exp(nan) = nan
if (xbits.is_nan()) if (xbits.is_nan())
return x; return x;
if (fputil::get_round() == FE_UPWARD) if (fputil::get_round() == FE_UPWARD)
return FPBits(FPBits::MIN_SUBNORMAL).get_val(); return FPB(FPB::MIN_SUBNORMAL).get_val();
if (x != 0.0f) if (x != 0.0f)
errno = ERANGE; errno = ERANGE;
return 0.0f; return 0.0f;
} }
} }
// Check exceptional values. // Check exceptional values.
if (unlikely(x_u & exval_mask) == exval_mask) { if (unlikely(x_u & exval_mask) == exval_mask) {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

libc/src/math/generic/expf.cpp

Show All 15 Lines
#include "src/__support/FPUtil/nearest_integer.h" #include "src/__support/FPUtil/nearest_integer.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include <errno.h> #include <errno.h>
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, expf, (float x)) { LLVM_LIBC_FUNCTION(float, expf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
uint32_t x_u = xbits.uintval(); uint32_t x_u = xbits.uintval();
uint32_t x_abs = x_u & 0x7fff'ffffU; uint32_t x_abs = x_u & 0x7fff'ffffU;
// Exceptional values // Exceptional values
if (unlikely(x_u == 0xc236'bd8cU)) { // x = -0x1.6d7b18p+5f if (unlikely(x_u == 0xc236'bd8cU)) { // x = -0x1.6d7b18p+5f
return 0x1.108a58p-66f - x * 0x1.0p-95f; return 0x1.108a58p-66f - x * 0x1.0p-95f;
} }
Show All 9 Lines if (unlikely(x_abs >= 0x42b2'0000U || x_abs <= 0x3280'0000U)) {
if (xbits.uintval() >= 0xc2cf'f1b5U) { if (xbits.uintval() >= 0xc2cf'f1b5U) {
// exp(-Inf) = 0 // exp(-Inf) = 0
if (xbits.is_inf()) if (xbits.is_inf())
return 0.0f; return 0.0f;
// exp(nan) = nan // exp(nan) = nan
if (xbits.is_nan()) if (xbits.is_nan())
return x; return x;
if (fputil::get_round() == FE_UPWARD) if (fputil::get_round() == FE_UPWARD)
return static_cast<float>(FPBits(FPBits::MIN_SUBNORMAL)); return static_cast<float>(FPB(FPB::MIN_SUBNORMAL));
errno = ERANGE; errno = ERANGE;
return 0.0f; return 0.0f;
} }
// x >= 89 or nan // x >= 89 or nan
if (!xbits.get_sign() && (xbits.uintval() >= 0x42b2'0000)) { if (!xbits.get_sign() && (xbits.uintval() >= 0x42b2'0000)) {
// x is finite // x is finite
if (xbits.uintval() < 0x7f80'0000U) { if (xbits.uintval() < 0x7f80'0000U) {
int rounding = fputil::get_round(); int rounding = fputil::get_round();
if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO) if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)
return static_cast<float>(FPBits(FPBits::MAX_NORMAL)); return static_cast<float>(FPB(FPB::MAX_NORMAL));
errno = ERANGE; errno = ERANGE;
} }
// x is +inf or nan // x is +inf or nan
return x + static_cast<float>(FPBits::inf()); return x + static_cast<float>(FPB::inf());
} }
} }
// For -104 < x < 89, to compute exp(x), we perform the following range // For -104 < x < 89, to compute exp(x), we perform the following range
// reduction: find hi, mid, lo such that: // reduction: find hi, mid, lo such that:
// x = hi + mid + lo, in which // x = hi + mid + lo, in which
// hi is an integer, // hi is an integer,
// mid * 2^7 is an integer // mid * 2^7 is an integer
// -2^(-8) <= lo < 2^-8. // -2^(-8) <= lo < 2^-8.
Show All 30 Lines

libc/src/math/generic/expm1f.cpp

Show All 17 Lines
#include "src/__support/common.h" #include "src/__support/common.h"
#include "src/__support/cpu_features.h" #include "src/__support/cpu_features.h"
#include <errno.h> #include <errno.h>
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, expm1f, (float x)) { LLVM_LIBC_FUNCTION(float, expm1f, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
uint32_t x_u = xbits.uintval(); uint32_t x_u = xbits.uintval();
uint32_t x_abs = x_u & 0x7fff'ffffU; uint32_t x_abs = x_u & 0x7fff'ffffU;
// Exceptional value // Exceptional value
if (unlikely(x_u == 0x3e35'bec5U)) { // x = 0x1.6b7d8ap-3f if (unlikely(x_u == 0x3e35'bec5U)) { // x = 0x1.6b7d8ap-3f
int round_mode = fputil::get_round(); int round_mode = fputil::get_round();
if (round_mode == FE_TONEAREST || round_mode == FE_UPWARD) if (round_mode == FE_TONEAREST || round_mode == FE_UPWARD)
Show All 25 Lines if (xbits.get_sign()) {
return -0x1.ffff'fep-1f; // -1.0f + 0x1.0p-24f return -0x1.ffff'fep-1f; // -1.0f + 0x1.0p-24f
return -1.0f; return -1.0f;
} else { } else {
// x >= 89 or nan // x >= 89 or nan
if (xbits.uintval() >= 0x42b2'0000) { if (xbits.uintval() >= 0x42b2'0000) {
if (xbits.uintval() < 0x7f80'0000U) { if (xbits.uintval() < 0x7f80'0000U) {
int rounding = fputil::get_round(); int rounding = fputil::get_round();
if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO) if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)
return static_cast<float>(FPBits(FPBits::MAX_NORMAL)); return static_cast<float>(FPB(FPB::MAX_NORMAL));
errno = ERANGE; errno = ERANGE;
} }
return x + static_cast<float>(FPBits::inf()); return x + static_cast<float>(FPB::inf());
} }
} }
} }
// |x| < 2^-4 // |x| < 2^-4
if (x_abs < 0x3d80'0000U) { if (x_abs < 0x3d80'0000U) {
// |x| < 2^-25 // |x| < 2^-25
if (x_abs < 0x3300'0000U) { if (x_abs < 0x3300'0000U) {
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

libc/src/math/generic/hypotf.cpp

Show All 9 Lines
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/sqrt.h" #include "src/__support/FPUtil/sqrt.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, hypotf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, hypotf, (float x, float y)) {
using DoubleBits = fputil::FPBits<double>; using DoubleBits = fputil::FPBits<double>;
using FPBits = fputil::FPBits<float>; using FPB = fputil::FPBits<float>;
FPBits x_bits(x), y_bits(y); FPB x_bits(x), y_bits(y);
uint16_t x_exp = x_bits.get_unbiased_exponent(); uint16_t x_exp = x_bits.get_unbiased_exponent();
uint16_t y_exp = y_bits.get_unbiased_exponent(); uint16_t y_exp = y_bits.get_unbiased_exponent();
uint16_t exp_diff = (x_exp > y_exp) ? (x_exp - y_exp) : (y_exp - x_exp); uint16_t exp_diff = (x_exp > y_exp) ? (x_exp - y_exp) : (y_exp - x_exp);
if (exp_diff >= fputil::MantissaWidth<float>::VALUE + 2) { if (exp_diff >= fputil::MantissaWidth<float>::VALUE + 2) {
return fputil::abs(x) + fputil::abs(y); return fputil::abs(x) + fputil::abs(y);
} }
Show All 23 Lines if (!DoubleBits(sum_sq).is_inf_or_nan()) {
uint64_t lrs = result.uintval() & mask; uint64_t lrs = result.uintval() & mask;
if (lrs == 0x0000'0000'1000'0000ULL && err < diff) { if (lrs == 0x0000'0000'1000'0000ULL && err < diff) {
result.bits |= 1ULL; result.bits |= 1ULL;
} else if (lrs == 0x0000'0000'3000'0000ULL && err > diff) { } else if (lrs == 0x0000'0000'3000'0000ULL && err > diff) {
result.bits -= 1ULL; result.bits -= 1ULL;
} }
} else { } else {
FPBits bits_x(x), bits_y(y); FPB bits_x(x), bits_y(y);
if (bits_x.is_inf_or_nan() || bits_y.is_inf_or_nan()) { if (bits_x.is_inf_or_nan() || bits_y.is_inf_or_nan()) {
if (bits_x.is_inf() || bits_y.is_inf()) if (bits_x.is_inf() || bits_y.is_inf())
return static_cast<float>(FPBits::inf()); return static_cast<float>(FPB::inf());
if (bits_x.is_nan()) if (bits_x.is_nan())
return x; return x;
return y; return y;
} }
} }
return static_cast<float>(static_cast<double>(result)); return static_cast<float>(static_cast<double>(result));
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/log10.cpp

Show First 20 Lines • Show All 938 Lines • ▼ Show 20 Linesdouble log10_accurate(int e_x, int index, double m_x) {
return static_cast<double>(fputil::quick_add(sum, p)); return static_cast<double>(fputil::quick_add(sum, p));
} }
} // namespace } // namespace
// TODO(lntue): Make the implementation correctly rounded for non-FMA targets. // TODO(lntue): Make the implementation correctly rounded for non-FMA targets.
LLVM_LIBC_FUNCTION(double, log10, (double x)) { LLVM_LIBC_FUNCTION(double, log10, (double x)) {
using FPBits_t = typename fputil::FPBits<double>; using FPB = typename fputil::FPBits<double>;
FPBits_t xbits(x); FPB xbits(x);
int x_e = -1023; int x_e = -1023;
if (unlikely(xbits.uintval() < FPBits_t::MIN_NORMAL || if (unlikely(xbits.uintval() < FPB::MIN_NORMAL ||
xbits.uintval() > FPBits_t::MAX_NORMAL)) { xbits.uintval() > FPB::MAX_NORMAL)) {
if (xbits.is_zero()) { if (xbits.is_zero()) {
// return -Inf and raise FE_DIVBYZERO. // return -Inf and raise FE_DIVBYZERO.
return -1.0 / 0.0; return -1.0 / 0.0;
} }
if (xbits.get_sign() && !xbits.is_nan()) { if (xbits.get_sign() && !xbits.is_nan()) {
return FPBits_t::build_quiet_nan(0); return FPB::build_quiet_nan(0);
} }
if (xbits.is_inf_or_nan()) { if (xbits.is_inf_or_nan()) {
return x; return x;
} }
// Normalize denormal inputs. // Normalize denormal inputs.
xbits.set_val(x * 0x1.0p52); xbits.set_val(x * 0x1.0p52);
x_e -= 52; x_e -= 52;
} }
Show All 29 LinesLLVM_LIBC_FUNCTION(double, log10, (double x)) {
// Theorem 1 says that // Theorem 1 says that
// the difference between a+b and hi+lo is bounded by 2u^2|a+b| // the difference between a+b and hi+lo is bounded by 2u^2|a+b|
// and also by 2u^2|hi|. Here u=2^-53, thus we get: // and also by 2u^2|hi|. Here u=2^-53, thus we get:
// |(a+b)-(hi+lo)| <= 2^-105 min(|a+b|,|hi|) // |(a+b)-(hi+lo)| <= 2^-105 min(|a+b|,|hi|)
// So the overall errors <= 2^-105 min(|a+b|, |hi|) + 2*(...) // So the overall errors <= 2^-105 min(|a+b|, |hi|) + 2*(...)
fputil::DoubleDouble rr = fputil::exact_add(hi, lo); fputil::DoubleDouble rr = fputil::exact_add(hi, lo);
uint64_t x_m = (x_u & 0x000F'FFFF'FFFF'FFFFULL) | 0x3FF0'0000'0000'0000ULL; uint64_t x_m = (x_u & 0x000F'FFFF'FFFF'FFFFULL) | 0x3FF0'0000'0000'0000ULL;
double m = FPBits_t(x_m).get_val(); double m = FPB(x_m).get_val();
double u = fputil::multiply_add(r, m, -1.0); // exact double u = fputil::multiply_add(r, m, -1.0); // exact
err = fputil::multiply_add(u, P_ERR, err); err = fputil::multiply_add(u, P_ERR, err);
// Degree-7 minimax polynomial // Degree-7 minimax polynomial
double u_sq = u * u; double u_sq = u * u;
double p0 = u * COEFFS[0]; double p0 = u * COEFFS[0];
double p1 = fputil::multiply_add(u, COEFFS[2], COEFFS[1]); double p1 = fputil::multiply_add(u, COEFFS[2], COEFFS[1]);
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libc/src/math/generic/log10f.cpp

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Linesstatic constexpr double LOG10_F[128] = {
0x1.20b91a8e76105p-2, 0x1.2288d7a9b2b64p-2, 0x1.2456b3282f786p-2, 0x1.20b91a8e76105p-2, 0x1.2288d7a9b2b64p-2, 0x1.2456b3282f786p-2,
0x1.2622b0ee3b79dp-2, 0x1.27ecd4d41eb67p-2, 0x1.29b522a64b609p-2, 0x1.2622b0ee3b79dp-2, 0x1.27ecd4d41eb67p-2, 0x1.29b522a64b609p-2,
0x1.2b7b9e258e422p-2, 0x1.2d404b073e27ep-2, 0x1.2f032cf56a5bep-2, 0x1.2b7b9e258e422p-2, 0x1.2d404b073e27ep-2, 0x1.2f032cf56a5bep-2,
0x1.30c4478f0835fp-2, 0x1.32839e681fc62p-2}; 0x1.30c4478f0835fp-2, 0x1.32839e681fc62p-2};
LLVM_LIBC_FUNCTION(float, log10f, (float x)) { LLVM_LIBC_FUNCTION(float, log10f, (float x)) {
constexpr double LOG10_2 = 0x1.34413509f79ffp-2; constexpr double LOG10_2 = 0x1.34413509f79ffp-2;
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
double m = 0.0; double m = 0.0;
// Exact powers of 10 and other hard-to-round cases. // Exact powers of 10 and other hard-to-round cases.
switch (xbits.uintval()) { switch (xbits.uintval()) {
case 0x4120'0000U: // x = 10 case 0x4120'0000U: // x = 10
return 1.0f; return 1.0f;
case 0x42c8'0000U: // x = 100 case 0x42c8'0000U: // x = 100
return 2.0f; return 2.0f;
Show All 20 LinesLLVM_LIBC_FUNCTION(float, log10f, (float x)) {
case 0x7956'ba5eU: { // x = 69683218960000541503257137270226944.0 case 0x7956'ba5eU: { // x = 69683218960000541503257137270226944.0
int round_mode = fputil::get_round(); int round_mode = fputil::get_round();
if (round_mode == FE_DOWNWARD || round_mode == FE_TOWARDZERO) if (round_mode == FE_DOWNWARD || round_mode == FE_TOWARDZERO)
return 0x1.16bebap+5f; return 0x1.16bebap+5f;
break; break;
} }
} }
if (xbits.uintval() < FPBits::MIN_NORMAL || if (xbits.uintval() < FPB::MIN_NORMAL || xbits.uintval() > FPB::MAX_NORMAL) {
xbits.uintval() > FPBits::MAX_NORMAL) {
if (xbits.is_zero()) { if (xbits.is_zero()) {
return static_cast<float>(FPBits::neg_inf()); return static_cast<float>(FPB::neg_inf());
} }
if (xbits.get_sign() && !xbits.is_nan()) { if (xbits.get_sign() && !xbits.is_nan()) {
return FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1)); return FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
if (xbits.is_inf_or_nan()) { if (xbits.is_inf_or_nan()) {
return x; return x;
} }
// Normalize denormal inputs. // Normalize denormal inputs.
xbits.set_val(xbits.get_val() * 0x1.0p23f); xbits.set_val(xbits.get_val() * 0x1.0p23f);
m -= 23.0; m -= 23.0;
} }
m += static_cast<double>(xbits.get_exponent()); m += static_cast<double>(xbits.get_exponent());
// Set bits to 1.m // Set bits to 1.m
xbits.set_unbiased_exponent(0x7F); xbits.set_unbiased_exponent(0x7F);
int f_index = xbits.get_mantissa() >> 16; int f_index = xbits.get_mantissa() >> 16;
FPBits f = xbits; FPB f = xbits;
f.bits &= ~0x0000'FFFF; f.bits &= ~0x0000'FFFF;
double d = static_cast<float>(xbits) - static_cast<float>(f); double d = static_cast<float>(xbits) - static_cast<float>(f);
d *= ONE_OVER_F[f_index]; d *= ONE_OVER_F[f_index];
double extra_factor = fputil::multiply_add(m, LOG10_2, LOG10_F[f_index]); double extra_factor = fputil::multiply_add(m, LOG10_2, LOG10_F[f_index]);
double r = fputil::polyeval(d, extra_factor, 0x1.bcb7b1526e4c5p-2, double r = fputil::polyeval(d, extra_factor, 0x1.bcb7b1526e4c5p-2,
-0x1.bcb7b1518a5e9p-3, 0x1.287a72a6f716p-3, -0x1.bcb7b1518a5e9p-3, 0x1.287a72a6f716p-3,
-0x1.bcadb40b85565p-4, 0x1.5e0bc97f97e22p-4); -0x1.bcadb40b85565p-4, 0x1.5e0bc97f97e22p-4);
return static_cast<float>(r); return static_cast<float>(r);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/log1pf.cpp

Show All 29 Lines
namespace __llvm_libc { namespace __llvm_libc {
namespace internal { namespace internal {
// We don't need to treat denormal // We don't need to treat denormal
static inline float log(double x) { static inline float log(double x) {
constexpr double LOG_2 = 0x1.62e42fefa39efp-1; constexpr double LOG_2 = 0x1.62e42fefa39efp-1;
using FPBits = typename fputil::FPBits<double>; using FPB = typename fputil::FPBits<double>;
FPBits xbits(x); FPB xbits(x);
if (xbits.is_zero()) { if (xbits.is_zero()) {
return static_cast<float>(fputil::FPBits<float>::neg_inf()); return static_cast<float>(fputil::FPBits<float>::neg_inf());
} }
if (xbits.uintval() > FPBits::MAX_NORMAL) { if (xbits.uintval() > FPB::MAX_NORMAL) {
if (xbits.get_sign() && !xbits.is_nan()) { if (xbits.get_sign() && !xbits.is_nan()) {
return fputil::FPBits<float>::build_nan( return fputil::FPBits<float>::build_nan(
1 << (fputil::MantissaWidth<float>::VALUE - 1)); 1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
return static_cast<float>(x); return static_cast<float>(x);
} }
double m = static_cast<double>(xbits.get_exponent()); double m = static_cast<double>(xbits.get_exponent());
// Set bits to 1.m // Set bits to 1.m
xbits.set_unbiased_exponent(0x3FF); xbits.set_unbiased_exponent(0x3FF);
// Get the 8 highest bits, use 7 bits (excluding the implicit hidden bit) for // Get the 8 highest bits, use 7 bits (excluding the implicit hidden bit) for
// lookup tables. // lookup tables.
int f_index = int f_index =
xbits.get_mantissa() >> 45; // fputil::MantissaWidth<double>::VALUE - 7 xbits.get_mantissa() >> 45; // fputil::MantissaWidth<double>::VALUE - 7
FPBits f = xbits; FPB f = xbits;
// Clear the lowest 45 bits. // Clear the lowest 45 bits.
f.bits &= ~0x0000'1FFF'FFFF'FFFFULL; f.bits &= ~0x0000'1FFF'FFFF'FFFFULL;
double d = static_cast<double>(xbits) - static_cast<double>(f); double d = static_cast<double>(xbits) - static_cast<double>(f);
d *= ONE_OVER_F[f_index]; d *= ONE_OVER_F[f_index];
double extra_factor = fputil::multiply_add(m, LOG_2, LOG_F[f_index]); double extra_factor = fputil::multiply_add(m, LOG_2, LOG_F[f_index]);
double r = fputil::polyeval(d, extra_factor, 0x1.fffffffffffacp-1, double r = fputil::polyeval(d, extra_factor, 0x1.fffffffffffacp-1,
-0x1.fffffffef9cb2p-2, 0x1.5555513bc679ap-2, -0x1.fffffffef9cb2p-2, 0x1.5555513bc679ap-2,
-0x1.fff4805ea441p-3, 0x1.930180dbde91ap-3); -0x1.fff4805ea441p-3, 0x1.930180dbde91ap-3);
return static_cast<float>(r); return static_cast<float>(r);
} }
} // namespace internal } // namespace internal
LLVM_LIBC_FUNCTION(float, log1pf, (float x)) { LLVM_LIBC_FUNCTION(float, log1pf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
double xd = static_cast<double>(x); double xd = static_cast<double>(x);
if (xbits.get_exponent() >= -8) { if (xbits.get_exponent() >= -8) {
// Hard-to-round cases. // Hard-to-round cases.
switch (xbits.uintval()) { switch (xbits.uintval()) {
case 0x3b9315c8U: // x = 0x1.262b9p-8f case 0x3b9315c8U: // x = 0x1.262b9p-8f
if (fputil::get_round() != FE_UPWARD) if (fputil::get_round() != FE_UPWARD)
return 0x1.25830cp-8f; return 0x1.25830cp-8f;
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libc/src/math/generic/log2f.cpp

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Linesstatic constexpr double LOG2_F[128] = {
0x1.cd3e6a0ca8907p-1, 0x1.d053f6d260896p-1, 0x1.d3663b27f31d5p-1, 0x1.cd3e6a0ca8907p-1, 0x1.d053f6d260896p-1, 0x1.d3663b27f31d5p-1,
0x1.d6753e032ea0fp-1, 0x1.d9810643d6615p-1, 0x1.dc899ab3ff56cp-1, 0x1.d6753e032ea0fp-1, 0x1.d9810643d6615p-1, 0x1.dc899ab3ff56cp-1,
0x1.df8f02086af2cp-1, 0x1.e29142e0e0140p-1, 0x1.e59063c8822cep-1, 0x1.df8f02086af2cp-1, 0x1.e29142e0e0140p-1, 0x1.e59063c8822cep-1,
0x1.e88c6b3626a73p-1, 0x1.eb855f8ca88fbp-1, 0x1.ee7b471b3a950p-1, 0x1.e88c6b3626a73p-1, 0x1.eb855f8ca88fbp-1, 0x1.ee7b471b3a950p-1,
0x1.f16e281db7630p-1, 0x1.f45e08bcf0655p-1, 0x1.f74aef0efafaep-1, 0x1.f16e281db7630p-1, 0x1.f45e08bcf0655p-1, 0x1.f74aef0efafaep-1,
0x1.fa34e1177c233p-1, 0x1.fd1be4c7f2af9p-1}; 0x1.fa34e1177c233p-1, 0x1.fd1be4c7f2af9p-1};
LLVM_LIBC_FUNCTION(float, log2f, (float x)) { LLVM_LIBC_FUNCTION(float, log2f, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
int m = 0; int m = 0;
// Hard to round value(s). // Hard to round value(s).
switch (FPBits(x).uintval()) { switch (FPB(x).uintval()) {
case 0x3f81d0b5U: { case 0x3f81d0b5U: {
int rounding_mode = fputil::get_round(); int rounding_mode = fputil::get_round();
if (rounding_mode == FE_DOWNWARD || rounding_mode == FE_TOWARDZERO) { if (rounding_mode == FE_DOWNWARD || rounding_mode == FE_TOWARDZERO) {
return 0x1.4cdc4cp-6f; return 0x1.4cdc4cp-6f;
} }
break; break;
} }
case 0x3f7e3274U: case 0x3f7e3274U:
if (fputil::get_round() == FE_TONEAREST) { if (fputil::get_round() == FE_TONEAREST) {
return -0x1.4e1d16p-7f; return -0x1.4e1d16p-7f;
} }
break; break;
case 0x3f7d57f5U: case 0x3f7d57f5U:
if (fputil::get_round() == FE_TOWARDZERO) { if (fputil::get_round() == FE_TOWARDZERO) {
return -0x1.ed1c32p-7f; return -0x1.ed1c32p-7f;
} }
break; break;
} }
// Exceptional inputs. // Exceptional inputs.
if (xbits.uintval() < FPBits::MIN_NORMAL || if (xbits.uintval() < FPB::MIN_NORMAL || xbits.uintval() > FPB::MAX_NORMAL) {
xbits.uintval() > FPBits::MAX_NORMAL) {
if (xbits.is_zero()) { if (xbits.is_zero()) {
return static_cast<float>(FPBits::neg_inf()); return static_cast<float>(FPB::neg_inf());
} }
if (xbits.get_sign() && !xbits.is_nan()) { if (xbits.get_sign() && !xbits.is_nan()) {
return FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1)); return FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
if (xbits.is_inf_or_nan()) { if (xbits.is_inf_or_nan()) {
return x; return x;
} }
// Normalize denormal inputs. // Normalize denormal inputs.
xbits.set_val(xbits.get_val() * 0x1.0p23f); xbits.set_val(xbits.get_val() * 0x1.0p23f);
m = -23; m = -23;
} }
m += xbits.get_exponent(); m += xbits.get_exponent();
// Set bits to 1.m // Set bits to 1.m
xbits.set_unbiased_exponent(0x7F); xbits.set_unbiased_exponent(0x7F);
// Get the 8 highest bits, use 7 bits (excluding the implicit hidden bit) for // Get the 8 highest bits, use 7 bits (excluding the implicit hidden bit) for
// lookup tables. // lookup tables.
int f_index = xbits.get_mantissa() >> 16; int f_index = xbits.get_mantissa() >> 16;
FPBits f = xbits; FPB f = xbits;
// Clear the lowest 16 bits. // Clear the lowest 16 bits.
f.bits &= ~0x0000'FFFF; f.bits &= ~0x0000'FFFF;
double d = static_cast<float>(xbits) - static_cast<float>(f); double d = static_cast<float>(xbits) - static_cast<float>(f);
d *= ONE_OVER_F[f_index]; d *= ONE_OVER_F[f_index];
double extra_factor = static_cast<double>(m) + LOG2_F[f_index]; double extra_factor = static_cast<double>(m) + LOG2_F[f_index];
double r = __llvm_libc::fputil::polyeval( double r = __llvm_libc::fputil::polyeval(
d, extra_factor, 0x1.71547652bd4fp+0, -0x1.7154769b978c7p-1, d, extra_factor, 0x1.71547652bd4fp+0, -0x1.7154769b978c7p-1,
0x1.ec71a99e349c8p-2, -0x1.720d90e6aac6cp-2, 0x1.5132da3583dap-2); 0x1.ec71a99e349c8p-2, -0x1.720d90e6aac6cp-2, 0x1.5132da3583dap-2);
return static_cast<float>(r); return static_cast<float>(r);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/logf.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
// Symposium on Principles of Programming Languages (POPL-2022), Philadelphia, // Symposium on Principles of Programming Languages (POPL-2022), Philadelphia,
// USA, January 16-22, 2022. // USA, January 16-22, 2022.
// https://people.cs.rutgers.edu/~sn349/papers/rlibmall-popl-2022.pdf // https://people.cs.rutgers.edu/~sn349/papers/rlibmall-popl-2022.pdf
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, logf, (float x)) { LLVM_LIBC_FUNCTION(float, logf, (float x)) {
constexpr double LOG_2 = 0x1.62e42fefa39efp-1; constexpr double LOG_2 = 0x1.62e42fefa39efp-1;
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
switch (FPBits(x).uintval()) { switch (FPB(x).uintval()) {
case 0x41178febU: // x = 0x1.2f1fd6p+3f case 0x41178febU: // x = 0x1.2f1fd6p+3f
if (fputil::get_round() == FE_TONEAREST) if (fputil::get_round() == FE_TONEAREST)
return 0x1.1fcbcep+1f; return 0x1.1fcbcep+1f;
break; break;
case 0x4c5d65a5U: // x = 0x1.bacb4ap+25f case 0x4c5d65a5U: // x = 0x1.bacb4ap+25f
if (fputil::get_round() == FE_TONEAREST) if (fputil::get_round() == FE_TONEAREST)
return 0x1.1e0696p+4f; return 0x1.1e0696p+4f;
break; break;
Show All 20 LinesLLVM_LIBC_FUNCTION(float, logf, (float x)) {
case 0x5cd69e88U: // x = 0x1.ad3d1p+58f case 0x5cd69e88U: // x = 0x1.ad3d1p+58f
if (fputil::get_round() != FE_UPWARD) if (fputil::get_round() != FE_UPWARD)
return 0x1.45c146p+5f; return 0x1.45c146p+5f;
break; break;
} }
int m = 0; int m = 0;
if (xbits.uintval() < FPBits::MIN_NORMAL || if (xbits.uintval() < FPB::MIN_NORMAL || xbits.uintval() > FPB::MAX_NORMAL) {
xbits.uintval() > FPBits::MAX_NORMAL) {
if (xbits.is_zero()) { if (xbits.is_zero()) {
return static_cast<float>(FPBits::neg_inf()); return static_cast<float>(FPB::neg_inf());
} }
if (xbits.get_sign() && !xbits.is_nan()) { if (xbits.get_sign() && !xbits.is_nan()) {
return FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1)); return FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
if (xbits.is_inf_or_nan()) { if (xbits.is_inf_or_nan()) {
return x; return x;
} }
// Normalize denormal inputs. // Normalize denormal inputs.
xbits.set_val(xbits.get_val() * 0x1.0p23f); xbits.set_val(xbits.get_val() * 0x1.0p23f);
m = -23; m = -23;
} }
m += xbits.get_exponent(); m += xbits.get_exponent();
// Set bits to 1.m // Set bits to 1.m
xbits.set_unbiased_exponent(0x7F); xbits.set_unbiased_exponent(0x7F);
int f_index = xbits.get_mantissa() >> 16; int f_index = xbits.get_mantissa() >> 16;
FPBits f = xbits; FPB f = xbits;
f.bits &= ~0x0000'FFFF; f.bits &= ~0x0000'FFFF;
double d = static_cast<float>(xbits) - static_cast<float>(f); double d = static_cast<float>(xbits) - static_cast<float>(f);
d *= ONE_OVER_F[f_index]; d *= ONE_OVER_F[f_index];
double extra_factor = double extra_factor =
fputil::multiply_add(static_cast<double>(m), LOG_2, LOG_F[f_index]); fputil::multiply_add(static_cast<double>(m), LOG_2, LOG_F[f_index]);
double r = __llvm_libc::fputil::polyeval( double r = __llvm_libc::fputil::polyeval(
d, extra_factor, 0x1.fffffffffffacp-1, -0x1.fffffffef9cb2p-2, d, extra_factor, 0x1.fffffffffffacp-1, -0x1.fffffffef9cb2p-2,
0x1.5555513bc679ap-2, -0x1.fff4805ea441p-3, 0x1.930180dbde91ap-3); 0x1.5555513bc679ap-2, -0x1.fff4805ea441p-3, 0x1.930180dbde91ap-3);
return static_cast<float>(r); return static_cast<float>(r);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/sincosf.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linesstatic constexpr uint32_t EXCEPT_OUTPUTS_COS[N_EXCEPTS][4] = {
{0x3f4ea5d2, 1, 0, 0}, // x = 0x1.64a032p43, cos(x) = 0x1.9d4ba4p-1 (RZ) {0x3f4ea5d2, 1, 0, 0}, // x = 0x1.64a032p43, cos(x) = 0x1.9d4ba4p-1 (RZ)
{0x3f08aebe, 1, 0, 1}, // x = 0x1.4555p51, cos(x) = 0x1.115d7cp-1 (RZ) {0x3f08aebe, 1, 0, 1}, // x = 0x1.4555p51, cos(x) = 0x1.115d7cp-1 (RZ)
{0x3f7f14bb, 1, 0, 0}, // x = 0x1.3170fp63, cos(x) = 0x1.fe2976p-1 (RZ) {0x3f7f14bb, 1, 0, 0}, // x = 0x1.3170fp63, cos(x) = 0x1.fe2976p-1 (RZ)
{0x3f78142e, 1, 0, 1}, // x = 0x1.2b9622p67, cos(x) = 0x1.f0285cp-1 (RZ) {0x3f78142e, 1, 0, 1}, // x = 0x1.2b9622p67, cos(x) = 0x1.f0285cp-1 (RZ)
{0x3f08a21c, 1, 0, 0}, // x = 0x1.ddebdep120, cos(x) = 0x1.114438p-1 (RZ) {0x3f08a21c, 1, 0, 0}, // x = 0x1.ddebdep120, cos(x) = 0x1.114438p-1 (RZ)
}; };
LLVM_LIBC_FUNCTION(void, sincosf, (float x, float *sinp, float *cosp)) { LLVM_LIBC_FUNCTION(void, sincosf, (float x, float *sinp, float *cosp)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU; uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU;
double xd = static_cast<double>(x); double xd = static_cast<double>(x);
// Range reduction: // Range reduction:
// For |x| >= 2^-12, we perform range reduction as follows: // For |x| >= 2^-12, we perform range reduction as follows:
// Find k and y such that: // Find k and y such that:
// x = (k + y) * pi/32 // x = (k + y) * pi/32
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines if (unlikely(x_abs < 0x3980'0000U)) {
// instead. // instead.
// Note: to use the formula x - 2^-25*x to decide the correct rounding, we // Note: to use the formula x - 2^-25*x to decide the correct rounding, we
// do need fma(x, -2^-25, x) to prevent underflow caused by -2^-25*x when // do need fma(x, -2^-25, x) to prevent underflow caused by -2^-25*x when
// |x| < 2^-125. For targets without FMA instructions, we simply use // |x| < 2^-125. For targets without FMA instructions, we simply use
// double for intermediate results as it is more efficient than using an // double for intermediate results as it is more efficient than using an
// emulated version of FMA. // emulated version of FMA.
#if defined(LIBC_TARGET_HAS_FMA) #if defined(LIBC_TARGET_HAS_FMA)
*sinp = fputil::multiply_add(x, -0x1.0p-25f, x); *sinp = fputil::multiply_add(x, -0x1.0p-25f, x);
*cosp = fputil::multiply_add(FPBits(x_abs).get_val(), -0x1.0p-25f, 1.0f); *cosp = fputil::multiply_add(FPB(x_abs).get_val(), -0x1.0p-25f, 1.0f);
#else #else
*sinp = static_cast<float>(fputil::multiply_add(xd, -0x1.0p-25, xd)); *sinp = static_cast<float>(fputil::multiply_add(xd, -0x1.0p-25, xd));
*cosp = static_cast<float>(fputil::multiply_add( *cosp = static_cast<float>(fputil::multiply_add(
static_cast<double>(FPBits(x_abs).get_val()), -0x1.0p-25, 1.0)); static_cast<double>(FPB(x_abs).get_val()), -0x1.0p-25, 1.0));
#endif // LIBC_TARGET_HAS_FMA #endif // LIBC_TARGET_HAS_FMA
return; return;
} }
// x is inf or nan. // x is inf or nan.
if (unlikely(x_abs >= 0x7f80'0000U)) { if (unlikely(x_abs >= 0x7f80'0000U)) {
if (x_abs == 0x7f80'0000U) { if (x_abs == 0x7f80'0000U) {
errno = EDOM; errno = EDOM;
fputil::set_except(FE_INVALID); fputil::set_except(FE_INVALID);
} }
*sinp = *sinp = x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
x + FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
*cosp = *sinp; *cosp = *sinp;
return; return;
} }
// Check exceptional values. // Check exceptional values.
for (int i = 0; i < N_EXCEPTS; ++i) { for (int i = 0; i < N_EXCEPTS; ++i) {
if (unlikely(x_abs == EXCEPT_INPUTS[i])) { if (unlikely(x_abs == EXCEPT_INPUTS[i])) {
uint32_t s = EXCEPT_OUTPUTS_SIN[i][0]; // FE_TOWARDZERO uint32_t s = EXCEPT_OUTPUTS_SIN[i][0]; // FE_TOWARDZERO
uint32_t c = EXCEPT_OUTPUTS_COS[i][0]; // FE_TOWARDZERO uint32_t c = EXCEPT_OUTPUTS_COS[i][0]; // FE_TOWARDZERO
bool x_sign = x < 0; bool x_sign = x < 0;
switch (fputil::get_round()) { switch (fputil::get_round()) {
case FE_UPWARD: case FE_UPWARD:
s += x_sign ? EXCEPT_OUTPUTS_SIN[i][2] : EXCEPT_OUTPUTS_SIN[i][1]; s += x_sign ? EXCEPT_OUTPUTS_SIN[i][2] : EXCEPT_OUTPUTS_SIN[i][1];
c += EXCEPT_OUTPUTS_COS[i][1]; c += EXCEPT_OUTPUTS_COS[i][1];
break; break;
case FE_DOWNWARD: case FE_DOWNWARD:
s += x_sign ? EXCEPT_OUTPUTS_SIN[i][1] : EXCEPT_OUTPUTS_SIN[i][2]; s += x_sign ? EXCEPT_OUTPUTS_SIN[i][1] : EXCEPT_OUTPUTS_SIN[i][2];
c += EXCEPT_OUTPUTS_COS[i][2]; c += EXCEPT_OUTPUTS_COS[i][2];
break; break;
case FE_TONEAREST: case FE_TONEAREST:
s += EXCEPT_OUTPUTS_SIN[i][3]; s += EXCEPT_OUTPUTS_SIN[i][3];
c += EXCEPT_OUTPUTS_COS[i][3]; c += EXCEPT_OUTPUTS_COS[i][3];
break; break;
} }
*sinp = x_sign ? -FPBits(s).get_val() : FPBits(s).get_val(); *sinp = x_sign ? -FPB(s).get_val() : FPB(s).get_val();
*cosp = FPBits(c).get_val(); *cosp = FPB(c).get_val();
return; return;
} }
} }
// Combine the results with the sine and cosine of sum formulas: // Combine the results with the sine and cosine of sum formulas:
// sin(x) = sin((k + y)*pi/32) // sin(x) = sin((k + y)*pi/32)
// = sin(y*pi/32) * cos(k*pi/32) + cos(y*pi/32) * sin(k*pi/32) // = sin(y*pi/32) * cos(k*pi/32) + cos(y*pi/32) * sin(k*pi/32)
Show All 17 Lines

libc/src/math/generic/sinf.cpp

Show All 21 Lines
#include "range_reduction_fma.h" #include "range_reduction_fma.h"
#else #else
#include "range_reduction.h" #include "range_reduction.h"
#endif #endif
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, sinf, (float x)) { LLVM_LIBC_FUNCTION(float, sinf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
uint32_t x_u = xbits.uintval(); uint32_t x_u = xbits.uintval();
uint32_t x_abs = x_u & 0x7fff'ffffU; uint32_t x_abs = x_u & 0x7fff'ffffU;
double xd = static_cast<double>(x); double xd = static_cast<double>(x);
// Range reduction: // Range reduction:
// For |x| > pi/32, we perform range reduction as follows: // For |x| > pi/32, we perform range reduction as follows:
// Find k and y such that: // Find k and y such that:
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines if (unlikely(x_abs == 0x4619'9998U)) { // x = 0x1.33333p13
return xbits.get_sign() ? -r : r; return xbits.get_sign() ? -r : r;
} }
if (unlikely(x_abs >= 0x7f80'0000U)) { if (unlikely(x_abs >= 0x7f80'0000U)) {
if (x_abs == 0x7f80'0000U) { if (x_abs == 0x7f80'0000U) {
errno = EDOM; errno = EDOM;
fputil::set_except(FE_INVALID); fputil::set_except(FE_INVALID);
} }
return x + return x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
// Combine the results with the sine of sum formula: // Combine the results with the sine of sum formula:
// sin(x) = sin((k + y)*pi/32) // sin(x) = sin((k + y)*pi/32)
// = sin(y*pi/32) * cos(k*pi/32) + cos(y*pi/32) * sin(k*pi/32) // = sin(y*pi/32) * cos(k*pi/32) + cos(y*pi/32) * sin(k*pi/32)
// = sin_y * cos_k + (1 + cosm1_y) * sin_k // = sin_y * cos_k + (1 + cosm1_y) * sin_k
// = sin_y * cos_k + (cosm1_y * sin_k + sin_k) // = sin_y * cos_k + (cosm1_y * sin_k + sin_k)
double sin_k, cos_k, sin_y, cosm1_y; double sin_k, cos_k, sin_y, cosm1_y;
sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y); sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y);
return fputil::multiply_add(sin_y, cos_k, return fputil::multiply_add(sin_y, cos_k,
fputil::multiply_add(cosm1_y, sin_k, sin_k)); fputil::multiply_add(cosm1_y, sin_k, sin_k));
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/sinhf.cpp

//===-- Single-precision sinh function ------------------------------------===// //===-- Single-precision sinh function ------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sinhf.h" #include "src/math/sinhf.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/generic/explogxf.h" #include "src/math/generic/explogxf.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, sinhf, (float x)) { LLVM_LIBC_FUNCTION(float, sinhf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
bool sign = xbits.get_sign(); bool sign = xbits.get_sign();
uint32_t x_abs = xbits.uintval() & FPBits::FloatProp::EXP_MANT_MASK; uint32_t x_abs = xbits.uintval() & FPB::FloatProp::EXP_MANT_MASK;
// |x| <= 2^-26 // |x| <= 2^-26
if (unlikely(x_abs <= 0x3280'0000U)) { if (unlikely(x_abs <= 0x3280'0000U)) {
return unlikely(x_abs == 0) ? x : (x + 0.25 * x * x * x); return unlikely(x_abs == 0) ? x : (x + 0.25 * x * x * x);
} }
// When |x| >= 90, or x is inf or nan // When |x| >= 90, or x is inf or nan
if (unlikely(x_abs >= 0x42b4'0000U)) { if (unlikely(x_abs >= 0x42b4'0000U)) {
if (xbits.is_nan()) if (xbits.is_nan())
return x + 1.0f; // sNaN to qNaN + signal return x + 1.0f; // sNaN to qNaN + signal
if (xbits.is_inf()) if (xbits.is_inf())
return x; return x;
int rounding = fputil::get_round(); int rounding = fputil::get_round();
if (sign) { if (sign) {
if (unlikely(rounding == FE_UPWARD || rounding == FE_TOWARDZERO)) if (unlikely(rounding == FE_UPWARD || rounding == FE_TOWARDZERO))
return FPBits(FPBits::MAX_NORMAL | FPBits::FloatProp::SIGN_MASK) return FPB(FPB::MAX_NORMAL | FPB::FloatProp::SIGN_MASK).get_val();
.get_val();
} else { } else {
if (unlikely(rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)) if (unlikely(rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO))
return FPBits(FPBits::MAX_NORMAL).get_val(); return FPB(FPB::MAX_NORMAL).get_val();
} }
errno = ERANGE; errno = ERANGE;
return x + FPBits::inf(sign).get_val(); return x + FPB::inf(sign).get_val();
} }
// |x| <= 0.078125 // |x| <= 0.078125
if (unlikely(x_abs <= 0x3da0'0000U)) { if (unlikely(x_abs <= 0x3da0'0000U)) {
// |x| = 0.0005589424981735646724700927734375 // |x| = 0.0005589424981735646724700927734375
if (unlikely(x_abs == 0x3a12'85ffU)) { if (unlikely(x_abs == 0x3a12'85ffU)) {
if (fputil::get_round() == FE_TONEAREST) if (fputil::get_round() == FE_TONEAREST)
return x; return x;
Show All 19 Lines

libc/src/math/generic/tanf.cpp

Show All 35 Linesconstexpr fputil::ExceptValues<float, N_EXCEPTS> TANF_EXCEPTS{{
{0x5980445e, 0x3fe50f68, 1, 0, 0}, {0x5980445e, 0x3fe50f68, 1, 0, 0},
// x = 0x1.f90dfcp72, tan(x) = 0x1.597f9cp-1 (RZ) // x = 0x1.f90dfcp72, tan(x) = 0x1.597f9cp-1 (RZ)
{0x63fc86fe, 0x3f2cbfce, 1, 0, 0}, {0x63fc86fe, 0x3f2cbfce, 1, 0, 0},
// x = 0x1.a6ce12p86, tan(x) = -0x1.c5612ep-1 (RZ) // x = 0x1.a6ce12p86, tan(x) = -0x1.c5612ep-1 (RZ)
{0x6ad36709, 0xbf62b097, 0, 1, 0}, {0x6ad36709, 0xbf62b097, 0, 1, 0},
}}; }};
LLVM_LIBC_FUNCTION(float, tanf, (float x)) { LLVM_LIBC_FUNCTION(float, tanf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
bool x_sign = xbits.uintval() >> 31; bool x_sign = xbits.uintval() >> 31;
uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU; uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU;
// |x| < pi/32 // |x| < pi/32
if (unlikely(x_abs <= 0x3dc9'0fdbU)) { if (unlikely(x_abs <= 0x3dc9'0fdbU)) {
double xd = static_cast<double>(x); double xd = static_cast<double>(x);
// |x| < 0x1.0p-12f // |x| < 0x1.0p-12f
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines#endif // LIBC_TARGET_HAS_FMA
// |x| > 0x1.ada6a8p+27f // |x| > 0x1.ada6a8p+27f
if (unlikely(x_abs > 0x4d56'd354U)) { if (unlikely(x_abs > 0x4d56'd354U)) {
// Inf or NaN // Inf or NaN
if (unlikely(x_abs >= 0x7f80'0000U)) { if (unlikely(x_abs >= 0x7f80'0000U)) {
if (x_abs == 0x7f80'0000U) { if (x_abs == 0x7f80'0000U) {
errno = EDOM; errno = EDOM;
fputil::set_except(FE_INVALID); fputil::set_except(FE_INVALID);
} }
return x + return x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
// Other large exceptional values // Other large exceptional values
if (auto r = TANF_EXCEPTS.lookup_odd(x_abs, x_sign); if (auto r = TANF_EXCEPTS.lookup_odd(x_abs, x_sign);
unlikely(r.has_value())) unlikely(r.has_value()))
return r.value(); return r.value();
} }
// For |x| >= pi/32, we use the definition of tan(x) function: // For |x| >= pi/32, we use the definition of tan(x) function:
Show All 16 Lines

libc/src/math/generic/tanhf.cpp

//===-- Single-precision tanh function ------------------------------------===// //===-- Single-precision tanh function ------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/tanhf.h" #include "src/math/tanhf.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/__support/cpu_features.h" #include "src/__support/cpu_features.h"
#include "src/math/generic/explogxf.h" #include "src/math/generic/explogxf.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, tanhf, (float x)) { LLVM_LIBC_FUNCTION(float, tanhf, (float x)) {
using FPBits = typename fputil::FPBits<float>; using FPB = typename fputil::FPBits<float>;
FPBits xbits(x); FPB xbits(x);
bool sign = xbits.get_sign(); bool sign = xbits.get_sign();
uint32_t x_abs = xbits.uintval() & FPBits::FloatProp::EXP_MANT_MASK; uint32_t x_abs = xbits.uintval() & FPB::FloatProp::EXP_MANT_MASK;
// |x| <= 2^-26 // |x| <= 2^-26
if (unlikely(x_abs <= 0x3280'0000U)) { if (unlikely(x_abs <= 0x3280'0000U)) {
return unlikely(x_abs == 0) ? x : (x - 0x1.5555555555555p-2 * x * x * x); return unlikely(x_abs == 0) ? x : (x - 0x1.5555555555555p-2 * x * x * x);
} }
// When |x| >= 15, or x is inf or nan // When |x| >= 15, or x is inf or nan
if (unlikely(x_abs >= 0x4170'0000U)) { if (unlikely(x_abs >= 0x4170'0000U)) {
if (xbits.is_nan()) if (xbits.is_nan())
return x + 1.0f; // sNaN to qNaN + signal return x + 1.0f; // sNaN to qNaN + signal
if (xbits.is_inf()) if (xbits.is_inf())
return sign ? -1.0f : 1.0f; return sign ? -1.0f : 1.0f;
if (sign) { if (sign) {
return -1.0f + opt_barrier(FPBits(FPBits::MIN_NORMAL).get_val()); return -1.0f + opt_barrier(FPB(FPB::MIN_NORMAL).get_val());
} else } else
return 1.0f - opt_barrier(FPBits(FPBits::MIN_NORMAL).get_val()); return 1.0f - opt_barrier(FPB(FPB::MIN_NORMAL).get_val());
} }
// |x| <= 0.078125 // |x| <= 0.078125
if (unlikely(x_abs <= 0x3da0'0000U)) { if (unlikely(x_abs <= 0x3da0'0000U)) {
double xdbl = x; double xdbl = x;
double x2 = xdbl * xdbl; double x2 = xdbl * xdbl;
// Pure Taylor series. // Pure Taylor series.
double pe = fputil::polyeval(x2, 0.0, -0x1.5555555555555p-2, double pe = fputil::polyeval(x2, 0.0, -0x1.5555555555555p-2,
0x1.1111111111111p-3, -0x1.ba1ba1ba1ba1cp-5, 0x1.1111111111111p-3, -0x1.ba1ba1ba1ba1cp-5,
0x1.664f4882c10fap-6, -0x1.226e355e6c23dp-7); 0x1.664f4882c10fap-6, -0x1.226e355e6c23dp-7);
return fputil::multiply_add(xdbl, pe, xdbl); return fputil::multiply_add(xdbl, pe, xdbl);
} }
if (unlikely(xbits.bits == 0x4058'e0a3U)) { if (unlikely(xbits.bits == 0x4058'e0a3U)) {
if (fputil::get_round() == FE_DOWNWARD) if (fputil::get_round() == FE_DOWNWARD)
return FPBits(0x3f7f'6ad9U).get_val(); return FPB(0x3f7f'6ad9U).get_val();
} }
// Range reduction: e^(2x) = 2^(mid + hi) * e^lo // Range reduction: e^(2x) = 2^(mid + hi) * e^lo
auto ep = exp_b_range_reduc<ExpBase>(2.0f * x); // exp(2 * x) auto ep = exp_b_range_reduc<ExpBase>(2.0f * x); // exp(2 * x)
double r = ExpBase::powb_lo(ep.lo); double r = ExpBase::powb_lo(ep.lo);
// tanh(x) = (exp(2x) - 1) / (exp(2x) + 1) // tanh(x) = (exp(2x) - 1) / (exp(2x) + 1)
#if defined(LIBC_TARGET_HAS_FMA) #if defined(LIBC_TARGET_HAS_FMA)
return fputil::multiply_add(ep.mh, r, -1.0) / return fputil::multiply_add(ep.mh, r, -1.0) /
fputil::multiply_add(ep.mh, r, 1.0); fputil::multiply_add(ep.mh, r, 1.0);
#else #else
double exp_x = ep.mh * r; double exp_x = ep.mh * r;
return (exp_x - 1.0) / (exp_x + 1.0); return (exp_x - 1.0) / (exp_x + 1.0);
#endif // LIBC_TARGET_HAS_FMA #endif // LIBC_TARGET_HAS_FMA
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/test/src/math/CeilTest.h

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines void testFractions(CeilFunc func) {
EXPECT_FP_EQ(T(1235.0), func(T(1234.96))); EXPECT_FP_EQ(T(1235.0), func(T(1234.96)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96))); EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96)));
} }
void testRange(CeilFunc func) { void testRange(CeilFunc func) {
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, func(x), 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, func(x), 0.0);
} }
} }
}; };
#define LIST_CEIL_TESTS(T, func) \ #define LIST_CEIL_TESTS(T, func) \
using LlvmLibcCeilTest = CeilTest<T>; \ using LlvmLibcCeilTest = CeilTest<T>; \
TEST_F(LlvmLibcCeilTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcCeilTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcCeilTest, RoundedNubmers) { testRoundedNumbers(&func); } \ TEST_F(LlvmLibcCeilTest, RoundedNubmers) { testRoundedNumbers(&func); } \
TEST_F(LlvmLibcCeilTest, Fractions) { testFractions(&func); } \ TEST_F(LlvmLibcCeilTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcCeilTest, Range) { testRange(&func); } TEST_F(LlvmLibcCeilTest, Range) { testRange(&func); }

libc/test/src/math/CopySignTest.h

Show All 30 Lines void testSpecialNumbers(CopySignFunc func) {
EXPECT_FP_EQ(neg_zero, func(zero, -1.0)); EXPECT_FP_EQ(neg_zero, func(zero, -1.0));
EXPECT_FP_EQ(zero, func(neg_zero, 1.0)); EXPECT_FP_EQ(zero, func(neg_zero, 1.0));
} }
void testRange(CopySignFunc func) { void testRange(CopySignFunc func) {
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
double res1 = func(x, -x); double res1 = func(x, -x);
ASSERT_FP_EQ(res1, -x); ASSERT_FP_EQ(res1, -x);
double res2 = func(x, x); double res2 = func(x, x);
ASSERT_FP_EQ(res2, x); ASSERT_FP_EQ(res2, x);
} }
} }
}; };
#define LIST_COPYSIGN_TESTS(T, func) \ #define LIST_COPYSIGN_TESTS(T, func) \
using LlvmLibcCopySignTest = CopySignTest<T>; \ using LlvmLibcCopySignTest = CopySignTest<T>; \
TEST_F(LlvmLibcCopySignTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcCopySignTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcCopySignTest, Range) { testRange(&func); } TEST_F(LlvmLibcCopySignTest, Range) { testRange(&func); }

libc/test/src/math/FAbsTest.h

Show All 29 Lines void testSpecialNumbers(FabsFunc func) {
EXPECT_FP_EQ(zero, func(zero)); EXPECT_FP_EQ(zero, func(zero));
EXPECT_FP_EQ(zero, func(neg_zero)); EXPECT_FP_EQ(zero, func(neg_zero));
} }
void testRange(FabsFunc func) { void testRange(FabsFunc func) {
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, func(x), 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, func(x), 0.0);
} }
} }
}; };
#define LIST_FABS_TESTS(T, func) \ #define LIST_FABS_TESTS(T, func) \
using LlvmLibcFAbsTest = FAbsTest<T>; \ using LlvmLibcFAbsTest = FAbsTest<T>; \
TEST_F(LlvmLibcFAbsTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcFAbsTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcFAbsTest, Range) { testRange(&func); } TEST_F(LlvmLibcFAbsTest, Range) { testRange(&func); }

libc/test/src/math/FDimTest.h

Show All 10 Lines
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
template <typename T> template <typename T>
class FDimTestTemplate : public __llvm_libc::testing::Test { class FDimTestTemplate : public __llvm_libc::testing::Test {
public: public:
using FuncPtr = T (*)(T, T); using FuncPtr = T (*)(T, T);
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPB = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
void test_na_n_arg(FuncPtr func) { void test_na_n_arg(FuncPtr func) {
EXPECT_FP_EQ(nan, func(nan, inf)); EXPECT_FP_EQ(nan, func(nan, inf));
EXPECT_FP_EQ(nan, func(neg_inf, nan)); EXPECT_FP_EQ(nan, func(neg_inf, nan));
EXPECT_FP_EQ(nan, func(nan, zero)); EXPECT_FP_EQ(nan, func(nan, zero));
EXPECT_FP_EQ(nan, func(neg_zero, nan)); EXPECT_FP_EQ(nan, func(neg_zero, nan));
EXPECT_FP_EQ(nan, func(nan, T(-1.2345))); EXPECT_FP_EQ(nan, func(nan, T(-1.2345)));
EXPECT_FP_EQ(nan, func(T(1.2345), nan)); EXPECT_FP_EQ(nan, func(T(1.2345), nan));
Show All 23 Lines void test_both_zero(FuncPtr func) {
EXPECT_FP_EQ(zero, func(neg_zero, neg_zero)); EXPECT_FP_EQ(zero, func(neg_zero, neg_zero));
} }
void test_in_range(FuncPtr func) { void test_in_range(FuncPtr func) {
constexpr UIntType COUNT = 10000001; constexpr UIntType COUNT = 10000001;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
++i, v += STEP, w -= STEP) { ++i, v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w)); T x = T(FPB(v)), y = T(FPB(w));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if (x > y) { if (x > y) {
EXPECT_FP_EQ(x - y, func(x, y)); EXPECT_FP_EQ(x - y, func(x, y));
} else { } else {
EXPECT_FP_EQ(zero, func(x, y)); EXPECT_FP_EQ(zero, func(x, y));
} }
} }
} }
private: private:
// constexpr does not work on FPBits yet, so we cannot have these constants as // constexpr does not work on FPB yet, so we cannot have these constants as
// static. // static.
const T nan = T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1)); const T nan = T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1));
const T inf = T(__llvm_libc::fputil::FPBits<T>::inf()); const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf()); const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
const T zero = T(__llvm_libc::fputil::FPBits<T>::zero()); const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero()); const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
}; };

libc/test/src/math/FMaxTest.h

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines void testBothZero(FMaxFunc func) {
EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
} }
void testRange(FMaxFunc func) { void testRange(FMaxFunc func) {
constexpr UIntType COUNT = 10000001; constexpr UIntType COUNT = 10000001;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
++i, v += STEP, w -= STEP) { ++i, v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w)); T x = T(FPB(v)), y = T(FPB(w));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if ((x == 0) && (y == 0)) if ((x == 0) && (y == 0))
continue; continue;
if (x > y) { if (x > y) {
Show All 15 Lines

libc/test/src/math/FMinTest.h

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines void testBothZero(FMinFunc func) {
EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
} }
void testRange(FMinFunc func) { void testRange(FMinFunc func) {
constexpr UIntType COUNT = 10000001; constexpr UIntType COUNT = 10000001;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
++i, v += STEP, w -= STEP) { ++i, v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w)); T x = T(FPB(v)), y = T(FPB(w));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if ((x == 0) && (y == 0)) if ((x == 0) && (y == 0))
continue; continue;
if (x > y) { if (x > y) {
Show All 15 Lines

libc/test/src/math/FloorTest.h

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines void testFractions(FloorFunc func) {
EXPECT_FP_EQ(T(1234.0), func(T(1234.96))); EXPECT_FP_EQ(T(1234.0), func(T(1234.96)));
EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96))); EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96)));
} }
void testRange(FloorFunc func) { void testRange(FloorFunc func) {
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, func(x), 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, func(x), 0.0);
} }
} }
}; };
#define LIST_FLOOR_TESTS(T, func) \ #define LIST_FLOOR_TESTS(T, func) \
using LlvmLibcFloorTest = FloorTest<T>; \ using LlvmLibcFloorTest = FloorTest<T>; \
TEST_F(LlvmLibcFloorTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcFloorTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcFloorTest, RoundedNubmers) { testRoundedNumbers(&func); } \ TEST_F(LlvmLibcFloorTest, RoundedNubmers) { testRoundedNumbers(&func); } \
TEST_F(LlvmLibcFloorTest, Fractions) { testFractions(&func); } \ TEST_F(LlvmLibcFloorTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcFloorTest, Range) { testRange(&func); } TEST_F(LlvmLibcFloorTest, Range) { testRange(&func); }

libc/test/src/math/FmaTest.h

Show All 15 Lines
#include "utils/testutils/RandUtils.h" #include "utils/testutils/RandUtils.h"
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> template <typename T>
class FmaTestTemplate : public __llvm_libc::testing::Test { class FmaTestTemplate : public __llvm_libc::testing::Test {
private: private:
using Func = T (*)(T, T, T); using Func = T (*)(T, T, T);
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPB = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
const T nan = T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1)); const T nan = T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1));
const T inf = T(__llvm_libc::fputil::FPBits<T>::inf()); const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf()); const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
const T zero = T(__llvm_libc::fputil::FPBits<T>::zero()); const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero()); const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
UIntType get_random_bit_pattern() { UIntType get_random_bit_pattern() {
UIntType bits{0}; UIntType bits{0};
Show All 11 Lines void test_special_numbers(Func func) {
EXPECT_FP_EQ(func(inf, inf, zero), inf); EXPECT_FP_EQ(func(inf, inf, zero), inf);
EXPECT_FP_EQ(func(neg_inf, inf, neg_inf), neg_inf); EXPECT_FP_EQ(func(neg_inf, inf, neg_inf), neg_inf);
EXPECT_FP_EQ(func(inf, zero, zero), nan); EXPECT_FP_EQ(func(inf, zero, zero), nan);
EXPECT_FP_EQ(func(inf, neg_inf, inf), nan); EXPECT_FP_EQ(func(inf, neg_inf, inf), nan);
EXPECT_FP_EQ(func(nan, zero, inf), nan); EXPECT_FP_EQ(func(nan, zero, inf), nan);
EXPECT_FP_EQ(func(inf, neg_inf, nan), nan); EXPECT_FP_EQ(func(inf, neg_inf, nan), nan);
// Test underflow rounding up. // Test underflow rounding up.
EXPECT_FP_EQ(func(T(0.5), T(FPBits(FPBits::MIN_SUBNORMAL)), EXPECT_FP_EQ(
T(FPBits(FPBits::MIN_SUBNORMAL))), func(T(0.5), T(FPB(FPB::MIN_SUBNORMAL)), T(FPB(FPB::MIN_SUBNORMAL))),
T(FPBits(UIntType(2)))); T(FPB(UIntType(2))));
// Test underflow rounding down. // Test underflow rounding down.
T v = T(FPBits(FPBits::MIN_NORMAL + UIntType(1))); T v = T(FPB(FPB::MIN_NORMAL + UIntType(1)));
EXPECT_FP_EQ(func(T(1) / T(FPBits::MIN_NORMAL << 1), v, EXPECT_FP_EQ(
T(FPBits(FPBits::MIN_NORMAL))), func(T(1) / T(FPB::MIN_NORMAL << 1), v, T(FPB(FPB::MIN_NORMAL))), v);
v);
// Test overflow. // Test overflow.
T z = T(FPBits(FPBits::MAX_NORMAL)); T z = T(FPB(FPB::MAX_NORMAL));
EXPECT_FP_EQ(func(T(1.75), z, -z), T(0.75) * z); EXPECT_FP_EQ(func(T(1.75), z, -z), T(0.75) * z);
// Exact cancellation. // Exact cancellation.
EXPECT_FP_EQ(func(T(3.0), T(5.0), -T(15.0)), T(0.0)); EXPECT_FP_EQ(func(T(3.0), T(5.0), -T(15.0)), T(0.0));
EXPECT_FP_EQ(func(T(-3.0), T(5.0), T(15.0)), T(0.0)); EXPECT_FP_EQ(func(T(-3.0), T(5.0), T(15.0)), T(0.0));
} }
void test_subnormal_range(Func func) { void test_subnormal_range(Func func) {
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType STEP = constexpr UIntType STEP = (FPB::MAX_SUBNORMAL - FPB::MIN_SUBNORMAL) / COUNT;
(FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT; for (UIntType v = FPB::MIN_SUBNORMAL, w = FPB::MAX_SUBNORMAL;
for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL; v <= FPB::MAX_SUBNORMAL && w >= FPB::MIN_SUBNORMAL;
v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL;
v += STEP, w -= STEP) { v += STEP, w -= STEP) {
T x = T(FPBits(get_random_bit_pattern())), y = T(FPBits(v)), T x = T(FPB(get_random_bit_pattern())), y = T(FPB(v)), z = T(FPB(w));
z = T(FPBits(w));
mpfr::TernaryInput<T> input{x, y, z}; mpfr::TernaryInput<T> input{x, y, z};
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Fma, input, func(x, y, z), ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Fma, input, func(x, y, z),
0.5); 0.5);
} }
} }
void test_normal_range(Func func) { void test_normal_range(Func func) {
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT; constexpr UIntType STEP = (FPB::MAX_NORMAL - FPB::MIN_NORMAL) / COUNT;
for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL; for (UIntType v = FPB::MIN_NORMAL, w = FPB::MAX_NORMAL;
v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL; v <= FPB::MAX_NORMAL && w >= FPB::MIN_NORMAL; v += STEP, w -= STEP) {
v += STEP, w -= STEP) { T x = T(FPB(v)), y = T(FPB(w)), z = T(FPB(get_random_bit_pattern()));
T x = T(FPBits(v)), y = T(FPBits(w)),
z = T(FPBits(get_random_bit_pattern()));
mpfr::TernaryInput<T> input{x, y, z}; mpfr::TernaryInput<T> input{x, y, z};
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Fma, input, func(x, y, z), ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Fma, input, func(x, y, z),
0.5); 0.5);
} }
} }
}; };
#endif // LLVM_LIBC_TEST_SRC_MATH_FMATEST_H #endif // LLVM_LIBC_TEST_SRC_MATH_FMATEST_H

libc/test/src/math/FrexpTest.h

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines void testSomeIntegers(FrexpFunc func) {
EXPECT_FP_EQ(T(0.78125), func(T(800.0), &exponent)); EXPECT_FP_EQ(T(0.78125), func(T(800.0), &exponent));
EXPECT_EQ(exponent, 10); EXPECT_EQ(exponent, 10);
EXPECT_FP_EQ(T(-0.78125), func(T(-800.0), &exponent)); EXPECT_FP_EQ(T(-0.78125), func(T(-800.0), &exponent));
EXPECT_EQ(exponent, 10); EXPECT_EQ(exponent, 10);
} }
void testRange(FrexpFunc func) { void testRange(FrexpFunc func) {
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = static_cast<T>(FPBits(v)); T x = static_cast<T>(FPB(v));
if (isnan(x) || isinf(x) || x == 0.0l) if (isnan(x) || isinf(x) || x == 0.0l)
continue; continue;
mpfr::BinaryOutput<T> result; mpfr::BinaryOutput<T> result;
result.f = func(x, &result.i); result.f = func(x, &result.i);
ASSERT_TRUE(__llvm_libc::fputil::abs(result.f) < 1.0); ASSERT_TRUE(__llvm_libc::fputil::abs(result.f) < 1.0);
ASSERT_TRUE(__llvm_libc::fputil::abs(result.f) >= 0.5); ASSERT_TRUE(__llvm_libc::fputil::abs(result.f) >= 0.5);
Show All 11 Lines

libc/test/src/math/HypotTest.h

Show All 16 Lines
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> template <typename T>
class HypotTestTemplate : public __llvm_libc::testing::Test { class HypotTestTemplate : public __llvm_libc::testing::Test {
private: private:
using Func = T (*)(T, T); using Func = T (*)(T, T);
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPB = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
const T nan = T(FPBits::build_quiet_nan(1)); const T nan = T(FPB::build_quiet_nan(1));
const T inf = T(FPBits::inf()); const T inf = T(FPB::inf());
const T neg_inf = T(FPBits::neg_inf()); const T neg_inf = T(FPB::neg_inf());
const T zero = T(FPBits::zero()); const T zero = T(FPB::zero());
const T neg_zero = T(FPBits::neg_zero()); const T neg_zero = T(FPB::neg_zero());
const T max_normal = T(FPBits(FPBits::MAX_NORMAL)); const T max_normal = T(FPB(FPB::MAX_NORMAL));
const T min_normal = T(FPBits(FPBits::MIN_NORMAL)); const T min_normal = T(FPB(FPB::MIN_NORMAL));
const T max_subnormal = T(FPBits(FPBits::MAX_SUBNORMAL)); const T max_subnormal = T(FPB(FPB::MAX_SUBNORMAL));
const T min_subnormal = T(FPBits(FPBits::MIN_SUBNORMAL)); const T min_subnormal = T(FPB(FPB::MIN_SUBNORMAL));
public: public:
void test_special_numbers(Func func) { void test_special_numbers(Func func) {
constexpr int N = 13; constexpr int N = 13;
const T SpecialInputs[N] = {inf, neg_inf, zero, const T SpecialInputs[N] = {inf, neg_inf, zero,
neg_zero, max_normal, min_normal, neg_zero, max_normal, min_normal,
max_subnormal, min_subnormal, -max_normal, max_subnormal, min_subnormal, -max_normal,
-min_normal, -max_subnormal, -min_subnormal}; -min_normal, -max_subnormal, -min_subnormal};
Show All 12 Lines for (int i = 0; i < N; ++i) {
0.5); 0.5);
} }
} }
} }
void test_subnormal_range(Func func) { void test_subnormal_range(Func func) {
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
for (unsigned scale = 0; scale < 4; ++scale) { for (unsigned scale = 0; scale < 4; ++scale) {
UIntType max_value = FPBits::MAX_SUBNORMAL << scale; UIntType max_value = FPB::MAX_SUBNORMAL << scale;
UIntType step = (max_value - FPBits::MIN_SUBNORMAL) / COUNT; UIntType step = (max_value - FPB::MIN_SUBNORMAL) / COUNT;
for (int signs = 0; signs < 4; ++signs) { for (int signs = 0; signs < 4; ++signs) {
for (UIntType v = FPBits::MIN_SUBNORMAL, w = max_value; for (UIntType v = FPB::MIN_SUBNORMAL, w = max_value;
v <= max_value && w >= FPBits::MIN_SUBNORMAL; v <= max_value && w >= FPB::MIN_SUBNORMAL; v += step, w -= step) {
v += step, w -= step) { T x = T(FPB(v)), y = T(FPB(w));
T x = T(FPBits(v)), y = T(FPBits(w));
if (signs % 2 == 1) { if (signs % 2 == 1) {
x = -x; x = -x;
} }
if (signs >= 2) { if (signs >= 2) {
y = -y; y = -y;
} }
mpfr::BinaryInput<T> input{x, y}; mpfr::BinaryInput<T> input{x, y};
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Hypot, input, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Hypot, input,
func(x, y), 0.5); func(x, y), 0.5);
} }
} }
} }
} }
void test_normal_range(Func func) { void test_normal_range(Func func) {
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT; constexpr UIntType STEP = (FPB::MAX_NORMAL - FPB::MIN_NORMAL) / COUNT;
for (int signs = 0; signs < 4; ++signs) { for (int signs = 0; signs < 4; ++signs) {
for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL; for (UIntType v = FPB::MIN_NORMAL, w = FPB::MAX_NORMAL;
v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL; v <= FPB::MAX_NORMAL && w >= FPB::MIN_NORMAL; v += STEP, w -= STEP) {
v += STEP, w -= STEP) { T x = T(FPB(v)), y = T(FPB(w));
T x = T(FPBits(v)), y = T(FPBits(w));
if (signs % 2 == 1) { if (signs % 2 == 1) {
x = -x; x = -x;
} }
if (signs >= 2) { if (signs >= 2) {
y = -y; y = -y;
} }
mpfr::BinaryInput<T> input{x, y}; mpfr::BinaryInput<T> input{x, y};
Show All 15 Lines

libc/test/src/math/ILogbTest.h

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines void test_some_integers(typename ILogbFunc<T>::Func func) {
EXPECT_EQ(4, func(-31.0)); EXPECT_EQ(4, func(-31.0));
EXPECT_EQ(5, func(55.0)); EXPECT_EQ(5, func(55.0));
EXPECT_EQ(5, func(-55.0)); EXPECT_EQ(5, func(-55.0));
} }
template <typename T> template <typename T>
void test_subnormal_range(typename ILogbFunc<T>::Func func) { void test_subnormal_range(typename ILogbFunc<T>::Func func) {
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPB = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType STEP = constexpr UIntType STEP = (FPB::MAX_SUBNORMAL - FPB::MIN_SUBNORMAL) / COUNT;
(FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT; for (UIntType v = FPB::MIN_SUBNORMAL; v <= FPB::MAX_SUBNORMAL; v += STEP) {
for (UIntType v = FPBits::MIN_SUBNORMAL; v <= FPBits::MAX_SUBNORMAL; T x = T(FPB(v));
v += STEP) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x) || x == 0.0) if (isnan(x) || isinf(x) || x == 0.0)
continue; continue;
int exponent; int exponent;
__llvm_libc::fputil::frexp(x, exponent); __llvm_libc::fputil::frexp(x, exponent);
ASSERT_EQ(exponent, func(x) + 1); ASSERT_EQ(exponent, func(x) + 1);
} }
} }
template <typename T> template <typename T>
void test_normal_range(typename ILogbFunc<T>::Func func) { void test_normal_range(typename ILogbFunc<T>::Func func) {
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPB = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT; constexpr UIntType STEP = (FPB::MAX_NORMAL - FPB::MIN_NORMAL) / COUNT;
for (UIntType v = FPBits::MIN_NORMAL; v <= FPBits::MAX_NORMAL; v += STEP) { for (UIntType v = FPB::MIN_NORMAL; v <= FPB::MAX_NORMAL; v += STEP) {
T x = T(FPBits(v)); T x = T(FPB(v));
if (isnan(x) || isinf(x) || x == 0.0) if (isnan(x) || isinf(x) || x == 0.0)
continue; continue;
int exponent; int exponent;
__llvm_libc::fputil::frexp(x, exponent); __llvm_libc::fputil::frexp(x, exponent);
ASSERT_EQ(exponent, func(x) + 1); ASSERT_EQ(exponent, func(x) + 1);
} }
} }
}; };
#endif // LLVM_LIBC_TEST_SRC_MATH_ILOGBTEST_H #endif // LLVM_LIBC_TEST_SRC_MATH_ILOGBTEST_H

libc/test/src/math/LdExpTest.h

Show All 14 Lines
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <limits.h> #include <limits.h>
#include <math.h> #include <math.h>
#include <stdint.h> #include <stdint.h>
template <typename T> template <typename T>
class LdExpTestTemplate : public __llvm_libc::testing::Test { class LdExpTestTemplate : public __llvm_libc::testing::Test {
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPB = __llvm_libc::fputil::FPBits<T>;
using NormalFloat = __llvm_libc::fputil::NormalFloat<T>; using NormalFloat = __llvm_libc::fputil::NormalFloat<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
static constexpr UIntType MANTISSA_WIDTH = static constexpr UIntType MANTISSA_WIDTH =
__llvm_libc::fputil::MantissaWidth<T>::VALUE; __llvm_libc::fputil::MantissaWidth<T>::VALUE;
// A normalized mantissa to be used with tests. // A normalized mantissa to be used with tests.
static constexpr UIntType MANTISSA = NormalFloat::ONE + 0x1234; static constexpr UIntType MANTISSA = NormalFloat::ONE + 0x1234;
const T zero = T(__llvm_libc::fputil::FPBits<T>::zero()); const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero()); const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
const T inf = T(__llvm_libc::fputil::FPBits<T>::inf()); const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
Show All 21 Lines for (int32_t exp : exp_array) {
for (int32_t val : val_array) { for (int32_t val : val_array) {
ASSERT_FP_EQ(T(val << exp), func(T(val), exp)); ASSERT_FP_EQ(T(val << exp), func(T(val), exp));
ASSERT_FP_EQ(T(-1 * (val << exp)), func(T(-val), exp)); ASSERT_FP_EQ(T(-1 * (val << exp)), func(T(-val), exp));
} }
} }
} }
void testOverflow(LdExpFunc func) { void testOverflow(LdExpFunc func) {
NormalFloat x(FPBits::MAX_EXPONENT - 10, NormalFloat::ONE + 0xF00BA, 0); NormalFloat x(FPB::MAX_EXPONENT - 10, NormalFloat::ONE + 0xF00BA, 0);
for (int32_t exp = 10; exp < 100; ++exp) { for (int32_t exp = 10; exp < 100; ++exp) {
ASSERT_FP_EQ(inf, func(T(x), exp)); ASSERT_FP_EQ(inf, func(T(x), exp));
ASSERT_FP_EQ(neg_inf, func(-T(x), exp)); ASSERT_FP_EQ(neg_inf, func(-T(x), exp));
} }
} }
void testUnderflowToZeroOnNormal(LdExpFunc func) { void testUnderflowToZeroOnNormal(LdExpFunc func) {
// In this test, we pass a normal nubmer to func and expect zero // In this test, we pass a normal nubmer to func and expect zero
// to be returned due to underflow. // to be returned due to underflow.
int32_t base_exponent = FPBits::EXPONENT_BIAS + MANTISSA_WIDTH; int32_t base_exponent = FPB::EXPONENT_BIAS + MANTISSA_WIDTH;
int32_t exp_array[] = {base_exponent + 5, base_exponent + 4, int32_t exp_array[] = {base_exponent + 5, base_exponent + 4,
base_exponent + 3, base_exponent + 2, base_exponent + 3, base_exponent + 2,
base_exponent + 1}; base_exponent + 1};
T x = NormalFloat(0, MANTISSA, 0); T x = NormalFloat(0, MANTISSA, 0);
for (int32_t exp : exp_array) { for (int32_t exp : exp_array) {
ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero); ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero);
} }
} }
void testUnderflowToZeroOnSubnormal(LdExpFunc func) { void testUnderflowToZeroOnSubnormal(LdExpFunc func) {
// In this test, we pass a normal nubmer to func and expect zero // In this test, we pass a normal nubmer to func and expect zero
// to be returned due to underflow. // to be returned due to underflow.
int32_t base_exponent = FPBits::EXPONENT_BIAS + MANTISSA_WIDTH; int32_t base_exponent = FPB::EXPONENT_BIAS + MANTISSA_WIDTH;
int32_t exp_array[] = {base_exponent + 5, base_exponent + 4, int32_t exp_array[] = {base_exponent + 5, base_exponent + 4,
base_exponent + 3, base_exponent + 2, base_exponent + 3, base_exponent + 2,
base_exponent + 1}; base_exponent + 1};
T x = NormalFloat(-FPBits::EXPONENT_BIAS, MANTISSA, 0); T x = NormalFloat(-FPB::EXPONENT_BIAS, MANTISSA, 0);
for (int32_t exp : exp_array) { for (int32_t exp : exp_array) {
ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero); ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero);
} }
} }
void testNormalOperation(LdExpFunc func) { void testNormalOperation(LdExpFunc func) {
T val_array[] = { T val_array[] = {
// Normal numbers // Normal numbers
NormalFloat(100, MANTISSA, 0), NormalFloat(-100, MANTISSA, 0), NormalFloat(100, MANTISSA, 0), NormalFloat(-100, MANTISSA, 0),
NormalFloat(100, MANTISSA, 1), NormalFloat(-100, MANTISSA, 1), NormalFloat(100, MANTISSA, 1), NormalFloat(-100, MANTISSA, 1),
// Subnormal numbers // Subnormal numbers
NormalFloat(-FPBits::EXPONENT_BIAS, MANTISSA, 0), NormalFloat(-FPB::EXPONENT_BIAS, MANTISSA, 0),
NormalFloat(-FPBits::EXPONENT_BIAS, MANTISSA, 1)}; NormalFloat(-FPB::EXPONENT_BIAS, MANTISSA, 1)};
for (int32_t exp = 0; exp <= static_cast<int32_t>(MANTISSA_WIDTH); ++exp) { for (int32_t exp = 0; exp <= static_cast<int32_t>(MANTISSA_WIDTH); ++exp) {
for (T x : val_array) { for (T x : val_array) {
// We compare the result of ldexp with the result // We compare the result of ldexp with the result
// of the native multiplication/division instruction. // of the native multiplication/division instruction.
ASSERT_FP_EQ(func(x, exp), x * (UIntType(1) << exp)); ASSERT_FP_EQ(func(x, exp), x * (UIntType(1) << exp));
ASSERT_FP_EQ(func(x, -exp), x / (UIntType(1) << exp)); ASSERT_FP_EQ(func(x, -exp), x / (UIntType(1) << exp));
} }
} }
// Normal which trigger mantissa overflow. // Normal which trigger mantissa overflow.
T x = NormalFloat(-FPBits::EXPONENT_BIAS + 1, 2 * NormalFloat::ONE - 1, 0); T x = NormalFloat(-FPB::EXPONENT_BIAS + 1, 2 * NormalFloat::ONE - 1, 0);
ASSERT_FP_EQ(func(x, -1), x / 2); ASSERT_FP_EQ(func(x, -1), x / 2);
ASSERT_FP_EQ(func(-x, -1), -x / 2); ASSERT_FP_EQ(func(-x, -1), -x / 2);
// Start with a normal number high exponent but pass a very low number for // Start with a normal number high exponent but pass a very low number for
// exp. The result should be a subnormal number. // exp. The result should be a subnormal number.
x = NormalFloat(FPBits::EXPONENT_BIAS, NormalFloat::ONE, 0); x = NormalFloat(FPB::EXPONENT_BIAS, NormalFloat::ONE, 0);
int exp = -FPBits::MAX_EXPONENT - 5; int exp = -FPB::MAX_EXPONENT - 5;
T result = func(x, exp); T result = func(x, exp);
FPBits result_bits(result); FPB result_bits(result);
ASSERT_FALSE(result_bits.is_zero()); ASSERT_FALSE(result_bits.is_zero());
// Verify that the result is indeed subnormal. // Verify that the result is indeed subnormal.
ASSERT_EQ(result_bits.get_unbiased_exponent(), uint16_t(0)); ASSERT_EQ(result_bits.get_unbiased_exponent(), uint16_t(0));
// But if the exp is so less that normalization leads to zero, then // But if the exp is so less that normalization leads to zero, then
// the result should be zero. // the result should be zero.
result = func(x, -FPBits::MAX_EXPONENT - int(MANTISSA_WIDTH) - 5); result = func(x, -FPB::MAX_EXPONENT - int(MANTISSA_WIDTH) - 5);
ASSERT_TRUE(FPBits(result).is_zero()); ASSERT_TRUE(FPB(result).is_zero());
// Start with a subnormal number but pass a very high number for exponent. // Start with a subnormal number but pass a very high number for exponent.
// The result should not be infinity. // The result should not be infinity.
x = NormalFloat(-FPBits::EXPONENT_BIAS + 1, NormalFloat::ONE >> 10, 0); x = NormalFloat(-FPB::EXPONENT_BIAS + 1, NormalFloat::ONE >> 10, 0);
exp = FPBits::MAX_EXPONENT + 5; exp = FPB::MAX_EXPONENT + 5;
ASSERT_FALSE(FPBits(func(x, exp)).is_inf()); ASSERT_FALSE(FPB(func(x, exp)).is_inf());
// But if the exp is large enough to oversome than the normalization shift, // But if the exp is large enough to oversome than the normalization shift,
// then it should result in infinity. // then it should result in infinity.
exp = FPBits::MAX_EXPONENT + 15; exp = FPB::MAX_EXPONENT + 15;
ASSERT_FP_EQ(func(x, exp), inf); ASSERT_FP_EQ(func(x, exp), inf);
} }
}; };
#define LIST_LDEXP_TESTS(T, func) \ #define LIST_LDEXP_TESTS(T, func) \
using LlvmLibcLdExpTest = LdExpTestTemplate<T>; \ using LlvmLibcLdExpTest = LdExpTestTemplate<T>; \
TEST_F(LlvmLibcLdExpTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcLdExpTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcLdExpTest, PowersOfTwo) { testPowersOfTwo(&func); } \ TEST_F(LlvmLibcLdExpTest, PowersOfTwo) { testPowersOfTwo(&func); } \
Show All 10 Lines

libc/test/src/math/LogbTest.h

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines void testSomeIntegers(LogbFunc func) {
EXPECT_FP_EQ(T(4.0), func(T(31.0))); EXPECT_FP_EQ(T(4.0), func(T(31.0)));
EXPECT_FP_EQ(T(4.0), func(T(-31.0))); EXPECT_FP_EQ(T(4.0), func(T(-31.0)));
EXPECT_FP_EQ(T(5.0), func(T(55.0))); EXPECT_FP_EQ(T(5.0), func(T(55.0)));
EXPECT_FP_EQ(T(5.0), func(T(-55.0))); EXPECT_FP_EQ(T(5.0), func(T(-55.0)));
} }
void testRange(LogbFunc func) { void testRange(LogbFunc func) {
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = static_cast<T>(FPBits(v)); T x = static_cast<T>(FPB(v));
if (isnan(x) || isinf(x) || x == 0.0l) if (isnan(x) || isinf(x) || x == 0.0l)
continue; continue;
int exponent; int exponent;
__llvm_libc::fputil::frexp(x, exponent); __llvm_libc::fputil::frexp(x, exponent);
ASSERT_FP_EQ(T(exponent), func(x) + T(1.0)); ASSERT_FP_EQ(T(exponent), func(x) + T(1.0));
} }
} }
}; };
#define LIST_LOGB_TESTS(T, func) \ #define LIST_LOGB_TESTS(T, func) \
using LlvmLibcLogbTest = LogbTest<T>; \ using LlvmLibcLogbTest = LogbTest<T>; \
TEST_F(LlvmLibcLogbTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcLogbTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcLogbTest, PowersOfTwo) { testPowersOfTwo(&func); } \ TEST_F(LlvmLibcLogbTest, PowersOfTwo) { testPowersOfTwo(&func); } \
TEST_F(LlvmLibcLogbTest, SomeIntegers) { testSomeIntegers(&func); } \ TEST_F(LlvmLibcLogbTest, SomeIntegers) { testSomeIntegers(&func); } \
TEST_F(LlvmLibcLogbTest, InRange) { testRange(&func); } TEST_F(LlvmLibcLogbTest, InRange) { testRange(&func); }

libc/test/src/math/ModfTest.h

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines void testFractions(ModfFunc func) {
EXPECT_FP_EQ(T(-0.125), func(T(-100.125), &integral)); EXPECT_FP_EQ(T(-0.125), func(T(-100.125), &integral));
EXPECT_FP_EQ(integral, T(-100.0)); EXPECT_FP_EQ(integral, T(-100.0));
} }
void testRange(ModfFunc func) { void testRange(ModfFunc func) {
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPB(v));
if (isnan(x) || isinf(x) || x == T(0.0)) if (isnan(x) || isinf(x) || x == T(0.0))
continue; continue;
T integral; T integral;
T frac = func(x, &integral); T frac = func(x, &integral);
ASSERT_TRUE(__llvm_libc::fputil::abs(frac) < 1.0l); ASSERT_TRUE(__llvm_libc::fputil::abs(frac) < 1.0l);
ASSERT_TRUE(__llvm_libc::fputil::trunc(x) == integral); ASSERT_TRUE(__llvm_libc::fputil::trunc(x) == integral);
ASSERT_TRUE(integral + frac == x); ASSERT_TRUE(integral + frac == x);
Show All 10 Lines

libc/test/src/math/NextAfterTest.h

Show All 13 Lines
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
template <typename T> template <typename T>
class NextAfterTestTemplate : public __llvm_libc::testing::Test { class NextAfterTestTemplate : public __llvm_libc::testing::Test {
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPB = __llvm_libc::fputil::FPBits<T>;
using MantissaWidth = __llvm_libc::fputil::MantissaWidth<T>; using MantissaWidth = __llvm_libc::fputil::MantissaWidth<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
static constexpr int BIT_WIDTH_OF_TYPE = static constexpr int BIT_WIDTH_OF_TYPE =
__llvm_libc::fputil::FloatProperties<T>::BIT_WIDTH; __llvm_libc::fputil::FloatProperties<T>::BIT_WIDTH;
const T zero = T(FPBits::zero()); const T zero = T(FPB::zero());
const T neg_zero = T(FPBits::neg_zero()); const T neg_zero = T(FPB::neg_zero());
const T inf = T(FPBits::inf()); const T inf = T(FPB::inf());
const T neg_inf = T(FPBits::neg_inf()); const T neg_inf = T(FPB::neg_inf());
const T nan = T(FPBits::build_quiet_nan(1)); const T nan = T(FPB::build_quiet_nan(1));
const UIntType min_subnormal = FPBits::MIN_SUBNORMAL; const UIntType min_subnormal = FPB::MIN_SUBNORMAL;
const UIntType max_subnormal = FPBits::MAX_SUBNORMAL; const UIntType max_subnormal = FPB::MAX_SUBNORMAL;
const UIntType min_normal = FPBits::MIN_NORMAL; const UIntType min_normal = FPB::MIN_NORMAL;
const UIntType max_normal = FPBits::MAX_NORMAL; const UIntType max_normal = FPB::MAX_NORMAL;
public: public:
typedef T (*NextAfterFunc)(T, T); typedef T (*NextAfterFunc)(T, T);
void testNaN(NextAfterFunc func) { void testNaN(NextAfterFunc func) {
ASSERT_FP_EQ(func(nan, 0), nan); ASSERT_FP_EQ(func(nan, 0), nan);
ASSERT_FP_EQ(func(0, nan), nan); ASSERT_FP_EQ(func(0, nan), nan);
} }
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines void testBoundaries(NextAfterFunc func) {
expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + max_normal; expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + max_normal;
expected = __llvm_libc::cpp::bit_cast<T>(expected_bits); expected = __llvm_libc::cpp::bit_cast<T>(expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
ASSERT_FP_EQ(func(x, neg_inf), neg_inf); ASSERT_FP_EQ(func(x, neg_inf), neg_inf);
// 'from' is a power of 2. // 'from' is a power of 2.
x = T(32.0); x = T(32.0);
result = func(x, 0); result = func(x, 0);
FPBits x_bits = FPBits(x); FPB x_bits = FPB(x);
FPBits result_bits = FPBits(result); FPB result_bits = FPB(result);
ASSERT_EQ(result_bits.get_unbiased_exponent(), ASSERT_EQ(result_bits.get_unbiased_exponent(),
uint16_t(x_bits.get_unbiased_exponent() - 1)); uint16_t(x_bits.get_unbiased_exponent() - 1));
ASSERT_EQ(result_bits.get_mantissa(), ASSERT_EQ(result_bits.get_mantissa(),
(UIntType(1) << MantissaWidth::VALUE) - 1); (UIntType(1) << MantissaWidth::VALUE) - 1);
result = func(x, T(33.0)); result = func(x, T(33.0));
result_bits = FPBits(result); result_bits = FPB(result);
ASSERT_EQ(result_bits.get_unbiased_exponent(), ASSERT_EQ(result_bits.get_unbiased_exponent(),
x_bits.get_unbiased_exponent()); x_bits.get_unbiased_exponent());
ASSERT_EQ(result_bits.get_mantissa(), x_bits.get_mantissa() + UIntType(1)); ASSERT_EQ(result_bits.get_mantissa(), x_bits.get_mantissa() + UIntType(1));
x = -x; x = -x;
result = func(x, 0); result = func(x, 0);
result_bits = FPBits(result); result_bits = FPB(result);
ASSERT_EQ(result_bits.get_unbiased_exponent(), ASSERT_EQ(result_bits.get_unbiased_exponent(),
uint16_t(x_bits.get_unbiased_exponent() - 1)); uint16_t(x_bits.get_unbiased_exponent() - 1));
ASSERT_EQ(result_bits.get_mantissa(), ASSERT_EQ(result_bits.get_mantissa(),
(UIntType(1) << MantissaWidth::VALUE) - 1); (UIntType(1) << MantissaWidth::VALUE) - 1);
result = func(x, T(-33.0)); result = func(x, T(-33.0));
result_bits = FPBits(result); result_bits = FPB(result);
ASSERT_EQ(result_bits.get_unbiased_exponent(), ASSERT_EQ(result_bits.get_unbiased_exponent(),
x_bits.get_unbiased_exponent()); x_bits.get_unbiased_exponent());
ASSERT_EQ(result_bits.get_mantissa(), x_bits.get_mantissa() + UIntType(1)); ASSERT_EQ(result_bits.get_mantissa(), x_bits.get_mantissa() + UIntType(1));
} }
}; };
#define LIST_NEXTAFTER_TESTS(T, func) \ #define LIST_NEXTAFTER_TESTS(T, func) \
using LlvmLibcNextAfterTest = NextAfterTestTemplate<T>; \ using LlvmLibcNextAfterTest = NextAfterTestTemplate<T>; \
TEST_F(LlvmLibcNextAfterTest, TestNaN) { testNaN(&func); } \ TEST_F(LlvmLibcNextAfterTest, TestNaN) { testNaN(&func); } \
TEST_F(LlvmLibcNextAfterTest, TestBoundaries) { testBoundaries(&func); } TEST_F(LlvmLibcNextAfterTest, TestBoundaries) { testBoundaries(&func); }
#endif // LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H #endif // LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H

libc/test/src/math/RIntTest.h

Show All 24 Linesstatic constexpr int ROUNDING_MODES[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
FE_TONEAREST}; FE_TONEAREST};
template <typename T> template <typename T>
class RIntTestTemplate : public __llvm_libc::testing::Test { class RIntTestTemplate : public __llvm_libc::testing::Test {
public: public:
typedef T (*RIntFunc)(T); typedef T (*RIntFunc)(T);
private: private:
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPB = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
const T zero = T(FPBits::zero()); const T zero = T(FPB::zero());
const T neg_zero = T(FPBits::neg_zero()); const T neg_zero = T(FPB::neg_zero());
const T inf = T(FPBits::inf()); const T inf = T(FPB::inf());
const T neg_inf = T(FPBits::neg_inf()); const T neg_inf = T(FPB::neg_inf());
const T nan = T(FPBits::build_quiet_nan(1)); const T nan = T(FPB::build_quiet_nan(1));
static inline mpfr::RoundingMode to_mpfr_rounding_mode(int mode) { static inline mpfr::RoundingMode to_mpfr_rounding_mode(int mode) {
switch (mode) { switch (mode) {
case FE_UPWARD: case FE_UPWARD:
return mpfr::RoundingMode::Upward; return mpfr::RoundingMode::Upward;
case FE_DOWNWARD: case FE_DOWNWARD:
return mpfr::RoundingMode::Downward; return mpfr::RoundingMode::Downward;
case FE_TOWARDZERO: case FE_TOWARDZERO:
Show All 40 Lines for (int mode : ROUNDING_MODES) {
ASSERT_FP_EQ(func(T(-0.115)), mpfr::round(T(-0.115), mpfr_mode)); ASSERT_FP_EQ(func(T(-0.115)), mpfr::round(T(-0.115), mpfr_mode));
ASSERT_FP_EQ(func(T(0.715)), mpfr::round(T(0.715), mpfr_mode)); ASSERT_FP_EQ(func(T(0.715)), mpfr::round(T(0.715), mpfr_mode));
ASSERT_FP_EQ(func(T(-0.715)), mpfr::round(T(-0.715), mpfr_mode)); ASSERT_FP_EQ(func(T(-0.715)), mpfr::round(T(-0.715), mpfr_mode));
} }
} }
void testSubnormalRange(RIntFunc func) { void testSubnormalRange(RIntFunc func) {
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType STEP = constexpr UIntType STEP = (FPB::MAX_SUBNORMAL - FPB::MIN_SUBNORMAL) / COUNT;
(FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT; for (UIntType i = FPB::MIN_SUBNORMAL; i <= FPB::MAX_SUBNORMAL; i += STEP) {
for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL; T x = T(FPB(i));
i += STEP) {
T x = T(FPBits(i));
for (int mode : ROUNDING_MODES) { for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode); __llvm_libc::fputil::set_round(mode);
mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(mode); mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(mode);
ASSERT_FP_EQ(func(x), mpfr::round(x, mpfr_mode)); ASSERT_FP_EQ(func(x), mpfr::round(x, mpfr_mode));
} }
} }
} }
void testNormalRange(RIntFunc func) { void testNormalRange(RIntFunc func) {
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT; constexpr UIntType STEP = (FPB::MAX_NORMAL - FPB::MIN_NORMAL) / COUNT;
for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += STEP) { for (UIntType i = FPB::MIN_NORMAL; i <= FPB::MAX_NORMAL; i += STEP) {
T x = T(FPBits(i)); T x = T(FPB(i));
// In normal range on x86 platforms, the long double implicit 1 bit can be // In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. We will skip them. // zero making the numbers NaN. We will skip them.
if (isnan(x)) { if (isnan(x)) {
continue; continue;
} }
for (int mode : ROUNDING_MODES) { for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode); __llvm_libc::fputil::set_round(mode);
Show All 16 Lines

libc/test/src/math/RemQuoTest.h

Show All 14 Lines
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> template <typename T>
class RemQuoTestTemplate : public __llvm_libc::testing::Test { class RemQuoTestTemplate : public __llvm_libc::testing::Test {
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPB = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
const T zero = T(__llvm_libc::fputil::FPBits<T>::zero()); const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero()); const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
const T inf = T(__llvm_libc::fputil::FPBits<T>::inf()); const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf()); const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
const T nan = T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1)); const T nan = T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1));
public: public:
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines void testEqualNumeratorAndDenominator(RemQuoFunc func) {
EXPECT_EQ(q, -1); EXPECT_EQ(q, -1);
EXPECT_FP_EQ(func(-x, -y, &q), neg_zero); EXPECT_FP_EQ(func(-x, -y, &q), neg_zero);
EXPECT_EQ(q, 1); EXPECT_EQ(q, 1);
} }
void testSubnormalRange(RemQuoFunc func) { void testSubnormalRange(RemQuoFunc func) {
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType STEP = constexpr UIntType STEP = (FPB::MAX_SUBNORMAL - FPB::MIN_SUBNORMAL) / COUNT;
(FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT; for (UIntType v = FPB::MIN_SUBNORMAL, w = FPB::MAX_SUBNORMAL;
for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL; v <= FPB::MAX_SUBNORMAL && w >= FPB::MIN_SUBNORMAL;
v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL;
v += STEP, w -= STEP) { v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w)); T x = T(FPB(v)), y = T(FPB(w));
mpfr::BinaryOutput<T> result; mpfr::BinaryOutput<T> result;
mpfr::BinaryInput<T> input{x, y}; mpfr::BinaryInput<T> input{x, y};
result.f = func(x, y, &result.i); result.f = func(x, y, &result.i);
ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
} }
} }
void testNormalRange(RemQuoFunc func) { void testNormalRange(RemQuoFunc func) {
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT; constexpr UIntType STEP = (FPB::MAX_NORMAL - FPB::MIN_NORMAL) / COUNT;
for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL; for (UIntType v = FPB::MIN_NORMAL, w = FPB::MAX_NORMAL;
v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL; v <= FPB::MAX_NORMAL && w >= FPB::MIN_NORMAL; v += STEP, w -= STEP) {
v += STEP, w -= STEP) { T x = T(FPB(v)), y = T(FPB(w));
T x = T(FPBits(v)), y = T(FPBits(w));
mpfr::BinaryOutput<T> result; mpfr::BinaryOutput<T> result;
mpfr::BinaryInput<T> input{x, y}; mpfr::BinaryInput<T> input{x, y};
result.f = func(x, y, &result.i); result.f = func(x, y, &result.i);
// In normal range on x86 platforms, the long double implicit 1 bit can be // In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. Hence we test for them separately. // zero making the numbers NaN. Hence we test for them separately.
if (isnan(x) || isnan(y)) { if (isnan(x) || isnan(y)) {
ASSERT_FP_EQ(result.f, nan); ASSERT_FP_EQ(result.f, nan);
Show All 18 Lines

libc/test/src/math/RoundTest.h

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines void testFractions(RoundFunc func) {
EXPECT_FP_EQ(T(1235.0), func(T(1234.96))); EXPECT_FP_EQ(T(1235.0), func(T(1234.96)));
EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96))); EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96)));
} }
void testRange(RoundFunc func) { void testRange(RoundFunc func) {
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, func(x), 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, func(x), 0.0);
} }
} }
}; };
#define LIST_ROUND_TESTS(T, func) \ #define LIST_ROUND_TESTS(T, func) \
using LlvmLibcRoundTest = RoundTest<T>; \ using LlvmLibcRoundTest = RoundTest<T>; \
TEST_F(LlvmLibcRoundTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcRoundTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcRoundTest, RoundedNubmers) { testRoundedNumbers(&func); } \ TEST_F(LlvmLibcRoundTest, RoundedNubmers) { testRoundedNumbers(&func); } \
TEST_F(LlvmLibcRoundTest, Fractions) { testFractions(&func); } \ TEST_F(LlvmLibcRoundTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcRoundTest, Range) { testRange(&func); } TEST_F(LlvmLibcRoundTest, Range) { testRange(&func); }

libc/test/src/math/RoundToIntegerTest.h

Show All 23 Linesstatic constexpr int ROUNDING_MODES[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
FE_TONEAREST}; FE_TONEAREST};
template <typename F, typename I, bool TestModes = false> template <typename F, typename I, bool TestModes = false>
class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test { class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
public: public:
typedef I (*RoundToIntegerFunc)(F); typedef I (*RoundToIntegerFunc)(F);
private: private:
using FPBits = __llvm_libc::fputil::FPBits<F>; using FPB = __llvm_libc::fputil::FPBits<F>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
const F zero = F(__llvm_libc::fputil::FPBits<F>::zero()); const F zero = F(__llvm_libc::fputil::FPBits<F>::zero());
const F neg_zero = F(__llvm_libc::fputil::FPBits<F>::neg_zero()); const F neg_zero = F(__llvm_libc::fputil::FPBits<F>::neg_zero());
const F inf = F(__llvm_libc::fputil::FPBits<F>::inf()); const F inf = F(__llvm_libc::fputil::FPBits<F>::inf());
const F neg_inf = F(__llvm_libc::fputil::FPBits<F>::neg_inf()); const F neg_inf = F(__llvm_libc::fputil::FPBits<F>::neg_inf());
const F nan = F(__llvm_libc::fputil::FPBits<F>::build_quiet_nan(1)); const F nan = F(__llvm_libc::fputil::FPBits<F>::build_quiet_nan(1));
static constexpr I INTEGER_MIN = I(1) << (sizeof(I) * 8 - 1); static constexpr I INTEGER_MIN = I(1) << (sizeof(I) * 8 - 1);
static constexpr I INTEGER_MAX = -(INTEGER_MIN + 1); static constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines void do_round_numbers_test(RoundToIntegerFunc func) {
// the remaining tests only if the width of I less than equal to that of // the remaining tests only if the width of I less than equal to that of
// long. // long.
if (sizeof(I) > sizeof(long)) if (sizeof(I) > sizeof(long))
return; return;
constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1; constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1;
// We start with 1.0 so that the implicit bit for x86 long doubles // We start with 1.0 so that the implicit bit for x86 long doubles
// is set. // is set.
FPBits bits(F(1.0)); FPB bits(F(1.0));
bits.set_unbiased_exponent(EXPONENT_LIMIT + FPBits::EXPONENT_BIAS); bits.set_unbiased_exponent(EXPONENT_LIMIT + FPB::EXPONENT_BIAS);
bits.set_sign(1); bits.set_sign(1);
bits.set_mantissa(0); bits.set_mantissa(0);
F x = F(bits); F x = F(bits);
long mpfr_result; long mpfr_result;
bool erangeflag = mpfr::round_to_long(x, mpfr_result); bool erangeflag = mpfr::round_to_long(x, mpfr_result);
ASSERT_FALSE(erangeflag); ASSERT_FALSE(erangeflag);
test_one_input(func, x, mpfr_result, false); test_one_input(func, x, mpfr_result, false);
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines void testIntegerOverflow(RoundToIntegerFunc func) {
// comparisons in this function only if the width of I less than equal to // comparisons in this function only if the width of I less than equal to
// that of long. // that of long.
if (sizeof(I) > sizeof(long)) if (sizeof(I) > sizeof(long))
return; return;
constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1; constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1;
// We start with 1.0 so that the implicit bit for x86 long doubles // We start with 1.0 so that the implicit bit for x86 long doubles
// is set. // is set.
FPBits bits(F(1.0)); FPB bits(F(1.0));
bits.set_unbiased_exponent(EXPONENT_LIMIT + FPBits::EXPONENT_BIAS); bits.set_unbiased_exponent(EXPONENT_LIMIT + FPB::EXPONENT_BIAS);
bits.set_sign(1); bits.set_sign(1);
bits.set_mantissa(UIntType(0x1) bits.set_mantissa(UIntType(0x1)
<< (__llvm_libc::fputil::MantissaWidth<F>::VALUE - 1)); << (__llvm_libc::fputil::MantissaWidth<F>::VALUE - 1));
F x = F(bits); F x = F(bits);
if (TestModes) { if (TestModes) {
for (int m : ROUNDING_MODES) { for (int m : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(m); __llvm_libc::fputil::set_round(m);
long mpfr_long_result; long mpfr_long_result;
bool erangeflag = bool erangeflag =
mpfr::round_to_long(x, to_mpfr_rounding_mode(m), mpfr_long_result); mpfr::round_to_long(x, to_mpfr_rounding_mode(m), mpfr_long_result);
ASSERT_TRUE(erangeflag); ASSERT_TRUE(erangeflag);
test_one_input(func, x, INTEGER_MIN, true); test_one_input(func, x, INTEGER_MIN, true);
} }
} else { } else {
long mpfr_long_result; long mpfr_long_result;
bool erangeflag = mpfr::round_to_long(x, mpfr_long_result); bool erangeflag = mpfr::round_to_long(x, mpfr_long_result);
ASSERT_TRUE(erangeflag); ASSERT_TRUE(erangeflag);
test_one_input(func, x, INTEGER_MIN, true); test_one_input(func, x, INTEGER_MIN, true);
} }
} }
void testSubnormalRange(RoundToIntegerFunc func) { void testSubnormalRange(RoundToIntegerFunc func) {
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType STEP = constexpr UIntType STEP = (FPB::MAX_SUBNORMAL - FPB::MIN_SUBNORMAL) / COUNT;
(FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT; for (UIntType i = FPB::MIN_SUBNORMAL; i <= FPB::MAX_SUBNORMAL; i += STEP) {
for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL; F x = F(FPB(i));
i += STEP) {
F x = F(FPBits(i));
if (x == F(0.0)) if (x == F(0.0))
continue; continue;
// All subnormal numbers should round to zero. // All subnormal numbers should round to zero.
if (TestModes) { if (TestModes) {
if (x > 0) { if (x > 0) {
__llvm_libc::fputil::set_round(FE_UPWARD); __llvm_libc::fputil::set_round(FE_UPWARD);
test_one_input(func, x, I(1), false); test_one_input(func, x, I(1), false);
__llvm_libc::fputil::set_round(FE_DOWNWARD); __llvm_libc::fputil::set_round(FE_DOWNWARD);
Show All 23 Lines void testNormalRange(RoundToIntegerFunc func) {
// floating point numbers to long values. There is no MPFR function to // floating point numbers to long values. There is no MPFR function to
// round to long long or wider integer values. So, we will peform the // round to long long or wider integer values. So, we will peform the
// comparisons in this function only if the width of I less than equal to // comparisons in this function only if the width of I less than equal to
// that of long. // that of long.
if (sizeof(I) > sizeof(long)) if (sizeof(I) > sizeof(long))
return; return;
constexpr UIntType COUNT = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT; constexpr UIntType STEP = (FPB::MAX_NORMAL - FPB::MIN_NORMAL) / COUNT;
for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += STEP) { for (UIntType i = FPB::MIN_NORMAL; i <= FPB::MAX_NORMAL; i += STEP) {
F x = F(FPBits(i)); F x = F(FPB(i));
// In normal range on x86 platforms, the long double implicit 1 bit can be // In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. We will skip them. // zero making the numbers NaN. We will skip them.
if (isnan(x)) { if (isnan(x)) {
continue; continue;
} }
if (TestModes) { if (TestModes) {
for (int m : ROUNDING_MODES) { for (int m : ROUNDING_MODES) {
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libc/test/src/math/SqrtTest.h

Show All 33 Lines void test_special_numbers(SqrtFunc func) {
ASSERT_FP_EQ(aNaN, func(T(-1.0))); ASSERT_FP_EQ(aNaN, func(T(-1.0)));
ASSERT_FP_EQ(T(1.0), func(T(1.0))); ASSERT_FP_EQ(T(1.0), func(T(1.0)));
ASSERT_FP_EQ(T(2.0), func(T(4.0))); ASSERT_FP_EQ(T(2.0), func(T(4.0)));
ASSERT_FP_EQ(T(3.0), func(T(9.0))); ASSERT_FP_EQ(T(3.0), func(T(9.0)));
} }
void test_denormal_values(SqrtFunc func) { void test_denormal_values(SqrtFunc func) {
for (UIntType mant = 1; mant < HIDDEN_BIT; mant <<= 1) { for (UIntType mant = 1; mant < HIDDEN_BIT; mant <<= 1) {
FPBits denormal(T(0.0)); FPB denormal(T(0.0));
denormal.set_mantissa(mant); denormal.set_mantissa(mant);
test_all_rounding_modes(func, T(denormal)); test_all_rounding_modes(func, T(denormal));
} }
constexpr UIntType COUNT = 1'000'001; constexpr UIntType COUNT = 1'000'001;
constexpr UIntType STEP = HIDDEN_BIT / COUNT; constexpr UIntType STEP = HIDDEN_BIT / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libc/test/src/math/TruncTest.h

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines void testFractions(TruncFunc func) {
EXPECT_FP_EQ(T(1234.0), func(T(1234.96))); EXPECT_FP_EQ(T(1234.0), func(T(1234.96)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96))); EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96)));
} }
void testRange(TruncFunc func) { void testRange(TruncFunc func) {
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, func(x), 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, func(x), 0.0);
} }
} }
}; };
#define LIST_TRUNC_TESTS(T, func) \ #define LIST_TRUNC_TESTS(T, func) \
using LlvmLibcTruncTest = TruncTest<T>; \ using LlvmLibcTruncTest = TruncTest<T>; \
TEST_F(LlvmLibcTruncTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcTruncTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcTruncTest, RoundedNubmers) { testRoundedNumbers(&func); } \ TEST_F(LlvmLibcTruncTest, RoundedNubmers) { testRoundedNumbers(&func); } \
TEST_F(LlvmLibcTruncTest, Fractions) { testFractions(&func); } \ TEST_F(LlvmLibcTruncTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcTruncTest, Range) { testRange(&func); } TEST_F(LlvmLibcTruncTest, Range) { testRange(&func); }

libc/test/src/math/acosf_test.cpp

Show All 10 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAcosfTest, SpecialNumbers) { TEST(LlvmLibcAcosfTest, SpecialNumbers) {
errno = 0; errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(inf));
EXPECT_MATH_ERRNO(EDOM); EXPECT_MATH_ERRNO(EDOM);
EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(neg_inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(neg_inf));
EXPECT_MATH_ERRNO(EDOM); EXPECT_MATH_ERRNO(EDOM);
} }
TEST(LlvmLibcAcosfTest, InFloatRange) { TEST(LlvmLibcAcosfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acos, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acos, x,
__llvm_libc::acosf(x), 0.5); __llvm_libc::acosf(x), 0.5);
} }
} }
TEST(LlvmLibcAcosfTest, SpecificBitPatterns) { TEST(LlvmLibcAcosfTest, SpecificBitPatterns) {
Show All 10 Lines constexpr uint32_t INPUTS[N] = {
0x39826222, // x = 0x1.04c444p-12 0x39826222, // x = 0x1.04c444p-12
0x3d09bf86, // x = 0x1.137f0cp-5f 0x3d09bf86, // x = 0x1.137f0cp-5f
0x3de5fa1e, // x = 0x1.cbf43cp-4f 0x3de5fa1e, // x = 0x1.cbf43cp-4f
0x3f083a1a, // x = 0x1.107434p-1f 0x3f083a1a, // x = 0x1.107434p-1f
0x3f7741b6, // x = 0x1.ee836cp-1f 0x3f7741b6, // x = 0x1.ee836cp-1f
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acos, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acos, x,
__llvm_libc::acosf(x), 0.5); __llvm_libc::acosf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acos, -x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acos, -x,
__llvm_libc::acosf(-x), 0.5); __llvm_libc::acosf(-x), 0.5);
} }
} }

libc/test/src/math/asin_test.cpp

Show All 9 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<double>; using FPB = __llvm_libc::fputil::FPBits<double>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibcAsinTest, SpecialNumbers) { TEST(LlvmLibcAsinTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 15 Lines

libc/test/src/math/asinf_test.cpp

Show All 11 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAsinfTest, SpecialNumbers) { TEST(LlvmLibcAsinfTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 12 LinesTEST(LlvmLibcAsinfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::asinf(neg_inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::asinf(neg_inf));
EXPECT_MATH_ERRNO(EDOM); EXPECT_MATH_ERRNO(EDOM);
} }
TEST(LlvmLibcAsinfTest, InFloatRange) { TEST(LlvmLibcAsinfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asin, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asin, x,
__llvm_libc::asinf(x), 0.5); __llvm_libc::asinf(x), 0.5);
} }
} }
TEST(LlvmLibcAsinfTest, SpecificBitPatterns) { TEST(LlvmLibcAsinfTest, SpecificBitPatterns) {
constexpr int N = 11; constexpr int N = 11;
constexpr uint32_t INPUTS[N] = { constexpr uint32_t INPUTS[N] = {
0x3f000000, // x = 0.5f 0x3f000000, // x = 0.5f
0x3f3504f3, // x = sqrt(2)/2, FE_DOWNWARD 0x3f3504f3, // x = sqrt(2)/2, FE_DOWNWARD
0x3f3504f4, // x = sqrt(2)/2, FE_UPWARD 0x3f3504f4, // x = sqrt(2)/2, FE_UPWARD
0x3f5db3d7, // x = sqrt(3)/2, FE_DOWNWARD 0x3f5db3d7, // x = sqrt(3)/2, FE_DOWNWARD
0x3f5db3d8, // x = sqrt(3)/2, FE_UPWARD 0x3f5db3d8, // x = sqrt(3)/2, FE_UPWARD
0x3f800000, // x = 1.0f 0x3f800000, // x = 1.0f
0x40000000, // x = 2.0f 0x40000000, // x = 2.0f
0x3d09bf86, // x = 0x1.137f0cp-5f 0x3d09bf86, // x = 0x1.137f0cp-5f
0x3de5fa1e, // x = 0x1.cbf43cp-4f 0x3de5fa1e, // x = 0x1.cbf43cp-4f
0x3f083a1a, // x = 0x1.107434p-1f 0x3f083a1a, // x = 0x1.107434p-1f
0x3f7741b6, // x = 0x1.ee836cp-1f 0x3f7741b6, // x = 0x1.ee836cp-1f
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asin, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asin, x,
__llvm_libc::asinf(x), 0.5); __llvm_libc::asinf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asin, -x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asin, -x,
__llvm_libc::asinf(-x), 0.5); __llvm_libc::asinf(-x), 0.5);
} }
} }

libc/test/src/math/asinhf_test.cpp

Show All 10 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits_t = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAsinhfTest, SpecialNumbers) { TEST(LlvmLibcAsinhfTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 12 LinesTEST(LlvmLibcAsinhfTest, SpecialNumbers) {
EXPECT_FP_EQ(neg_inf, __llvm_libc::asinhf(neg_inf)); EXPECT_FP_EQ(neg_inf, __llvm_libc::asinhf(neg_inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcAsinhfTest, InFloatRange) { TEST(LlvmLibcAsinhfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits_t(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, x,
__llvm_libc::asinhf(x), 0.5); __llvm_libc::asinhf(x), 0.5);
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, -x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, -x,
__llvm_libc::asinhf(-x), 0.5); __llvm_libc::asinhf(-x), 0.5);
} }
} }
Show All 10 Lines constexpr uint32_t INPUTS[N] = {
0x5e68984e, // |x| = 0x1.d1309cp61f 0x5e68984e, // |x| = 0x1.d1309cp61f
0x655890d3, // |x| = 0x1.b121a6p75f 0x655890d3, // |x| = 0x1.b121a6p75f
0x65de7ca6, // |x| = 0x1.bcf94cp76f 0x65de7ca6, // |x| = 0x1.bcf94cp76f
0x6eb1a8ec, // |x| = 0x1.6351d8p94f 0x6eb1a8ec, // |x| = 0x1.6351d8p94f
0x7997f30a, // |x| = 0x1.2fe614p116f 0x7997f30a, // |x| = 0x1.2fe614p116f
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits_t(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, x,
__llvm_libc::asinhf(x), 0.5); __llvm_libc::asinhf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, -x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, -x,
__llvm_libc::asinhf(-x), 0.5); __llvm_libc::asinhf(-x), 0.5);
} }
} }

libc/test/src/math/atanf_test.cpp

Show All 12 Lines
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
#include <initializer_list> #include <initializer_list>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAtanfTest, SpecialNumbers) { TEST(LlvmLibcAtanfTest, SpecialNumbers) {
errno = 0; errno = 0;
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
Show All 9 LinesTEST(LlvmLibcAtanfTest, SpecialNumbers) {
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
EXPECT_FP_EQ(-0.0f, __llvm_libc::atanf(-0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::atanf(-0.0f));
EXPECT_FP_EXCEPTION(0); EXPECT_FP_EXCEPTION(0);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcAtanfTest, InFloatRange) { TEST(LlvmLibcAtanfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
const uint32_t STEP = FPBits(inf).uintval() / COUNT; const uint32_t STEP = FPB(inf).uintval() / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, x,
__llvm_libc::atanf(x), 0.5); __llvm_libc::atanf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, -x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, -x,
__llvm_libc::atanf(-x), 0.5); __llvm_libc::atanf(-x), 0.5);
} }
} }
// For small values, tanh(x) is x. // For small values, tanh(x) is x.
TEST(LlvmLibcAtanfTest, SpecialValues) { TEST(LlvmLibcAtanfTest, SpecialValues) {
for (uint32_t v : {0x3d8d6b23U, 0x3feefcfbU, 0xbd8d6b23U, 0xbfeefcfbU, for (uint32_t v : {0x3d8d6b23U, 0x3feefcfbU, 0xbd8d6b23U, 0xbfeefcfbU,
0x7F800000U, 0xFF800000U}) { 0x7F800000U, 0xFF800000U}) {
float x = float(FPBits(v)); float x = float(FPB(v));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, x,
__llvm_libc::atanf(x), 0.5); __llvm_libc::atanf(x), 0.5);
} }
} }

libc/test/src/math/atanhf_test.cpp

Show All 10 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAtanhfTest, SpecialNumbers) { TEST(LlvmLibcAtanhfTest, SpecialNumbers) {
errno = 0; errno = 0;
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
Show All 16 LinesTEST(LlvmLibcAtanhfTest, SpecialNumbers) {
EXPECT_FP_EXCEPTION(FE_DIVBYZERO); EXPECT_FP_EXCEPTION(FE_DIVBYZERO);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
EXPECT_FP_EQ(neg_inf, __llvm_libc::atanhf(-1.0f)); EXPECT_FP_EQ(neg_inf, __llvm_libc::atanhf(-1.0f));
EXPECT_FP_EXCEPTION(FE_DIVBYZERO); EXPECT_FP_EXCEPTION(FE_DIVBYZERO);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
auto bt = FPBits(1.0f); auto bt = FPB(1.0f);
bt.bits += 1; bt.bits += 1;
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
EXPECT_FP_EQ(aNaN, __llvm_libc::atanhf(bt.get_val())); EXPECT_FP_EQ(aNaN, __llvm_libc::atanhf(bt.get_val()));
EXPECT_FP_EXCEPTION(FE_INVALID); EXPECT_FP_EXCEPTION(FE_INVALID);
EXPECT_MATH_ERRNO(EDOM); EXPECT_MATH_ERRNO(EDOM);
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
Show All 20 LinesTEST(LlvmLibcAtanhfTest, SpecialNumbers) {
bt.set_sign(true); bt.set_sign(true);
EXPECT_FP_EQ(aNaN, __llvm_libc::atanhf(neg_inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::atanhf(neg_inf));
EXPECT_FP_EXCEPTION(FE_INVALID); EXPECT_FP_EXCEPTION(FE_INVALID);
EXPECT_MATH_ERRNO(EDOM); EXPECT_MATH_ERRNO(EDOM);
} }
TEST(LlvmLibcAtanhfTest, InFloatRange) { TEST(LlvmLibcAtanhfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
const uint32_t STEP = FPBits(1.0f).uintval() / COUNT; const uint32_t STEP = FPB(1.0f).uintval() / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
ASSERT_MPFR_MATCH(mpfr::Operation::Atanh, x, __llvm_libc::atanhf(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Atanh, x, __llvm_libc::atanhf(x), 0.5);
ASSERT_MPFR_MATCH(mpfr::Operation::Atanh, -x, __llvm_libc::atanhf(-x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Atanh, -x, __llvm_libc::atanhf(-x), 0.5);
} }
} }
// For small values, atanh(x) is x. // For small values, atanh(x) is x.
TEST(LlvmLibcAtanhfTest, SmallValues) { TEST(LlvmLibcAtanhfTest, SmallValues) {
float x = float(FPBits(uint32_t(0x17800000))); float x = float(FPB(uint32_t(0x17800000)));
float result = __llvm_libc::atanhf(x); float result = __llvm_libc::atanhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Atanh, x, result, 0.5); EXPECT_MPFR_MATCH(mpfr::Operation::Atanh, x, result, 0.5);
EXPECT_FP_EQ(x, result); EXPECT_FP_EQ(x, result);
x = float(FPBits(uint32_t(0x00400000))); x = float(FPB(uint32_t(0x00400000)));
result = __llvm_libc::atanhf(x); result = __llvm_libc::atanhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Atanh, x, result, 0.5); EXPECT_MPFR_MATCH(mpfr::Operation::Atanh, x, result, 0.5);
EXPECT_FP_EQ(x, result); EXPECT_FP_EQ(x, result);
} }

libc/test/src/math/cos_test.cpp

Show All 16 Lines
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibccosTest, Range) { TEST(LlvmLibccosTest, Range) {
static constexpr double _2pi = 6.283185307179586; static constexpr double _2pi = 6.283185307179586;
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
double x = double(FPBits(v)); double x = double(FPB(v));
// TODO: Expand the range of testing after range reduction is implemented. // TODO: Expand the range of testing after range reduction is implemented.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi) if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cos(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cos(x), 1.0);
} }
} }

libc/test/src/math/cosf_test.cpp

Show All 12 Lines
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::SDCOMP26094_VALUES; using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcCosfTest, SpecialNumbers) { TEST(LlvmLibcCosfTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 12 LinesTEST(LlvmLibcCosfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(neg_inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(neg_inf));
EXPECT_MATH_ERRNO(EDOM); EXPECT_MATH_ERRNO(EDOM);
} }
TEST(LlvmLibcCosfTest, InFloatRange) { TEST(LlvmLibcCosfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Cos, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Cos, x,
__llvm_libc::cosf(x), 0.5); __llvm_libc::cosf(x), 0.5);
} }
} }
TEST(LlvmLibcCosfTest, SpecificBitPatterns) { TEST(LlvmLibcCosfTest, SpecificBitPatterns) {
Show All 39 Lines constexpr uint32_t INPUTS[N] = {
0x6c55'da58U, // x = 0x1.abb4bp+89f 0x6c55'da58U, // x = 0x1.abb4bp+89f
0x6f79'be45U, // x = 0x1.f37c8ap+95f 0x6f79'be45U, // x = 0x1.f37c8ap+95f
0x7276'69d4U, // x = 0x1.ecd3a8p+101f 0x7276'69d4U, // x = 0x1.ecd3a8p+101f
0x7758'4625U, // x = 0x1.b08c4ap+111f 0x7758'4625U, // x = 0x1.b08c4ap+111f
0x7bee'f5efU, // x = 0x1.ddebdep+120f 0x7bee'f5efU, // x = 0x1.ddebdep+120f
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Cos, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Cos, x,
__llvm_libc::cosf(x), 0.5); __llvm_libc::cosf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Cos, -x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Cos, -x,
__llvm_libc::cosf(-x), 0.5); __llvm_libc::cosf(-x), 0.5);
} }
} }
// SDCOMP-26094: check cosf in the cases for which the range reducer // SDCOMP-26094: check cosf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4. // returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcCosfTest, SDCOMP_26094) { TEST(LlvmLibcCosfTest, SDCOMP_26094) {
for (uint32_t v : SDCOMP26094_VALUES) { for (uint32_t v : SDCOMP26094_VALUES) {
float x = float(FPBits(v)); float x = float(FPB(v));
ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), 0.5);
} }
} }

libc/test/src/math/coshf_test.cpp

Show All 11 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcCoshfTest, SpecialNumbers) { TEST(LlvmLibcCoshfTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 10 LinesTEST(LlvmLibcCoshfTest, SpecialNumbers) {
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::coshf(-0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::coshf(-0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcCoshfTest, Overflow) { TEST(LlvmLibcCoshfTest, Overflow) {
errno = 0; errno = 0;
EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPBits(0x7f7fffffU)))); EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPB(0x7f7fffffU))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPBits(0x42cffff8U)))); EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPB(0x42cffff8U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPBits(0x42d00008U)))); EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPB(0x42d00008U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
TEST(LlvmLibcCoshfTest, InFloatRange) { TEST(LlvmLibcCoshfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Cosh, x, __llvm_libc::coshf(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Cosh, x, __llvm_libc::coshf(x), 0.5);
} }
} }
TEST(LlvmLibcCoshfTest, SmallValues) { TEST(LlvmLibcCoshfTest, SmallValues) {
float x = float(FPBits(0x17800000U)); float x = float(FPB(0x17800000U));
float result = __llvm_libc::coshf(x); float result = __llvm_libc::coshf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x, result, 0.5); EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x, result, 0.5);
EXPECT_FP_EQ(1.0f, result); EXPECT_FP_EQ(1.0f, result);
x = float(FPBits(0x0040000U)); x = float(FPB(0x0040000U));
result = __llvm_libc::coshf(x); result = __llvm_libc::coshf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x, result, 0.5); EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x, result, 0.5);
EXPECT_FP_EQ(1.0f, result); EXPECT_FP_EQ(1.0f, result);
} }

libc/test/src/math/differential_testing/BinaryOpSingleOutputDiff.h

//===-- Common utility class for differential analysis --------------------===// //===-- Common utility class for differential analysis --------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/testutils/StreamWrapper.h" #include "utils/testutils/StreamWrapper.h"
#include "utils/testutils/Timer.h" #include "utils/testutils/Timer.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace testing { namespace testing {
template <typename T> class BinaryOpSingleOutputDiff { template <typename T> class BinaryOpSingleOutputDiff {
using FPBits = fputil::FPBits<T>; using FPB = fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
static constexpr UIntType MSBIT = UIntType(1) << (8 * sizeof(UIntType) - 1); static constexpr UIntType MSBIT = UIntType(1) << (8 * sizeof(UIntType) - 1);
static constexpr UIntType UINTMAX = (MSBIT - 1) + MSBIT; static constexpr UIntType UINTMAX = (MSBIT - 1) + MSBIT;
public: public:
typedef T Func(T, T); typedef T Func(T, T);
static uint64_t run_diff_in_range(Func myFunc, Func otherFunc, static uint64_t run_diff_in_range(Func myFunc, Func otherFunc,
UIntType startingBit, UIntType endingBit, UIntType startingBit, UIntType endingBit,
UIntType N, UIntType N,
testutils::OutputFileStream &log) { testutils::OutputFileStream &log) {
uint64_t result = 0; uint64_t result = 0;
if (endingBit < startingBit) { if (endingBit < startingBit) {
return result; return result;
} }
UIntType step = (endingBit - startingBit) / N; UIntType step = (endingBit - startingBit) / N;
for (UIntType bitsX = startingBit, bitsY = endingBit;; for (UIntType bitsX = startingBit, bitsY = endingBit;;
bitsX += step, bitsY -= step) { bitsX += step, bitsY -= step) {
T x = T(FPBits(bitsX)); T x = T(FPB(bitsX));
T y = T(FPBits(bitsY)); T y = T(FPB(bitsY));
FPBits myBits = FPBits(myFunc(x, y)); FPB myBits = FPB(myFunc(x, y));
FPBits otherBits = FPBits(otherFunc(x, y)); FPB otherBits = FPB(otherFunc(x, y));
if (myBits.uintval() != otherBits.uintval()) { if (myBits.uintval() != otherBits.uintval()) {
result++; result++;
log << " Input: " << bitsX << ", " << bitsY << " (" << x << ", " log << " Input: " << bitsX << ", " << bitsY << " (" << x << ", "
<< y << ")\n" << y << ")\n"
<< " My result: " << myBits.uintval() << " (" << myBits.get_val() << " My result: " << myBits.uintval() << " (" << myBits.get_val()
<< ")\n" << ")\n"
<< "Other result: " << otherBits.uintval() << " (" << "Other result: " << otherBits.uintval() << " ("
<< otherBits.get_val() << ")\n" << otherBits.get_val() << ")\n"
Show All 14 Lines auto runner = [=](Func func) {
volatile T result; volatile T result;
if (endingBit < startingBit) { if (endingBit < startingBit) {
return; return;
} }
UIntType step = (endingBit - startingBit) / N; UIntType step = (endingBit - startingBit) / N;
for (UIntType bitsX = startingBit, bitsY = endingBit;; for (UIntType bitsX = startingBit, bitsY = endingBit;;
bitsX += step, bitsY -= step) { bitsX += step, bitsY -= step) {
T x = T(FPBits(bitsX)); T x = T(FPB(bitsX));
T y = T(FPBits(bitsY)); T y = T(FPB(bitsY));
result = func(x, y); result = func(x, y);
if (endingBit - bitsX < step) { if (endingBit - bitsX < step) {
break; break;
} }
} }
}; };
Timer timer; Timer timer;
Show All 22 Lines static void run_perf_in_range(Func myFunc, Func otherFunc,
log << "-- Average runtime ratio --\n"; log << "-- Average runtime ratio --\n";
log << " Mine / Other's : " << my_average / other_average << " \n"; log << " Mine / Other's : " << my_average / other_average << " \n";
} }
static void run_perf(Func myFunc, Func otherFunc, const char *logFile) { static void run_perf(Func myFunc, Func otherFunc, const char *logFile) {
testutils::OutputFileStream log(logFile); testutils::OutputFileStream log(logFile);
log << " Performance tests with inputs in denormal range:\n"; log << " Performance tests with inputs in denormal range:\n";
run_perf_in_range(myFunc, otherFunc, /* startingBit= */ UIntType(0), run_perf_in_range(myFunc, otherFunc, /* startingBit= */ UIntType(0),
/* endingBit= */ FPBits::MAX_SUBNORMAL, 1'000'001, log); /* endingBit= */ FPB::MAX_SUBNORMAL, 1'000'001, log);
log << "\n Performance tests with inputs in normal range:\n"; log << "\n Performance tests with inputs in normal range:\n";
run_perf_in_range(myFunc, otherFunc, /* startingBit= */ FPBits::MIN_NORMAL, run_perf_in_range(myFunc, otherFunc, /* startingBit= */ FPB::MIN_NORMAL,
/* endingBit= */ FPBits::MAX_NORMAL, 100'000'001, log); /* endingBit= */ FPB::MAX_NORMAL, 100'000'001, log);
log << "\n Performance tests with inputs in normal range with exponents " log << "\n Performance tests with inputs in normal range with exponents "
"close to each other:\n"; "close to each other:\n";
run_perf_in_range( run_perf_in_range(
myFunc, otherFunc, /* startingBit= */ FPBits(T(0x1.0p-10)).uintval(), myFunc, otherFunc, /* startingBit= */ FPB(T(0x1.0p-10)).uintval(),
/* endingBit= */ FPBits(T(0x1.0p+10)).uintval(), 10'000'001, log); /* endingBit= */ FPB(T(0x1.0p+10)).uintval(), 10'000'001, log);
} }
static void run_diff(Func myFunc, Func otherFunc, const char *logFile) { static void run_diff(Func myFunc, Func otherFunc, const char *logFile) {
uint64_t diffCount = 0; uint64_t diffCount = 0;
testutils::OutputFileStream log(logFile); testutils::OutputFileStream log(logFile);
log << " Diff tests with inputs in denormal range:\n"; log << " Diff tests with inputs in denormal range:\n";
diffCount += run_diff_in_range( diffCount +=
myFunc, otherFunc, /* startingBit= */ UIntType(0), run_diff_in_range(myFunc, otherFunc, /* startingBit= */ UIntType(0),
/* endingBit= */ FPBits::MAX_SUBNORMAL, 1'000'001, log); /* endingBit= */ FPB::MAX_SUBNORMAL, 1'000'001, log);
log << "\n Diff tests with inputs in normal range:\n"; log << "\n Diff tests with inputs in normal range:\n";
diffCount += run_diff_in_range( diffCount +=
myFunc, otherFunc, /* startingBit= */ FPBits::MIN_NORMAL, run_diff_in_range(myFunc, otherFunc, /* startingBit= */ FPB::MIN_NORMAL,
/* endingBit= */ FPBits::MAX_NORMAL, 100'000'001, log); /* endingBit= */ FPB::MAX_NORMAL, 100'000'001, log);
log << "\n Diff tests with inputs in normal range with exponents " log << "\n Diff tests with inputs in normal range with exponents "
"close to each other:\n"; "close to each other:\n";
diffCount += run_diff_in_range( diffCount += run_diff_in_range(
myFunc, otherFunc, /* startingBit= */ FPBits(T(0x1.0p-10)).uintval(), myFunc, otherFunc, /* startingBit= */ FPB(T(0x1.0p-10)).uintval(),
/* endingBit= */ FPBits(T(0x1.0p+10)).uintval(), 10'000'001, log); /* endingBit= */ FPB(T(0x1.0p+10)).uintval(), 10'000'001, log);
log << "Total number of differing results: " << diffCount << '\n'; log << "Total number of differing results: " << diffCount << '\n';
} }
}; };
} // namespace testing } // namespace testing
} // namespace __llvm_libc } // namespace __llvm_libc
Show All 13 Lines

libc/test/src/math/differential_testing/SingleInputSingleOutputDiff.h

//===-- Common utility class for differential analysis --------------------===// //===-- Common utility class for differential analysis --------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/testutils/StreamWrapper.h" #include "utils/testutils/StreamWrapper.h"
#include "utils/testutils/Timer.h" #include "utils/testutils/Timer.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace testing { namespace testing {
template <typename T> class SingleInputSingleOutputDiff { template <typename T> class SingleInputSingleOutputDiff {
using FPBits = fputil::FPBits<T>; using FPB = fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPB::UIntType;
static constexpr UIntType MSBit = UIntType(1) << (8 * sizeof(UIntType) - 1); static constexpr UIntType MSBit = UIntType(1) << (8 * sizeof(UIntType) - 1);
static constexpr UIntType UIntMax = (MSBit - 1) + MSBit; static constexpr UIntType UIntMax = (MSBit - 1) + MSBit;
public: public:
typedef T Func(T); typedef T Func(T);
static void runDiff(Func myFunc, Func otherFunc, const char *logFile) { static void runDiff(Func myFunc, Func otherFunc, const char *logFile) {
UIntType diffCount = 0; UIntType diffCount = 0;
testutils::OutputFileStream log(logFile); testutils::OutputFileStream log(logFile);
log << "Starting diff for values from 0 to " << UIntMax << '\n' log << "Starting diff for values from 0 to " << UIntMax << '\n'
<< "Only differing results will be logged.\n\n"; << "Only differing results will be logged.\n\n";
for (UIntType bits = 0;; ++bits) { for (UIntType bits = 0;; ++bits) {
T x = T(FPBits(bits)); T x = T(FPB(bits));
T myResult = myFunc(x); T myResult = myFunc(x);
T otherResult = otherFunc(x); T otherResult = otherFunc(x);
UIntType myBits = FPBits(myResult).uintval(); UIntType myBits = FPB(myResult).uintval();
UIntType otherBits = FPBits(otherResult).uintval(); UIntType otherBits = FPB(otherResult).uintval();
if (myBits != otherBits) { if (myBits != otherBits) {
++diffCount; ++diffCount;
log << " Input: " << bits << " (" << x << ")\n" log << " Input: " << bits << " (" << x << ")\n"
<< " My result: " << myBits << " (" << myResult << ")\n" << " My result: " << myBits << " (" << myResult << ")\n"
<< "Other result: " << otherBits << " (" << otherResult << ")\n" << "Other result: " << otherBits << " (" << otherResult << ")\n"
<< '\n'; << '\n';
} }
if (bits == UIntMax) if (bits == UIntMax)
break; break;
} }
log << "Total number of differing results: " << diffCount << '\n'; log << "Total number of differing results: " << diffCount << '\n';
} }
static void runPerfInRange(Func myFunc, Func otherFunc, UIntType startingBit, static void runPerfInRange(Func myFunc, Func otherFunc, UIntType startingBit,
UIntType endingBit, UIntType endingBit,
testutils::OutputFileStream &log) { testutils::OutputFileStream &log) {
auto runner = [=](Func func) { auto runner = [=](Func func) {
volatile T result; volatile T result;
for (UIntType bits = startingBit;; ++bits) { for (UIntType bits = startingBit;; ++bits) {
T x = T(FPBits(bits)); T x = T(FPB(bits));
result = func(x); result = func(x);
if (bits == endingBit) if (bits == endingBit)
break; break;
} }
}; };
Timer timer; Timer timer;
timer.start(); timer.start();
Show All 23 Lines static void runPerfInRange(Func myFunc, Func otherFunc, UIntType startingBit,
log << "-- Average runtime ratio --\n"; log << "-- Average runtime ratio --\n";
log << " Mine / Other's : " << myAverage / otherAverage << " \n"; log << " Mine / Other's : " << myAverage / otherAverage << " \n";
} }
static void runPerf(Func myFunc, Func otherFunc, const char *logFile) { static void runPerf(Func myFunc, Func otherFunc, const char *logFile) {
testutils::OutputFileStream log(logFile); testutils::OutputFileStream log(logFile);
log << " Performance tests with inputs in denormal range:\n"; log << " Performance tests with inputs in denormal range:\n";
runPerfInRange(myFunc, otherFunc, /* startingBit= */ UIntType(0), runPerfInRange(myFunc, otherFunc, /* startingBit= */ UIntType(0),
/* endingBit= */ FPBits::MAX_SUBNORMAL, log); /* endingBit= */ FPB::MAX_SUBNORMAL, log);
log << "\n Performance tests with inputs in normal range:\n"; log << "\n Performance tests with inputs in normal range:\n";
runPerfInRange(myFunc, otherFunc, /* startingBit= */ FPBits::MIN_NORMAL, runPerfInRange(myFunc, otherFunc, /* startingBit= */ FPB::MIN_NORMAL,
/* endingBit= */ FPBits::MAX_NORMAL, log); /* endingBit= */ FPB::MAX_NORMAL, log);
} }
}; };
} // namespace testing } // namespace testing
} // namespace __llvm_libc } // namespace __llvm_libc
#define SINGLE_INPUT_SINGLE_OUTPUT_DIFF(T, myFunc, otherFunc, filename) \ #define SINGLE_INPUT_SINGLE_OUTPUT_DIFF(T, myFunc, otherFunc, filename) \
int main() { \ int main() { \
Show All 11 Lines

libc/test/src/math/exhaustive/acosf_test.cpp

//===-- Exhaustive test for acosf -----------------------------------------===// //===-- Exhaustive test for acosf -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/acosf.h" #include "src/math/acosf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcAcosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcAcosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Acos, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Acos, x,
__llvm_libc::acosf(x), 0.5, rounding); __llvm_libc::acosf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/asinf_test.cpp

//===-- Exhaustive test for asinf -----------------------------------------===// //===-- Exhaustive test for asinf -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/asinf.h" #include "src/math/asinf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcAsinfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcAsinfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Asin, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Asin, x,
__llvm_libc::asinf(x), 0.5, rounding); __llvm_libc::asinf(x), 0.5, rounding);
// if (!result) break; // if (!result) break;
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/asinhf_test.cpp

//===-- Exhaustive test for asinhf ----------------------------------------===// //===-- Exhaustive test for asinhf ----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/asinhf.h" #include "src/math/asinhf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcAsinhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcAsinhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Asinh, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Asinh, x,
__llvm_libc::asinhf(x), 0.5, rounding); __llvm_libc::asinhf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/atanf_test.cpp

//===-- Exhaustive test for atanf -----------------------------------------===// //===-- Exhaustive test for atanf -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/atanf.h" #include "src/math/atanf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcAtanfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcAtanfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Atan, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Atan, x,
__llvm_libc::atanf(x), 0.5, rounding); __llvm_libc::atanf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
static const int NUM_THREADS = std::thread::hardware_concurrency(); static const int NUM_THREADS = std::thread::hardware_concurrency();
// Range: [0, 1.0]; // Range: [0, 1.0];
static const uint32_t POS_START = 0x0000'0000U; static const uint32_t POS_START = 0x0000'0000U;
static const uint32_t POS_STOP = FPBits::inf().uintval(); static const uint32_t POS_STOP = FPB::inf().uintval();
TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundNearestTieToEven) { TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundNearestTieToEven) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest);
} }
TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundUp) { TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundUp) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Upward); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Upward);
} }
TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundDown) { TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundDown) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Downward); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Downward);
} }
TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundTowardZero) { TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundTowardZero) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::TowardZero); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::TowardZero);
} }
// Range: [-1.0, 0]; // Range: [-1.0, 0];
static const uint32_t NEG_START = 0x8000'0000U; static const uint32_t NEG_START = 0x8000'0000U;
static const uint32_t NEG_STOP = FPBits::neg_inf().uintval(); static const uint32_t NEG_STOP = FPB::neg_inf().uintval();
TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundNearestTieToEven) { TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundNearestTieToEven) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Nearest); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Nearest);
} }
TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundUp) { TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundUp) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Upward); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Upward);
} }
TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundDown) { TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundDown) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Downward); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Downward);
} }
TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundTowardZero) { TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundTowardZero) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::TowardZero); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::TowardZero);
} }

libc/test/src/math/exhaustive/atanhf_test.cpp

//===-- Exhaustive test for atanhf ----------------------------------------===// //===-- Exhaustive test for atanhf ----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/atanhf.h" #include "src/math/atanhf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcAtanhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcAtanhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Atanh, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Atanh, x,
__llvm_libc::atanhf(x), 0.5, rounding); __llvm_libc::atanhf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
static const int NUM_THREADS = std::thread::hardware_concurrency(); static const int NUM_THREADS = std::thread::hardware_concurrency();
// Range: [0, 1.0]; // Range: [0, 1.0];
static const uint32_t POS_START = 0x0000'0000U; static const uint32_t POS_START = 0x0000'0000U;
static const uint32_t POS_STOP = FPBits(1.0f).uintval(); static const uint32_t POS_STOP = FPB(1.0f).uintval();
TEST_F(LlvmLibcAtanhfExhaustiveTest, PostiveRangeRoundNearestTieToEven) { TEST_F(LlvmLibcAtanhfExhaustiveTest, PostiveRangeRoundNearestTieToEven) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest);
} }
TEST_F(LlvmLibcAtanhfExhaustiveTest, PostiveRangeRoundUp) { TEST_F(LlvmLibcAtanhfExhaustiveTest, PostiveRangeRoundUp) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Upward); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Upward);
} }
TEST_F(LlvmLibcAtanhfExhaustiveTest, PostiveRangeRoundDown) { TEST_F(LlvmLibcAtanhfExhaustiveTest, PostiveRangeRoundDown) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Downward); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Downward);
} }
TEST_F(LlvmLibcAtanhfExhaustiveTest, PostiveRangeRoundTowardZero) { TEST_F(LlvmLibcAtanhfExhaustiveTest, PostiveRangeRoundTowardZero) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::TowardZero); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::TowardZero);
} }
// Range: [-1.0, 0]; // Range: [-1.0, 0];
static const uint32_t NEG_START = 0x8000'0000U; static const uint32_t NEG_START = 0x8000'0000U;
static const uint32_t NEG_STOP = FPBits(-1.0f).uintval(); static const uint32_t NEG_STOP = FPB(-1.0f).uintval();
TEST_F(LlvmLibcAtanhfExhaustiveTest, NegativeRangeRoundNearestTieToEven) { TEST_F(LlvmLibcAtanhfExhaustiveTest, NegativeRangeRoundNearestTieToEven) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Nearest); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Nearest);
} }
TEST_F(LlvmLibcAtanhfExhaustiveTest, NegativeRangeRoundUp) { TEST_F(LlvmLibcAtanhfExhaustiveTest, NegativeRangeRoundUp) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Upward); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Upward);
} }
TEST_F(LlvmLibcAtanhfExhaustiveTest, NegativeRangeRoundDown) { TEST_F(LlvmLibcAtanhfExhaustiveTest, NegativeRangeRoundDown) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Downward); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Downward);
} }
TEST_F(LlvmLibcAtanhfExhaustiveTest, NegativeRangeRoundTowardZero) { TEST_F(LlvmLibcAtanhfExhaustiveTest, NegativeRangeRoundTowardZero) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::TowardZero); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::TowardZero);
} }

libc/test/src/math/exhaustive/cosf_test.cpp

//===-- Exhaustive test for cosf ------------------------------------------===// //===-- Exhaustive test for cosf ------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/cosf.h" #include "src/math/cosf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcCosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcCosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x),
0.5, rounding); 0.5, rounding);
result &= r; result &= r;
} while (++bits < stop); } while (++bits < stop);
return result; return result;
} }
}; };
Show All 40 Lines

libc/test/src/math/exhaustive/coshf_test.cpp

//===-- Exhaustive test for coshf -----------------------------------------===// //===-- Exhaustive test for coshf -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/coshf.h" #include "src/math/coshf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcCoshfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcCoshfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x,
__llvm_libc::coshf(x), 0.5, rounding); __llvm_libc::coshf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
Show All 19 Lines

libc/test/src/math/exhaustive/exp10f_test.cpp

//===-- Exhaustive test for exp10f ----------------------------------------===// //===-- Exhaustive test for exp10f ----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/exp10f.h" #include "src/math/exp10f.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcExp10fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcExp10fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp10, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp10, x,
__llvm_libc::exp10f(x), 0.5, rounding); __llvm_libc::exp10f(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
Show All 39 Lines

libc/test/src/math/exhaustive/exp2f_test.cpp

//===-- Exhaustive test for exp2f -----------------------------------------===// //===-- Exhaustive test for exp2f -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/exp2f.h" #include "src/math/exp2f.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcExp2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcExp2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5, rounding); __llvm_libc::exp2f(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
Show All 39 Lines

libc/test/src/math/exhaustive/expf_test.cpp

//===-- Exhaustive test for expf ------------------------------------------===// //===-- Exhaustive test for expf ------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/expf.h" #include "src/math/expf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcExpfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcExpfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5, rounding); 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
Show All 39 Lines

libc/test/src/math/exhaustive/expm1f_test.cpp

//===-- Exhaustive test for expm1f ----------------------------------------===// //===-- Exhaustive test for expm1f ----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/expm1f.h" #include "src/math/expm1f.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcExpm1fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcExpm1fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = stop; uint32_t bits = stop;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Expm1, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5, rounding); __llvm_libc::expm1f(x), 0.5, rounding);
} while (bits-- > start); } while (bits-- > start);
return result; return result;
} }
}; };
Show All 39 Lines

libc/test/src/math/exhaustive/hypotf_test.cpp

//===-- Exhaustive test for hypotf ----------------------------------------===// //===-- Exhaustive test for hypotf ----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/Hypot.h" #include "src/__support/FPUtil/Hypot.h"
#include "src/math/hypotf.h" #include "src/math/hypotf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcHypotfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcHypotfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
// Range of the second input: [2^37, 2^48). // Range of the second input: [2^37, 2^48).
constexpr uint32_t Y_START = (37U + 127U) << 23; constexpr uint32_t Y_START = (37U + 127U) << 23;
constexpr uint32_t Y_STOP = (48U + 127U) << 23; constexpr uint32_t Y_STOP = (48U + 127U) << 23;
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t xbits = start; uint32_t xbits = start;
bool result = true; bool result = true;
do { do {
float x = float(FPBits(xbits)); float x = float(FPB(xbits));
uint32_t ybits = Y_START; uint32_t ybits = Y_START;
do { do {
float y = float(FPBits(ybits)); float y = float(FPB(ybits));
result &= EXPECT_FP_EQ(__llvm_libc::fputil::hypot(x, y), result &= EXPECT_FP_EQ(__llvm_libc::fputil::hypot(x, y),
__llvm_libc::hypotf(x, y)); __llvm_libc::hypotf(x, y));
// Using MPFR will be much slower. // Using MPFR will be much slower.
// mpfr::BinaryInput<float> input{x, y}; // mpfr::BinaryInput<float> input{x, y};
// EXPECT_MPFR_MATCH(mpfr::Operation::Hypot, input, // EXPECT_MPFR_MATCH(mpfr::Operation::Hypot, input,
// __llvm_libc::hypotf(x, y), 0.5, // __llvm_libc::hypotf(x, y), 0.5,
// rounding); // rounding);
} while (ybits++ < Y_STOP); } while (ybits++ < Y_STOP);
Show All 24 Lines

libc/test/src/math/exhaustive/log10f_test.cpp

//===-- Exhaustive test for log10f ----------------------------------------===// //===-- Exhaustive test for log10f ----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/log10f.h" #include "src/math/log10f.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcLog10fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcLog10fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log10, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log10, x,
__llvm_libc::log10f(x), 0.5, rounding); __llvm_libc::log10f(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
Show All 21 Lines

libc/test/src/math/exhaustive/log1pf_test.cpp

//===-- Exhaustive test for log1pf ----------------------------------------===// //===-- Exhaustive test for log1pf ----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/log1pf.h" #include "src/math/log1pf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibclog1pfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibclog1pfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log1p, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log1p, x,
__llvm_libc::log1pf(x), 0.5, rounding); __llvm_libc::log1pf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
Show All 22 Lines

libc/test/src/math/exhaustive/log2f_test.cpp

//===-- Exhaustive test for log2f -----------------------------------------===// //===-- Exhaustive test for log2f -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/log2f.h" #include "src/math/log2f.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcLog2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcLog2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log2, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log2, x,
__llvm_libc::log2f(x), 0.5, rounding); __llvm_libc::log2f(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
Show All 19 Lines

libc/test/src/math/exhaustive/logf_test.cpp

//===-- Exhaustive test for logf ------------------------------------------===// //===-- Exhaustive test for logf ------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/logf.h" #include "src/math/logf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcLogfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcLogfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x),
0.5, rounding); 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
Show All 19 Lines

libc/test/src/math/exhaustive/sincosf_test.cpp

//===-- Exhaustive test for sincosf ---------------------------------------===// //===-- Exhaustive test for sincosf ---------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/sincosf.h" #include "src/math/sincosf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcSinCosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcSinCosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
float sinx, cosx; float sinx, cosx;
__llvm_libc::sincosf(x, &sinx, &cosx); __llvm_libc::sincosf(x, &sinx, &cosx);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, sinx, 0.5, rounding); result &= EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, sinx, 0.5, rounding);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, cosx, 0.5, rounding); result &= EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, cosx, 0.5, rounding);
} while (++bits < stop); } while (++bits < stop);
return result; return result;
} }
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/sinf_test.cpp

//===-- Exhaustive test for sinf ------------------------------------------===// //===-- Exhaustive test for sinf ------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/sinf.h" #include "src/math/sinf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcSinfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcSinfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x),
0.5, rounding); 0.5, rounding);
result &= r; result &= r;
} while (++bits < stop); } while (++bits < stop);
return result; return result;
} }
}; };
Show All 40 Lines

libc/test/src/math/exhaustive/sinhf_test.cpp

//===-- Exhaustive test for sinhf -----------------------------------------===// //===-- Exhaustive test for sinhf -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/sinhf.h" #include "src/math/sinhf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcSinhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcSinhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x,
__llvm_libc::sinhf(x), 0.5, rounding); __llvm_libc::sinhf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
Show All 39 Lines

libc/test/src/math/exhaustive/sqrtf_test.cpp

//===-- Exhaustive test for sqrtf -----------------------------------------===// //===-- Exhaustive test for sqrtf -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/sqrtf.h" #include "src/math/sqrtf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
TEST(LlvmLibcSqrtfExhaustiveTest, AllValues) { TEST(LlvmLibcSqrtfExhaustiveTest, AllValues) {
uint32_t bits = 0; uint32_t bits = 0;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, __llvm_libc::sqrtf(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, __llvm_libc::sqrtf(x), 0.5);
} while (bits++ < 0xffff'ffffU); } while (bits++ < 0xffff'ffffU);
} }

libc/test/src/math/exhaustive/tanf_test.cpp

Show All 9 Lines
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/tanf.h" #include "src/math/tanf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
static constexpr int TOLERANCE = 3; static constexpr int TOLERANCE = 3;
struct LlvmLibcTanfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcTanfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
int tol = TOLERANCE; int tol = TOLERANCE;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tanf(x), bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tanf(x),
0.5, rounding); 0.5, rounding);
result &= r; result &= r;
if (!r) if (!r)
--tol; --tol;
if (!tol) if (!tol)
break; break;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/tanhf_test.cpp

//===-- Exhaustive test for tanhf -----------------------------------------===// //===-- Exhaustive test for tanhf -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exhaustive_test.h" #include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/tanhf.h" #include "src/math/tanhf.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <thread> #include <thread>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcTanhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcTanhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPB xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Tanh, x, result &= EXPECT_MPFR_MATCH(mpfr::Operation::Tanh, x,
__llvm_libc::tanhf(x), 0.5, rounding); __llvm_libc::tanhf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
return result; return result;
} }
}; };
static const int NUM_THREADS = std::thread::hardware_concurrency(); static const int NUM_THREADS = std::thread::hardware_concurrency();
// Range: [0, INF]; // Range: [0, INF];
static const uint32_t POS_START = 0x0000'0000U; static const uint32_t POS_START = 0x0000'0000U;
static const uint32_t POS_STOP = FPBits::inf(false).uintval(); static const uint32_t POS_STOP = FPB::inf(false).uintval();
TEST_F(LlvmLibcTanhfExhaustiveTest, PostiveRangeRoundNearestTieToEven) { TEST_F(LlvmLibcTanhfExhaustiveTest, PostiveRangeRoundNearestTieToEven) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest);
} }
TEST_F(LlvmLibcTanhfExhaustiveTest, PostiveRangeRoundUp) { TEST_F(LlvmLibcTanhfExhaustiveTest, PostiveRangeRoundUp) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Upward); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Upward);
} }
TEST_F(LlvmLibcTanhfExhaustiveTest, PostiveRangeRoundDown) { TEST_F(LlvmLibcTanhfExhaustiveTest, PostiveRangeRoundDown) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Downward); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Downward);
} }
TEST_F(LlvmLibcTanhfExhaustiveTest, PostiveRangeRoundTowardZero) { TEST_F(LlvmLibcTanhfExhaustiveTest, PostiveRangeRoundTowardZero) {
test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::TowardZero); test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::TowardZero);
} }
// Range: [-INF, 0]; // Range: [-INF, 0];
static const uint32_t NEG_START = 0x8000'0000U; static const uint32_t NEG_START = 0x8000'0000U;
static const uint32_t NEG_STOP = FPBits::inf(true).uintval(); static const uint32_t NEG_STOP = FPB::inf(true).uintval();
TEST_F(LlvmLibcTanhfExhaustiveTest, NegativeRangeRoundNearestTieToEven) { TEST_F(LlvmLibcTanhfExhaustiveTest, NegativeRangeRoundNearestTieToEven) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Nearest); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Nearest);
} }
TEST_F(LlvmLibcTanhfExhaustiveTest, NegativeRangeRoundUp) { TEST_F(LlvmLibcTanhfExhaustiveTest, NegativeRangeRoundUp) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Upward); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Upward);
} }
TEST_F(LlvmLibcTanhfExhaustiveTest, NegativeRangeRoundDown) { TEST_F(LlvmLibcTanhfExhaustiveTest, NegativeRangeRoundDown) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Downward); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Downward);
} }
TEST_F(LlvmLibcTanhfExhaustiveTest, NegativeRangeRoundTowardZero) { TEST_F(LlvmLibcTanhfExhaustiveTest, NegativeRangeRoundTowardZero) {
test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::TowardZero); test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::TowardZero);
} }

libc/test/src/math/exp10f_test.cpp

Show All 35 LinesTEST(LlvmLibcExp10fTest, SpecialNumbers) {
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::exp10f(-0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::exp10f(-0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcExp10fTest, Overflow) { TEST(LlvmLibcExp10fTest, Overflow) {
errno = 0; errno = 0;
EXPECT_FP_EQ(inf, __llvm_libc::exp10f(float(FPBits(0x7f7fffffU)))); EXPECT_FP_EQ(inf, __llvm_libc::exp10f(float(FPB(0x7f7fffffU))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::exp10f(float(FPBits(0x43000000U)))); EXPECT_FP_EQ(inf, __llvm_libc::exp10f(float(FPB(0x43000000U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::exp10f(float(FPBits(0x43000001U)))); EXPECT_FP_EQ(inf, __llvm_libc::exp10f(float(FPB(0x43000001U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
TEST(LlvmLibcExp10fTest, TrickyInputs) { TEST(LlvmLibcExp10fTest, TrickyInputs) {
constexpr int N = 20; constexpr int N = 20;
constexpr uint32_t INPUTS[N] = { constexpr uint32_t INPUTS[N] = {
0x325e5bd8, // x = 0x1.bcb7bp-27f 0x325e5bd8, // x = 0x1.bcb7bp-27f
0x325e5bd9, // x = 0x1.bcb7b2p-27f 0x325e5bd9, // x = 0x1.bcb7b2p-27f
Show All 13 Lines constexpr uint32_t INPUTS[N] = {
0x40c00000, // x = 6.0f 0x40c00000, // x = 6.0f
0x40e00000, // x = 7.0f 0x40e00000, // x = 7.0f
0x41000000, // x = 8.0f 0x41000000, // x = 8.0f
0x41100000, // x = 9.0f 0x41100000, // x = 9.0f
0x41200000, // x = 10.0f 0x41200000, // x = 10.0f
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
errno = 0; errno = 0;
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x,
__llvm_libc::exp10f(x), 0.5); __llvm_libc::exp10f(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, -x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, -x,
__llvm_libc::exp10f(-x), 0.5); __llvm_libc::exp10f(-x), 0.5);
} }
} }
TEST(LlvmLibcExp10fTest, InFloatRange) { TEST(LlvmLibcExp10fTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::exp10f(x); float result = __llvm_libc::exp10f(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x,
__llvm_libc::exp10f(x), 0.5); __llvm_libc::exp10f(x), 0.5);
} }
} }

libc/test/src/math/exp2f_test.cpp

Show All 35 LinesTEST(LlvmLibcExp2fTest, SpecialNumbers) {
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(-0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(-0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcExp2fTest, Overflow) { TEST(LlvmLibcExp2fTest, Overflow) {
errno = 0; errno = 0;
EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x7f7fffffU)))); EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPB(0x7f7fffffU))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x43000000U)))); EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPB(0x43000000U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x43000001U)))); EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPB(0x43000001U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
TEST(LlvmLibcExp2fTest, TrickyInputs) { TEST(LlvmLibcExp2fTest, TrickyInputs) {
constexpr int N = 12; constexpr int N = 12;
constexpr uint32_t INPUTS[N] = { constexpr uint32_t INPUTS[N] = {
0x3b429d37U, /*0x1.853a6ep-9f*/ 0x3b429d37U, /*0x1.853a6ep-9f*/
0x3c02a9adU, /*0x1.05535ap-7f*/ 0x3c02a9adU, /*0x1.05535ap-7f*/
0x3ca66e26U, /*0x1.4cdc4cp-6f*/ 0x3ca66e26U, /*0x1.4cdc4cp-6f*/
0x3d92a282U, /*0x1.254504p-4f*/ 0x3d92a282U, /*0x1.254504p-4f*/
0x42fa0001U, /*0x1.f40002p+6f*/ 0x42fa0001U, /*0x1.f40002p+6f*/
0x42ffffffU, /*0x1.fffffep+6f*/ 0x42ffffffU, /*0x1.fffffep+6f*/
0xb8d3d026U, /*-0x1.a7a04cp-14f*/ 0xb8d3d026U, /*-0x1.a7a04cp-14f*/
0xbcf3a937U, /*-0x1.e7526ep-6f*/ 0xbcf3a937U, /*-0x1.e7526ep-6f*/
0xc2fa0001U, /*-0x1.f40002p+6f*/ 0xc2fa0001U, /*-0x1.f40002p+6f*/
0xc2fc0000U, /*-0x1.f8p+6f*/ 0xc2fc0000U, /*-0x1.f8p+6f*/
0xc2fc0001U, /*-0x1.f80002p+6f*/ 0xc2fc0001U, /*-0x1.f80002p+6f*/
0xc3150000U, /*-0x1.2ap+7f*/ 0xc3150000U, /*-0x1.2ap+7f*/
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
errno = 0; errno = 0;
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5); __llvm_libc::exp2f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
} }
TEST(LlvmLibcExp2fTest, Underflow) { TEST(LlvmLibcExp2fTest, Underflow) {
errno = 0; errno = 0;
EXPECT_FP_EQ(0.0f, __llvm_libc::exp2f(float(FPBits(0xff7fffffU)))); EXPECT_FP_EQ(0.0f, __llvm_libc::exp2f(float(FPB(0xff7fffffU))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
float x = float(FPBits(0xc3158000U)); float x = float(FPB(0xc3158000U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5); __llvm_libc::exp2f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0xc3160000U)); x = float(FPB(0xc3160000U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5); __llvm_libc::exp2f(x), 0.5);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
x = float(FPBits(0xc3165432U)); x = float(FPB(0xc3165432U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5); __llvm_libc::exp2f(x), 0.5);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
TEST(LlvmLibcExp2fTest, InFloatRange) { TEST(LlvmLibcExp2fTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::exp2f(x); float result = __llvm_libc::exp2f(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5); __llvm_libc::exp2f(x), 0.5);
} }
} }

libc/test/src/math/expf_test.cpp

Show All 35 LinesTEST(LlvmLibcExpfTest, SpecialNumbers) {
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::expf(-0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::expf(-0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcExpfTest, Overflow) { TEST(LlvmLibcExpfTest, Overflow) {
errno = 0; errno = 0;
EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPBits(0x7f7fffffU)))); EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPB(0x7f7fffffU))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPBits(0x42cffff8U)))); EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPB(0x42cffff8U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPBits(0x42d00008U)))); EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPB(0x42d00008U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
TEST(LlvmLibcExpfTest, Underflow) { TEST(LlvmLibcExpfTest, Underflow) {
errno = 0; errno = 0;
EXPECT_FP_EQ(0.0f, __llvm_libc::expf(float(FPBits(0xff7fffffU)))); EXPECT_FP_EQ(0.0f, __llvm_libc::expf(float(FPB(0xff7fffffU))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
float x = float(FPBits(0xc2cffff8U)); float x = float(FPB(0xc2cffff8U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x), EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5); 0.5);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
x = float(FPBits(0xc2d00008U)); x = float(FPB(0xc2d00008U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x), EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5); 0.5);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
// Test with inputs which are the borders of underflow/overflow but still // Test with inputs which are the borders of underflow/overflow but still
// produce valid results without setting errno. // produce valid results without setting errno.
TEST(LlvmLibcExpfTest, Borderline) { TEST(LlvmLibcExpfTest, Borderline) {
float x; float x;
errno = 0; errno = 0;
x = float(FPBits(0x42affff8U)); x = float(FPB(0x42affff8U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x), ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5); 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0x42b00008U)); x = float(FPB(0x42b00008U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x), ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5); 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0xc2affff8U)); x = float(FPB(0xc2affff8U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x), ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5); 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0xc2b00008U)); x = float(FPB(0xc2b00008U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x), ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5); 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0xc236bd8cU)); x = float(FPB(0xc236bd8cU));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x), EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5); 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcExpfTest, InFloatRange) { TEST(LlvmLibcExpfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::expf(x); float result = __llvm_libc::expf(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x,
__llvm_libc::expf(x), 0.5); __llvm_libc::expf(x), 0.5);
} }
} }

libc/test/src/math/expm1f_test.cpp

Show All 35 LinesTEST(LlvmLibcExpm1fTest, SpecialNumbers) {
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(-0.0f, __llvm_libc::expm1f(-0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::expm1f(-0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcExpm1fTest, Overflow) { TEST(LlvmLibcExpm1fTest, Overflow) {
errno = 0; errno = 0;
EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPBits(0x7f7fffffU)))); EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPB(0x7f7fffffU))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPBits(0x42cffff8U)))); EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPB(0x42cffff8U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPBits(0x42d00008U)))); EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPB(0x42d00008U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
TEST(LlvmLibcExpm1fTest, Underflow) { TEST(LlvmLibcExpm1fTest, Underflow) {
errno = 0; errno = 0;
EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(float(FPBits(0xff7fffffU)))); EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(float(FPB(0xff7fffffU))));
float x = float(FPBits(0xc2cffff8U)); float x = float(FPB(0xc2cffff8U));
EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(x)); EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(x));
x = float(FPBits(0xc2d00008U)); x = float(FPB(0xc2d00008U));
EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(x)); EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(x));
} }
// Test with inputs which are the borders of underflow/overflow but still // Test with inputs which are the borders of underflow/overflow but still
// produce valid results without setting errno. // produce valid results without setting errno.
TEST(LlvmLibcExpm1fTest, Borderline) { TEST(LlvmLibcExpm1fTest, Borderline) {
float x; float x;
errno = 0; errno = 0;
x = float(FPBits(0x42affff8U)); x = float(FPB(0x42affff8U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0x42b00008U)); x = float(FPB(0x42b00008U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0xc2affff8U)); x = float(FPB(0xc2affff8U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0xc2b00008U)); x = float(FPB(0xc2b00008U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0x3dc252ddU)); x = float(FPB(0x3dc252ddU));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0x3e35bec5U)); x = float(FPB(0x3e35bec5U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0x942ed494U)); x = float(FPB(0x942ed494U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0xbdc1c6cbU)); x = float(FPB(0xbdc1c6cbU));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcExpm1fTest, InFloatRange) { TEST(LlvmLibcExpm1fTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::expm1f(x); float result = __llvm_libc::expm1f(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
} }
} }

libc/test/src/math/in_float_range_test_helper.h

// //
// Created by kirill on 8/30/22. // Created by kirill on 8/30/22.
// //
#ifndef LLVM_IN_FLOAT_RANGE_TEST_HELPER_H #ifndef LLVM_IN_FLOAT_RANGE_TEST_HELPER_H
#define LLVM_IN_FLOAT_RANGE_TEST_HELPER_H #define LLVM_IN_FLOAT_RANGE_TEST_HELPER_H
#include <stdint.h> #include <stdint.h>
#define CHECK_DATA(start, stop, mfp_op, f, f_check, count, prec) \ #define CHECK_DATA(start, stop, mfp_op, f, f_check, count, prec) \
{ \ { \
uint64_t ustart = FPBits(start).uintval(); \ uint64_t ustart = FPB(start).uintval(); \
uint64_t ustop = FPBits(stop).uintval(); \ uint64_t ustop = FPB(stop).uintval(); \
for (uint64_t i = 0;; ++i) { \ for (uint64_t i = 0;; ++i) { \
uint64_t v = ustart + (ustop - ustart) * i / count; \ uint64_t v = ustart + (ustop - ustart) * i / count; \
if (v > ustop) \ if (v > ustop) \
break; \ break; \
float x = FPBits(uint32_t(v)).get_val(); \ float x = FPB(uint32_t(v)).get_val(); \
if ((f_check)(x)) { \ if ((f_check)(x)) { \
EXPECT_MPFR_MATCH_ALL_ROUNDING(mfp_op, x, static_cast<float>((f)(x)), \ EXPECT_MPFR_MATCH_ALL_ROUNDING(mfp_op, x, static_cast<float>((f)(x)), \
(prec)); \ (prec)); \
} \ } \
} \ } \
} }
#endif // LLVM_IN_FLOAT_RANGE_TEST_HELPER_H #endif // LLVM_IN_FLOAT_RANGE_TEST_HELPER_H

libc/test/src/math/log10_test.cpp

Show All 19 Lines
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
auto outs = __llvm_libc::testutils::outs(); auto outs = __llvm_libc::testutils::outs();
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibcLog10Test, SpecialNumbers) { TEST(LlvmLibcLog10Test, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::log10(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::log10(aNaN));
EXPECT_FP_EQ(inf, __llvm_libc::log10(inf)); EXPECT_FP_EQ(inf, __llvm_libc::log10(inf));
EXPECT_TRUE(FPBits(__llvm_libc::log10(neg_inf)).is_nan()); EXPECT_TRUE(FPB(__llvm_libc::log10(neg_inf)).is_nan());
EXPECT_FP_EQ(neg_inf, __llvm_libc::log10(0.0)); EXPECT_FP_EQ(neg_inf, __llvm_libc::log10(0.0));
EXPECT_FP_EQ(neg_inf, __llvm_libc::log10(-0.0)); EXPECT_FP_EQ(neg_inf, __llvm_libc::log10(-0.0));
EXPECT_TRUE(FPBits(__llvm_libc::log10(-1.0)).is_nan()); EXPECT_TRUE(FPB(__llvm_libc::log10(-1.0)).is_nan());
EXPECT_FP_EQ(zero, __llvm_libc::log10(1.0)); EXPECT_FP_EQ(zero, __llvm_libc::log10(1.0));
} }
TEST(LlvmLibcLog10Test, TrickyInputs) { TEST(LlvmLibcLog10Test, TrickyInputs) {
constexpr int N = 27; constexpr int N = 27;
constexpr uint64_t INPUTS[N] = { constexpr uint64_t INPUTS[N] = {
0x3ff0000000000000, // x = 1.0 0x3ff0000000000000, // x = 1.0
0x4024000000000000, // x = 10.0 0x4024000000000000, // x = 10.0
Show All 17 Lines constexpr uint64_t INPUTS[N] = {
0x43e158e460913d00, // x = 10^19 0x43e158e460913d00, // x = 10^19
0x4415af1d78b58c40, // x = 10^20 0x4415af1d78b58c40, // x = 10^20
0x444b1ae4d6e2ef50, // x = 10^21 0x444b1ae4d6e2ef50, // x = 10^21
0x4480f0cf064dd592, // x = 10^22 0x4480f0cf064dd592, // x = 10^22
0x3fefffffffef06ad, 0x3fefde0f22c7d0eb, 0x3fefffffffef06ad, 0x3fefde0f22c7d0eb,
0x225e7812faadb32f, 0x3fee1076964c2903, 0x225e7812faadb32f, 0x3fee1076964c2903,
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
double x = double(FPBits(INPUTS[i])); double x = double(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log10, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log10, x,
__llvm_libc::log10(x), 0.5); __llvm_libc::log10(x), 0.5);
} }
} }
TEST(LlvmLibcLog10Test, InDoubleRange) { TEST(LlvmLibcLog10Test, InDoubleRange) {
constexpr uint64_t COUNT = 1234561; constexpr uint64_t COUNT = 1234561;
constexpr uint64_t STEP = 0x3FF0'0000'0000'0000ULL / COUNT; constexpr uint64_t STEP = 0x3FF0'0000'0000'0000ULL / COUNT;
auto test = [&](mpfr::RoundingMode rounding_mode) { auto test = [&](mpfr::RoundingMode rounding_mode) {
mpfr::ForceRoundingMode __r(rounding_mode); mpfr::ForceRoundingMode __r(rounding_mode);
uint64_t fails = 0; uint64_t fails = 0;
uint64_t count = 0; uint64_t count = 0;
uint64_t cc = 0; uint64_t cc = 0;
double mx, mr = 0.0; double mx, mr = 0.0;
double tol = 0.5; double tol = 0.5;
for (uint64_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint64_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
double x = FPBits(v).get_val(); double x = FPB(v).get_val();
if (isnan(x) || isinf(x) || x < 0.0) if (isnan(x) || isinf(x) || x < 0.0)
continue; continue;
errno = 0; errno = 0;
double result = __llvm_libc::log10(x); double result = __llvm_libc::log10(x);
++cc; ++cc;
if (isnan(result)) if (isnan(result))
continue; continue;
Show All 33 Lines

libc/test/src/math/log10f_test.cpp

Show All 17 Lines
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcLog10fTest, SpecialNumbers) { TEST(LlvmLibcLog10fTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::log10f(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::log10f(aNaN));
EXPECT_FP_EQ(inf, __llvm_libc::log10f(inf)); EXPECT_FP_EQ(inf, __llvm_libc::log10f(inf));
EXPECT_TRUE(FPBits(__llvm_libc::log10f(neg_inf)).is_nan()); EXPECT_TRUE(FPB(__llvm_libc::log10f(neg_inf)).is_nan());
EXPECT_FP_EQ(neg_inf, __llvm_libc::log10f(0.0f)); EXPECT_FP_EQ(neg_inf, __llvm_libc::log10f(0.0f));
EXPECT_FP_EQ(neg_inf, __llvm_libc::log10f(-0.0f)); EXPECT_FP_EQ(neg_inf, __llvm_libc::log10f(-0.0f));
EXPECT_TRUE(FPBits(__llvm_libc::log10f(-1.0f)).is_nan()); EXPECT_TRUE(FPB(__llvm_libc::log10f(-1.0f)).is_nan());
EXPECT_FP_EQ(zero, __llvm_libc::log10f(1.0f)); EXPECT_FP_EQ(zero, __llvm_libc::log10f(1.0f));
} }
TEST(LlvmLibcLog10fTest, TrickyInputs) { TEST(LlvmLibcLog10fTest, TrickyInputs) {
constexpr int N = 12; constexpr int N = 12;
constexpr uint32_t INPUTS[N] = { constexpr uint32_t INPUTS[N] = {
0x41200000U /*10.0f*/, 0x41200000U /*10.0f*/,
0x42c80000U /*100.0f*/, 0x42c80000U /*100.0f*/,
0x447a0000U /*1,000.0f*/, 0x447a0000U /*1,000.0f*/,
0x461c4000U /*10,000.0f*/, 0x461c4000U /*10,000.0f*/,
0x47c35000U /*100,000.0f*/, 0x47c35000U /*100,000.0f*/,
0x49742400U /*1,000,000.0f*/, 0x49742400U /*1,000,000.0f*/,
0x4b189680U /*10,000,000.0f*/, 0x4b189680U /*10,000,000.0f*/,
0x4cbebc20U /*100,000,000.0f*/, 0x4cbebc20U /*100,000,000.0f*/,
0x4e6e6b28U /*1,000,000,000.0f*/, 0x4e6e6b28U /*1,000,000,000.0f*/,
0x501502f9U /*10,000,000,000.0f*/, 0x501502f9U /*10,000,000,000.0f*/,
0x4f134f83U /*2471461632.0f*/, 0x4f134f83U /*2471461632.0f*/,
0x7956ba5eU /*69683218960000541503257137270226944.0f*/}; 0x7956ba5eU /*69683218960000541503257137270226944.0f*/};
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log10, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log10, x,
__llvm_libc::log10f(x), 0.5); __llvm_libc::log10f(x), 0.5);
} }
} }
TEST(LlvmLibcLog10fTest, InFloatRange) { TEST(LlvmLibcLog10fTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::log10f(x); float result = __llvm_libc::log10f(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log10, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log10, x,
__llvm_libc::log10f(x), 0.5); __llvm_libc::log10f(x), 0.5);
} }
} }

libc/test/src/math/log1pf_test.cpp

Show All 17 Lines
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibclog1pfTest, SpecialNumbers) { TEST(LlvmLibclog1pfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::log1pf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::log1pf(aNaN));
EXPECT_FP_EQ(inf, __llvm_libc::log1pf(inf)); EXPECT_FP_EQ(inf, __llvm_libc::log1pf(inf));
EXPECT_TRUE(FPBits((__llvm_libc::log1pf(neg_inf))).is_nan()); EXPECT_TRUE(FPB((__llvm_libc::log1pf(neg_inf))).is_nan());
EXPECT_FP_EQ(zero, __llvm_libc::log1pf(0.0f)); EXPECT_FP_EQ(zero, __llvm_libc::log1pf(0.0f));
EXPECT_FP_EQ(neg_zero, __llvm_libc::log1pf(-0.0f)); EXPECT_FP_EQ(neg_zero, __llvm_libc::log1pf(-0.0f));
EXPECT_FP_EQ(neg_inf, __llvm_libc::log1pf(-1.0f)); EXPECT_FP_EQ(neg_inf, __llvm_libc::log1pf(-1.0f));
} }
TEST(LlvmLibclog1pfTest, TrickyInputs) { TEST(LlvmLibclog1pfTest, TrickyInputs) {
constexpr int N = 20; constexpr int N = 20;
constexpr uint32_t INPUTS[N] = { constexpr uint32_t INPUTS[N] = {
Show All 14 Lines constexpr uint32_t INPUTS[N] = {
0xb53ffffdU, /*-0x1.7ffffap-21f*/ 0xb53ffffdU, /*-0x1.7ffffap-21f*/
0xb70fffe5U, /*-0x1.1fffcap-17f*/ 0xb70fffe5U, /*-0x1.1fffcap-17f*/
0xbb0ec8c4U, /*-0x1.1d9188p-9f*/ 0xbb0ec8c4U, /*-0x1.1d9188p-9f*/
0xbc4d092cU, /*-0x1.9a1258p-7f*/ 0xbc4d092cU, /*-0x1.9a1258p-7f*/
0xbc657728U, /*-0x1.caee5p-7f*/ 0xbc657728U, /*-0x1.caee5p-7f*/
0xbd1d20afU, /*-0x1.3a415ep-5f*/ 0xbd1d20afU, /*-0x1.3a415ep-5f*/
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
__llvm_libc::log1pf(x), 0.5); __llvm_libc::log1pf(x), 0.5);
} }
} }
TEST(LlvmLibclog1pfTest, InFloatRange) { TEST(LlvmLibclog1pfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::log1pf(x); float result = __llvm_libc::log1pf(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
__llvm_libc::log1pf(x), 0.5); __llvm_libc::log1pf(x), 0.5);
} }
} }

libc/test/src/math/log2f_test.cpp

Show All 17 Lines
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcLog2fTest, SpecialNumbers) { TEST(LlvmLibcLog2fTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::log2f(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::log2f(aNaN));
EXPECT_FP_EQ(inf, __llvm_libc::log2f(inf)); EXPECT_FP_EQ(inf, __llvm_libc::log2f(inf));
EXPECT_TRUE(FPBits(__llvm_libc::log2f(neg_inf)).is_nan()); EXPECT_TRUE(FPB(__llvm_libc::log2f(neg_inf)).is_nan());
EXPECT_FP_EQ(neg_inf, __llvm_libc::log2f(0.0f)); EXPECT_FP_EQ(neg_inf, __llvm_libc::log2f(0.0f));
EXPECT_FP_EQ(neg_inf, __llvm_libc::log2f(-0.0f)); EXPECT_FP_EQ(neg_inf, __llvm_libc::log2f(-0.0f));
EXPECT_TRUE(FPBits(__llvm_libc::log2f(-1.0f)).is_nan()); EXPECT_TRUE(FPB(__llvm_libc::log2f(-1.0f)).is_nan());
EXPECT_FP_EQ(zero, __llvm_libc::log2f(1.0f)); EXPECT_FP_EQ(zero, __llvm_libc::log2f(1.0f));
} }
TEST(LlvmLibcLog2fTest, TrickyInputs) { TEST(LlvmLibcLog2fTest, TrickyInputs) {
constexpr int N = 10; constexpr int N = 10;
constexpr uint32_t INPUTS[N] = { constexpr uint32_t INPUTS[N] = {
0x3f7d57f5U, 0x3f7e3274U, 0x3f7ed848U, 0x3f7fd6ccU, 0x3f7fffffU, 0x3f7d57f5U, 0x3f7e3274U, 0x3f7ed848U, 0x3f7fd6ccU, 0x3f7fffffU,
0x3f80079bU, 0x3f81d0b5U, 0x3f82e602U, 0x3f83c98dU, 0x3f8cba39U}; 0x3f80079bU, 0x3f81d0b5U, 0x3f82e602U, 0x3f83c98dU, 0x3f8cba39U};
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log2, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log2, x,
__llvm_libc::log2f(x), 0.5); __llvm_libc::log2f(x), 0.5);
} }
} }
TEST(LlvmLibcLog2fTest, InFloatRange) { TEST(LlvmLibcLog2fTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::log2f(x); float result = __llvm_libc::log2f(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log2, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log2, x,
__llvm_libc::log2f(x), 0.5); __llvm_libc::log2f(x), 0.5);
} }
} }

libc/test/src/math/logf_test.cpp

Show All 17 Lines
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcLogfTest, SpecialNumbers) { TEST(LlvmLibcLogfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::logf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::logf(aNaN));
EXPECT_FP_EQ(inf, __llvm_libc::logf(inf)); EXPECT_FP_EQ(inf, __llvm_libc::logf(inf));
EXPECT_TRUE(FPBits((__llvm_libc::logf(neg_inf))).is_nan()); EXPECT_TRUE(FPB((__llvm_libc::logf(neg_inf))).is_nan());
EXPECT_FP_EQ(neg_inf, __llvm_libc::logf(0.0f)); EXPECT_FP_EQ(neg_inf, __llvm_libc::logf(0.0f));
EXPECT_FP_EQ(neg_inf, __llvm_libc::logf(-0.0f)); EXPECT_FP_EQ(neg_inf, __llvm_libc::logf(-0.0f));
EXPECT_TRUE(FPBits(__llvm_libc::logf(-1.0f)).is_nan()); EXPECT_TRUE(FPB(__llvm_libc::logf(-1.0f)).is_nan());
EXPECT_FP_EQ(zero, __llvm_libc::logf(1.0f)); EXPECT_FP_EQ(zero, __llvm_libc::logf(1.0f));
} }
TEST(LlvmLibcLogfTest, TrickyInputs) { TEST(LlvmLibcLogfTest, TrickyInputs) {
constexpr int N = 28; constexpr int N = 28;
constexpr uint32_t INPUTS[N] = { constexpr uint32_t INPUTS[N] = {
0x3509dcf6U, /*0x1.13b9ecp-21f*/ 0x3509dcf6U, /*0x1.13b9ecp-21f*/
0x3bf86ef0U, /*0x1.f0ddep-8f*/ 0x3bf86ef0U, /*0x1.f0ddep-8f*/
Show All 20 Lines constexpr uint32_t INPUTS[N] = {
0x4e85f412U, /*0x1.0be824p+30f*/ 0x4e85f412U, /*0x1.0be824p+30f*/
0x500ffb03U, /*0x1.1ff606p+33f*/ 0x500ffb03U, /*0x1.1ff606p+33f*/
0x5cd69e88U, /*0x1.ad3d1p+58f*/ 0x5cd69e88U, /*0x1.ad3d1p+58f*/
0x65d890d3U, /*0x1.b121a6p+76f*/ 0x65d890d3U, /*0x1.b121a6p+76f*/
0x6f31a8ecU, /*0x1.6351d8p+95f*/ 0x6f31a8ecU, /*0x1.6351d8p+95f*/
0x7a17f30aU, /*0x1.2fe614p+117f*/ 0x7a17f30aU, /*0x1.2fe614p+117f*/
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), 0.5); EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), 0.5);
} }
} }
TEST(LlvmLibcLogfTest, InFloatRange) { TEST(LlvmLibcLogfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::logf(x); float result = __llvm_libc::logf(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), 0.5);
} }
} }

libc/test/src/math/mod_k_pi_test.cpp

//===-- Unittests mod_2pi, mod_pi_over_4 and mod_pi_over_2 ----------------===// //===-- Unittests mod_2pi, mod_pi_over_4 and mod_pi_over_2 ----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/generic/dp_trig.h" #include "src/math/generic/dp_trig.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
using FPBits = __llvm_libc::fputil::FPBits<double>; using FPB = __llvm_libc::fputil::FPBits<double>;
using UIntType = FPBits::UIntType; using UIntType = FPB::UIntType;
TEST(LlvmLibcMod2PITest, Range) { TEST(LlvmLibcMod2PITest, Range) {
constexpr UIntType count = 1000000000; constexpr UIntType count = 1000000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
double x = double(FPBits(v)); double x = double(FPB(v));
if (isnan(x) || isinf(x) || x <= 0.0) if (isnan(x) || isinf(x) || x <= 0.0)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Mod2PI, x, __llvm_libc::mod_2pi(x), 0); ASSERT_MPFR_MATCH(mpfr::Operation::Mod2PI, x, __llvm_libc::mod_2pi(x), 0);
} }
} }
TEST(LlvmLibcModPIOver2Test, Range) { TEST(LlvmLibcModPIOver2Test, Range) {
constexpr UIntType count = 1000000000; constexpr UIntType count = 1000000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
double x = double(FPBits(v)); double x = double(FPB(v));
if (isnan(x) || isinf(x) || x <= 0.0) if (isnan(x) || isinf(x) || x <= 0.0)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::ModPIOver2, x, ASSERT_MPFR_MATCH(mpfr::Operation::ModPIOver2, x,
__llvm_libc::mod_pi_over_2(x), 0); __llvm_libc::mod_pi_over_2(x), 0);
} }
} }
TEST(LlvmLibcModPIOver4Test, Range) { TEST(LlvmLibcModPIOver4Test, Range) {
constexpr UIntType count = 1000000000; constexpr UIntType count = 1000000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
double x = double(FPBits(v)); double x = double(FPB(v));
if (isnan(x) || isinf(x) || x <= 0.0) if (isnan(x) || isinf(x) || x <= 0.0)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::ModPIOver4, x, ASSERT_MPFR_MATCH(mpfr::Operation::ModPIOver4, x,
__llvm_libc::mod_pi_over_4(x), 0); __llvm_libc::mod_pi_over_4(x), 0);
} }
} }

libc/test/src/math/pow_test.cpp

Show All 9 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<double>; using FPB = __llvm_libc::fputil::FPBits<double>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibcAsinTest, SpecialNumbers) { TEST(LlvmLibcAsinTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 11 Lines

libc/test/src/math/sin_test.cpp

Show All 17 Lines
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibcSinTest, Range) { TEST(LlvmLibcSinTest, Range) {
static constexpr double _2pi = 6.283185307179586; static constexpr double _2pi = 6.283185307179586;
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
double x = double(FPBits(v)); double x = double(FPB(v));
// TODO: Expand the range of testing after range reduction is implemented. // TODO: Expand the range of testing after range reduction is implemented.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi) if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sin(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sin(x), 1.0);
} }
} }

libc/test/src/math/sincosf_test.cpp

Show All 12 Lines
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::SDCOMP26094_VALUES; using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcSinCosfTest, SpecialNumbers) { TEST(LlvmLibcSinCosfTest, SpecialNumbers) {
errno = 0; errno = 0;
float sin, cos; float sin, cos;
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines#define EXPECT_SINCOS_MATCH_ALL_ROUNDING(input) \
EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5, \ EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5, \
mpfr::RoundingMode::TowardZero); \ mpfr::RoundingMode::TowardZero); \
} }
TEST(LlvmLibcSinCosfTest, InFloatRange) { TEST(LlvmLibcSinCosfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits((v))); float x = float(FPB((v)));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
EXPECT_SINCOS_MATCH_ALL_ROUNDING(x); EXPECT_SINCOS_MATCH_ALL_ROUNDING(x);
EXPECT_SINCOS_MATCH_ALL_ROUNDING(-x); EXPECT_SINCOS_MATCH_ALL_ROUNDING(-x);
} }
} }
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines constexpr uint32_t INPUTS[N] = {
0x6c55'da58U, // x = 0x1.abb4bp+89f 0x6c55'da58U, // x = 0x1.abb4bp+89f
0x6f79'be45U, // x = 0x1.f37c8ap+95f 0x6f79'be45U, // x = 0x1.f37c8ap+95f
0x7276'69d4U, // x = 0x1.ecd3a8p+101f 0x7276'69d4U, // x = 0x1.ecd3a8p+101f
0x7758'4625U, // x = 0x1.b08c4ap+111f 0x7758'4625U, // x = 0x1.b08c4ap+111f
0x7bee'f5efU, // x = 0x1.ddebdep+120f 0x7bee'f5efU, // x = 0x1.ddebdep+120f
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_SINCOS_MATCH_ALL_ROUNDING(x); EXPECT_SINCOS_MATCH_ALL_ROUNDING(x);
EXPECT_SINCOS_MATCH_ALL_ROUNDING(-x); EXPECT_SINCOS_MATCH_ALL_ROUNDING(-x);
} }
} }
// SDCOMP-26094: check sinf in the cases for which the range reducer // SDCOMP-26094: check sinf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4. // returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcSinCosfTest, SDCOMP_26094) { TEST(LlvmLibcSinCosfTest, SDCOMP_26094) {
for (uint32_t v : SDCOMP26094_VALUES) { for (uint32_t v : SDCOMP26094_VALUES) {
float x = float(FPBits((v))); float x = float(FPB((v)));
EXPECT_SINCOS_MATCH_ALL_ROUNDING(x); EXPECT_SINCOS_MATCH_ALL_ROUNDING(x);
EXPECT_SINCOS_MATCH_ALL_ROUNDING(-x); EXPECT_SINCOS_MATCH_ALL_ROUNDING(-x);
} }
} }

libc/test/src/math/sinf_test.cpp

Show All 12 Lines
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::SDCOMP26094_VALUES; using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcSinfTest, SpecialNumbers) { TEST(LlvmLibcSinfTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 12 LinesTEST(LlvmLibcSinfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(neg_inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(neg_inf));
EXPECT_MATH_ERRNO(EDOM); EXPECT_MATH_ERRNO(EDOM);
} }
TEST(LlvmLibcSinfTest, InFloatRange) { TEST(LlvmLibcSinfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x,
__llvm_libc::sinf(x), 0.5); __llvm_libc::sinf(x), 0.5);
} }
} }
TEST(LlvmLibcSinfTest, SpecificBitPatterns) { TEST(LlvmLibcSinfTest, SpecificBitPatterns) {
Show All 33 Lines constexpr uint32_t INPUTS[N] = {
0x6a19'76f1U, // x = 0x1.32ede2p+85f 0x6a19'76f1U, // x = 0x1.32ede2p+85f
0x6c55'da58U, // x = 0x1.abb4bp+89f 0x6c55'da58U, // x = 0x1.abb4bp+89f
0x6f79'be45U, // x = 0x1.f37c8ap+95f 0x6f79'be45U, // x = 0x1.f37c8ap+95f
0x7276'69d4U, // x = 0x1.ecd3a8p+101f 0x7276'69d4U, // x = 0x1.ecd3a8p+101f
0x7758'4625U, // x = 0x1.b08c4ap+111f 0x7758'4625U, // x = 0x1.b08c4ap+111f
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x,
__llvm_libc::sinf(x), 0.5); __llvm_libc::sinf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, -x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, -x,
__llvm_libc::sinf(-x), 0.5); __llvm_libc::sinf(-x), 0.5);
} }
} }
// For small values, sin(x) is x. // For small values, sin(x) is x.
TEST(LlvmLibcSinfTest, SmallValues) { TEST(LlvmLibcSinfTest, SmallValues) {
float x = float(FPBits(0x1780'0000U)); float x = float(FPB(0x1780'0000U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x, __llvm_libc::sinf(x),
0.5); 0.5);
x = float(FPBits(0x0040'0000U)); x = float(FPB(0x0040'0000U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x, __llvm_libc::sinf(x),
0.5); 0.5);
} }
// SDCOMP-26094: check sinf in the cases for which the range reducer // SDCOMP-26094: check sinf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4. // returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcSinfTest, SDCOMP_26094) { TEST(LlvmLibcSinfTest, SDCOMP_26094) {
for (uint32_t v : SDCOMP26094_VALUES) { for (uint32_t v : SDCOMP26094_VALUES) {
float x = float(FPBits((v))); float x = float(FPB((v)));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x,
__llvm_libc::sinf(x), 0.5); __llvm_libc::sinf(x), 0.5);
} }
} }

libc/test/src/math/sinhf_test.cpp

Show All 11 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcSinhfTest, SpecialNumbers) { TEST(LlvmLibcSinhfTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 12 LinesTEST(LlvmLibcSinhfTest, SpecialNumbers) {
EXPECT_FP_EQ(neg_inf, __llvm_libc::sinhf(neg_inf)); EXPECT_FP_EQ(neg_inf, __llvm_libc::sinhf(neg_inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcSinhfTest, InFloatRange) { TEST(LlvmLibcSinhfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Sinh, x, __llvm_libc::sinhf(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Sinh, x, __llvm_libc::sinhf(x), 0.5);
} }
} }
// For small values, sinh(x) is x. // For small values, sinh(x) is x.
TEST(LlvmLibcSinhfTest, SmallValues) { TEST(LlvmLibcSinhfTest, SmallValues) {
float x = float(FPBits(uint32_t(0x17800000))); float x = float(FPB(uint32_t(0x17800000)));
float result = __llvm_libc::sinhf(x); float result = __llvm_libc::sinhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x, result, 0.5); EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x, result, 0.5);
EXPECT_FP_EQ(x, result); EXPECT_FP_EQ(x, result);
x = float(FPBits(uint32_t(0x00400000))); x = float(FPB(uint32_t(0x00400000)));
result = __llvm_libc::sinhf(x); result = __llvm_libc::sinhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x, result, 0.5); EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x, result, 0.5);
EXPECT_FP_EQ(x, result); EXPECT_FP_EQ(x, result);
} }
TEST(LlvmLibcSinhfTest, Overflow) { TEST(LlvmLibcSinhfTest, Overflow) {
errno = 0; errno = 0;
EXPECT_FP_EQ(inf, __llvm_libc::sinhf(float(FPBits(0x7f7fffffU)))); EXPECT_FP_EQ(inf, __llvm_libc::sinhf(float(FPB(0x7f7fffffU))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::sinhf(float(FPBits(0x42cffff8U)))); EXPECT_FP_EQ(inf, __llvm_libc::sinhf(float(FPB(0x42cffff8U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ(inf, __llvm_libc::sinhf(float(FPBits(0x42d00008U)))); EXPECT_FP_EQ(inf, __llvm_libc::sinhf(float(FPB(0x42d00008U))));
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
TEST(LlvmLibcSinhfTest, ExceptionalValues) { TEST(LlvmLibcSinhfTest, ExceptionalValues) {
float x = float(FPBits(uint32_t(0x3a12'85ffU))); float x = float(FPB(uint32_t(0x3a12'85ffU)));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sinh, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sinh, x,
__llvm_libc::sinhf(x), 0.5); __llvm_libc::sinhf(x), 0.5);
x = -float(FPBits(uint32_t(0x3a12'85ffU))); x = -float(FPB(uint32_t(0x3a12'85ffU)));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sinh, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sinh, x,
__llvm_libc::sinhf(x), 0.5); __llvm_libc::sinhf(x), 0.5);
} }

libc/test/src/math/tan_test.cpp

Show All 16 Lines
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibctanTest, Range) { TEST(LlvmLibctanTest, Range) {
static constexpr double _2pi = 6.283185307179586; static constexpr double _2pi = 6.283185307179586;
constexpr UIntType COUNT = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
double x = double(FPBits(v)); double x = double(FPB(v));
// TODO: Expand the range of testing after range reduction is implemented. // TODO: Expand the range of testing after range reduction is implemented.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi) if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tan(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tan(x), 1.0);
} }
} }

libc/test/src/math/tanf_test.cpp

Show All 12 Lines
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::SDCOMP26094_VALUES; using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcTanfTest, SpecialNumbers) { TEST(LlvmLibcTanfTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 12 LinesTEST(LlvmLibcTanfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::tanf(neg_inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::tanf(neg_inf));
EXPECT_MATH_ERRNO(EDOM); EXPECT_MATH_ERRNO(EDOM);
} }
TEST(LlvmLibcTanfTest, InFloatRange) { TEST(LlvmLibcTanfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tan, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tan, x,
__llvm_libc::tanf(x), 0.5); __llvm_libc::tanf(x), 0.5);
} }
} }
TEST(LlvmLibcTanfTest, SpecificBitPatterns) { TEST(LlvmLibcTanfTest, SpecificBitPatterns) {
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines constexpr uint32_t INPUTS[N] = {
0x6f79'be45U, // x = 0x1.f37c8ap+95f 0x6f79'be45U, // x = 0x1.f37c8ap+95f
0x7276'69d4U, // x = 0x1.ecd3a8p+101f 0x7276'69d4U, // x = 0x1.ecd3a8p+101f
0x72b5'05bbU, // x = 0x1.6a0b76p+102f 0x72b5'05bbU, // x = 0x1.6a0b76p+102f
0x7758'4625U, // x = 0x1.b08c4ap+111f 0x7758'4625U, // x = 0x1.b08c4ap+111f
0x7bee'f5efU, // x = 0x1.ddebdep+120f 0x7bee'f5efU, // x = 0x1.ddebdep+120f
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i])); float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tan, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tan, x,
__llvm_libc::tanf(x), 0.5); __llvm_libc::tanf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tan, -x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tan, -x,
__llvm_libc::tanf(-x), 0.5); __llvm_libc::tanf(-x), 0.5);
} }
} }
// SDCOMP-26094: check tanf in the cases for which the range reducer // SDCOMP-26094: check tanf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4. // returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcTanfTest, SDCOMP_26094) { TEST(LlvmLibcTanfTest, SDCOMP_26094) {
for (uint32_t v : SDCOMP26094_VALUES) { for (uint32_t v : SDCOMP26094_VALUES) {
float x = float(FPBits(v)); float x = float(FPB(v));
ASSERT_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tanf(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tanf(x), 0.5);
} }
} }

libc/test/src/math/tanhf_test.cpp

Show All 10 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcTanhfTest, SpecialNumbers) { TEST(LlvmLibcTanhfTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 12 LinesTEST(LlvmLibcTanhfTest, SpecialNumbers) {
EXPECT_FP_EQ(-1.0f, __llvm_libc::tanhf(neg_inf)); EXPECT_FP_EQ(-1.0f, __llvm_libc::tanhf(neg_inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcTanhfTest, InFloatRange) { TEST(LlvmLibcTanhfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPB(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Tanh, x, __llvm_libc::tanhf(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Tanh, x, __llvm_libc::tanhf(x), 0.5);
} }
} }
// For small values, tanh(x) is x. // For small values, tanh(x) is x.
TEST(LlvmLibcTanhfTest, SmallValues) { TEST(LlvmLibcTanhfTest, SmallValues) {
float x = float(FPBits(uint32_t(0x17800000))); float x = float(FPB(uint32_t(0x17800000)));
float result = __llvm_libc::tanhf(x); float result = __llvm_libc::tanhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Tanh, x, result, 0.5); EXPECT_MPFR_MATCH(mpfr::Operation::Tanh, x, result, 0.5);
EXPECT_FP_EQ(x, result); EXPECT_FP_EQ(x, result);
x = float(FPBits(uint32_t(0x00400000))); x = float(FPB(uint32_t(0x00400000)));
result = __llvm_libc::tanhf(x); result = __llvm_libc::tanhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Tanh, x, result, 0.5); EXPECT_MPFR_MATCH(mpfr::Operation::Tanh, x, result, 0.5);
EXPECT_FP_EQ(x, result); EXPECT_FP_EQ(x, result);
} }
TEST(LlvmLibcTanhfTest, ExceptionalValues) { TEST(LlvmLibcTanhfTest, ExceptionalValues) {
float x = float(FPBits(uint32_t(0x3a12'85ffU))); float x = float(FPB(uint32_t(0x3a12'85ffU)));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tanh, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tanh, x,
__llvm_libc::tanhf(x), 0.5); __llvm_libc::tanhf(x), 0.5);
x = -float(FPBits(uint32_t(0x3a12'85ffU))); x = -float(FPB(uint32_t(0x3a12'85ffU)));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tanh, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tanh, x,
__llvm_libc::tanhf(x), 0.5); __llvm_libc::tanhf(x), 0.5);
} }

libc/test/utils/FPUtil/x86_long_double_test.cpp

//===-- Unittests for x86 long double -------------------------------------===// //===-- Unittests for x86 long double -------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
using FPBits = __llvm_libc::fputil::FPBits<long double>; using FPB = __llvm_libc::fputil::FPBits<long double>;
TEST(X86LongDoubleTest, is_nan) { TEST(X86LongDoubleTest, is_nan) {
// In the nan checks below, we use the macro isnan from math.h to ensure that // In the nan checks below, we use the macro isnan from math.h to ensure that
// a number is actually a NaN. The isnan macro resolves to the compiler // a number is actually a NaN. The isnan macro resolves to the compiler
// builtin function. Hence, matching LLVM-libc's notion of NaN with the // builtin function. Hence, matching LLVM-libc's notion of NaN with the
// isnan result ensures that LLVM-libc's behavior matches the compiler's // isnan result ensures that LLVM-libc's behavior matches the compiler's
// behavior. // behavior.
FPBits bits(0.0l); FPB bits(0.0l);
bits.exponent = FPBits::MAX_EXPONENT; bits.exponent = FPB::MAX_EXPONENT;
for (unsigned int i = 0; i < 1000000; ++i) { for (unsigned int i = 0; i < 1000000; ++i) {
// If exponent has the max value and the implicit bit is 0, // If exponent has the max value and the implicit bit is 0,
// then the number is a NaN for all values of mantissa. // then the number is a NaN for all values of mantissa.
bits.mantissa = i; bits.mantissa = i;
long double nan = bits; long double nan = bits;
ASSERT_NE(isnan(nan), 0); ASSERT_NE(isnan(nan), 0);
ASSERT_TRUE(bits.is_nan()); ASSERT_TRUE(bits.is_nan());
} }
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libc/utils/MPFRWrapper/MPFRUtils.cpp

Show All 25 Lines
// `#include <mpfr.h>` is either disallowed or not possible. If that is the // `#include <mpfr.h>` is either disallowed or not possible. If that is the
// case, a file named `CustomMPFRIncluder.h` should be added through which the // case, a file named `CustomMPFRIncluder.h` should be added through which the
// MPFR header can be included in manner allowed in that repo. // MPFR header can be included in manner allowed in that repo.
#include "CustomMPFRIncluder.h" #include "CustomMPFRIncluder.h"
#else #else
#include <mpfr.h> #include <mpfr.h>
#endif #endif
template <typename T> using FPBits = __llvm_libc::fputil::FPBits<T>;
namespace __llvm_libc { namespace __llvm_libc {
namespace testing { namespace testing {
namespace mpfr { namespace mpfr {
template <typename T> struct Precision; template <typename T> struct Precision;
template <> struct Precision<float> { template <> struct Precision<float> {
static constexpr unsigned int VALUE = 24; static constexpr unsigned int VALUE = 24;
▲ Show 20 Lines • Show All 751 Lines • ▼ Show 20 Lines
template <typename T> template <typename T>
void explain_binary_operation_one_output_error( void explain_binary_operation_one_output_error(
Operation op, const BinaryInput<T> &input, T libc_result, Operation op, const BinaryInput<T> &input, T libc_result,
double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS) { double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS) {
unsigned int precision = get_precision<T>(ulp_tolerance); unsigned int precision = get_precision<T>(ulp_tolerance);
MPFRNumber mpfrX(input.x, precision); MPFRNumber mpfrX(input.x, precision);
MPFRNumber mpfrY(input.y, precision); MPFRNumber mpfrY(input.y, precision);
FPBits<T> xbits(input.x); fputil::FPBits<T> xbits(input.x);
FPBits<T> ybits(input.y); fputil::FPBits<T> ybits(input.y);
MPFRNumber mpfr_result = MPFRNumber mpfr_result =
binary_operation_one_output(op, input.x, input.y, precision, rounding); binary_operation_one_output(op, input.x, input.y, precision, rounding);
MPFRNumber mpfrMatchValue(libc_result); MPFRNumber mpfrMatchValue(libc_result);
std::stringstream ss; std::stringstream ss;
ss << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n'; ss << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n';
__llvm_libc::fputil::testing::describeValue("First input bits: ", input.x, __llvm_libc::fputil::testing::describeValue("First input bits: ", input.x,
ss); ss);
Show All 23 Lines
template <typename T> template <typename T>
void explain_ternary_operation_one_output_error( void explain_ternary_operation_one_output_error(
Operation op, const TernaryInput<T> &input, T libc_result, Operation op, const TernaryInput<T> &input, T libc_result,
double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS) { double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS) {
unsigned int precision = get_precision<T>(ulp_tolerance); unsigned int precision = get_precision<T>(ulp_tolerance);
MPFRNumber mpfrX(input.x, precision); MPFRNumber mpfrX(input.x, precision);
MPFRNumber mpfrY(input.y, precision); MPFRNumber mpfrY(input.y, precision);
MPFRNumber mpfrZ(input.z, precision); MPFRNumber mpfrZ(input.z, precision);
FPBits<T> xbits(input.x); fputil::FPBits<T> xbits(input.x);
FPBits<T> ybits(input.y); fputil::FPBits<T> ybits(input.y);
FPBits<T> zbits(input.z); fputil::FPBits<T> zbits(input.z);
MPFRNumber mpfr_result = ternary_operation_one_output( MPFRNumber mpfr_result = ternary_operation_one_output(
op, input.x, input.y, input.z, precision, rounding); op, input.x, input.y, input.z, precision, rounding);
MPFRNumber mpfrMatchValue(libc_result); MPFRNumber mpfrMatchValue(libc_result);
std::stringstream ss; std::stringstream ss;
ss << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() ss << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str()
<< " z: " << mpfrZ.str() << '\n'; << " z: " << mpfrZ.str() << '\n';
__llvm_libc::fputil::testing::describeValue("First input bits: ", input.x, __llvm_libc::fputil::testing::describeValue("First input bits: ", input.x,
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

libc/utils/UnitTest/FPMatcher.h

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 LinesFPMatcher<T, C> getMatcher(T expectedValue) {
return FPMatcher<T, C>(expectedValue); return FPMatcher<T, C>(expectedValue);
} }
} // namespace testing } // namespace testing
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#define DECLARE_SPECIAL_CONSTANTS(T) \ #define DECLARE_SPECIAL_CONSTANTS(T) \
using FPBits = __llvm_libc::fputil::FPBits<T>; \ using FPB = __llvm_libc::fputil::FPBits<T>; \
using UIntType = typename FPBits::UIntType; \ using UIntType = typename FPB::UIntType; \
const T zero = T(FPBits::zero()); \ const T zero = T(FPB::zero()); \
const T neg_zero = T(FPBits::neg_zero()); \ const T neg_zero = T(FPB::neg_zero()); \
const T aNaN = T(FPBits::build_quiet_nan(1)); \ const T aNaN = T(FPB::build_quiet_nan(1)); \
const T inf = T(FPBits::inf()); \ const T inf = T(FPB::inf()); \
const T neg_inf = T(FPBits::neg_inf()); const T neg_inf = T(FPB::neg_inf());
#define EXPECT_FP_EQ(expected, actual) \ #define EXPECT_FP_EQ(expected, actual) \
EXPECT_THAT( \ EXPECT_THAT( \
actual, \ actual, \
__llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_EQ>( \ __llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_EQ>( \
expected)) expected))
#define ASSERT_FP_EQ(expected, actual) \ #define ASSERT_FP_EQ(expected, actual) \
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines