diff --git a/libc/src/__support/FPUtil/Hypot.h b/libc/src/__support/FPUtil/Hypot.h
--- a/libc/src/__support/FPUtil/Hypot.h
+++ b/libc/src/__support/FPUtil/Hypot.h
@@ -100,14 +100,14 @@
//
template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
LIBC_INLINE T hypot(T x, T y) {
- using FPBits_t = FPBits<T>;
+ using FPB = FPBits<T>;
using UIntType = typename FPBits<T>::UIntType;
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()) {
- return T(FPBits_t::inf());
+ return T(FPB::inf());
}
if (x_bits.is_nan()) {
return x;
@@ -189,11 +189,11 @@
sticky_bits = sticky_bits || ((sum & 0x3U) != 0);
sum >>= 2;
++out_exp;
- if (out_exp >= FPBits_t::MAX_EXPONENT) {
+ if (out_exp >= FPB::MAX_EXPONENT) {
if (int round_mode = get_round();
round_mode == FE_TONEAREST || round_mode == FE_UPWARD)
- return T(FPBits_t::inf());
- return T(FPBits_t(FPBits_t::MAX_NORMAL));
+ return T(FPB::inf());
+ return T(FPB(FPB::MAX_NORMAL));
}
} else {
// For denormal result, we simply move the leading bit of the result to
@@ -247,10 +247,10 @@
if (y_new >= (ONE >> 1)) {
y_new -= ONE >> 1;
++out_exp;
- if (out_exp >= FPBits_t::MAX_EXPONENT) {
+ if (out_exp >= FPB::MAX_EXPONENT) {
if (round_mode == FE_TONEAREST || round_mode == FE_UPWARD)
- return T(FPBits_t::inf());
- return T(FPBits_t(FPBits_t::MAX_NORMAL));
+ return T(FPB::inf());
+ return T(FPB(FPB::MAX_NORMAL));
}
}
diff --git a/libc/src/__support/FPUtil/generic/FMA.h b/libc/src/__support/FPUtil/generic/FMA.h
--- a/libc/src/__support/FPUtil/generic/FMA.h
+++ b/libc/src/__support/FPUtil/generic/FMA.h
@@ -92,7 +92,7 @@
} // namespace internal
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>;
if (unlikely(x == 0 || y == 0 || z == 0)) {
@@ -104,20 +104,20 @@
int z_exp = 0;
// Normalize denormal inputs.
- if (unlikely(FPBits(x).get_unbiased_exponent() == 0)) {
+ if (unlikely(FPB(x).get_unbiased_exponent() == 0)) {
x_exp -= 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 *= 0x1.0p+52;
}
- if (unlikely(FPBits(z).get_unbiased_exponent() == 0)) {
+ if (unlikely(FPB(z).get_unbiased_exponent() == 0)) {
z_exp -= 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 y_sign = y_bits.get_sign();
bool z_sign = z_bits.get_sign();
@@ -126,14 +126,14 @@
y_exp += y_bits.get_unbiased_exponent();
z_exp += z_bits.get_unbiased_exponent();
- if (unlikely(x_exp == FPBits::MAX_EXPONENT || y_exp == FPBits::MAX_EXPONENT ||
- z_exp == FPBits::MAX_EXPONENT))
+ if (unlikely(x_exp == FPB::MAX_EXPONENT || y_exp == FPB::MAX_EXPONENT ||
+ z_exp == FPB::MAX_EXPONENT))
return x * y + z;
// Extract mantissa and append hidden leading bits.
- UInt128 x_mant = x_bits.get_mantissa() | FPBits::MIN_NORMAL;
- UInt128 y_mant = y_bits.get_mantissa() | FPBits::MIN_NORMAL;
- UInt128 z_mant = z_bits.get_mantissa() | FPBits::MIN_NORMAL;
+ UInt128 x_mant = x_bits.get_mantissa() | FPB::MIN_NORMAL;
+ UInt128 y_mant = y_bits.get_mantissa() | FPB::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
// precision beside the entire product x*y is needed. On the other hand, when
@@ -157,7 +157,7 @@
UInt128 prod_mant = x_mant * y_mant << 10;
int prod_lsb_exp =
x_exp + y_exp -
- (FPBits::EXPONENT_BIAS + 2 * MantissaWidth<double>::VALUE + 10);
+ (FPB::EXPONENT_BIAS + 2 * MantissaWidth<double>::VALUE + 10);
z_mant <<= 64;
int z_lsb_exp = z_exp - (MantissaWidth<double>::VALUE + 64);
@@ -253,16 +253,16 @@
// Finalize the result.
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) ||
(round_mode == FE_UPWARD && prod_sign) ||
(round_mode == FE_DOWNWARD && !prod_sign)) {
- result = FPBits::MAX_NORMAL;
+ result = FPB::MAX_NORMAL;
return prod_sign ? -cpp::bit_cast<double>(result)
: cpp::bit_cast<double>(result);
}
- return prod_sign ? static_cast<double>(FPBits::neg_inf())
- : static_cast<double>(FPBits::inf());
+ return prod_sign ? static_cast<double>(FPB::neg_inf())
+ : static_cast<double>(FPB::inf());
}
// Remove hidden bit and append the exponent field and sign bit.
diff --git a/libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h b/libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h
--- a/libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h
+++ b/libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h
@@ -24,12 +24,12 @@
namespace fputil {
LIBC_INLINE long double nextafter(long double from, long double to) {
- using FPBits = FPBits<long double>;
- FPBits from_bits(from);
+ using FPB = FPBits<long double>;
+ FPB from_bits(from);
if (from_bits.is_nan())
return from;
- FPBits to_bits(to);
+ FPB to_bits(to);
if (to_bits.is_nan())
return to;
@@ -42,17 +42,17 @@
from_bits.set_unbiased_exponent(1);
}
- using UIntType = FPBits::UIntType;
+ using UIntType = FPB::UIntType;
constexpr UIntType SIGN_VAL = (UIntType(1) << 79);
constexpr UIntType MANTISSA_MASK =
(UIntType(1) << MantissaWidth<long double>::VALUE) - 1;
UIntType int_val = from_bits.uintval();
if (from < 0.0l) {
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
// 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) {
from_bits.set_mantissa(0);
// Incrementing exponent might overflow the value to infinity,
@@ -64,10 +64,10 @@
++int_val;
}
} 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
// 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) {
from_bits.set_mantissa(MANTISSA_MASK);
// from == 0 is handled separately so decrementing the exponent will not
@@ -85,8 +85,8 @@
int_val = 1;
} else {
if (from > to) {
- if (int_val == FPBits::MIN_NORMAL) {
- int_val = FPBits::MAX_SUBNORMAL;
+ if (int_val == FPB::MIN_NORMAL) {
+ int_val = FPB::MAX_SUBNORMAL;
} else if ((int_val & MANTISSA_MASK) == 0) {
from_bits.set_mantissa(MANTISSA_MASK);
// from == 0 is handled separately so decrementing the exponent will not
@@ -97,8 +97,8 @@
--int_val;
}
} else {
- if (int_val == FPBits::MAX_SUBNORMAL) {
- int_val = FPBits::MIN_NORMAL;
+ if (int_val == FPB::MAX_SUBNORMAL) {
+ int_val = FPB::MIN_NORMAL;
} else if ((int_val & MANTISSA_MASK) == MANTISSA_MASK) {
from_bits.set_mantissa(0);
// Incrementing exponent might overflow the value to infinity,
diff --git a/libc/src/math/generic/acosf.cpp b/libc/src/math/generic/acosf.cpp
--- a/libc/src/math/generic/acosf.cpp
+++ b/libc/src/math/generic/acosf.cpp
@@ -36,8 +36,8 @@
}};
LLVM_LIBC_FUNCTION(float, acosf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
uint32_t x_uint = xbits.uintval();
uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU;
uint32_t x_sign = x_uint >> 31;
@@ -78,8 +78,7 @@
errno = EDOM;
fputil::set_except(FE_INVALID);
}
- return x +
- FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
+ return x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
}
// When 0.5 < |x| <= 1, we perform range reduction as follow:
diff --git a/libc/src/math/generic/asinf.cpp b/libc/src/math/generic/asinf.cpp
--- a/libc/src/math/generic/asinf.cpp
+++ b/libc/src/math/generic/asinf.cpp
@@ -42,8 +42,8 @@
}};
LLVM_LIBC_FUNCTION(float, asinf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
uint32_t x_uint = xbits.uintval();
uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU;
constexpr double SIGN[2] = {1.0, -1.0};
@@ -107,8 +107,7 @@
errno = EDOM;
fputil::set_except(FE_INVALID);
}
- return x +
- FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
+ return x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
}
// Check for exceptional values
diff --git a/libc/src/math/generic/asinhf.cpp b/libc/src/math/generic/asinhf.cpp
--- a/libc/src/math/generic/asinhf.cpp
+++ b/libc/src/math/generic/asinhf.cpp
@@ -17,10 +17,10 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, asinhf, (float x)) {
- using FPBits_t = typename fputil::FPBits<float>;
- FPBits_t xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
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
if (unlikely(x_abs <= 0x3e80'0000U)) {
diff --git a/libc/src/math/generic/atanf.cpp b/libc/src/math/generic/atanf.cpp
--- a/libc/src/math/generic/atanf.cpp
+++ b/libc/src/math/generic/atanf.cpp
@@ -14,8 +14,8 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, atanf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
bool sign = xbits.get_sign();
xbits.set_sign(false);
@@ -29,7 +29,7 @@
if (unlikely(xbits.uintval() == 0x3d8d6b23U)) {
if (fputil::get_round() == FE_TONEAREST) {
// 0.06894256919622421
- FPBits br(0x3d8d31c3U);
+ FPB br(0x3d8d31c3U);
br.set_sign(sign);
return br.get_val();
}
@@ -41,12 +41,12 @@
if (sign) {
if (rounding_mode == FE_DOWNWARD) {
// -1.0790828466415405
- return FPBits(0xbf8a1f63U).get_val();
+ return FPB(0xbf8a1f63U).get_val();
}
} else {
if (rounding_mode == FE_UPWARD) {
// 1.0790828466415405
- return FPBits(0x3f8a1f63U).get_val();
+ return FPB(0x3f8a1f63U).get_val();
}
}
}
diff --git a/libc/src/math/generic/atanhf.cpp b/libc/src/math/generic/atanhf.cpp
--- a/libc/src/math/generic/atanhf.cpp
+++ b/libc/src/math/generic/atanhf.cpp
@@ -13,10 +13,10 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, atanhf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
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
if (unlikely(x_abs >= 0x3F80'0000U)) {
@@ -26,12 +26,11 @@
// |x| == 0
if (x_abs == 0x3F80'0000U) {
fputil::set_except(FE_DIVBYZERO);
- return with_errno(FPBits::inf(sign).get_val(), ERANGE);
+ return with_errno(FPB::inf(sign).get_val(), ERANGE);
} else {
fputil::set_except(FE_INVALID);
return with_errno(
- FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1)),
- EDOM);
+ FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1)), EDOM);
}
}
diff --git a/libc/src/math/generic/cosf.cpp b/libc/src/math/generic/cosf.cpp
--- a/libc/src/math/generic/cosf.cpp
+++ b/libc/src/math/generic/cosf.cpp
@@ -40,8 +40,8 @@
}};
LLVM_LIBC_FUNCTION(float, cosf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
xbits.set_sign(false);
uint32_t x_abs = xbits.uintval();
@@ -116,8 +116,7 @@
errno = EDOM;
fputil::set_except(FE_INVALID);
}
- return x +
- FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
+ return x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
}
// Combine the results with the sine of sum formula:
diff --git a/libc/src/math/generic/coshf.cpp b/libc/src/math/generic/coshf.cpp
--- a/libc/src/math/generic/coshf.cpp
+++ b/libc/src/math/generic/coshf.cpp
@@ -14,8 +14,8 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, coshf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
xbits.set_sign(false);
x = xbits.get_val();
@@ -29,15 +29,15 @@
// When |x| >= 90, or x is inf or nan
if (unlikely(x_u >= 0x42b4'0000U)) {
if (xbits.is_inf_or_nan())
- return x + FPBits::inf().get_val();
+ return x + FPB::inf().get_val();
int rounding = fputil::get_round();
if (unlikely(rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO))
- return FPBits(FPBits::MAX_NORMAL).get_val();
+ return FPB(FPB::MAX_NORMAL).get_val();
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
diff --git a/libc/src/math/generic/dp_trig.cpp b/libc/src/math/generic/dp_trig.cpp
--- a/libc/src/math/generic/dp_trig.cpp
+++ b/libc/src/math/generic/dp_trig.cpp
@@ -11,7 +11,7 @@
#include "src/__support/FPUtil/UInt.h"
#include "src/__support/FPUtil/XFloat.h"
-using FPBits = __llvm_libc::fputil::FPBits<double>;
+using FPB = __llvm_libc::fputil::FPBits<double>;
namespace __llvm_libc {
@@ -29,7 +29,7 @@
static double mod_impl(double x, const uint64_t y_bits[3],
const uint64_t inv_y_bits[20], int y_exponent,
int inv_y_exponent) {
- FPBits bits(x);
+ FPB bits(x);
int exponent = bits.get_exponent();
int bit_drop = (exponent - 52) + inv_y_exponent + 1;
bit_drop = bit_drop >= 0 ? bit_drop : 0;
diff --git a/libc/src/math/generic/exp10f.cpp b/libc/src/math/generic/exp10f.cpp
--- a/libc/src/math/generic/exp10f.cpp
+++ b/libc/src/math/generic/exp10f.cpp
@@ -21,8 +21,8 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, exp10f, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
uint32_t x_u = xbits.uintval();
uint32_t x_abs = x_u & 0x7fff'ffffU;
@@ -38,7 +38,7 @@
if (xbits.is_nan())
return x;
if (fputil::get_round() == FE_UPWARD)
- return static_cast<float>(FPBits(FPBits::MIN_SUBNORMAL));
+ return static_cast<float>(FPB(FPB::MIN_SUBNORMAL));
errno = ERANGE;
return 0.0f;
}
@@ -48,12 +48,12 @@
if (x_u < 0x7f80'0000U) {
int rounding = fputil::get_round();
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;
}
// x is +inf or nan
- return x + static_cast<float>(FPBits::inf());
+ return x + static_cast<float>(FPB::inf());
}
}
diff --git a/libc/src/math/generic/exp2f.cpp b/libc/src/math/generic/exp2f.cpp
--- a/libc/src/math/generic/exp2f.cpp
+++ b/libc/src/math/generic/exp2f.cpp
@@ -25,8 +25,8 @@
constexpr uint32_t exval_mask = exval1 & exval2;
LLVM_LIBC_FUNCTION(float, exp2f, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
uint32_t x_u = xbits.uintval();
uint32_t x_abs = x_u & 0x7fff'ffffU;
@@ -45,12 +45,12 @@
if (x_u < 0x7f80'0000U) {
int rounding = fputil::get_round();
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;
}
// x is +inf or nan
- return x + FPBits::inf().get_val();
+ return x + FPB::inf().get_val();
}
// x <= -150
if (x_u >= 0xc316'0000U) {
@@ -61,7 +61,7 @@
if (xbits.is_nan())
return x;
if (fputil::get_round() == FE_UPWARD)
- return FPBits(FPBits::MIN_SUBNORMAL).get_val();
+ return FPB(FPB::MIN_SUBNORMAL).get_val();
if (x != 0.0f)
errno = ERANGE;
return 0.0f;
diff --git a/libc/src/math/generic/expf.cpp b/libc/src/math/generic/expf.cpp
--- a/libc/src/math/generic/expf.cpp
+++ b/libc/src/math/generic/expf.cpp
@@ -21,8 +21,8 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, expf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
uint32_t x_u = xbits.uintval();
uint32_t x_abs = x_u & 0x7fff'ffffU;
@@ -48,7 +48,7 @@
if (xbits.is_nan())
return x;
if (fputil::get_round() == FE_UPWARD)
- return static_cast<float>(FPBits(FPBits::MIN_SUBNORMAL));
+ return static_cast<float>(FPB(FPB::MIN_SUBNORMAL));
errno = ERANGE;
return 0.0f;
}
@@ -58,12 +58,12 @@
if (xbits.uintval() < 0x7f80'0000U) {
int rounding = fputil::get_round();
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;
}
// 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
diff --git a/libc/src/math/generic/expm1f.cpp b/libc/src/math/generic/expm1f.cpp
--- a/libc/src/math/generic/expm1f.cpp
+++ b/libc/src/math/generic/expm1f.cpp
@@ -23,8 +23,8 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, expm1f, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
uint32_t x_u = xbits.uintval();
uint32_t x_abs = x_u & 0x7fff'ffffU;
@@ -66,11 +66,11 @@
if (xbits.uintval() < 0x7f80'0000U) {
int rounding = fputil::get_round();
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;
}
- return x + static_cast<float>(FPBits::inf());
+ return x + static_cast<float>(FPB::inf());
}
}
}
diff --git a/libc/src/math/generic/hypotf.cpp b/libc/src/math/generic/hypotf.cpp
--- a/libc/src/math/generic/hypotf.cpp
+++ b/libc/src/math/generic/hypotf.cpp
@@ -15,9 +15,9 @@
LLVM_LIBC_FUNCTION(float, hypotf, (float x, float y)) {
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 y_exp = y_bits.get_unbiased_exponent();
@@ -57,10 +57,10 @@
result.bits -= 1ULL;
}
} 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() || bits_y.is_inf())
- return static_cast<float>(FPBits::inf());
+ return static_cast<float>(FPB::inf());
if (bits_x.is_nan())
return x;
return y;
diff --git a/libc/src/math/generic/log10.cpp b/libc/src/math/generic/log10.cpp
--- a/libc/src/math/generic/log10.cpp
+++ b/libc/src/math/generic/log10.cpp
@@ -944,18 +944,18 @@
// TODO(lntue): Make the implementation correctly rounded for non-FMA targets.
LLVM_LIBC_FUNCTION(double, log10, (double x)) {
- using FPBits_t = typename fputil::FPBits<double>;
- FPBits_t xbits(x);
+ using FPB = typename fputil::FPBits<double>;
+ FPB xbits(x);
int x_e = -1023;
- if (unlikely(xbits.uintval() < FPBits_t::MIN_NORMAL ||
- xbits.uintval() > FPBits_t::MAX_NORMAL)) {
+ if (unlikely(xbits.uintval() < FPB::MIN_NORMAL ||
+ xbits.uintval() > FPB::MAX_NORMAL)) {
if (xbits.is_zero()) {
// return -Inf and raise FE_DIVBYZERO.
return -1.0 / 0.0;
}
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()) {
return x;
@@ -1001,7 +1001,7 @@
fputil::DoubleDouble rr = fputil::exact_add(hi, lo);
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
err = fputil::multiply_add(u, P_ERR, err);
diff --git a/libc/src/math/generic/log10f.cpp b/libc/src/math/generic/log10f.cpp
--- a/libc/src/math/generic/log10f.cpp
+++ b/libc/src/math/generic/log10f.cpp
@@ -104,8 +104,8 @@
LLVM_LIBC_FUNCTION(float, log10f, (float x)) {
constexpr double LOG10_2 = 0x1.34413509f79ffp-2;
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
double m = 0.0;
// Exact powers of 10 and other hard-to-round cases.
@@ -142,13 +142,12 @@
}
}
- if (xbits.uintval() < FPBits::MIN_NORMAL ||
- xbits.uintval() > FPBits::MAX_NORMAL) {
+ if (xbits.uintval() < FPB::MIN_NORMAL || xbits.uintval() > FPB::MAX_NORMAL) {
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()) {
- 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()) {
return x;
@@ -163,7 +162,7 @@
xbits.set_unbiased_exponent(0x7F);
int f_index = xbits.get_mantissa() >> 16;
- FPBits f = xbits;
+ FPB f = xbits;
f.bits &= ~0x0000'FFFF;
double d = static_cast<float>(xbits) - static_cast<float>(f);
diff --git a/libc/src/math/generic/log1pf.cpp b/libc/src/math/generic/log1pf.cpp
--- a/libc/src/math/generic/log1pf.cpp
+++ b/libc/src/math/generic/log1pf.cpp
@@ -35,14 +35,14 @@
static inline float log(double x) {
constexpr double LOG_2 = 0x1.62e42fefa39efp-1;
- using FPBits = typename fputil::FPBits<double>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<double>;
+ FPB xbits(x);
if (xbits.is_zero()) {
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()) {
return fputil::FPBits<float>::build_nan(
1 << (fputil::MantissaWidth<float>::VALUE - 1));
@@ -59,7 +59,7 @@
int f_index =
xbits.get_mantissa() >> 45; // fputil::MantissaWidth<double>::VALUE - 7
- FPBits f = xbits;
+ FPB f = xbits;
// Clear the lowest 45 bits.
f.bits &= ~0x0000'1FFF'FFFF'FFFFULL;
@@ -78,8 +78,8 @@
} // namespace internal
LLVM_LIBC_FUNCTION(float, log1pf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
double xd = static_cast<double>(x);
if (xbits.get_exponent() >= -8) {
diff --git a/libc/src/math/generic/log2f.cpp b/libc/src/math/generic/log2f.cpp
--- a/libc/src/math/generic/log2f.cpp
+++ b/libc/src/math/generic/log2f.cpp
@@ -99,12 +99,12 @@
0x1.fa34e1177c233p-1, 0x1.fd1be4c7f2af9p-1};
LLVM_LIBC_FUNCTION(float, log2f, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
int m = 0;
// Hard to round value(s).
- switch (FPBits(x).uintval()) {
+ switch (FPB(x).uintval()) {
case 0x3f81d0b5U: {
int rounding_mode = fputil::get_round();
if (rounding_mode == FE_DOWNWARD || rounding_mode == FE_TOWARDZERO) {
@@ -125,13 +125,12 @@
}
// Exceptional inputs.
- if (xbits.uintval() < FPBits::MIN_NORMAL ||
- xbits.uintval() > FPBits::MAX_NORMAL) {
+ if (xbits.uintval() < FPB::MIN_NORMAL || xbits.uintval() > FPB::MAX_NORMAL) {
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()) {
- 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()) {
return x;
@@ -148,7 +147,7 @@
// lookup tables.
int f_index = xbits.get_mantissa() >> 16;
- FPBits f = xbits;
+ FPB f = xbits;
// Clear the lowest 16 bits.
f.bits &= ~0x0000'FFFF;
diff --git a/libc/src/math/generic/logf.cpp b/libc/src/math/generic/logf.cpp
--- a/libc/src/math/generic/logf.cpp
+++ b/libc/src/math/generic/logf.cpp
@@ -51,10 +51,10 @@
LLVM_LIBC_FUNCTION(float, logf, (float x)) {
constexpr double LOG_2 = 0x1.62e42fefa39efp-1;
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
- switch (FPBits(x).uintval()) {
+ switch (FPB(x).uintval()) {
case 0x41178febU: // x = 0x1.2f1fd6p+3f
if (fputil::get_round() == FE_TONEAREST)
return 0x1.1fcbcep+1f;
@@ -91,13 +91,12 @@
int m = 0;
- if (xbits.uintval() < FPBits::MIN_NORMAL ||
- xbits.uintval() > FPBits::MAX_NORMAL) {
+ if (xbits.uintval() < FPB::MIN_NORMAL || xbits.uintval() > FPB::MAX_NORMAL) {
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()) {
- 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()) {
return x;
@@ -112,7 +111,7 @@
xbits.set_unbiased_exponent(0x7F);
int f_index = xbits.get_mantissa() >> 16;
- FPBits f = xbits;
+ FPB f = xbits;
f.bits &= ~0x0000'FFFF;
double d = static_cast<float>(xbits) - static_cast<float>(f);
diff --git a/libc/src/math/generic/sincosf.cpp b/libc/src/math/generic/sincosf.cpp
--- a/libc/src/math/generic/sincosf.cpp
+++ b/libc/src/math/generic/sincosf.cpp
@@ -49,8 +49,8 @@
};
LLVM_LIBC_FUNCTION(void, sincosf, (float x, float *sinp, float *cosp)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU;
double xd = static_cast<double>(x);
@@ -131,11 +131,11 @@
// emulated version of FMA.
#if defined(LIBC_TARGET_HAS_FMA)
*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
*sinp = static_cast<float>(fputil::multiply_add(xd, -0x1.0p-25, xd));
*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
return;
}
@@ -146,8 +146,7 @@
errno = EDOM;
fputil::set_except(FE_INVALID);
}
- *sinp =
- x + FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
+ *sinp = x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
*cosp = *sinp;
return;
}
@@ -172,8 +171,8 @@
c += EXCEPT_OUTPUTS_COS[i][3];
break;
}
- *sinp = x_sign ? -FPBits(s).get_val() : FPBits(s).get_val();
- *cosp = FPBits(c).get_val();
+ *sinp = x_sign ? -FPB(s).get_val() : FPB(s).get_val();
+ *cosp = FPB(c).get_val();
return;
}
diff --git a/libc/src/math/generic/sinf.cpp b/libc/src/math/generic/sinf.cpp
--- a/libc/src/math/generic/sinf.cpp
+++ b/libc/src/math/generic/sinf.cpp
@@ -27,8 +27,8 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, sinf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
uint32_t x_u = xbits.uintval();
uint32_t x_abs = x_u & 0x7fff'ffffU;
@@ -137,8 +137,7 @@
errno = EDOM;
fputil::set_except(FE_INVALID);
}
- return x +
- FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
+ return x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
}
// Combine the results with the sine of sum formula:
diff --git a/libc/src/math/generic/sinhf.cpp b/libc/src/math/generic/sinhf.cpp
--- a/libc/src/math/generic/sinhf.cpp
+++ b/libc/src/math/generic/sinhf.cpp
@@ -13,10 +13,10 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, sinhf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
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
if (unlikely(x_abs <= 0x3280'0000U)) {
@@ -34,16 +34,15 @@
int rounding = fputil::get_round();
if (sign) {
if (unlikely(rounding == FE_UPWARD || rounding == FE_TOWARDZERO))
- return FPBits(FPBits::MAX_NORMAL | FPBits::FloatProp::SIGN_MASK)
- .get_val();
+ return FPB(FPB::MAX_NORMAL | FPB::FloatProp::SIGN_MASK).get_val();
} else {
if (unlikely(rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO))
- return FPBits(FPBits::MAX_NORMAL).get_val();
+ return FPB(FPB::MAX_NORMAL).get_val();
}
errno = ERANGE;
- return x + FPBits::inf(sign).get_val();
+ return x + FPB::inf(sign).get_val();
}
// |x| <= 0.078125
diff --git a/libc/src/math/generic/tanf.cpp b/libc/src/math/generic/tanf.cpp
--- a/libc/src/math/generic/tanf.cpp
+++ b/libc/src/math/generic/tanf.cpp
@@ -41,8 +41,8 @@
}};
LLVM_LIBC_FUNCTION(float, tanf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
bool x_sign = xbits.uintval() >> 31;
uint32_t x_abs = xbits.uintval() & 0x7fff'ffffU;
@@ -108,8 +108,7 @@
errno = EDOM;
fputil::set_except(FE_INVALID);
}
- return x +
- FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
+ return x + FPB::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
}
// Other large exceptional values
if (auto r = TANF_EXCEPTS.lookup_odd(x_abs, x_sign);
diff --git a/libc/src/math/generic/tanhf.cpp b/libc/src/math/generic/tanhf.cpp
--- a/libc/src/math/generic/tanhf.cpp
+++ b/libc/src/math/generic/tanhf.cpp
@@ -14,10 +14,10 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, tanhf, (float x)) {
- using FPBits = typename fputil::FPBits<float>;
- FPBits xbits(x);
+ using FPB = typename fputil::FPBits<float>;
+ FPB xbits(x);
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
if (unlikely(x_abs <= 0x3280'0000U)) {
@@ -33,9 +33,9 @@
return sign ? -1.0f : 1.0f;
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
- 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
@@ -51,7 +51,7 @@
if (unlikely(xbits.bits == 0x4058'e0a3U)) {
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
diff --git a/libc/test/src/math/CeilTest.h b/libc/test/src/math/CeilTest.h
--- a/libc/test/src/math/CeilTest.h
+++ b/libc/test/src/math/CeilTest.h
@@ -67,7 +67,7 @@
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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))
continue;
diff --git a/libc/test/src/math/CopySignTest.h b/libc/test/src/math/CopySignTest.h
--- a/libc/test/src/math/CopySignTest.h
+++ b/libc/test/src/math/CopySignTest.h
@@ -36,7 +36,7 @@
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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))
continue;
diff --git a/libc/test/src/math/FAbsTest.h b/libc/test/src/math/FAbsTest.h
--- a/libc/test/src/math/FAbsTest.h
+++ b/libc/test/src/math/FAbsTest.h
@@ -35,7 +35,7 @@
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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))
continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, func(x), 0.0);
diff --git a/libc/test/src/math/FDimTest.h b/libc/test/src/math/FDimTest.h
--- a/libc/test/src/math/FDimTest.h
+++ b/libc/test/src/math/FDimTest.h
@@ -16,8 +16,8 @@
class FDimTestTemplate : public __llvm_libc::testing::Test {
public:
using FuncPtr = T (*)(T, T);
- using FPBits = __llvm_libc::fputil::FPBits<T>;
- using UIntType = typename FPBits::UIntType;
+ using FPB = __llvm_libc::fputil::FPBits<T>;
+ using UIntType = typename FPB::UIntType;
void test_na_n_arg(FuncPtr func) {
EXPECT_FP_EQ(nan, func(nan, inf));
@@ -57,7 +57,7 @@
constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
++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))
continue;
if (isnan(y) || isinf(y))
@@ -72,7 +72,7 @@
}
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.
const T nan = T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1));
const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
diff --git a/libc/test/src/math/FMaxTest.h b/libc/test/src/math/FMaxTest.h
--- a/libc/test/src/math/FMaxTest.h
+++ b/libc/test/src/math/FMaxTest.h
@@ -59,7 +59,7 @@
constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
++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))
continue;
if (isnan(y) || isinf(y))
diff --git a/libc/test/src/math/FMinTest.h b/libc/test/src/math/FMinTest.h
--- a/libc/test/src/math/FMinTest.h
+++ b/libc/test/src/math/FMinTest.h
@@ -59,7 +59,7 @@
constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
++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))
continue;
if (isnan(y) || isinf(y))
diff --git a/libc/test/src/math/FloorTest.h b/libc/test/src/math/FloorTest.h
--- a/libc/test/src/math/FloorTest.h
+++ b/libc/test/src/math/FloorTest.h
@@ -67,7 +67,7 @@
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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))
continue;
diff --git a/libc/test/src/math/FmaTest.h b/libc/test/src/math/FmaTest.h
--- a/libc/test/src/math/FmaTest.h
+++ b/libc/test/src/math/FmaTest.h
@@ -21,8 +21,8 @@
class FmaTestTemplate : public __llvm_libc::testing::Test {
private:
using Func = T (*)(T, T, T);
- using FPBits = __llvm_libc::fputil::FPBits<T>;
- using UIntType = typename FPBits::UIntType;
+ using FPB = __llvm_libc::fputil::FPBits<T>;
+ using UIntType = typename FPB::UIntType;
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 neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
@@ -50,16 +50,15 @@
EXPECT_FP_EQ(func(inf, neg_inf, nan), nan);
// Test underflow rounding up.
- EXPECT_FP_EQ(func(T(0.5), T(FPBits(FPBits::MIN_SUBNORMAL)),
- T(FPBits(FPBits::MIN_SUBNORMAL))),
- T(FPBits(UIntType(2))));
+ EXPECT_FP_EQ(
+ func(T(0.5), T(FPB(FPB::MIN_SUBNORMAL)), T(FPB(FPB::MIN_SUBNORMAL))),
+ T(FPB(UIntType(2))));
// Test underflow rounding down.
- T v = T(FPBits(FPBits::MIN_NORMAL + UIntType(1)));
- EXPECT_FP_EQ(func(T(1) / T(FPBits::MIN_NORMAL << 1), v,
- T(FPBits(FPBits::MIN_NORMAL))),
- v);
+ T v = T(FPB(FPB::MIN_NORMAL + UIntType(1)));
+ EXPECT_FP_EQ(
+ func(T(1) / T(FPB::MIN_NORMAL << 1), v, T(FPB(FPB::MIN_NORMAL))), v);
// 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);
// Exact cancellation.
EXPECT_FP_EQ(func(T(3.0), T(5.0), -T(15.0)), T(0.0));
@@ -68,13 +67,11 @@
void test_subnormal_range(Func func) {
constexpr UIntType COUNT = 1000001;
- constexpr UIntType STEP =
- (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
- for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL;
- v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL;
+ constexpr UIntType STEP = (FPB::MAX_SUBNORMAL - FPB::MIN_SUBNORMAL) / COUNT;
+ for (UIntType v = FPB::MIN_SUBNORMAL, w = FPB::MAX_SUBNORMAL;
+ v <= FPB::MAX_SUBNORMAL && w >= FPB::MIN_SUBNORMAL;
v += STEP, w -= STEP) {
- T x = T(FPBits(get_random_bit_pattern())), y = T(FPBits(v)),
- z = T(FPBits(w));
+ T x = T(FPB(get_random_bit_pattern())), y = T(FPB(v)), z = T(FPB(w));
mpfr::TernaryInput<T> input{x, y, z};
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Fma, input, func(x, y, z),
0.5);
@@ -83,12 +80,10 @@
void test_normal_range(Func func) {
constexpr UIntType COUNT = 1000001;
- constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
- for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
- v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
- v += STEP, w -= STEP) {
- T x = T(FPBits(v)), y = T(FPBits(w)),
- z = T(FPBits(get_random_bit_pattern()));
+ constexpr UIntType STEP = (FPB::MAX_NORMAL - FPB::MIN_NORMAL) / COUNT;
+ for (UIntType v = FPB::MIN_NORMAL, w = FPB::MAX_NORMAL;
+ v <= FPB::MAX_NORMAL && w >= FPB::MIN_NORMAL; v += STEP, w -= STEP) {
+ T x = T(FPB(v)), y = T(FPB(w)), z = T(FPB(get_random_bit_pattern()));
mpfr::TernaryInput<T> input{x, y, z};
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Fma, input, func(x, y, z),
0.5);
diff --git a/libc/test/src/math/FrexpTest.h b/libc/test/src/math/FrexpTest.h
--- a/libc/test/src/math/FrexpTest.h
+++ b/libc/test/src/math/FrexpTest.h
@@ -92,11 +92,11 @@
}
void testRange(FrexpFunc func) {
- using UIntType = typename FPBits::UIntType;
+ using UIntType = typename FPB::UIntType;
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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)
continue;
diff --git a/libc/test/src/math/HypotTest.h b/libc/test/src/math/HypotTest.h
--- a/libc/test/src/math/HypotTest.h
+++ b/libc/test/src/math/HypotTest.h
@@ -22,17 +22,17 @@
class HypotTestTemplate : public __llvm_libc::testing::Test {
private:
using Func = T (*)(T, T);
- using FPBits = __llvm_libc::fputil::FPBits<T>;
- using UIntType = typename FPBits::UIntType;
- const T nan = T(FPBits::build_quiet_nan(1));
- const T inf = T(FPBits::inf());
- const T neg_inf = T(FPBits::neg_inf());
- const T zero = T(FPBits::zero());
- const T neg_zero = T(FPBits::neg_zero());
- const T max_normal = T(FPBits(FPBits::MAX_NORMAL));
- const T min_normal = T(FPBits(FPBits::MIN_NORMAL));
- const T max_subnormal = T(FPBits(FPBits::MAX_SUBNORMAL));
- const T min_subnormal = T(FPBits(FPBits::MIN_SUBNORMAL));
+ using FPB = __llvm_libc::fputil::FPBits<T>;
+ using UIntType = typename FPB::UIntType;
+ const T nan = T(FPB::build_quiet_nan(1));
+ const T inf = T(FPB::inf());
+ const T neg_inf = T(FPB::neg_inf());
+ const T zero = T(FPB::zero());
+ const T neg_zero = T(FPB::neg_zero());
+ const T max_normal = T(FPB(FPB::MAX_NORMAL));
+ const T min_normal = T(FPB(FPB::MIN_NORMAL));
+ const T max_subnormal = T(FPB(FPB::MAX_SUBNORMAL));
+ const T min_subnormal = T(FPB(FPB::MIN_SUBNORMAL));
public:
void test_special_numbers(Func func) {
@@ -61,13 +61,12 @@
void test_subnormal_range(Func func) {
constexpr UIntType COUNT = 1000001;
for (unsigned scale = 0; scale < 4; ++scale) {
- UIntType max_value = FPBits::MAX_SUBNORMAL << scale;
- UIntType step = (max_value - FPBits::MIN_SUBNORMAL) / COUNT;
+ UIntType max_value = FPB::MAX_SUBNORMAL << scale;
+ UIntType step = (max_value - FPB::MIN_SUBNORMAL) / COUNT;
for (int signs = 0; signs < 4; ++signs) {
- for (UIntType v = FPBits::MIN_SUBNORMAL, w = max_value;
- v <= max_value && w >= FPBits::MIN_SUBNORMAL;
- v += step, w -= step) {
- T x = T(FPBits(v)), y = T(FPBits(w));
+ for (UIntType v = FPB::MIN_SUBNORMAL, w = max_value;
+ v <= max_value && w >= FPB::MIN_SUBNORMAL; v += step, w -= step) {
+ T x = T(FPB(v)), y = T(FPB(w));
if (signs % 2 == 1) {
x = -x;
}
@@ -85,12 +84,11 @@
void test_normal_range(Func func) {
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 (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
- v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
- v += STEP, w -= STEP) {
- T x = T(FPBits(v)), y = T(FPBits(w));
+ for (UIntType v = FPB::MIN_NORMAL, w = FPB::MAX_NORMAL;
+ v <= FPB::MAX_NORMAL && w >= FPB::MIN_NORMAL; v += STEP, w -= STEP) {
+ T x = T(FPB(v)), y = T(FPB(w));
if (signs % 2 == 1) {
x = -x;
}
diff --git a/libc/test/src/math/ILogbTest.h b/libc/test/src/math/ILogbTest.h
--- a/libc/test/src/math/ILogbTest.h
+++ b/libc/test/src/math/ILogbTest.h
@@ -73,14 +73,12 @@
template <typename T>
void test_subnormal_range(typename ILogbFunc<T>::Func func) {
- using FPBits = __llvm_libc::fputil::FPBits<T>;
- using UIntType = typename FPBits::UIntType;
+ using FPB = __llvm_libc::fputil::FPBits<T>;
+ using UIntType = typename FPB::UIntType;
constexpr UIntType COUNT = 1000001;
- constexpr UIntType STEP =
- (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
- for (UIntType v = FPBits::MIN_SUBNORMAL; v <= FPBits::MAX_SUBNORMAL;
- v += STEP) {
- T x = T(FPBits(v));
+ constexpr UIntType STEP = (FPB::MAX_SUBNORMAL - FPB::MIN_SUBNORMAL) / COUNT;
+ for (UIntType v = FPB::MIN_SUBNORMAL; v <= FPB::MAX_SUBNORMAL; v += STEP) {
+ T x = T(FPB(v));
if (isnan(x) || isinf(x) || x == 0.0)
continue;
@@ -92,12 +90,12 @@
template <typename T>
void test_normal_range(typename ILogbFunc<T>::Func func) {
- using FPBits = __llvm_libc::fputil::FPBits<T>;
- using UIntType = typename FPBits::UIntType;
+ using FPB = __llvm_libc::fputil::FPBits<T>;
+ using UIntType = typename FPB::UIntType;
constexpr UIntType COUNT = 1000001;
- constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
- for (UIntType v = FPBits::MIN_NORMAL; v <= FPBits::MAX_NORMAL; v += STEP) {
- T x = T(FPBits(v));
+ constexpr UIntType STEP = (FPB::MAX_NORMAL - FPB::MIN_NORMAL) / COUNT;
+ for (UIntType v = FPB::MIN_NORMAL; v <= FPB::MAX_NORMAL; v += STEP) {
+ T x = T(FPB(v));
if (isnan(x) || isinf(x) || x == 0.0)
continue;
diff --git a/libc/test/src/math/LdExpTest.h b/libc/test/src/math/LdExpTest.h
--- a/libc/test/src/math/LdExpTest.h
+++ b/libc/test/src/math/LdExpTest.h
@@ -20,9 +20,9 @@
template <typename T>
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 UIntType = typename FPBits::UIntType;
+ using UIntType = typename FPB::UIntType;
static constexpr UIntType MANTISSA_WIDTH =
__llvm_libc::fputil::MantissaWidth<T>::VALUE;
// A normalized mantissa to be used with tests.
@@ -60,7 +60,7 @@
}
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) {
ASSERT_FP_EQ(inf, func(T(x), exp));
ASSERT_FP_EQ(neg_inf, func(-T(x), exp));
@@ -70,7 +70,7 @@
void testUnderflowToZeroOnNormal(LdExpFunc func) {
// In this test, we pass a normal nubmer to func and expect zero
// 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,
base_exponent + 3, base_exponent + 2,
base_exponent + 1};
@@ -83,11 +83,11 @@
void testUnderflowToZeroOnSubnormal(LdExpFunc func) {
// In this test, we pass a normal nubmer to func and expect zero
// 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,
base_exponent + 3, base_exponent + 2,
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) {
ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero);
}
@@ -99,8 +99,8 @@
NormalFloat(100, MANTISSA, 0), NormalFloat(-100, MANTISSA, 0),
NormalFloat(100, MANTISSA, 1), NormalFloat(-100, MANTISSA, 1),
// Subnormal numbers
- NormalFloat(-FPBits::EXPONENT_BIAS, MANTISSA, 0),
- NormalFloat(-FPBits::EXPONENT_BIAS, MANTISSA, 1)};
+ NormalFloat(-FPB::EXPONENT_BIAS, MANTISSA, 0),
+ NormalFloat(-FPB::EXPONENT_BIAS, MANTISSA, 1)};
for (int32_t exp = 0; exp <= static_cast<int32_t>(MANTISSA_WIDTH); ++exp) {
for (T x : val_array) {
// We compare the result of ldexp with the result
@@ -111,32 +111,32 @@
}
// 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);
// Start with a normal number high exponent but pass a very low number for
// exp. The result should be a subnormal number.
- x = NormalFloat(FPBits::EXPONENT_BIAS, NormalFloat::ONE, 0);
- int exp = -FPBits::MAX_EXPONENT - 5;
+ x = NormalFloat(FPB::EXPONENT_BIAS, NormalFloat::ONE, 0);
+ int exp = -FPB::MAX_EXPONENT - 5;
T result = func(x, exp);
- FPBits result_bits(result);
+ FPB result_bits(result);
ASSERT_FALSE(result_bits.is_zero());
// Verify that the result is indeed subnormal.
ASSERT_EQ(result_bits.get_unbiased_exponent(), uint16_t(0));
// But if the exp is so less that normalization leads to zero, then
// the result should be zero.
- result = func(x, -FPBits::MAX_EXPONENT - int(MANTISSA_WIDTH) - 5);
- ASSERT_TRUE(FPBits(result).is_zero());
+ result = func(x, -FPB::MAX_EXPONENT - int(MANTISSA_WIDTH) - 5);
+ ASSERT_TRUE(FPB(result).is_zero());
// Start with a subnormal number but pass a very high number for exponent.
// The result should not be infinity.
- x = NormalFloat(-FPBits::EXPONENT_BIAS + 1, NormalFloat::ONE >> 10, 0);
- exp = FPBits::MAX_EXPONENT + 5;
- ASSERT_FALSE(FPBits(func(x, exp)).is_inf());
+ x = NormalFloat(-FPB::EXPONENT_BIAS + 1, NormalFloat::ONE >> 10, 0);
+ exp = FPB::MAX_EXPONENT + 5;
+ ASSERT_FALSE(FPB(func(x, exp)).is_inf());
// But if the exp is large enough to oversome than the normalization shift,
// then it should result in infinity.
- exp = FPBits::MAX_EXPONENT + 15;
+ exp = FPB::MAX_EXPONENT + 15;
ASSERT_FP_EQ(func(x, exp), inf);
}
};
diff --git a/libc/test/src/math/LogbTest.h b/libc/test/src/math/LogbTest.h
--- a/libc/test/src/math/LogbTest.h
+++ b/libc/test/src/math/LogbTest.h
@@ -71,11 +71,11 @@
}
void testRange(LogbFunc func) {
- using UIntType = typename FPBits::UIntType;
+ using UIntType = typename FPB::UIntType;
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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)
continue;
diff --git a/libc/test/src/math/ModfTest.h b/libc/test/src/math/ModfTest.h
--- a/libc/test/src/math/ModfTest.h
+++ b/libc/test/src/math/ModfTest.h
@@ -87,7 +87,7 @@
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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))
continue;
diff --git a/libc/test/src/math/NextAfterTest.h b/libc/test/src/math/NextAfterTest.h
--- a/libc/test/src/math/NextAfterTest.h
+++ b/libc/test/src/math/NextAfterTest.h
@@ -19,22 +19,22 @@
template <typename T>
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 UIntType = typename FPBits::UIntType;
+ using UIntType = typename FPB::UIntType;
static constexpr int BIT_WIDTH_OF_TYPE =
__llvm_libc::fputil::FloatProperties<T>::BIT_WIDTH;
- const T zero = T(FPBits::zero());
- const T neg_zero = T(FPBits::neg_zero());
- const T inf = T(FPBits::inf());
- const T neg_inf = T(FPBits::neg_inf());
- const T nan = T(FPBits::build_quiet_nan(1));
- const UIntType min_subnormal = FPBits::MIN_SUBNORMAL;
- const UIntType max_subnormal = FPBits::MAX_SUBNORMAL;
- const UIntType min_normal = FPBits::MIN_NORMAL;
- const UIntType max_normal = FPBits::MAX_NORMAL;
+ const T zero = T(FPB::zero());
+ const T neg_zero = T(FPB::neg_zero());
+ const T inf = T(FPB::inf());
+ const T neg_inf = T(FPB::neg_inf());
+ const T nan = T(FPB::build_quiet_nan(1));
+ const UIntType min_subnormal = FPB::MIN_SUBNORMAL;
+ const UIntType max_subnormal = FPB::MAX_SUBNORMAL;
+ const UIntType min_normal = FPB::MIN_NORMAL;
+ const UIntType max_normal = FPB::MAX_NORMAL;
public:
typedef T (*NextAfterFunc)(T, T);
@@ -160,15 +160,15 @@
// 'from' is a power of 2.
x = T(32.0);
result = func(x, 0);
- FPBits x_bits = FPBits(x);
- FPBits result_bits = FPBits(result);
+ FPB x_bits = FPB(x);
+ FPB result_bits = FPB(result);
ASSERT_EQ(result_bits.get_unbiased_exponent(),
uint16_t(x_bits.get_unbiased_exponent() - 1));
ASSERT_EQ(result_bits.get_mantissa(),
(UIntType(1) << MantissaWidth::VALUE) - 1);
result = func(x, T(33.0));
- result_bits = FPBits(result);
+ result_bits = FPB(result);
ASSERT_EQ(result_bits.get_unbiased_exponent(),
x_bits.get_unbiased_exponent());
ASSERT_EQ(result_bits.get_mantissa(), x_bits.get_mantissa() + UIntType(1));
@@ -176,14 +176,14 @@
x = -x;
result = func(x, 0);
- result_bits = FPBits(result);
+ result_bits = FPB(result);
ASSERT_EQ(result_bits.get_unbiased_exponent(),
uint16_t(x_bits.get_unbiased_exponent() - 1));
ASSERT_EQ(result_bits.get_mantissa(),
(UIntType(1) << MantissaWidth::VALUE) - 1);
result = func(x, T(-33.0));
- result_bits = FPBits(result);
+ result_bits = FPB(result);
ASSERT_EQ(result_bits.get_unbiased_exponent(),
x_bits.get_unbiased_exponent());
ASSERT_EQ(result_bits.get_mantissa(), x_bits.get_mantissa() + UIntType(1));
diff --git a/libc/test/src/math/RIntTest.h b/libc/test/src/math/RIntTest.h
--- a/libc/test/src/math/RIntTest.h
+++ b/libc/test/src/math/RIntTest.h
@@ -30,14 +30,14 @@
typedef T (*RIntFunc)(T);
private:
- using FPBits = __llvm_libc::fputil::FPBits<T>;
- using UIntType = typename FPBits::UIntType;
+ using FPB = __llvm_libc::fputil::FPBits<T>;
+ using UIntType = typename FPB::UIntType;
- const T zero = T(FPBits::zero());
- const T neg_zero = T(FPBits::neg_zero());
- const T inf = T(FPBits::inf());
- const T neg_inf = T(FPBits::neg_inf());
- const T nan = T(FPBits::build_quiet_nan(1));
+ const T zero = T(FPB::zero());
+ const T neg_zero = T(FPB::neg_zero());
+ const T inf = T(FPB::inf());
+ const T neg_inf = T(FPB::neg_inf());
+ const T nan = T(FPB::build_quiet_nan(1));
static inline mpfr::RoundingMode to_mpfr_rounding_mode(int mode) {
switch (mode) {
@@ -94,11 +94,9 @@
void testSubnormalRange(RIntFunc func) {
constexpr UIntType COUNT = 1000001;
- constexpr UIntType STEP =
- (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
- for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL;
- i += STEP) {
- T x = T(FPBits(i));
+ constexpr UIntType STEP = (FPB::MAX_SUBNORMAL - FPB::MIN_SUBNORMAL) / COUNT;
+ for (UIntType i = FPB::MIN_SUBNORMAL; i <= FPB::MAX_SUBNORMAL; i += STEP) {
+ T x = T(FPB(i));
for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode);
mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(mode);
@@ -109,9 +107,9 @@
void testNormalRange(RIntFunc func) {
constexpr UIntType COUNT = 1000001;
- constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
- for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += STEP) {
- T x = T(FPBits(i));
+ constexpr UIntType STEP = (FPB::MAX_NORMAL - FPB::MIN_NORMAL) / COUNT;
+ for (UIntType i = FPB::MIN_NORMAL; i <= FPB::MAX_NORMAL; i += STEP) {
+ T x = T(FPB(i));
// In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. We will skip them.
if (isnan(x)) {
diff --git a/libc/test/src/math/RemQuoTest.h b/libc/test/src/math/RemQuoTest.h
--- a/libc/test/src/math/RemQuoTest.h
+++ b/libc/test/src/math/RemQuoTest.h
@@ -20,8 +20,8 @@
template <typename T>
class RemQuoTestTemplate : public __llvm_libc::testing::Test {
- using FPBits = __llvm_libc::fputil::FPBits<T>;
- using UIntType = typename FPBits::UIntType;
+ using FPB = __llvm_libc::fputil::FPBits<T>;
+ using UIntType = typename FPB::UIntType;
const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
@@ -96,12 +96,11 @@
void testSubnormalRange(RemQuoFunc func) {
constexpr UIntType COUNT = 1000001;
- constexpr UIntType STEP =
- (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
- for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL;
- v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL;
+ constexpr UIntType STEP = (FPB::MAX_SUBNORMAL - FPB::MIN_SUBNORMAL) / COUNT;
+ for (UIntType v = FPB::MIN_SUBNORMAL, w = FPB::MAX_SUBNORMAL;
+ v <= FPB::MAX_SUBNORMAL && w >= FPB::MIN_SUBNORMAL;
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::BinaryInput<T> input{x, y};
result.f = func(x, y, &result.i);
@@ -111,11 +110,10 @@
void testNormalRange(RemQuoFunc func) {
constexpr UIntType COUNT = 1000001;
- constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
- for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
- v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
- v += STEP, w -= STEP) {
- T x = T(FPBits(v)), y = T(FPBits(w));
+ constexpr UIntType STEP = (FPB::MAX_NORMAL - FPB::MIN_NORMAL) / COUNT;
+ for (UIntType v = FPB::MIN_NORMAL, w = FPB::MAX_NORMAL;
+ v <= FPB::MAX_NORMAL && w >= FPB::MIN_NORMAL; v += STEP, w -= STEP) {
+ T x = T(FPB(v)), y = T(FPB(w));
mpfr::BinaryOutput<T> result;
mpfr::BinaryInput<T> input{x, y};
result.f = func(x, y, &result.i);
diff --git a/libc/test/src/math/RoundTest.h b/libc/test/src/math/RoundTest.h
--- a/libc/test/src/math/RoundTest.h
+++ b/libc/test/src/math/RoundTest.h
@@ -67,7 +67,7 @@
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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))
continue;
diff --git a/libc/test/src/math/RoundToIntegerTest.h b/libc/test/src/math/RoundToIntegerTest.h
--- a/libc/test/src/math/RoundToIntegerTest.h
+++ b/libc/test/src/math/RoundToIntegerTest.h
@@ -29,8 +29,8 @@
typedef I (*RoundToIntegerFunc)(F);
private:
- using FPBits = __llvm_libc::fputil::FPBits<F>;
- using UIntType = typename FPBits::UIntType;
+ using FPB = __llvm_libc::fputil::FPBits<F>;
+ using UIntType = typename FPB::UIntType;
const F zero = F(__llvm_libc::fputil::FPBits<F>::zero());
const F neg_zero = F(__llvm_libc::fputil::FPBits<F>::neg_zero());
@@ -122,8 +122,8 @@
constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1;
// We start with 1.0 so that the implicit bit for x86 long doubles
// is set.
- FPBits bits(F(1.0));
- bits.set_unbiased_exponent(EXPONENT_LIMIT + FPBits::EXPONENT_BIAS);
+ FPB bits(F(1.0));
+ bits.set_unbiased_exponent(EXPONENT_LIMIT + FPB::EXPONENT_BIAS);
bits.set_sign(1);
bits.set_mantissa(0);
@@ -186,8 +186,8 @@
constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1;
// We start with 1.0 so that the implicit bit for x86 long doubles
// is set.
- FPBits bits(F(1.0));
- bits.set_unbiased_exponent(EXPONENT_LIMIT + FPBits::EXPONENT_BIAS);
+ FPB bits(F(1.0));
+ bits.set_unbiased_exponent(EXPONENT_LIMIT + FPB::EXPONENT_BIAS);
bits.set_sign(1);
bits.set_mantissa(UIntType(0x1)
<< (__llvm_libc::fputil::MantissaWidth<F>::VALUE - 1));
@@ -212,11 +212,9 @@
void testSubnormalRange(RoundToIntegerFunc func) {
constexpr UIntType COUNT = 1000001;
- constexpr UIntType STEP =
- (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
- for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL;
- i += STEP) {
- F x = F(FPBits(i));
+ constexpr UIntType STEP = (FPB::MAX_SUBNORMAL - FPB::MIN_SUBNORMAL) / COUNT;
+ for (UIntType i = FPB::MIN_SUBNORMAL; i <= FPB::MAX_SUBNORMAL; i += STEP) {
+ F x = F(FPB(i));
if (x == F(0.0))
continue;
// All subnormal numbers should round to zero.
@@ -256,9 +254,9 @@
return;
constexpr UIntType COUNT = 1000001;
- constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
- for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += STEP) {
- F x = F(FPBits(i));
+ constexpr UIntType STEP = (FPB::MAX_NORMAL - FPB::MIN_NORMAL) / COUNT;
+ for (UIntType i = FPB::MIN_NORMAL; i <= FPB::MAX_NORMAL; i += STEP) {
+ F x = F(FPB(i));
// In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. We will skip them.
if (isnan(x)) {
diff --git a/libc/test/src/math/SqrtTest.h b/libc/test/src/math/SqrtTest.h
--- a/libc/test/src/math/SqrtTest.h
+++ b/libc/test/src/math/SqrtTest.h
@@ -39,7 +39,7 @@
void test_denormal_values(SqrtFunc func) {
for (UIntType mant = 1; mant < HIDDEN_BIT; mant <<= 1) {
- FPBits denormal(T(0.0));
+ FPB denormal(T(0.0));
denormal.set_mantissa(mant);
test_all_rounding_modes(func, T(denormal));
diff --git a/libc/test/src/math/TruncTest.h b/libc/test/src/math/TruncTest.h
--- a/libc/test/src/math/TruncTest.h
+++ b/libc/test/src/math/TruncTest.h
@@ -67,7 +67,7 @@
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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))
continue;
diff --git a/libc/test/src/math/acosf_test.cpp b/libc/test/src/math/acosf_test.cpp
--- a/libc/test/src/math/acosf_test.cpp
+++ b/libc/test/src/math/acosf_test.cpp
@@ -16,7 +16,7 @@
#include <errno.h>
#include <stdint.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -39,7 +39,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acos, x,
@@ -66,7 +66,7 @@
};
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,
__llvm_libc::acosf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acos, -x,
diff --git a/libc/test/src/math/asin_test.cpp b/libc/test/src/math/asin_test.cpp
--- a/libc/test/src/math/asin_test.cpp
+++ b/libc/test/src/math/asin_test.cpp
@@ -15,7 +15,7 @@
#include <errno.h>
#include <stdint.h>
-using FPBits = __llvm_libc::fputil::FPBits<double>;
+using FPB = __llvm_libc::fputil::FPBits<double>;
namespace mpfr = __llvm_libc::testing::mpfr;
diff --git a/libc/test/src/math/asinf_test.cpp b/libc/test/src/math/asinf_test.cpp
--- a/libc/test/src/math/asinf_test.cpp
+++ b/libc/test/src/math/asinf_test.cpp
@@ -17,7 +17,7 @@
#include <errno.h>
#include <stdint.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -46,7 +46,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asin, x,
@@ -71,7 +71,7 @@
};
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,
__llvm_libc::asinf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asin, -x,
diff --git a/libc/test/src/math/asinhf_test.cpp b/libc/test/src/math/asinhf_test.cpp
--- a/libc/test/src/math/asinhf_test.cpp
+++ b/libc/test/src/math/asinhf_test.cpp
@@ -16,7 +16,7 @@
#include <errno.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;
@@ -45,7 +45,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, x,
@@ -72,7 +72,7 @@
};
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,
__llvm_libc::asinhf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, -x,
diff --git a/libc/test/src/math/atanf_test.cpp b/libc/test/src/math/atanf_test.cpp
--- a/libc/test/src/math/atanf_test.cpp
+++ b/libc/test/src/math/atanf_test.cpp
@@ -18,7 +18,7 @@
#include <initializer_list>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -44,9 +44,9 @@
TEST(LlvmLibcAtanfTest, InFloatRange) {
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) {
- float x = float(FPBits(v));
+ float x = float(FPB(v));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, x,
__llvm_libc::atanf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, -x,
@@ -58,7 +58,7 @@
TEST(LlvmLibcAtanfTest, SpecialValues) {
for (uint32_t v : {0x3d8d6b23U, 0x3feefcfbU, 0xbd8d6b23U, 0xbfeefcfbU,
0x7F800000U, 0xFF800000U}) {
- float x = float(FPBits(v));
+ float x = float(FPB(v));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, x,
__llvm_libc::atanf(x), 0.5);
}
diff --git a/libc/test/src/math/atanhf_test.cpp b/libc/test/src/math/atanhf_test.cpp
--- a/libc/test/src/math/atanhf_test.cpp
+++ b/libc/test/src/math/atanhf_test.cpp
@@ -16,7 +16,7 @@
#include <errno.h>
#include <stdint.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -49,7 +49,7 @@
EXPECT_FP_EXCEPTION(FE_DIVBYZERO);
EXPECT_MATH_ERRNO(ERANGE);
- auto bt = FPBits(1.0f);
+ auto bt = FPB(1.0f);
bt.bits += 1;
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
@@ -86,9 +86,9 @@
TEST(LlvmLibcAtanhfTest, InFloatRange) {
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) {
- 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);
}
@@ -96,12 +96,12 @@
// For small values, atanh(x) is x.
TEST(LlvmLibcAtanhfTest, SmallValues) {
- float x = float(FPBits(uint32_t(0x17800000)));
+ float x = float(FPB(uint32_t(0x17800000)));
float result = __llvm_libc::atanhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Atanh, x, result, 0.5);
EXPECT_FP_EQ(x, result);
- x = float(FPBits(uint32_t(0x00400000)));
+ x = float(FPB(uint32_t(0x00400000)));
result = __llvm_libc::atanhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Atanh, x, result, 0.5);
EXPECT_FP_EQ(x, result);
diff --git a/libc/test/src/math/cos_test.cpp b/libc/test/src/math/cos_test.cpp
--- a/libc/test/src/math/cos_test.cpp
+++ b/libc/test/src/math/cos_test.cpp
@@ -22,7 +22,7 @@
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
continue;
diff --git a/libc/test/src/math/cosf_test.cpp b/libc/test/src/math/cosf_test.cpp
--- a/libc/test/src/math/cosf_test.cpp
+++ b/libc/test/src/math/cosf_test.cpp
@@ -18,7 +18,7 @@
#include <stdint.h>
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;
@@ -47,7 +47,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Cos, x,
@@ -103,7 +103,7 @@
};
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,
__llvm_libc::cosf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Cos, -x,
@@ -115,7 +115,7 @@
// returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcCosfTest, SDCOMP_26094) {
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);
}
}
diff --git a/libc/test/src/math/coshf_test.cpp b/libc/test/src/math/coshf_test.cpp
--- a/libc/test/src/math/coshf_test.cpp
+++ b/libc/test/src/math/coshf_test.cpp
@@ -17,7 +17,7 @@
#include <errno.h>
#include <stdint.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -44,13 +44,13 @@
TEST(LlvmLibcCoshfTest, Overflow) {
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_FP_EQ(inf, __llvm_libc::coshf(float(FPBits(0x42cffff8U))));
+ EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPB(0x42cffff8U))));
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);
}
@@ -58,7 +58,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Cosh, x, __llvm_libc::coshf(x), 0.5);
@@ -66,12 +66,12 @@
}
TEST(LlvmLibcCoshfTest, SmallValues) {
- float x = float(FPBits(0x17800000U));
+ float x = float(FPB(0x17800000U));
float result = __llvm_libc::coshf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x, result, 0.5);
EXPECT_FP_EQ(1.0f, result);
- x = float(FPBits(0x0040000U));
+ x = float(FPB(0x0040000U));
result = __llvm_libc::coshf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x, result, 0.5);
EXPECT_FP_EQ(1.0f, result);
diff --git a/libc/test/src/math/differential_testing/BinaryOpSingleOutputDiff.h b/libc/test/src/math/differential_testing/BinaryOpSingleOutputDiff.h
--- a/libc/test/src/math/differential_testing/BinaryOpSingleOutputDiff.h
+++ b/libc/test/src/math/differential_testing/BinaryOpSingleOutputDiff.h
@@ -14,8 +14,8 @@
namespace testing {
template <typename T> class BinaryOpSingleOutputDiff {
- using FPBits = fputil::FPBits<T>;
- using UIntType = typename FPBits::UIntType;
+ using FPB = fputil::FPBits<T>;
+ using UIntType = typename FPB::UIntType;
static constexpr UIntType MSBIT = UIntType(1) << (8 * sizeof(UIntType) - 1);
static constexpr UIntType UINTMAX = (MSBIT - 1) + MSBIT;
@@ -34,10 +34,10 @@
UIntType step = (endingBit - startingBit) / N;
for (UIntType bitsX = startingBit, bitsY = endingBit;;
bitsX += step, bitsY -= step) {
- T x = T(FPBits(bitsX));
- T y = T(FPBits(bitsY));
- FPBits myBits = FPBits(myFunc(x, y));
- FPBits otherBits = FPBits(otherFunc(x, y));
+ T x = T(FPB(bitsX));
+ T y = T(FPB(bitsY));
+ FPB myBits = FPB(myFunc(x, y));
+ FPB otherBits = FPB(otherFunc(x, y));
if (myBits.uintval() != otherBits.uintval()) {
result++;
log << " Input: " << bitsX << ", " << bitsY << " (" << x << ", "
@@ -68,8 +68,8 @@
UIntType step = (endingBit - startingBit) / N;
for (UIntType bitsX = startingBit, bitsY = endingBit;;
bitsX += step, bitsY -= step) {
- T x = T(FPBits(bitsX));
- T y = T(FPBits(bitsY));
+ T x = T(FPB(bitsX));
+ T y = T(FPB(bitsY));
result = func(x, y);
if (endingBit - bitsX < step) {
break;
@@ -108,33 +108,33 @@
testutils::OutputFileStream log(logFile);
log << " Performance tests with inputs in denormal range:\n";
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";
- run_perf_in_range(myFunc, otherFunc, /* startingBit= */ FPBits::MIN_NORMAL,
- /* endingBit= */ FPBits::MAX_NORMAL, 100'000'001, log);
+ run_perf_in_range(myFunc, otherFunc, /* startingBit= */ FPB::MIN_NORMAL,
+ /* endingBit= */ FPB::MAX_NORMAL, 100'000'001, log);
log << "\n Performance tests with inputs in normal range with exponents "
"close to each other:\n";
run_perf_in_range(
- myFunc, otherFunc, /* startingBit= */ FPBits(T(0x1.0p-10)).uintval(),
- /* endingBit= */ FPBits(T(0x1.0p+10)).uintval(), 10'000'001, log);
+ myFunc, otherFunc, /* startingBit= */ FPB(T(0x1.0p-10)).uintval(),
+ /* endingBit= */ FPB(T(0x1.0p+10)).uintval(), 10'000'001, log);
}
static void run_diff(Func myFunc, Func otherFunc, const char *logFile) {
uint64_t diffCount = 0;
testutils::OutputFileStream log(logFile);
log << " Diff tests with inputs in denormal range:\n";
- diffCount += run_diff_in_range(
- myFunc, otherFunc, /* startingBit= */ UIntType(0),
- /* endingBit= */ FPBits::MAX_SUBNORMAL, 1'000'001, log);
+ diffCount +=
+ run_diff_in_range(myFunc, otherFunc, /* startingBit= */ UIntType(0),
+ /* endingBit= */ FPB::MAX_SUBNORMAL, 1'000'001, log);
log << "\n Diff tests with inputs in normal range:\n";
- diffCount += run_diff_in_range(
- myFunc, otherFunc, /* startingBit= */ FPBits::MIN_NORMAL,
- /* endingBit= */ FPBits::MAX_NORMAL, 100'000'001, log);
+ diffCount +=
+ run_diff_in_range(myFunc, otherFunc, /* startingBit= */ FPB::MIN_NORMAL,
+ /* endingBit= */ FPB::MAX_NORMAL, 100'000'001, log);
log << "\n Diff tests with inputs in normal range with exponents "
"close to each other:\n";
diffCount += run_diff_in_range(
- myFunc, otherFunc, /* startingBit= */ FPBits(T(0x1.0p-10)).uintval(),
- /* endingBit= */ FPBits(T(0x1.0p+10)).uintval(), 10'000'001, log);
+ myFunc, otherFunc, /* startingBit= */ FPB(T(0x1.0p-10)).uintval(),
+ /* endingBit= */ FPB(T(0x1.0p+10)).uintval(), 10'000'001, log);
log << "Total number of differing results: " << diffCount << '\n';
}
diff --git a/libc/test/src/math/differential_testing/SingleInputSingleOutputDiff.h b/libc/test/src/math/differential_testing/SingleInputSingleOutputDiff.h
--- a/libc/test/src/math/differential_testing/SingleInputSingleOutputDiff.h
+++ b/libc/test/src/math/differential_testing/SingleInputSingleOutputDiff.h
@@ -14,8 +14,8 @@
namespace testing {
template <typename T> class SingleInputSingleOutputDiff {
- using FPBits = fputil::FPBits<T>;
- using UIntType = typename FPBits::UIntType;
+ using FPB = fputil::FPBits<T>;
+ using UIntType = typename FPB::UIntType;
static constexpr UIntType MSBit = UIntType(1) << (8 * sizeof(UIntType) - 1);
static constexpr UIntType UIntMax = (MSBit - 1) + MSBit;
@@ -28,11 +28,11 @@
log << "Starting diff for values from 0 to " << UIntMax << '\n'
<< "Only differing results will be logged.\n\n";
for (UIntType bits = 0;; ++bits) {
- T x = T(FPBits(bits));
+ T x = T(FPB(bits));
T myResult = myFunc(x);
T otherResult = otherFunc(x);
- UIntType myBits = FPBits(myResult).uintval();
- UIntType otherBits = FPBits(otherResult).uintval();
+ UIntType myBits = FPB(myResult).uintval();
+ UIntType otherBits = FPB(otherResult).uintval();
if (myBits != otherBits) {
++diffCount;
log << " Input: " << bits << " (" << x << ")\n"
@@ -52,7 +52,7 @@
auto runner = [=](Func func) {
volatile T result;
for (UIntType bits = startingBit;; ++bits) {
- T x = T(FPBits(bits));
+ T x = T(FPB(bits));
result = func(x);
if (bits == endingBit)
break;
@@ -92,10 +92,10 @@
testutils::OutputFileStream log(logFile);
log << " Performance tests with inputs in denormal range:\n";
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";
- runPerfInRange(myFunc, otherFunc, /* startingBit= */ FPBits::MIN_NORMAL,
- /* endingBit= */ FPBits::MAX_NORMAL, log);
+ runPerfInRange(myFunc, otherFunc, /* startingBit= */ FPB::MIN_NORMAL,
+ /* endingBit= */ FPB::MAX_NORMAL, log);
}
};
diff --git a/libc/test/src/math/exhaustive/acosf_test.cpp b/libc/test/src/math/exhaustive/acosf_test.cpp
--- a/libc/test/src/math/exhaustive/acosf_test.cpp
+++ b/libc/test/src/math/exhaustive/acosf_test.cpp
@@ -13,7 +13,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -24,7 +24,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Acos, x,
__llvm_libc::acosf(x), 0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/asinf_test.cpp b/libc/test/src/math/exhaustive/asinf_test.cpp
--- a/libc/test/src/math/exhaustive/asinf_test.cpp
+++ b/libc/test/src/math/exhaustive/asinf_test.cpp
@@ -13,7 +13,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -24,7 +24,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Asin, x,
__llvm_libc::asinf(x), 0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/asinhf_test.cpp b/libc/test/src/math/exhaustive/asinhf_test.cpp
--- a/libc/test/src/math/exhaustive/asinhf_test.cpp
+++ b/libc/test/src/math/exhaustive/asinhf_test.cpp
@@ -13,7 +13,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -24,7 +24,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Asinh, x,
__llvm_libc::asinhf(x), 0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/atanf_test.cpp b/libc/test/src/math/exhaustive/atanf_test.cpp
--- a/libc/test/src/math/exhaustive/atanf_test.cpp
+++ b/libc/test/src/math/exhaustive/atanf_test.cpp
@@ -13,7 +13,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -24,7 +24,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Atan, x,
__llvm_libc::atanf(x), 0.5, rounding);
@@ -37,7 +37,7 @@
// Range: [0, 1.0];
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_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest);
@@ -57,7 +57,7 @@
// Range: [-1.0, 0];
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_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Nearest);
diff --git a/libc/test/src/math/exhaustive/atanhf_test.cpp b/libc/test/src/math/exhaustive/atanhf_test.cpp
--- a/libc/test/src/math/exhaustive/atanhf_test.cpp
+++ b/libc/test/src/math/exhaustive/atanhf_test.cpp
@@ -13,7 +13,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -24,7 +24,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Atanh, x,
__llvm_libc::atanhf(x), 0.5, rounding);
@@ -37,7 +37,7 @@
// Range: [0, 1.0];
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_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest);
@@ -57,7 +57,7 @@
// Range: [-1.0, 0];
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_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Nearest);
diff --git a/libc/test/src/math/exhaustive/cosf_test.cpp b/libc/test/src/math/exhaustive/cosf_test.cpp
--- a/libc/test/src/math/exhaustive/cosf_test.cpp
+++ b/libc/test/src/math/exhaustive/cosf_test.cpp
@@ -14,7 +14,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -25,7 +25,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x),
0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/coshf_test.cpp b/libc/test/src/math/exhaustive/coshf_test.cpp
--- a/libc/test/src/math/exhaustive/coshf_test.cpp
+++ b/libc/test/src/math/exhaustive/coshf_test.cpp
@@ -14,7 +14,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -25,7 +25,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x,
__llvm_libc::coshf(x), 0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/exp10f_test.cpp b/libc/test/src/math/exhaustive/exp10f_test.cpp
--- a/libc/test/src/math/exhaustive/exp10f_test.cpp
+++ b/libc/test/src/math/exhaustive/exp10f_test.cpp
@@ -14,7 +14,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -25,7 +25,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp10, x,
__llvm_libc::exp10f(x), 0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/exp2f_test.cpp b/libc/test/src/math/exhaustive/exp2f_test.cpp
--- a/libc/test/src/math/exhaustive/exp2f_test.cpp
+++ b/libc/test/src/math/exhaustive/exp2f_test.cpp
@@ -12,7 +12,7 @@
#include "utils/MPFRWrapper/MPFRUtils.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;
@@ -23,7 +23,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/expf_test.cpp b/libc/test/src/math/exhaustive/expf_test.cpp
--- a/libc/test/src/math/exhaustive/expf_test.cpp
+++ b/libc/test/src/math/exhaustive/expf_test.cpp
@@ -14,7 +14,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -25,7 +25,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/expm1f_test.cpp b/libc/test/src/math/exhaustive/expm1f_test.cpp
--- a/libc/test/src/math/exhaustive/expm1f_test.cpp
+++ b/libc/test/src/math/exhaustive/expm1f_test.cpp
@@ -14,7 +14,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -25,7 +25,7 @@
uint32_t bits = stop;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/hypotf_test.cpp b/libc/test/src/math/exhaustive/hypotf_test.cpp
--- a/libc/test/src/math/exhaustive/hypotf_test.cpp
+++ b/libc/test/src/math/exhaustive/hypotf_test.cpp
@@ -13,7 +13,7 @@
#include "utils/MPFRWrapper/MPFRUtils.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;
@@ -28,10 +28,10 @@
uint32_t xbits = start;
bool result = true;
do {
- float x = float(FPBits(xbits));
+ float x = float(FPB(xbits));
uint32_t ybits = Y_START;
do {
- float y = float(FPBits(ybits));
+ float y = float(FPB(ybits));
result &= EXPECT_FP_EQ(__llvm_libc::fputil::hypot(x, y),
__llvm_libc::hypotf(x, y));
// Using MPFR will be much slower.
diff --git a/libc/test/src/math/exhaustive/log10f_test.cpp b/libc/test/src/math/exhaustive/log10f_test.cpp
--- a/libc/test/src/math/exhaustive/log10f_test.cpp
+++ b/libc/test/src/math/exhaustive/log10f_test.cpp
@@ -12,7 +12,7 @@
#include "utils/MPFRWrapper/MPFRUtils.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;
@@ -23,7 +23,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log10, x,
__llvm_libc::log10f(x), 0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/log1pf_test.cpp b/libc/test/src/math/exhaustive/log1pf_test.cpp
--- a/libc/test/src/math/exhaustive/log1pf_test.cpp
+++ b/libc/test/src/math/exhaustive/log1pf_test.cpp
@@ -12,7 +12,7 @@
#include "utils/MPFRWrapper/MPFRUtils.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;
@@ -23,7 +23,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log1p, x,
__llvm_libc::log1pf(x), 0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/log2f_test.cpp b/libc/test/src/math/exhaustive/log2f_test.cpp
--- a/libc/test/src/math/exhaustive/log2f_test.cpp
+++ b/libc/test/src/math/exhaustive/log2f_test.cpp
@@ -12,7 +12,7 @@
#include "utils/MPFRWrapper/MPFRUtils.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;
@@ -23,7 +23,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log2, x,
__llvm_libc::log2f(x), 0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/logf_test.cpp b/libc/test/src/math/exhaustive/logf_test.cpp
--- a/libc/test/src/math/exhaustive/logf_test.cpp
+++ b/libc/test/src/math/exhaustive/logf_test.cpp
@@ -12,7 +12,7 @@
#include "utils/MPFRWrapper/MPFRUtils.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;
@@ -23,7 +23,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x),
0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/sincosf_test.cpp b/libc/test/src/math/exhaustive/sincosf_test.cpp
--- a/libc/test/src/math/exhaustive/sincosf_test.cpp
+++ b/libc/test/src/math/exhaustive/sincosf_test.cpp
@@ -14,7 +14,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -25,7 +25,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
float sinx, cosx;
__llvm_libc::sincosf(x, &sinx, &cosx);
diff --git a/libc/test/src/math/exhaustive/sinf_test.cpp b/libc/test/src/math/exhaustive/sinf_test.cpp
--- a/libc/test/src/math/exhaustive/sinf_test.cpp
+++ b/libc/test/src/math/exhaustive/sinf_test.cpp
@@ -14,7 +14,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -25,7 +25,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x),
0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/sinhf_test.cpp b/libc/test/src/math/exhaustive/sinhf_test.cpp
--- a/libc/test/src/math/exhaustive/sinhf_test.cpp
+++ b/libc/test/src/math/exhaustive/sinhf_test.cpp
@@ -14,7 +14,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -25,7 +25,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x,
__llvm_libc::sinhf(x), 0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/sqrtf_test.cpp b/libc/test/src/math/exhaustive/sqrtf_test.cpp
--- a/libc/test/src/math/exhaustive/sqrtf_test.cpp
+++ b/libc/test/src/math/exhaustive/sqrtf_test.cpp
@@ -11,14 +11,14 @@
#include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(LlvmLibcSqrtfExhaustiveTest, AllValues) {
uint32_t bits = 0;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, __llvm_libc::sqrtf(x), 0.5);
} while (bits++ < 0xffff'ffffU);
diff --git a/libc/test/src/math/exhaustive/tanf_test.cpp b/libc/test/src/math/exhaustive/tanf_test.cpp
--- a/libc/test/src/math/exhaustive/tanf_test.cpp
+++ b/libc/test/src/math/exhaustive/tanf_test.cpp
@@ -15,7 +15,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -29,7 +29,7 @@
bool result = true;
int tol = TOLERANCE;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tanf(x),
0.5, rounding);
diff --git a/libc/test/src/math/exhaustive/tanhf_test.cpp b/libc/test/src/math/exhaustive/tanhf_test.cpp
--- a/libc/test/src/math/exhaustive/tanhf_test.cpp
+++ b/libc/test/src/math/exhaustive/tanhf_test.cpp
@@ -13,7 +13,7 @@
#include <thread>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -24,7 +24,7 @@
uint32_t bits = start;
bool result = true;
do {
- FPBits xbits(bits);
+ FPB xbits(bits);
float x = float(xbits);
result &= EXPECT_MPFR_MATCH(mpfr::Operation::Tanh, x,
__llvm_libc::tanhf(x), 0.5, rounding);
@@ -37,7 +37,7 @@
// Range: [0, INF];
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_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest);
@@ -57,7 +57,7 @@
// Range: [-INF, 0];
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_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Nearest);
diff --git a/libc/test/src/math/exp10f_test.cpp b/libc/test/src/math/exp10f_test.cpp
--- a/libc/test/src/math/exp10f_test.cpp
+++ b/libc/test/src/math/exp10f_test.cpp
@@ -41,13 +41,13 @@
TEST(LlvmLibcExp10fTest, Overflow) {
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_FP_EQ(inf, __llvm_libc::exp10f(float(FPBits(0x43000000U))));
+ EXPECT_FP_EQ(inf, __llvm_libc::exp10f(float(FPB(0x43000000U))));
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);
}
@@ -77,7 +77,7 @@
};
for (int i = 0; i < N; ++i) {
errno = 0;
- float x = float(FPBits(INPUTS[i]));
+ float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x,
__llvm_libc::exp10f(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, -x,
@@ -89,7 +89,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
errno = 0;
diff --git a/libc/test/src/math/exp2f_test.cpp b/libc/test/src/math/exp2f_test.cpp
--- a/libc/test/src/math/exp2f_test.cpp
+++ b/libc/test/src/math/exp2f_test.cpp
@@ -41,13 +41,13 @@
TEST(LlvmLibcExp2fTest, Overflow) {
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_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x43000000U))));
+ EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPB(0x43000000U))));
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);
}
@@ -69,7 +69,7 @@
};
for (int i = 0; i < N; ++i) {
errno = 0;
- float x = float(FPBits(INPUTS[i]));
+ float x = float(FPB(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5);
EXPECT_MATH_ERRNO(0);
@@ -78,20 +78,20 @@
TEST(LlvmLibcExp2fTest, Underflow) {
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);
- float x = float(FPBits(0xc3158000U));
+ float x = float(FPB(0xc3158000U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5);
EXPECT_MATH_ERRNO(0);
- x = float(FPBits(0xc3160000U));
+ x = float(FPB(0xc3160000U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5);
EXPECT_MATH_ERRNO(ERANGE);
- x = float(FPBits(0xc3165432U));
+ x = float(FPB(0xc3165432U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5);
EXPECT_MATH_ERRNO(ERANGE);
@@ -101,7 +101,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
errno = 0;
diff --git a/libc/test/src/math/expf_test.cpp b/libc/test/src/math/expf_test.cpp
--- a/libc/test/src/math/expf_test.cpp
+++ b/libc/test/src/math/expf_test.cpp
@@ -41,27 +41,27 @@
TEST(LlvmLibcExpfTest, Overflow) {
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_FP_EQ(inf, __llvm_libc::expf(float(FPBits(0x42cffff8U))));
+ EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPB(0x42cffff8U))));
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);
}
TEST(LlvmLibcExpfTest, Underflow) {
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);
- float x = float(FPBits(0xc2cffff8U));
+ float x = float(FPB(0xc2cffff8U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5);
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),
0.5);
EXPECT_MATH_ERRNO(ERANGE);
@@ -73,27 +73,27 @@
float x;
errno = 0;
- x = float(FPBits(0x42affff8U));
+ x = float(FPB(0x42affff8U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5);
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),
0.5);
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),
0.5);
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),
0.5);
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),
0.5);
EXPECT_MATH_ERRNO(0);
@@ -103,7 +103,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
errno = 0;
diff --git a/libc/test/src/math/expm1f_test.cpp b/libc/test/src/math/expm1f_test.cpp
--- a/libc/test/src/math/expm1f_test.cpp
+++ b/libc/test/src/math/expm1f_test.cpp
@@ -41,24 +41,24 @@
TEST(LlvmLibcExpm1fTest, Overflow) {
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_FP_EQ(inf, __llvm_libc::expm1f(float(FPBits(0x42cffff8U))));
+ EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPB(0x42cffff8U))));
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);
}
TEST(LlvmLibcExpm1fTest, Underflow) {
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));
- x = float(FPBits(0xc2d00008U));
+ x = float(FPB(0xc2d00008U));
EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(x));
}
@@ -68,42 +68,42 @@
float x;
errno = 0;
- x = float(FPBits(0x42affff8U));
+ x = float(FPB(0x42affff8U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0);
- x = float(FPBits(0x42b00008U));
+ x = float(FPB(0x42b00008U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0);
- x = float(FPBits(0xc2affff8U));
+ x = float(FPB(0xc2affff8U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0);
- x = float(FPBits(0xc2b00008U));
+ x = float(FPB(0xc2b00008U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0);
- x = float(FPBits(0x3dc252ddU));
+ x = float(FPB(0x3dc252ddU));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0);
- x = float(FPBits(0x3e35bec5U));
+ x = float(FPB(0x3e35bec5U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0);
- x = float(FPBits(0x942ed494U));
+ x = float(FPB(0x942ed494U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0);
- x = float(FPBits(0xbdc1c6cbU));
+ x = float(FPB(0xbdc1c6cbU));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0);
@@ -113,7 +113,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
errno = 0;
diff --git a/libc/test/src/math/in_float_range_test_helper.h b/libc/test/src/math/in_float_range_test_helper.h
--- a/libc/test/src/math/in_float_range_test_helper.h
+++ b/libc/test/src/math/in_float_range_test_helper.h
@@ -9,13 +9,13 @@
#define CHECK_DATA(start, stop, mfp_op, f, f_check, count, prec) \
{ \
- uint64_t ustart = FPBits(start).uintval(); \
- uint64_t ustop = FPBits(stop).uintval(); \
+ uint64_t ustart = FPB(start).uintval(); \
+ uint64_t ustop = FPB(stop).uintval(); \
for (uint64_t i = 0;; ++i) { \
uint64_t v = ustart + (ustop - ustart) * i / count; \
if (v > ustop) \
break; \
- float x = FPBits(uint32_t(v)).get_val(); \
+ float x = FPB(uint32_t(v)).get_val(); \
if ((f_check)(x)) { \
EXPECT_MPFR_MATCH_ALL_ROUNDING(mfp_op, x, static_cast<float>((f)(x)), \
(prec)); \
diff --git a/libc/test/src/math/log10_test.cpp b/libc/test/src/math/log10_test.cpp
--- a/libc/test/src/math/log10_test.cpp
+++ b/libc/test/src/math/log10_test.cpp
@@ -25,10 +25,10 @@
TEST(LlvmLibcLog10Test, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::log10(aNaN));
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_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));
}
@@ -62,7 +62,7 @@
0x225e7812faadb32f, 0x3fee1076964c2903,
};
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,
__llvm_libc::log10(x), 0.5);
}
@@ -81,7 +81,7 @@
double tol = 0.5;
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)
continue;
errno = 0;
diff --git a/libc/test/src/math/log10f_test.cpp b/libc/test/src/math/log10f_test.cpp
--- a/libc/test/src/math/log10f_test.cpp
+++ b/libc/test/src/math/log10f_test.cpp
@@ -23,10 +23,10 @@
TEST(LlvmLibcLog10fTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::log10f(aNaN));
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_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));
}
@@ -47,7 +47,7 @@
0x7956ba5eU /*69683218960000541503257137270226944.0f*/};
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,
__llvm_libc::log10f(x), 0.5);
}
@@ -57,7 +57,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
errno = 0;
diff --git a/libc/test/src/math/log1pf_test.cpp b/libc/test/src/math/log1pf_test.cpp
--- a/libc/test/src/math/log1pf_test.cpp
+++ b/libc/test/src/math/log1pf_test.cpp
@@ -23,7 +23,7 @@
TEST(LlvmLibclog1pfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::log1pf(aNaN));
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(neg_zero, __llvm_libc::log1pf(-0.0f));
EXPECT_FP_EQ(neg_inf, __llvm_libc::log1pf(-1.0f));
@@ -54,7 +54,7 @@
0xbd1d20afU, /*-0x1.3a415ep-5f*/
};
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,
__llvm_libc::log1pf(x), 0.5);
}
@@ -64,7 +64,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
errno = 0;
diff --git a/libc/test/src/math/log2f_test.cpp b/libc/test/src/math/log2f_test.cpp
--- a/libc/test/src/math/log2f_test.cpp
+++ b/libc/test/src/math/log2f_test.cpp
@@ -23,10 +23,10 @@
TEST(LlvmLibcLog2fTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::log2f(aNaN));
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_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));
}
@@ -37,7 +37,7 @@
0x3f80079bU, 0x3f81d0b5U, 0x3f82e602U, 0x3f83c98dU, 0x3f8cba39U};
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,
__llvm_libc::log2f(x), 0.5);
}
@@ -47,7 +47,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
errno = 0;
diff --git a/libc/test/src/math/logf_test.cpp b/libc/test/src/math/logf_test.cpp
--- a/libc/test/src/math/logf_test.cpp
+++ b/libc/test/src/math/logf_test.cpp
@@ -23,10 +23,10 @@
TEST(LlvmLibcLogfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::logf(aNaN));
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_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));
}
@@ -63,7 +63,7 @@
0x7a17f30aU, /*0x1.2fe614p+117f*/
};
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);
}
}
@@ -72,7 +72,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
errno = 0;
diff --git a/libc/test/src/math/mod_k_pi_test.cpp b/libc/test/src/math/mod_k_pi_test.cpp
--- a/libc/test/src/math/mod_k_pi_test.cpp
+++ b/libc/test/src/math/mod_k_pi_test.cpp
@@ -14,14 +14,14 @@
#include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr;
-using FPBits = __llvm_libc::fputil::FPBits<double>;
-using UIntType = FPBits::UIntType;
+using FPB = __llvm_libc::fputil::FPBits<double>;
+using UIntType = FPB::UIntType;
TEST(LlvmLibcMod2PITest, Range) {
constexpr UIntType count = 1000000000;
constexpr UIntType step = UIntType(-1) / count;
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)
continue;
@@ -33,7 +33,7 @@
constexpr UIntType count = 1000000000;
constexpr UIntType step = UIntType(-1) / count;
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)
continue;
@@ -46,7 +46,7 @@
constexpr UIntType count = 1000000000;
constexpr UIntType step = UIntType(-1) / count;
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)
continue;
diff --git a/libc/test/src/math/pow_test.cpp b/libc/test/src/math/pow_test.cpp
--- a/libc/test/src/math/pow_test.cpp
+++ b/libc/test/src/math/pow_test.cpp
@@ -15,7 +15,7 @@
#include <errno.h>
#include <stdint.h>
-using FPBits = __llvm_libc::fputil::FPBits<double>;
+using FPB = __llvm_libc::fputil::FPBits<double>;
namespace mpfr = __llvm_libc::testing::mpfr;
diff --git a/libc/test/src/math/sin_test.cpp b/libc/test/src/math/sin_test.cpp
--- a/libc/test/src/math/sin_test.cpp
+++ b/libc/test/src/math/sin_test.cpp
@@ -23,7 +23,7 @@
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
continue;
diff --git a/libc/test/src/math/sincosf_test.cpp b/libc/test/src/math/sincosf_test.cpp
--- a/libc/test/src/math/sincosf_test.cpp
+++ b/libc/test/src/math/sincosf_test.cpp
@@ -18,7 +18,7 @@
#include <stdint.h>
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;
@@ -92,7 +92,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
@@ -151,7 +151,7 @@
};
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);
}
@@ -161,7 +161,7 @@
// returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcSinCosfTest, SDCOMP_26094) {
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);
}
diff --git a/libc/test/src/math/sinf_test.cpp b/libc/test/src/math/sinf_test.cpp
--- a/libc/test/src/math/sinf_test.cpp
+++ b/libc/test/src/math/sinf_test.cpp
@@ -18,7 +18,7 @@
#include <stdint.h>
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;
@@ -47,7 +47,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x,
@@ -97,7 +97,7 @@
};
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,
__llvm_libc::sinf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, -x,
@@ -107,11 +107,11 @@
// For small values, sin(x) is x.
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),
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),
0.5);
}
@@ -120,7 +120,7 @@
// returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcSinfTest, SDCOMP_26094) {
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,
__llvm_libc::sinf(x), 0.5);
}
diff --git a/libc/test/src/math/sinhf_test.cpp b/libc/test/src/math/sinhf_test.cpp
--- a/libc/test/src/math/sinhf_test.cpp
+++ b/libc/test/src/math/sinhf_test.cpp
@@ -17,7 +17,7 @@
#include <errno.h>
#include <stdint.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -46,7 +46,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Sinh, x, __llvm_libc::sinhf(x), 0.5);
@@ -55,12 +55,12 @@
// For small values, sinh(x) is x.
TEST(LlvmLibcSinhfTest, SmallValues) {
- float x = float(FPBits(uint32_t(0x17800000)));
+ float x = float(FPB(uint32_t(0x17800000)));
float result = __llvm_libc::sinhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x, result, 0.5);
EXPECT_FP_EQ(x, result);
- x = float(FPBits(uint32_t(0x00400000)));
+ x = float(FPB(uint32_t(0x00400000)));
result = __llvm_libc::sinhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x, result, 0.5);
EXPECT_FP_EQ(x, result);
@@ -68,22 +68,22 @@
TEST(LlvmLibcSinhfTest, Overflow) {
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_FP_EQ(inf, __llvm_libc::sinhf(float(FPBits(0x42cffff8U))));
+ EXPECT_FP_EQ(inf, __llvm_libc::sinhf(float(FPB(0x42cffff8U))));
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);
}
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,
__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,
__llvm_libc::sinhf(x), 0.5);
}
diff --git a/libc/test/src/math/tan_test.cpp b/libc/test/src/math/tan_test.cpp
--- a/libc/test/src/math/tan_test.cpp
+++ b/libc/test/src/math/tan_test.cpp
@@ -22,7 +22,7 @@
constexpr UIntType COUNT = 10000000;
constexpr UIntType STEP = UIntType(-1) / COUNT;
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.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
continue;
diff --git a/libc/test/src/math/tanf_test.cpp b/libc/test/src/math/tanf_test.cpp
--- a/libc/test/src/math/tanf_test.cpp
+++ b/libc/test/src/math/tanf_test.cpp
@@ -18,7 +18,7 @@
#include <stdint.h>
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;
@@ -47,7 +47,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tan, x,
@@ -115,7 +115,7 @@
};
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,
__llvm_libc::tanf(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tan, -x,
@@ -127,7 +127,7 @@
// returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcTanfTest, SDCOMP_26094) {
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);
}
}
diff --git a/libc/test/src/math/tanhf_test.cpp b/libc/test/src/math/tanhf_test.cpp
--- a/libc/test/src/math/tanhf_test.cpp
+++ b/libc/test/src/math/tanhf_test.cpp
@@ -16,7 +16,7 @@
#include <errno.h>
#include <stdint.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
+using FPB = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -45,7 +45,7 @@
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
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))
continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Tanh, x, __llvm_libc::tanhf(x), 0.5);
@@ -54,23 +54,23 @@
// For small values, tanh(x) is x.
TEST(LlvmLibcTanhfTest, SmallValues) {
- float x = float(FPBits(uint32_t(0x17800000)));
+ float x = float(FPB(uint32_t(0x17800000)));
float result = __llvm_libc::tanhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Tanh, x, result, 0.5);
EXPECT_FP_EQ(x, result);
- x = float(FPBits(uint32_t(0x00400000)));
+ x = float(FPB(uint32_t(0x00400000)));
result = __llvm_libc::tanhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Tanh, x, result, 0.5);
EXPECT_FP_EQ(x, result);
}
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,
__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,
__llvm_libc::tanhf(x), 0.5);
}
diff --git a/libc/test/utils/FPUtil/x86_long_double_test.cpp b/libc/test/utils/FPUtil/x86_long_double_test.cpp
--- a/libc/test/utils/FPUtil/x86_long_double_test.cpp
+++ b/libc/test/utils/FPUtil/x86_long_double_test.cpp
@@ -11,7 +11,7 @@
#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<long double>;
+using FPB = __llvm_libc::fputil::FPBits<long double>;
TEST(X86LongDoubleTest, is_nan) {
// In the nan checks below, we use the macro isnan from math.h to ensure that
@@ -20,8 +20,8 @@
// isnan result ensures that LLVM-libc's behavior matches the compiler's
// behavior.
- FPBits bits(0.0l);
- bits.exponent = FPBits::MAX_EXPONENT;
+ FPB bits(0.0l);
+ bits.exponent = FPB::MAX_EXPONENT;
for (unsigned int i = 0; i < 1000000; ++i) {
// If exponent has the max value and the implicit bit is 0,
// then the number is a NaN for all values of mantissa.
diff --git a/libc/utils/MPFRWrapper/MPFRUtils.cpp b/libc/utils/MPFRWrapper/MPFRUtils.cpp
--- a/libc/utils/MPFRWrapper/MPFRUtils.cpp
+++ b/libc/utils/MPFRWrapper/MPFRUtils.cpp
@@ -31,8 +31,6 @@
#include <mpfr.h>
#endif
-template <typename T> using FPBits = __llvm_libc::fputil::FPBits<T>;
-
namespace __llvm_libc {
namespace testing {
namespace mpfr {
@@ -800,8 +798,8 @@
unsigned int precision = get_precision<T>(ulp_tolerance);
MPFRNumber mpfrX(input.x, precision);
MPFRNumber mpfrY(input.y, precision);
- FPBits<T> xbits(input.x);
- FPBits<T> ybits(input.y);
+ fputil::FPBits<T> xbits(input.x);
+ fputil::FPBits<T> ybits(input.y);
MPFRNumber mpfr_result =
binary_operation_one_output(op, input.x, input.y, precision, rounding);
MPFRNumber mpfrMatchValue(libc_result);
@@ -841,9 +839,9 @@
MPFRNumber mpfrX(input.x, precision);
MPFRNumber mpfrY(input.y, precision);
MPFRNumber mpfrZ(input.z, precision);
- FPBits<T> xbits(input.x);
- FPBits<T> ybits(input.y);
- FPBits<T> zbits(input.z);
+ fputil::FPBits<T> xbits(input.x);
+ fputil::FPBits<T> ybits(input.y);
+ fputil::FPBits<T> zbits(input.z);
MPFRNumber mpfr_result = ternary_operation_one_output(
op, input.x, input.y, input.z, precision, rounding);
MPFRNumber mpfrMatchValue(libc_result);
diff --git a/libc/utils/UnitTest/FPMatcher.h b/libc/utils/UnitTest/FPMatcher.h
--- a/libc/utils/UnitTest/FPMatcher.h
+++ b/libc/utils/UnitTest/FPMatcher.h
@@ -69,13 +69,13 @@
} // namespace __llvm_libc
#define DECLARE_SPECIAL_CONSTANTS(T) \
- using FPBits = __llvm_libc::fputil::FPBits<T>; \
- using UIntType = typename FPBits::UIntType; \
- const T zero = T(FPBits::zero()); \
- const T neg_zero = T(FPBits::neg_zero()); \
- const T aNaN = T(FPBits::build_quiet_nan(1)); \
- const T inf = T(FPBits::inf()); \
- const T neg_inf = T(FPBits::neg_inf());
+ using FPB = __llvm_libc::fputil::FPBits<T>; \
+ using UIntType = typename FPB::UIntType; \
+ const T zero = T(FPB::zero()); \
+ const T neg_zero = T(FPB::neg_zero()); \
+ const T aNaN = T(FPB::build_quiet_nan(1)); \
+ const T inf = T(FPB::inf()); \
+ const T neg_inf = T(FPB::neg_inf());
#define EXPECT_FP_EQ(expected, actual) \
EXPECT_THAT( \