This is an archive of the discontinued LLVM Phabricator instance.

Differential D145349

[libc][math] Switch math functions to use libc_errno and fix some errno and floating point exceptions.
ClosedPublic

Authored by lntue on Mar 5 2023, 8:27 PM.

Details

Reviewers
michaelrj
sivachandra
Commits
rG31c39439a894: [libc][math] Switch math functions to use libc_errno and fix some errno and…
Summary

Switch math functions to use libc_errno and fix some errno and
floating point exceptions

Diff Detail

Event Timeline

lntue created this revision.Mar 5 2023, 8:27 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptMar 5 2023, 8:27 PM
Herald added subscribers: ecnelises, tschuett. · View Herald Transcript
lntue requested review of this revision.Mar 5 2023, 8:27 PM
Harbormaster completed remote builds in B217489: Diff 502511.Mar 5 2023, 8:33 PM
sivachandra accepted this revision.Mar 5 2023, 10:05 PM

For IWYU, we should include src/errno/libc_errno.h in the test .cpp files.

This revision is now accepted and ready to land.Mar 5 2023, 10:05 PM
lntue updated this revision to Diff 502916.Mar 6 2023, 9:48 PM

Include src/errno/libc_errno.h to unit tests.

This revision was landed with ongoing or failed builds.Mar 6 2023, 9:51 PM
Closed by commit rG31c39439a894: [libc][math] Switch math functions to use libc_errno and fix some errno and… (authored by lntue). · Explain Why
This revision was automatically updated to reflect the committed changes.
lntue added a commit: rG31c39439a894: [libc][math] Switch math functions to use libc_errno and fix some errno and….
Harbormaster completed remote builds in B217793: Diff 502916.Mar 6 2023, 10:25 PM

Revision Contents

PathSize
libc/
src/
__support/
FPUtil/
3 lines
4 lines
7 lines
math/
generic/
1 line
3 lines
3 lines
14 lines
3 lines
7 lines
6 lines
6 lines
4 lines
6 lines
3 lines
3 lines
test/
UnitTest/
9 lines
src/
math/
29 lines
2 lines
3 lines
7 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
5 lines
11 lines
11 lines
11 lines
11 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
5 lines
3 lines
3 lines

Diff 502918

libc/src/__support/FPUtil/CMakeLists.txt

add_header_library( add_header_library(
fenv_impl fenv_impl
HDRS HDRS
FEnvImpl.h FEnvImpl.h
DEPENDS DEPENDS
libc.include.errno
libc.include.fenv libc.include.fenv
libc.include.math libc.include.math
libc.src.__support.macros.attributes libc.src.__support.macros.attributes
libc.src.__support.macros.properties.architectures libc.src.__support.macros.properties.architectures
libc.src.__support.macros.sanitizer libc.src.__support.macros.sanitizer
libc.src.errno.errno libc.src.errno.errno
) )
Show All 32 Linesadd_header_library(
HDRS HDRS
NearestIntegerOperations.h NearestIntegerOperations.h
DEPENDS DEPENDS
.fp_bits .fp_bits
.fenv_impl .fenv_impl
libc.src.__support.CPP.type_traits libc.src.__support.CPP.type_traits
libc.src.__support.common libc.src.__support.common
libc.include.math libc.include.math
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
) )
add_header_library( add_header_library(
normal_float normal_float
HDRS HDRS
NormalFloat.h NormalFloat.h
DEPENDS DEPENDS
Show All 11 Lines DEPENDS
.nearest_integer_operations .nearest_integer_operations
.normal_float .normal_float
.platform_defs .platform_defs
libc.src.__support.CPP.bit libc.src.__support.CPP.bit
libc.src.__support.CPP.type_traits libc.src.__support.CPP.type_traits
libc.src.__support.common libc.src.__support.common
libc.src.__support.macros.optimization libc.src.__support.macros.optimization
libc.include.math libc.include.math
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
) )
add_header_library( add_header_library(
basic_operations basic_operations
HDRS HDRS
BasicOperations.h BasicOperations.h
DEPENDS DEPENDS
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

libc/src/__support/FPUtil/FEnvImpl.h

//===-- Floating point environment manipulation functions -------*- C++ -*-===// //===-- Floating point environment manipulation functions -------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVIMPL_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVIMPL_H
#define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVIMPL_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVIMPL_H
#include "src/__support/macros/attributes.h" // LIBC_INLINE #include "src/__support/macros/attributes.h" // LIBC_INLINE
#include "src/__support/macros/properties/architectures.h" #include "src/__support/macros/properties/architectures.h"
#include "src/errno/libc_errno.h"
#include <errno.h>
#include <fenv.h> #include <fenv.h>
#include <math.h> #include <math.h>
#if defined(LIBC_TARGET_ARCH_IS_AARCH64) #if defined(LIBC_TARGET_ARCH_IS_AARCH64)
#if defined(__APPLE__) #if defined(__APPLE__)
#include "aarch64/fenv_darwin_impl.h" #include "aarch64/fenv_darwin_impl.h"
#else #else
#include "aarch64/FEnvImpl.h" #include "aarch64/FEnvImpl.h"
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
LIBC_INLINE int raise_except_if_required(int excepts) { LIBC_INLINE int raise_except_if_required(int excepts) {
if (math_errhandling & MATH_ERREXCEPT) if (math_errhandling & MATH_ERREXCEPT)
return raise_except(excepts); return raise_except(excepts);
return 0; return 0;
} }
LIBC_INLINE void set_errno_if_required(int err) { LIBC_INLINE void set_errno_if_required(int err) {
if (math_errhandling & MATH_ERRNO) if (math_errhandling & MATH_ERRNO)
errno = err; libc_errno = err;
} }
} // namespace __llvm_libc::fputil } // namespace __llvm_libc::fputil
#endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVIMPL_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVIMPL_H

libc/src/__support/FPUtil/NearestIntegerOperations.h

Show All 9 Lines
#define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
#include "FEnvImpl.h" #include "FEnvImpl.h"
#include "FPBits.h" #include "FPBits.h"
#include "src/__support/CPP/type_traits.h" #include "src/__support/CPP/type_traits.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include <errno.h>
#include <math.h> #include <math.h>
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0> template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
LIBC_INLINE T trunc(T x) { LIBC_INLINE T trunc(T x) {
FPBits<T> bits(x); FPBits<T> bits(x);
▲ Show 20 Lines • Show All 206 Lines • ▼ Show 20 Lines
template <typename F, typename I, template <typename F, typename I,
cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>, cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>,
int> = 0> int> = 0>
LIBC_INLINE I rounded_float_to_signed_integer(F x) { LIBC_INLINE I rounded_float_to_signed_integer(F x) {
constexpr I INTEGER_MIN = (I(1) << (sizeof(I) * 8 - 1)); constexpr I INTEGER_MIN = (I(1) << (sizeof(I) * 8 - 1));
constexpr I INTEGER_MAX = -(INTEGER_MIN + 1); constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
FPBits<F> bits(x); FPBits<F> bits(x);
auto set_domain_error_and_raise_invalid = []() { auto set_domain_error_and_raise_invalid = []() {
if (math_errhandling & MATH_ERRNO) set_errno_if_required(EDOM);
errno = EDOM; raise_except_if_required(FE_INVALID);
if (math_errhandling & MATH_ERREXCEPT)
raise_except(FE_INVALID);
}; };
if (bits.is_inf_or_nan()) { if (bits.is_inf_or_nan()) {
set_domain_error_and_raise_invalid(); set_domain_error_and_raise_invalid();
return bits.get_sign() ? INTEGER_MIN : INTEGER_MAX; return bits.get_sign() ? INTEGER_MIN : INTEGER_MAX;
} }
int exponent = bits.get_exponent(); int exponent = bits.get_exponent();
Show All 40 Lines

libc/src/math/generic/CMakeLists.txt

Show First 20 Lines • Show All 768 Lines • ▼ Show 20 Lines
# TODO(lntue): Make log10 correctly rounded for non-FMA targets. # TODO(lntue): Make log10 correctly rounded for non-FMA targets.
add_entrypoint_object( add_entrypoint_object(
log10 log10
SRCS SRCS
log10.cpp log10.cpp
HDRS HDRS
../log10.h ../log10.h
DEPENDS DEPENDS
libc.src.__support.FPUtil.fenv_impl
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
libc.src.__support.FPUtil.multiply_add libc.src.__support.FPUtil.multiply_add
libc.src.__support.FPUtil.double_double libc.src.__support.FPUtil.double_double
libc.src.__support.FPUtil.dyadic_float libc.src.__support.FPUtil.dyadic_float
libc.src.__support.macros.optimization libc.src.__support.macros.optimization
COMPILE_OPTIONS COMPILE_OPTIONS
-O3 -O3
) )
▲ Show 20 Lines • Show All 708 Lines • Show Last 20 Lines

libc/src/math/generic/acosf.cpp

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 LinesLLVM_LIBC_FUNCTION(float, acosf, (float x)) {
} }
// |x| > 1, return NaNs. // |x| > 1, return NaNs.
if (LIBC_UNLIKELY(x_abs > 0x3f80'0000U)) { if (LIBC_UNLIKELY(x_abs > 0x3f80'0000U)) {
if (x_abs <= 0x7f80'0000U) { if (x_abs <= 0x7f80'0000U) {
fputil::set_errno_if_required(EDOM); fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID); fputil::raise_except_if_required(FE_INVALID);
} }
return x + return x + FPBits::build_quiet_nan(0);
FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
// When 0.5 < |x| <= 1, we perform range reduction as follow: // When 0.5 < |x| <= 1, we perform range reduction as follow:
// //
// Assume further that 0.5 < x <= 1, and let: // Assume further that 0.5 < x <= 1, and let:
// y = acos(x) // y = acos(x)
// We use the double angle formula: // We use the double angle formula:
// x = cos(y) = 1 - 2 sin^2(y/2) // x = cos(y) = 1 - 2 sin^2(y/2)
Show All 27 Lines

libc/src/math/generic/acoshf.cpp

Show All 19 Lines
LLVM_LIBC_FUNCTION(float, acoshf, (float x)) { LLVM_LIBC_FUNCTION(float, acoshf, (float x)) {
using FPBits_t = typename fputil::FPBits<float>; using FPBits_t = typename fputil::FPBits<float>;
FPBits_t xbits(x); FPBits_t xbits(x);
uint32_t x_u = xbits.uintval(); uint32_t x_u = xbits.uintval();
if (LIBC_UNLIKELY(x < 1.0f)) { if (LIBC_UNLIKELY(x < 1.0f)) {
// x < 1. // x < 1.
fputil::set_except(FE_INVALID); fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID);
return FPBits_t::build_quiet_nan(0); return FPBits_t::build_quiet_nan(0);
} }
if (LIBC_UNLIKELY(x_u >= 0x4f8ffb03)) { if (LIBC_UNLIKELY(x_u >= 0x4f8ffb03)) {
// Check for exceptional values. // Check for exceptional values.
uint32_t x_abs = x_u & FPBits_t::FloatProp::EXP_MANT_MASK; uint32_t x_abs = x_u & FPBits_t::FloatProp::EXP_MANT_MASK;
if (LIBC_UNLIKELY(x_abs >= 0x7f80'0000U)) { if (LIBC_UNLIKELY(x_abs >= 0x7f80'0000U)) {
// x is +inf or NaN. // x is +inf or NaN.
Show All 37 Lines

libc/src/math/generic/atanhf.cpp

Show All 18 LinesLLVM_LIBC_FUNCTION(float, atanhf, (float x)) {
bool sign = xbits.get_sign(); bool sign = xbits.get_sign();
uint32_t x_abs = xbits.uintval() & FPBits::FloatProp::EXP_MANT_MASK; uint32_t x_abs = xbits.uintval() & FPBits::FloatProp::EXP_MANT_MASK;
// |x| >= 1.0 // |x| >= 1.0
if (LIBC_UNLIKELY(x_abs >= 0x3F80'0000U)) { if (LIBC_UNLIKELY(x_abs >= 0x3F80'0000U)) {
if (xbits.is_nan()) { if (xbits.is_nan()) {
return x; return x;
} }
// |x| == 0 // |x| == 1.0
if (x_abs == 0x3F80'0000U) { if (x_abs == 0x3F80'0000U) {
fputil::set_except(FE_DIVBYZERO); fputil::set_errno_if_required(ERANGE);
return with_errno(FPBits::inf(sign).get_val(), ERANGE); fputil::raise_except_if_required(FE_DIVBYZERO);
return FPBits::inf(sign).get_val();
} else { } else {
fputil::set_except(FE_INVALID); fputil::set_errno_if_required(EDOM);
return with_errno( fputil::raise_except_if_required(FE_INVALID);
FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1)), return FPBits::build_quiet_nan(0);
EDOM);
} }
} }
// |x| < ~0.10 // |x| < ~0.10
if (LIBC_UNLIKELY(x_abs <= 0x3dcc'0000U)) { if (LIBC_UNLIKELY(x_abs <= 0x3dcc'0000U)) {
// |x| <= 2^-26 // |x| <= 2^-26
if (LIBC_UNLIKELY(x_abs <= 0x3280'0000U)) { if (LIBC_UNLIKELY(x_abs <= 0x3280'0000U)) {
return LIBC_UNLIKELY(x_abs == 0) ? x return LIBC_UNLIKELY(x_abs == 0) ? x
Show All 16 Lines

libc/src/math/generic/cosf.cpp

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Lines if (auto r = COSF_EXCEPTS.lookup(x_abs); LIBC_UNLIKELY(r.has_value()))
return r.value(); return r.value();
// x is inf or nan. // x is inf or nan.
if (LIBC_UNLIKELY(x_abs >= 0x7f80'0000U)) { if (LIBC_UNLIKELY(x_abs >= 0x7f80'0000U)) {
if (x_abs == 0x7f80'0000U) { if (x_abs == 0x7f80'0000U) {
fputil::set_errno_if_required(EDOM); fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID); fputil::raise_except_if_required(FE_INVALID);
} }
return x + return x + FPBits::build_quiet_nan(0);
FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
// Combine the results with the sine of sum formula: // Combine the results with the sine of sum formula:
// cos(x) = cos((k + y)*pi/32) // cos(x) = cos((k + y)*pi/32)
// = cos(y*pi/32) * cos(k*pi/32) - sin(y*pi/32) * sin(k*pi/32) // = cos(y*pi/32) * cos(k*pi/32) - sin(y*pi/32) * sin(k*pi/32)
// = cosm1_y * cos_k + sin_y * sin_k // = cosm1_y * cos_k + sin_y * sin_k
// = (cosm1_y * cos_k + cos_k) + sin_y * sin_k // = (cosm1_y * cos_k + cos_k) + sin_y * sin_k
double sin_k, cos_k, sin_y, cosm1_y; double sin_k, cos_k, sin_y, cosm1_y;
sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y); sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y);
return fputil::multiply_add(sin_y, -sin_k, return fputil::multiply_add(sin_y, -sin_k,
fputil::multiply_add(cosm1_y, cos_k, cos_k)); fputil::multiply_add(cosm1_y, cos_k, cos_k));
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/log10.cpp

//===-- Double-precision log10(x) function --------------------------------===// //===-- Double-precision log10(x) function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/log10.h" #include "src/math/log10.h"
#include "src/__support/FPUtil/FEnvImpl.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/double_double.h" #include "src/__support/FPUtil/double_double.h"
#include "src/__support/FPUtil/dyadic_float.h" #include "src/__support/FPUtil/dyadic_float.h"
#include "src/__support/FPUtil/multiply_add.h" #include "src/__support/FPUtil/multiply_add.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "src/__support/macros/optimization.h" // LIBC_UNLIKELY #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
namespace __llvm_libc { namespace __llvm_libc {
▲ Show 20 Lines • Show All 930 Lines • ▼ Show 20 LinesLLVM_LIBC_FUNCTION(double, log10, (double x)) {
using FPBits_t = typename fputil::FPBits<double>; using FPBits_t = typename fputil::FPBits<double>;
FPBits_t xbits(x); FPBits_t xbits(x);
int x_e = -1023; int x_e = -1023;
if (LIBC_UNLIKELY(xbits.uintval() < FPBits_t::MIN_NORMAL || if (LIBC_UNLIKELY(xbits.uintval() < FPBits_t::MIN_NORMAL ||
xbits.uintval() > FPBits_t::MAX_NORMAL)) { xbits.uintval() > FPBits_t::MAX_NORMAL)) {
if (xbits.is_zero()) { if (xbits.is_zero()) {
// return -Inf and raise FE_DIVBYZERO. // return -Inf and raise FE_DIVBYZERO.
return -1.0 / 0.0; fputil::set_errno_if_required(ERANGE);
fputil::raise_except_if_required(FE_DIVBYZERO);
return static_cast<double>(FPBits_t::neg_inf());
} }
if (xbits.get_sign() && !xbits.is_nan()) { if (xbits.get_sign() && !xbits.is_nan()) {
fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID);
return FPBits_t::build_quiet_nan(0); return FPBits_t::build_quiet_nan(0);
} }
if (xbits.is_inf_or_nan()) { if (xbits.is_inf_or_nan()) {
return x; return x;
} }
// Normalize denormal inputs. // Normalize denormal inputs.
xbits.set_val(x * 0x1.0p52); xbits.set_val(x * 0x1.0p52);
x_e -= 52; x_e -= 52;
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

libc/src/math/generic/log10f.cpp

Show First 20 Lines • Show All 146 Lines • ▼ Show 20 Lines
#endif // LIBC_TARGET_CPU_HAS_FMA #endif // LIBC_TARGET_CPU_HAS_FMA
} }
int m = -FPBits::EXPONENT_BIAS; int m = -FPBits::EXPONENT_BIAS;
if (LIBC_UNLIKELY(x_u < FPBits::MIN_NORMAL || x_u > FPBits::MAX_NORMAL)) { if (LIBC_UNLIKELY(x_u < FPBits::MIN_NORMAL || x_u > FPBits::MAX_NORMAL)) {
if (xbits.is_zero()) { if (xbits.is_zero()) {
// Return -inf and raise FE_DIVBYZERO // Return -inf and raise FE_DIVBYZERO
fputil::raise_except(FE_DIVBYZERO); fputil::set_errno_if_required(ERANGE);
fputil::raise_except_if_required(FE_DIVBYZERO);
return static_cast<float>(FPBits::neg_inf()); return static_cast<float>(FPBits::neg_inf());
} }
if (xbits.get_sign() && !xbits.is_nan()) { if (xbits.get_sign() && !xbits.is_nan()) {
// Return NaN and raise FE_INVALID // Return NaN and raise FE_INVALID
fputil::raise_except(FE_INVALID); fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID);
return FPBits::build_quiet_nan(0); return FPBits::build_quiet_nan(0);
} }
if (xbits.is_inf_or_nan()) { if (xbits.is_inf_or_nan()) {
return x; return x;
} }
// Normalize denormal inputs. // Normalize denormal inputs.
xbits.set_val(xbits.get_val() * 0x1.0p23f); xbits.set_val(xbits.get_val() * 0x1.0p23f);
m -= 23; m -= 23;
Show All 24 Lines

libc/src/math/generic/log1pf.cpp

Show All 39 LinesLIBC_INLINE float log(double x) {
using FPBits = typename fputil::FPBits<double>; using FPBits = typename fputil::FPBits<double>;
FPBits xbits(x); FPBits xbits(x);
uint64_t x_u = xbits.uintval(); uint64_t x_u = xbits.uintval();
if (LIBC_UNLIKELY(x_u > FPBits::MAX_NORMAL)) { if (LIBC_UNLIKELY(x_u > FPBits::MAX_NORMAL)) {
if (xbits.get_sign() && !xbits.is_nan()) { if (xbits.get_sign() && !xbits.is_nan()) {
fputil::raise_except(FE_INVALID); fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID);
return fputil::FPBits<float>::build_quiet_nan(0); return fputil::FPBits<float>::build_quiet_nan(0);
} }
return static_cast<float>(x); return static_cast<float>(x);
} }
double m = static_cast<double>(xbits.get_exponent()); double m = static_cast<double>(xbits.get_exponent());
// Get the 8 highest bits, use 7 bits (excluding the implicit hidden bit) for // Get the 8 highest bits, use 7 bits (excluding the implicit hidden bit) for
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines case 0x65d890d3U: // x = 0x1.b121a6p+76f
return fputil::round_result_slightly_down(0x1.a9a3f2p+5f); return fputil::round_result_slightly_down(0x1.a9a3f2p+5f);
case 0x6f31a8ecU: // x = 0x1.6351d8p+95f case 0x6f31a8ecU: // x = 0x1.6351d8p+95f
return fputil::round_result_slightly_down(0x1.08b512p+6f); return fputil::round_result_slightly_down(0x1.08b512p+6f);
case 0x7a17f30aU: // x = 0x1.2fe614p+117f case 0x7a17f30aU: // x = 0x1.2fe614p+117f
return fputil::round_result_slightly_up(0x1.451436p+6f); return fputil::round_result_slightly_up(0x1.451436p+6f);
case 0xbd1d20afU: // x = -0x1.3a415ep-5f case 0xbd1d20afU: // x = -0x1.3a415ep-5f
return fputil::round_result_slightly_up(-0x1.407112p-5f); return fputil::round_result_slightly_up(-0x1.407112p-5f);
case 0xbf800000U: // x = -1.0 case 0xbf800000U: // x = -1.0
fputil::raise_except(FE_DIVBYZERO); fputil::set_errno_if_required(ERANGE);
fputil::raise_except_if_required(FE_DIVBYZERO);
return static_cast<float>(fputil::FPBits<float>::neg_inf()); return static_cast<float>(fputil::FPBits<float>::neg_inf());
#ifndef LIBC_TARGET_CPU_HAS_FMA #ifndef LIBC_TARGET_CPU_HAS_FMA
case 0x4cc1c80bU: // x = 0x1.839016p+26f case 0x4cc1c80bU: // x = 0x1.839016p+26f
return fputil::round_result_slightly_down(0x1.26fc04p+4f); return fputil::round_result_slightly_down(0x1.26fc04p+4f);
case 0x5ee8984eU: // x = 0x1.d1309cp+62f case 0x5ee8984eU: // x = 0x1.d1309cp+62f
return fputil::round_result_slightly_up(0x1.5c9442p+5f); return fputil::round_result_slightly_up(0x1.5c9442p+5f);
case 0x665e7ca6U: // x = 0x1.bcf94cp+77f case 0x665e7ca6U: // x = 0x1.bcf94cp+77f
return fputil::round_result_slightly_up(0x1.af66cp+5f); return fputil::round_result_slightly_up(0x1.af66cp+5f);
Show All 40 Lines

libc/src/math/generic/log2f.cpp

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Lines case 0x3f81d0b5U: // x = 0x1.03a16ap0f
return round_result_slightly_up(0x1.4cdc4cp-6f); return round_result_slightly_up(0x1.4cdc4cp-6f);
} }
int m = -FPBits::EXPONENT_BIAS; int m = -FPBits::EXPONENT_BIAS;
// Exceptional inputs. // Exceptional inputs.
if (LIBC_UNLIKELY(x_u < FPBits::MIN_NORMAL || x_u > FPBits::MAX_NORMAL)) { if (LIBC_UNLIKELY(x_u < FPBits::MIN_NORMAL || x_u > FPBits::MAX_NORMAL)) {
if (xbits.is_zero()) { if (xbits.is_zero()) {
fputil::raise_except(FE_DIVBYZERO); fputil::set_errno_if_required(ERANGE);
fputil::raise_except_if_required(FE_DIVBYZERO);
return static_cast<float>(FPBits::neg_inf()); return static_cast<float>(FPBits::neg_inf());
} }
if (xbits.get_sign() && !xbits.is_nan()) { if (xbits.get_sign() && !xbits.is_nan()) {
fputil::set_errno_if_required(EDOM);
fputil::raise_except(FE_INVALID); fputil::raise_except(FE_INVALID);
return FPBits::build_quiet_nan(0); return FPBits::build_quiet_nan(0);
} }
if (xbits.is_inf_or_nan()) { if (xbits.is_inf_or_nan()) {
return x; return x;
} }
// Normalize denormal inputs. // Normalize denormal inputs.
xbits.set_val(xbits.get_val() * 0x1.0p23f); xbits.set_val(xbits.get_val() * 0x1.0p23f);
Show All 34 Lines

libc/src/math/generic/logf.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
#endif // LIBC_TARGET_CPU_HAS_FMA #endif // LIBC_TARGET_CPU_HAS_FMA
} }
int m = -FPBits::EXPONENT_BIAS; int m = -FPBits::EXPONENT_BIAS;
if (LIBC_UNLIKELY(x_u < FPBits::MIN_NORMAL || x_u > FPBits::MAX_NORMAL)) { if (LIBC_UNLIKELY(x_u < FPBits::MIN_NORMAL || x_u > FPBits::MAX_NORMAL)) {
if (xbits.is_zero()) { if (xbits.is_zero()) {
// Return -inf and raise FE_DIVBYZERO // Return -inf and raise FE_DIVBYZERO
fputil::raise_except(FE_DIVBYZERO); fputil::set_errno_if_required(ERANGE);
fputil::raise_except_if_required(FE_DIVBYZERO);
return static_cast<float>(FPBits::neg_inf()); return static_cast<float>(FPBits::neg_inf());
} }
if (xbits.get_sign() && !xbits.is_nan()) { if (xbits.get_sign() && !xbits.is_nan()) {
// Return NaN and raise FE_INVALID // Return NaN and raise FE_INVALID
fputil::raise_except(FE_INVALID); fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID);
return FPBits::build_quiet_nan(0); return FPBits::build_quiet_nan(0);
} }
if (xbits.is_inf_or_nan()) { if (xbits.is_inf_or_nan()) {
return x; return x;
} }
// Normalize denormal inputs. // Normalize denormal inputs.
xbits.set_val(xbits.get_val() * 0x1.0p23f); xbits.set_val(xbits.get_val() * 0x1.0p23f);
m -= 23; m -= 23;
Show All 24 Lines

libc/src/math/generic/sinf.cpp

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Lines if (LIBC_UNLIKELY(x_abs == 0x4619'9998U)) { // x = 0x1.33333p13
return xbits.get_sign() ? -r : r; return xbits.get_sign() ? -r : r;
} }
if (LIBC_UNLIKELY(x_abs >= 0x7f80'0000U)) { if (LIBC_UNLIKELY(x_abs >= 0x7f80'0000U)) {
if (x_abs == 0x7f80'0000U) { if (x_abs == 0x7f80'0000U) {
fputil::set_errno_if_required(EDOM); fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID); fputil::raise_except_if_required(FE_INVALID);
} }
return x + return x + FPBits::build_quiet_nan(0);
FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
// Combine the results with the sine of sum formula: // Combine the results with the sine of sum formula:
// sin(x) = sin((k + y)*pi/32) // sin(x) = sin((k + y)*pi/32)
// = sin(y*pi/32) * cos(k*pi/32) + cos(y*pi/32) * sin(k*pi/32) // = sin(y*pi/32) * cos(k*pi/32) + cos(y*pi/32) * sin(k*pi/32)
// = sin_y * cos_k + (1 + cosm1_y) * sin_k // = sin_y * cos_k + (1 + cosm1_y) * sin_k
// = sin_y * cos_k + (cosm1_y * sin_k + sin_k) // = sin_y * cos_k + (cosm1_y * sin_k + sin_k)
double sin_k, cos_k, sin_y, cosm1_y; double sin_k, cos_k, sin_y, cosm1_y;
sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y); sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y);
return fputil::multiply_add(sin_y, cos_k, return fputil::multiply_add(sin_y, cos_k,
fputil::multiply_add(cosm1_y, sin_k, sin_k)); fputil::multiply_add(cosm1_y, sin_k, sin_k));
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/tanf.cpp

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines#endif // LIBC_TARGET_CPU_HAS_FMA
// |x| > 0x1.ada6a8p+27f // |x| > 0x1.ada6a8p+27f
if (LIBC_UNLIKELY(x_abs > 0x4d56'd354U)) { if (LIBC_UNLIKELY(x_abs > 0x4d56'd354U)) {
// Inf or NaN // Inf or NaN
if (LIBC_UNLIKELY(x_abs >= 0x7f80'0000U)) { if (LIBC_UNLIKELY(x_abs >= 0x7f80'0000U)) {
if (x_abs == 0x7f80'0000U) { if (x_abs == 0x7f80'0000U) {
fputil::set_errno_if_required(EDOM); fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID); fputil::raise_except_if_required(FE_INVALID);
} }
return x + return x + FPBits::build_quiet_nan(0);
FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
} }
// Other large exceptional values // Other large exceptional values
if (auto r = TANF_EXCEPTS.lookup_odd(x_abs, x_sign); if (auto r = TANF_EXCEPTS.lookup_odd(x_abs, x_sign);
LIBC_UNLIKELY(r.has_value())) LIBC_UNLIKELY(r.has_value()))
return r.value(); return r.value();
} }
// For |x| >= pi/32, we use the definition of tan(x) function: // For |x| >= pi/32, we use the definition of tan(x) function:
Show All 16 Lines

libc/test/UnitTest/FPMatcher.h

//===-- FPMatchers.h --------------------------------------------*- C++ -*-===// //===-- FPMatchers.h --------------------------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H #ifndef LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H
#define LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H #define LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H
#include "src/__support/FPUtil/FEnvImpl.h" #include "src/__support/FPUtil/FEnvImpl.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/testutils/RoundingModeUtils.h" #include "utils/testutils/RoundingModeUtils.h"
#include <errno.h>
#include <math.h> #include <math.h>
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
namespace testing { namespace testing {
template <typename ValType, typename StreamType> template <typename ValType, typename StreamType>
cpp::enable_if_t<cpp::is_floating_point_v<ValType>, void> cpp::enable_if_t<cpp::is_floating_point_v<ValType>, void>
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines#define ASSERT_FP_NE(expected, actual) \
ASSERT_THAT( \ ASSERT_THAT( \
actual, \ actual, \
__llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_NE>( \ __llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_NE>( \
expected)) expected))
#define EXPECT_MATH_ERRNO(expected) \ #define EXPECT_MATH_ERRNO(expected) \
do { \ do { \
if (math_errhandling & MATH_ERRNO) { \ if (math_errhandling & MATH_ERRNO) { \
int actual = errno; \ int actual = libc_errno; \
errno = 0; \ libc_errno = 0; \
EXPECT_EQ(actual, expected); \ EXPECT_EQ(actual, expected); \
} \ } \
} while (0) } while (0)
#define ASSERT_MATH_ERRNO(expected) \ #define ASSERT_MATH_ERRNO(expected) \
do { \ do { \
if (math_errhandling & MATH_ERRNO) { \ if (math_errhandling & MATH_ERRNO) { \
int actual = errno; \ int actual = libc_errno; \
errno = 0; \ libc_errno = 0; \
ASSERT_EQ(actual, expected); \ ASSERT_EQ(actual, expected); \
} \ } \
} while (0) } while (0)
#define EXPECT_FP_EXCEPTION(expected) \ #define EXPECT_FP_EXCEPTION(expected) \
do { \ do { \
if (math_errhandling & MATH_ERREXCEPT) { \ if (math_errhandling & MATH_ERREXCEPT) { \
EXPECT_GE(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT) & expected, \ EXPECT_GE(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT) & expected, \
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libc/test/src/math/CMakeLists.txt

add_libc_testsuite(libc_math_unittests) add_libc_testsuite(libc_math_unittests)
add_fp_unittest( add_fp_unittest(
cosf_test cosf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
cosf_test.cpp cosf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.cosf libc.src.math.cosf
libc.src.__support.CPP.array libc.src.__support.CPP.array
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
cos_test cos_test
Show All 12 Linesadd_fp_unittest(
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
sinf_test.cpp sinf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.sinf libc.src.math.sinf
libc.src.__support.CPP.array libc.src.__support.CPP.array
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
sin_test sin_test
Show All 12 Linesadd_fp_unittest(
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
sincosf_test.cpp sincosf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.sincosf libc.src.math.sincosf
libc.src.__support.CPP.array libc.src.__support.CPP.array
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
tanf_test tanf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
tanf_test.cpp tanf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.tanf libc.src.math.tanf
libc.src.__support.CPP.array libc.src.__support.CPP.array
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
fabs_test fabs_test
▲ Show 20 Lines • Show All 225 Lines • ▼ Show 20 Linesadd_fp_unittest(
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
lround_test.cpp lround_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno
libc.include.math libc.include.math
libc.src.errno.errno libc.src.errno.errno
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.lround libc.src.math.lround
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
lroundf_test lroundf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
lroundf_test.cpp lroundf_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno
libc.include.math libc.include.math
libc.src.errno.errno libc.src.errno.errno
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.lroundf libc.src.math.lroundf
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
lroundl_test lroundl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
lroundl_test.cpp lroundl_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno
libc.include.math libc.include.math
libc.src.errno.errno libc.src.errno.errno
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.lroundl libc.src.math.lroundl
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
llround_test llround_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
llround_test.cpp llround_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno
libc.include.math libc.include.math
libc.src.errno.errno libc.src.errno.errno
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.llround libc.src.math.llround
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
llroundf_test llroundf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
llroundf_test.cpp llroundf_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno
libc.include.math libc.include.math
libc.src.errno.errno libc.src.errno.errno
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.llroundf libc.src.math.llroundf
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
llroundl_test llroundl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
llroundl_test.cpp llroundl_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno
libc.include.math libc.include.math
libc.src.errno.errno libc.src.errno.errno
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.llroundl libc.src.math.llroundl
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Lines
add_fp_unittest( add_fp_unittest(
expf_test expf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
expf_test.cpp expf_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.include.math libc.include.math
libc.src.math.expf libc.src.math.expf
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
exp2f_test exp2f_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
exp2f_test.cpp exp2f_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.include.math libc.include.math
libc.src.math.exp2f libc.src.math.exp2f
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
exp10f_test exp10f_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
exp10f_test.cpp exp10f_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.include.math libc.include.math
libc.src.math.exp10f libc.src.math.exp10f
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
copysign_test copysign_test
▲ Show 20 Lines • Show All 632 Lines • ▼ Show 20 Lines
add_fp_unittest( add_fp_unittest(
expm1f_test expm1f_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
expm1f_test.cpp expm1f_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.include.math libc.include.math
libc.src.math.expm1f libc.src.math.expm1f
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
mod_k_pi_test mod_k_pi_test
Show All 10 Lines
add_fp_unittest( add_fp_unittest(
logf_test logf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
logf_test.cpp logf_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.include.math libc.include.math
libc.src.math.logf libc.src.math.logf
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
log2f_test log2f_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
log2f_test.cpp log2f_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.include.math libc.include.math
libc.src.math.log2f libc.src.math.log2f
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
log10_test log10_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
log10_test.cpp log10_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.include.math libc.include.math
libc.src.math.log10 libc.src.math.log10
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
FLAGS FLAGS
FMA_OPT__ONLY FMA_OPT__ONLY
) )
add_fp_unittest( add_fp_unittest(
log10f_test log10f_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
log10f_test.cpp log10f_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.include.math libc.include.math
libc.src.math.log10f libc.src.math.log10f
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
log1pf_test log1pf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
log1pf_test.cpp log1pf_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.include.math libc.include.math
libc.src.math.log1pf libc.src.math.log1pf
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
fmodf_test fmodf_test
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesadd_fp_unittest(
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
coshf_test.cpp coshf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.coshf libc.src.math.coshf
libc.src.__support.CPP.array libc.src.__support.CPP.array
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
sinhf_test sinhf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
sinhf_test.cpp sinhf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.sinhf libc.src.math.sinhf
libc.src.__support.CPP.array libc.src.__support.CPP.array
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
tanhf_test tanhf_test
Show All 10 Lines
add_fp_unittest( add_fp_unittest(
atanhf_test atanhf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
atanhf_test.cpp atanhf_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.atanhf libc.src.math.atanhf
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
asinhf_test asinhf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
asinhf_test.cpp asinhf_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.asinhf libc.src.math.asinhf
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
acoshf_test acoshf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
acoshf_test.cpp acoshf_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.acoshf libc.src.math.acoshf
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
asinf_test asinf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
asinf_test.cpp asinf_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.asinf libc.src.math.asinf
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
asin_test asin_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
asin_test.cpp asin_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.asin libc.src.math.asin
) )
add_fp_unittest( add_fp_unittest(
acosf_test acosf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
acosf_test.cpp acosf_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.acosf libc.src.math.acosf
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
atanf_test atanf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
atanf_test.cpp atanf_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.atanf libc.src.math.atanf
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
) )
add_fp_unittest( add_fp_unittest(
inv_trigf_utils_test inv_trigf_utils_test
NEED_MPFR NEED_MPFR
Show All 11 Lines
add_fp_unittest( add_fp_unittest(
pow_test pow_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
pow_test.cpp pow_test.cpp
DEPENDS DEPENDS
libc.include.errno
libc.src.errno.errno libc.src.errno.errno
libc.src.math.pow libc.src.math.pow
) )
add_fp_unittest( add_fp_unittest(
scalbn_test scalbn_test
NEED_MPFR NEED_MPFR
SUITE SUITE
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libc/test/src/math/RoundToIntegerTest.h

Show All 36 Linesprivate:
const F inf = F(__llvm_libc::fputil::FPBits<F>::inf()); const F inf = F(__llvm_libc::fputil::FPBits<F>::inf());
const F neg_inf = F(__llvm_libc::fputil::FPBits<F>::neg_inf()); const F neg_inf = F(__llvm_libc::fputil::FPBits<F>::neg_inf());
const F nan = F(__llvm_libc::fputil::FPBits<F>::build_quiet_nan(1)); const F nan = F(__llvm_libc::fputil::FPBits<F>::build_quiet_nan(1));
static constexpr I INTEGER_MIN = I(1) << (sizeof(I) * 8 - 1); static constexpr I INTEGER_MIN = I(1) << (sizeof(I) * 8 - 1);
static constexpr I INTEGER_MAX = -(INTEGER_MIN + 1); static constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
void test_one_input(RoundToIntegerFunc func, F input, I expected, void test_one_input(RoundToIntegerFunc func, F input, I expected,
bool expectError) { bool expectError) {
errno = 0; libc_errno = 0;
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
ASSERT_EQ(func(input), expected); ASSERT_EQ(func(input), expected);
if (expectError) { if (expectError) {
ASSERT_FP_EXCEPTION(FE_INVALID); ASSERT_FP_EXCEPTION(FE_INVALID);
ASSERT_MATH_ERRNO(EDOM); ASSERT_MATH_ERRNO(EDOM);
} else { } else {
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

libc/test/src/math/acosf_test.cpp

//===-- Unittests for acosf -----------------------------------------------===// //===-- Unittests for acosf -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/acosf.h" #include "src/math/acosf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAcosfTest, SpecialNumbers) { TEST(LlvmLibcAcosfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(inf));
EXPECT_MATH_ERRNO(EDOM); EXPECT_MATH_ERRNO(EDOM);
EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(neg_inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(neg_inf));
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libc/test/src/math/acoshf_test.cpp

//===-- Unittests for acoshf ----------------------------------------------===// //===-- Unittests for acoshf ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/acoshf.h" #include "src/math/acoshf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits_t = __llvm_libc::fputil::FPBits<float>; using FPBits_t = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAcoshfTest, SpecialNumbers) { TEST(LlvmLibcAcoshfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::acoshf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::acoshf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(aNaN, __llvm_libc::acoshf(0.0f)); EXPECT_FP_EQ(aNaN, __llvm_libc::acoshf(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(EDOM);
EXPECT_FP_EQ(0.0f, __llvm_libc::acoshf(1.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::acoshf(1.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(inf, __llvm_libc::acoshf(inf)); EXPECT_FP_EQ(inf, __llvm_libc::acoshf(inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(aNaN, __llvm_libc::acoshf(neg_inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::acoshf(neg_inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(EDOM);
} }
TEST(LlvmLibcAcoshfTest, InFloatRange) { TEST(LlvmLibcAcoshfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits_t(v)); float x = float(FPBits_t(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
Show All 29 Lines

libc/test/src/math/asin_test.cpp

//===-- Unittests for asin ------------------------------------------------===// //===-- Unittests for asin ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/errno/libc_errno.h"
#include "src/math/asin.h" #include "src/math/asin.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<double>; using FPBits = __llvm_libc::fputil::FPBits<double>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibcAsinTest, SpecialNumbers) { TEST(LlvmLibcAsinTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::asin(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::asin(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(0.0, __llvm_libc::asin(0.0)); EXPECT_FP_EQ(0.0, __llvm_libc::asin(0.0));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(-0.0, __llvm_libc::asin(-0.0)); EXPECT_FP_EQ(-0.0, __llvm_libc::asin(-0.0));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(aNaN, __llvm_libc::asin(inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::asin(inf));
EXPECT_MATH_ERRNO(EDOM); EXPECT_MATH_ERRNO(EDOM);
EXPECT_FP_EQ(aNaN, __llvm_libc::asin(neg_inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::asin(neg_inf));
EXPECT_MATH_ERRNO(EDOM); EXPECT_MATH_ERRNO(EDOM);
} }

libc/test/src/math/asinf_test.cpp

//===-- Unittests for asinf //===-- Unittests for asinf
//------------------------------------------------===// //------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/asinf.h" #include "src/math/asinf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAsinfTest, SpecialNumbers) { TEST(LlvmLibcAsinfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::asinf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::asinf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(0.0f, __llvm_libc::asinf(0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::asinf(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(-0.0f, __llvm_libc::asinf(-0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::asinf(-0.0f));
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libc/test/src/math/asinhf_test.cpp

//===-- Unittests for asinhf ----------------------------------------------===// //===-- Unittests for asinhf ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/asinhf.h" #include "src/math/asinhf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits_t = __llvm_libc::fputil::FPBits<float>; using FPBits_t = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAsinhfTest, SpecialNumbers) { TEST(LlvmLibcAsinhfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::asinhf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::asinhf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(0.0f, __llvm_libc::asinhf(0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::asinhf(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(-0.0f, __llvm_libc::asinhf(-0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::asinhf(-0.0f));
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libc/test/src/math/atanf_test.cpp

//===-- Unittests for atanf -----------------------------------------------===// //===-- Unittests for atanf -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/atanf.h" #include "src/math/atanf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
#include <initializer_list> #include <initializer_list>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAtanfTest, SpecialNumbers) { TEST(LlvmLibcAtanfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
EXPECT_FP_EQ(aNaN, __llvm_libc::atanf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::atanf(aNaN));
EXPECT_FP_EXCEPTION(0); EXPECT_FP_EXCEPTION(0);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
EXPECT_FP_EQ(0.0f, __llvm_libc::atanf(0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::atanf(0.0f));
EXPECT_FP_EXCEPTION(0); EXPECT_FP_EXCEPTION(0);
Show All 29 Lines

libc/test/src/math/atanhf_test.cpp

//===-- Unittests for atanhf ----------------------------------------------===// //===-- Unittests for atanhf ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/atanhf.h" #include "src/math/atanhf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAtanhfTest, SpecialNumbers) { TEST(LlvmLibcAtanhfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
EXPECT_FP_EQ(aNaN, __llvm_libc::atanhf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::atanhf(aNaN));
EXPECT_FP_EXCEPTION(0); EXPECT_FP_EXCEPTION(0);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
EXPECT_FP_EQ(0.0f, __llvm_libc::atanhf(0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::atanhf(0.0f));
EXPECT_FP_EXCEPTION(0); EXPECT_FP_EXCEPTION(0);
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

libc/test/src/math/cosf_test.cpp

//===-- Unittests for cosf ------------------------------------------------===// //===-- Unittests for cosf ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/cosf.h" #include "src/math/cosf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "test/src/math/sdcomp26094.h" #include "test/src/math/sdcomp26094.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::SDCOMP26094_VALUES; using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcCosfTest, SpecialNumbers) { TEST(LlvmLibcCosfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::cosf(0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::cosf(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::cosf(-0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::cosf(-0.0f));
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

libc/test/src/math/coshf_test.cpp

//===-- Unittests for coshf -----------------------------------------------===// //===-- Unittests for coshf -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/CPP/array.h" #include "src/__support/CPP/array.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/coshf.h" #include "src/math/coshf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcCoshfTest, SpecialNumbers) { TEST(LlvmLibcCoshfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::coshf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::coshf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(inf, __llvm_libc::coshf(inf)); EXPECT_FP_EQ(inf, __llvm_libc::coshf(inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(inf, __llvm_libc::coshf(neg_inf)); EXPECT_FP_EQ(inf, __llvm_libc::coshf(neg_inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::coshf(0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::coshf(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::coshf(-0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::coshf(-0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcCoshfTest, Overflow) { TEST(LlvmLibcCoshfTest, Overflow) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::coshf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW); inf, __llvm_libc::coshf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::coshf(float(FPBits(0x42cffff8U))), FE_OVERFLOW); inf, __llvm_libc::coshf(float(FPBits(0x42cffff8U))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
Show All 27 Lines

libc/test/src/math/exp10f_test.cpp

//===-- Unittests for exp10f ----------------------------------------------===// //===-- Unittests for exp10f ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/exp10f.h" #include "src/math/exp10f.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcExp10fTest, SpecialNumbers) { TEST(LlvmLibcExp10fTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::exp10f(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::exp10f(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(inf, __llvm_libc::exp10f(inf)); EXPECT_FP_EQ(inf, __llvm_libc::exp10f(inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(0.0f, __llvm_libc::exp10f(neg_inf)); EXPECT_FP_EQ(0.0f, __llvm_libc::exp10f(neg_inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::exp10f(0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::exp10f(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::exp10f(-0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::exp10f(-0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcExp10fTest, Overflow) { TEST(LlvmLibcExp10fTest, Overflow) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::exp10f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW); inf, __llvm_libc::exp10f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::exp10f(float(FPBits(0x43000000U))), FE_OVERFLOW); inf, __llvm_libc::exp10f(float(FPBits(0x43000000U))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::exp10f(float(FPBits(0x43000001U))), FE_OVERFLOW); inf, __llvm_libc::exp10f(float(FPBits(0x43000001U))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
TEST(LlvmLibcExp10fTest, Underflow) { TEST(LlvmLibcExp10fTest, Underflow) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
0.0f, __llvm_libc::exp10f(float(FPBits(0xff7fffffU))), FE_UNDERFLOW); 0.0f, __llvm_libc::exp10f(float(FPBits(0xff7fffffU))), FE_UNDERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
float x = float(FPBits(0xc2cffff8U)); float x = float(FPBits(0xc2cffff8U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x,
__llvm_libc::exp10f(x), 0.5); __llvm_libc::exp10f(x), 0.5);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
Show All 24 Lines constexpr uint32_t INPUTS[N] = {
0x40a00000, // x = 5.0f 0x40a00000, // x = 5.0f
0x40c00000, // x = 6.0f 0x40c00000, // x = 6.0f
0x40e00000, // x = 7.0f 0x40e00000, // x = 7.0f
0x41000000, // x = 8.0f 0x41000000, // x = 8.0f
0x41100000, // x = 9.0f 0x41100000, // x = 9.0f
0x41200000, // x = 10.0f 0x41200000, // x = 10.0f
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
errno = 0; libc_errno = 0;
float x = float(FPBits(INPUTS[i])); float x = float(FPBits(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x,
__llvm_libc::exp10f(x), 0.5); __llvm_libc::exp10f(x), 0.5);
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, -x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, -x,
__llvm_libc::exp10f(-x), 0.5); __llvm_libc::exp10f(-x), 0.5);
} }
} }
TEST(LlvmLibcExp10fTest, InFloatRange) { TEST(LlvmLibcExp10fTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; libc_errno = 0;
float result = __llvm_libc::exp10f(x); float result = __llvm_libc::exp10f(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x,
__llvm_libc::exp10f(x), 0.5); __llvm_libc::exp10f(x), 0.5);
} }
} }

libc/test/src/math/exp2f_test.cpp

//===-- Unittests for exp2f -----------------------------------------------===// //===-- Unittests for exp2f -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/__support/macros/properties/cpu_features.h" // LIBC_TARGET_CPU_HAS_FMA #include "src/__support/macros/properties/cpu_features.h" // LIBC_TARGET_CPU_HAS_FMA
#include "src/errno/libc_errno.h"
#include "src/math/exp2f.h" #include "src/math/exp2f.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcExp2fTest, SpecialNumbers) { TEST(LlvmLibcExp2fTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::exp2f(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::exp2f(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(inf, __llvm_libc::exp2f(inf)); EXPECT_FP_EQ(inf, __llvm_libc::exp2f(inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(0.0f, __llvm_libc::exp2f(neg_inf)); EXPECT_FP_EQ(0.0f, __llvm_libc::exp2f(neg_inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(-0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(-0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcExp2fTest, Overflow) { TEST(LlvmLibcExp2fTest, Overflow) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::exp2f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW); inf, __llvm_libc::exp2f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::exp2f(float(FPBits(0x43000000U))), FE_OVERFLOW); inf, __llvm_libc::exp2f(float(FPBits(0x43000000U))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
Show All 14 Lines constexpr uint32_t INPUTS[N] = {
0xb8d3d026U, /*-0x1.a7a04cp-14f*/ 0xb8d3d026U, /*-0x1.a7a04cp-14f*/
0xbcf3a937U, /*-0x1.e7526ep-6f*/ 0xbcf3a937U, /*-0x1.e7526ep-6f*/
0xc2fa0001U, /*-0x1.f40002p+6f*/ 0xc2fa0001U, /*-0x1.f40002p+6f*/
0xc2fc0000U, /*-0x1.f8p+6f*/ 0xc2fc0000U, /*-0x1.f8p+6f*/
0xc2fc0001U, /*-0x1.f80002p+6f*/ 0xc2fc0001U, /*-0x1.f80002p+6f*/
0xc3150000U, /*-0x1.2ap+7f*/ 0xc3150000U, /*-0x1.2ap+7f*/
}; };
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
errno = 0; libc_errno = 0;
float x = float(FPBits(INPUTS[i])); float x = float(FPBits(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5); __llvm_libc::exp2f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
} }
TEST(LlvmLibcExp2fTest, Underflow) { TEST(LlvmLibcExp2fTest, Underflow) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
0.0f, __llvm_libc::exp2f(float(FPBits(0xff7fffffU))), FE_UNDERFLOW); 0.0f, __llvm_libc::exp2f(float(FPBits(0xff7fffffU))), FE_UNDERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
float x = float(FPBits(0xc3158000U)); float x = float(FPBits(0xc3158000U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5); __llvm_libc::exp2f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
Show All 11 Lines
TEST(LlvmLibcExp2fTest, InFloatRange) { TEST(LlvmLibcExp2fTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; libc_errno = 0;
float result = __llvm_libc::exp2f(x); float result = __llvm_libc::exp2f(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5); __llvm_libc::exp2f(x), 0.5);
} }
} }

libc/test/src/math/expf_test.cpp

//===-- Unittests for expf ------------------------------------------------===// //===-- Unittests for expf ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/expf.h" #include "src/math/expf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcExpfTest, SpecialNumbers) { TEST(LlvmLibcExpfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::expf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::expf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(inf, __llvm_libc::expf(inf)); EXPECT_FP_EQ(inf, __llvm_libc::expf(inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(0.0f, __llvm_libc::expf(neg_inf)); EXPECT_FP_EQ(0.0f, __llvm_libc::expf(neg_inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::expf(0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::expf(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0f, __llvm_libc::expf(-0.0f)); EXPECT_FP_EQ(1.0f, __llvm_libc::expf(-0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcExpfTest, Overflow) { TEST(LlvmLibcExpfTest, Overflow) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::expf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW); inf, __llvm_libc::expf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::expf(float(FPBits(0x42cffff8U))), FE_OVERFLOW); inf, __llvm_libc::expf(float(FPBits(0x42cffff8U))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::expf(float(FPBits(0x42d00008U))), FE_OVERFLOW); inf, __llvm_libc::expf(float(FPBits(0x42d00008U))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
TEST(LlvmLibcExpfTest, Underflow) { TEST(LlvmLibcExpfTest, Underflow) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
0.0f, __llvm_libc::expf(float(FPBits(0xff7fffffU))), FE_UNDERFLOW); 0.0f, __llvm_libc::expf(float(FPBits(0xff7fffffU))), FE_UNDERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
float x = float(FPBits(0xc2cffff8U)); float x = float(FPBits(0xc2cffff8U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x), EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5); 0.5);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
x = float(FPBits(0xc2d00008U)); x = float(FPBits(0xc2d00008U));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x), EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5); 0.5);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
// Test with inputs which are the borders of underflow/overflow but still // Test with inputs which are the borders of underflow/overflow but still
// produce valid results without setting errno. // produce valid results without setting errno.
TEST(LlvmLibcExpfTest, Borderline) { TEST(LlvmLibcExpfTest, Borderline) {
float x; float x;
errno = 0; libc_errno = 0;
x = float(FPBits(0x42affff8U)); x = float(FPBits(0x42affff8U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x), ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5); 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0x42b00008U)); x = float(FPBits(0x42b00008U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x), ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5); 0.5);
Show All 17 Lines
TEST(LlvmLibcExpfTest, InFloatRange) { TEST(LlvmLibcExpfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; libc_errno = 0;
float result = __llvm_libc::expf(x); float result = __llvm_libc::expf(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x,
__llvm_libc::expf(x), 0.5); __llvm_libc::expf(x), 0.5);
} }
} }

libc/test/src/math/expm1f_test.cpp

//===-- Unittests for expm1f-----------------------------------------------===// //===-- Unittests for expm1f-----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/expm1f.h" #include "src/math/expm1f.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcExpm1fTest, SpecialNumbers) { TEST(LlvmLibcExpm1fTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::expm1f(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::expm1f(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(inf, __llvm_libc::expm1f(inf)); EXPECT_FP_EQ(inf, __llvm_libc::expm1f(inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(neg_inf)); EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(neg_inf));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(0.0f, __llvm_libc::expm1f(0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::expm1f(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(-0.0f, __llvm_libc::expm1f(-0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::expm1f(-0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
} }
TEST(LlvmLibcExpm1fTest, Overflow) { TEST(LlvmLibcExpm1fTest, Overflow) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::expm1f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW); inf, __llvm_libc::expm1f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::expm1f(float(FPBits(0x42cffff8U))), FE_OVERFLOW); inf, __llvm_libc::expm1f(float(FPBits(0x42cffff8U))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::expm1f(float(FPBits(0x42d00008U))), FE_OVERFLOW); inf, __llvm_libc::expm1f(float(FPBits(0x42d00008U))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
} }
TEST(LlvmLibcExpm1fTest, Underflow) { TEST(LlvmLibcExpm1fTest, Underflow) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(float(FPBits(0xff7fffffU)))); EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(float(FPBits(0xff7fffffU))));
float x = float(FPBits(0xc2cffff8U)); float x = float(FPBits(0xc2cffff8U));
EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(x)); EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(x));
x = float(FPBits(0xc2d00008U)); x = float(FPBits(0xc2d00008U));
EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(x)); EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(x));
} }
// Test with inputs which are the borders of underflow/overflow but still // Test with inputs which are the borders of underflow/overflow but still
// produce valid results without setting errno. // produce valid results without setting errno.
TEST(LlvmLibcExpm1fTest, Borderline) { TEST(LlvmLibcExpm1fTest, Borderline) {
float x; float x;
errno = 0; libc_errno = 0;
x = float(FPBits(0x42affff8U)); x = float(FPBits(0x42affff8U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
x = float(FPBits(0x42b00008U)); x = float(FPBits(0x42b00008U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
Show All 32 Lines
TEST(LlvmLibcExpm1fTest, InFloatRange) { TEST(LlvmLibcExpm1fTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; libc_errno = 0;
float result = __llvm_libc::expm1f(x); float result = __llvm_libc::expm1f(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5); __llvm_libc::expm1f(x), 0.5);
} }
} }

libc/test/src/math/log10_test.cpp

//===-- Unittests for log10 -----------------------------------------------===// //===-- Unittests for log10 -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/log10.h" #include "src/math/log10.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/testutils/StreamWrapper.h" #include "utils/testutils/StreamWrapper.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines auto test = [&](mpfr::RoundingMode rounding_mode) {
uint64_t cc = 0; uint64_t cc = 0;
double mx, mr = 0.0; double mx, mr = 0.0;
double tol = 0.5; double tol = 0.5;
for (uint64_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint64_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
double x = FPBits(v).get_val(); double x = FPBits(v).get_val();
if (isnan(x) || isinf(x) || x < 0.0) if (isnan(x) || isinf(x) || x < 0.0)
continue; continue;
errno = 0; libc_errno = 0;
double result = __llvm_libc::log10(x); double result = __llvm_libc::log10(x);
++cc; ++cc;
if (isnan(result)) if (isnan(result))
continue; continue;
++count; ++count;
// ASSERT_MPFR_MATCH(mpfr::Operation::Log10, x, result, 0.5); // ASSERT_MPFR_MATCH(mpfr::Operation::Log10, x, result, 0.5);
if (!EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log10, x, if (!EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log10, x,
Show All 30 Lines

libc/test/src/math/log1pf_test.cpp

//===-- Unittests for log1pf ----------------------------------------------===// //===-- Unittests for log1pf ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/log1pf.h" #include "src/math/log1pf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
TEST(LlvmLibclog1pfTest, InFloatRange) { TEST(LlvmLibclog1pfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; libc_errno = 0;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
__llvm_libc::log1pf(x), 0.5); __llvm_libc::log1pf(x), 0.5);
} }
} }

libc/test/src/math/log2f_test.cpp

//===-- Unittests for log2f -----------------------------------------------===// //===-- Unittests for log2f -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/log2f.h" #include "src/math/log2f.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
Show All 27 Lines
TEST(LlvmLibcLog2fTest, InFloatRange) { TEST(LlvmLibcLog2fTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; libc_errno = 0;
float result = __llvm_libc::log2f(x); float result = __llvm_libc::log2f(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log2, x, ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log2, x,
__llvm_libc::log2f(x), 0.5); __llvm_libc::log2f(x), 0.5);
} }
} }

libc/test/src/math/pow_test.cpp

//===-- Unittests for pow -------------------------------------------------===// //===-- Unittests for pow -------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/errno/libc_errno.h"
#include "src/math/pow.h" #include "src/math/pow.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<double>; using FPBits = __llvm_libc::fputil::FPBits<double>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibcAsinTest, SpecialNumbers) { TEST(LlvmLibcAsinTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::pow(aNaN, aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::pow(aNaN, aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0, __llvm_libc::pow(1.0, 1.0)); EXPECT_FP_EQ(1.0, __llvm_libc::pow(1.0, 1.0));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(1.0, __llvm_libc::pow(1.0, 2.0)); EXPECT_FP_EQ(1.0, __llvm_libc::pow(1.0, 2.0));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(inf, __llvm_libc::pow(2.0, inf)); EXPECT_FP_EQ(inf, __llvm_libc::pow(2.0, inf));
} }

libc/test/src/math/sincosf_test.cpp

//===-- Unittests for sincosf ---------------------------------------------===// //===-- Unittests for sincosf ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/sincosf.h" #include "src/math/sincosf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "test/src/math/sdcomp26094.h" #include "test/src/math/sdcomp26094.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::SDCOMP26094_VALUES; using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcSinCosfTest, SpecialNumbers) { TEST(LlvmLibcSinCosfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
float sin, cos; float sin, cos;
__llvm_libc::sincosf(aNaN, &sin, &cos); __llvm_libc::sincosf(aNaN, &sin, &cos);
EXPECT_FP_EQ(aNaN, cos); EXPECT_FP_EQ(aNaN, cos);
EXPECT_FP_EQ(aNaN, sin); EXPECT_FP_EQ(aNaN, sin);
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
__llvm_libc::sincosf(0.0f, &sin, &cos); __llvm_libc::sincosf(0.0f, &sin, &cos);
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

libc/test/src/math/sinf_test.cpp

//===-- Unittests for sinf ------------------------------------------------===// //===-- Unittests for sinf ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/sinf.h" #include "src/math/sinf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "test/src/math/sdcomp26094.h" #include "test/src/math/sdcomp26094.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::SDCOMP26094_VALUES; using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcSinfTest, SpecialNumbers) { TEST(LlvmLibcSinfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(0.0f, __llvm_libc::sinf(0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::sinf(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(-0.0f, __llvm_libc::sinf(-0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::sinf(-0.0f));
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

libc/test/src/math/sinhf_test.cpp

//===-- Unittests for sinhf -----------------------------------------------===// //===-- Unittests for sinhf -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/CPP/array.h" #include "src/__support/CPP/array.h"
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/sinhf.h" #include "src/math/sinhf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcSinhfTest, SpecialNumbers) { TEST(LlvmLibcSinhfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::sinhf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::sinhf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(0.0f, __llvm_libc::sinhf(0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::sinhf(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(-0.0f, __llvm_libc::sinhf(-0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::sinhf(-0.0f));
Show All 26 LinesTEST(LlvmLibcSinhfTest, SmallValues) {
x = float(FPBits(uint32_t(0x00400000))); x = float(FPBits(uint32_t(0x00400000)));
result = __llvm_libc::sinhf(x); result = __llvm_libc::sinhf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x, result, 0.5); EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x, result, 0.5);
EXPECT_FP_EQ(x, result); EXPECT_FP_EQ(x, result);
} }
TEST(LlvmLibcSinhfTest, Overflow) { TEST(LlvmLibcSinhfTest, Overflow) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::sinhf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW); inf, __llvm_libc::sinhf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION( EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::sinhf(float(FPBits(0x42cffff8U))), FE_OVERFLOW); inf, __llvm_libc::sinhf(float(FPBits(0x42cffff8U))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE); EXPECT_MATH_ERRNO(ERANGE);
Show All 14 Lines

libc/test/src/math/tanf_test.cpp

//===-- Unittests for tanf ------------------------------------------------===// //===-- Unittests for tanf ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/tanf.h" #include "src/math/tanf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "test/src/math/sdcomp26094.h" #include "test/src/math/sdcomp26094.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::SDCOMP26094_VALUES; using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcTanfTest, SpecialNumbers) { TEST(LlvmLibcTanfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::tanf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::tanf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(0.0f, __llvm_libc::tanf(0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::tanf(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(-0.0f, __llvm_libc::tanf(-0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::tanf(-0.0f));
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

libc/test/src/math/tanhf_test.cpp

//===-- Unittests for tanhf -----------------------------------------------===// //===-- Unittests for tanhf -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/errno/libc_errno.h"
#include "src/math/tanhf.h" #include "src/math/tanhf.h"
#include "test/UnitTest/FPMatcher.h" #include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h" #include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcTanhfTest, SpecialNumbers) { TEST(LlvmLibcTanhfTest, SpecialNumbers) {
errno = 0; libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::tanhf(aNaN)); EXPECT_FP_EQ(aNaN, __llvm_libc::tanhf(aNaN));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(0.0f, __llvm_libc::tanhf(0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::tanhf(0.0f));
EXPECT_MATH_ERRNO(0); EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(-0.0f, __llvm_libc::tanhf(-0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::tanhf(-0.0f));
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines