maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[libc] Implement log1pf correctly rounded to all rounding modes. 

Implement log1pf correctly rounded to all rounding modes relying on logf implementation for exponent > 2^(-8).

Reviewed By: sivachandra, zimmermann6

Differential Revision: https://reviews.llvm.org/D118962
This commit is contained in:
Tue Ly 2022-02-03 21:27:26 -05:00
parent 4fb7c120fe
commit 9e7688c71e
19 changed files with 456 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
libc/config/linux/aarch64/entrypoints.txt
View File

@ -164,6 +164,7 @@ set(TARGET_LIBM_ENTRYPOINTS
libc.src.math.ldexpf
libc.src.math.ldexpl
libc.src.math.log10f
libc.src.math.log1pf
libc.src.math.log2f
libc.src.math.logf
libc.src.math.logb

1
libc/config/linux/x86_64/entrypoints.txt
View File

@ -163,6 +163,7 @@ set(TARGET_LIBM_ENTRYPOINTS
libc.src.math.llroundf
libc.src.math.llroundl
libc.src.math.log10f
libc.src.math.log1pf
libc.src.math.log2f
libc.src.math.logf
libc.src.math.logb

1
libc/config/windows/entrypoints.txt
View File

@ -118,6 +118,7 @@ set(TARGET_LIBM_ENTRYPOINTS
libc.src.math.llround
libc.src.math.llroundf
libc.src.math.llroundl
libc.src.math.log1pf
libc.src.math.log2f
libc.src.math.logf
libc.src.math.logb

2
libc/spec/stdc.td
View File

@ -398,6 +398,8 @@ def StdC : StandardSpec<"stdc"> {
FunctionSpec<"log10f", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
FunctionSpec<"log1pf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
FunctionSpec<"log2f", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
FunctionSpec<"logf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,

2
libc/src/math/CMakeLists.txt
View File

@ -118,6 +118,8 @@ add_math_entrypoint_object(ldexpl)
add_math_entrypoint_object(log10f)
add_math_entrypoint_object(log1pf)
add_math_entrypoint_object(log2f)
add_math_entrypoint_object(logf)

13
libc/src/math/generic/CMakeLists.txt
View File

@ -670,6 +670,19 @@ add_entrypoint_object(
-O3
)
add_entrypoint_object(
log1pf
SRCS
log1pf.cpp
HDRS
../log1pf.h
DEPENDS
.common_constants
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O3
)
add_entrypoint_object(
log2f
SRCS

46
libc/src/math/generic/common_constants.cpp
View File

@ -56,4 +56,50 @@ const double ONE_OVER_F[128] = {
0x1.05197f7d73404p-1, 0x1.0410410410410p-1, 0x1.03091b51f5e1ap-1,
0x1.0204081020408p-1, 0x1.0101010101010p-1};
// Lookup table for log(f) = log(1 + n*2^(-7)) where n = 0..127.
const double LOG_F[128] = {
0x0.0000000000000p+0, 0x1.fe02a6b106788p-8, 0x1.fc0a8b0fc03e3p-7,
0x1.7b91b07d5b11ap-6, 0x1.f829b0e783300p-6, 0x1.39e87b9febd5fp-5,
0x1.77458f632dcfcp-5, 0x1.b42dd711971bep-5, 0x1.f0a30c01162a6p-5,
0x1.16536eea37ae0p-4, 0x1.341d7961bd1d0p-4, 0x1.51b073f06183fp-4,
0x1.6f0d28ae56b4bp-4, 0x1.8c345d6319b20p-4, 0x1.a926d3a4ad563p-4,
0x1.c5e548f5bc743p-4, 0x1.e27076e2af2e5p-4, 0x1.fec9131dbeabap-4,
0x1.0d77e7cd08e59p-3, 0x1.1b72ad52f67a0p-3, 0x1.29552f81ff523p-3,
0x1.371fc201e8f74p-3, 0x1.44d2b6ccb7d1ep-3, 0x1.526e5e3a1b437p-3,
0x1.5ff3070a793d3p-3, 0x1.6d60fe719d21cp-3, 0x1.7ab890210d909p-3,
0x1.87fa06520c910p-3, 0x1.9525a9cf456b4p-3, 0x1.a23bc1fe2b563p-3,
0x1.af3c94e80bff2p-3, 0x1.bc286742d8cd6p-3, 0x1.c8ff7c79a9a21p-3,
0x1.d5c216b4fbb91p-3, 0x1.e27076e2af2e5p-3, 0x1.ef0adcbdc5936p-3,
0x1.fb9186d5e3e2ap-3, 0x1.0402594b4d040p-2, 0x1.0a324e27390e3p-2,
0x1.1058bf9ae4ad5p-2, 0x1.1675cababa60ep-2, 0x1.1c898c16999fap-2,
0x1.22941fbcf7965p-2, 0x1.2895a13de86a3p-2, 0x1.2e8e2bae11d30p-2,
0x1.347dd9a987d54p-2, 0x1.3a64c556945e9p-2, 0x1.404308686a7e3p-2,
0x1.4618bc21c5ec2p-2, 0x1.4be5f957778a0p-2, 0x1.51aad872df82dp-2,
0x1.5767717455a6cp-2, 0x1.5d1bdbf5809cap-2, 0x1.62c82f2b9c795p-2,
0x1.686c81e9b14aep-2, 0x1.6e08eaa2ba1e3p-2, 0x1.739d7f6bbd006p-2,
0x1.792a55fdd47a2p-2, 0x1.7eaf83b82afc3p-2, 0x1.842d1da1e8b17p-2,
0x1.89a3386c1425ap-2, 0x1.8f11e873662c7p-2, 0x1.947941c2116fap-2,
0x1.99d958117e08ap-2, 0x1.9f323ecbf984bp-2, 0x1.a484090e5bb0ap-2,
0x1.a9cec9a9a0849p-2, 0x1.af1293247786bp-2, 0x1.b44f77bcc8f62p-2,
0x1.b9858969310fbp-2, 0x1.beb4d9da71b7bp-2, 0x1.c3dd7a7cdad4dp-2,
0x1.c8ff7c79a9a21p-2, 0x1.ce1af0b85f3ebp-2, 0x1.d32fe7e00ebd5p-2,
0x1.d83e7258a2f3ep-2, 0x1.dd46a04c1c4a0p-2, 0x1.e24881a7c6c26p-2,
0x1.e744261d68787p-2, 0x1.ec399d2468cc0p-2, 0x1.f128f5faf06ecp-2,
0x1.f6123fa7028acp-2, 0x1.faf588f78f31ep-2, 0x1.ffd2e0857f498p-2,
0x1.02552a5a5d0fep-1, 0x1.04bdf9da926d2p-1, 0x1.0723e5c1cdf40p-1,
0x1.0986f4f573520p-1, 0x1.0be72e4252a82p-1, 0x1.0e44985d1cc8bp-1,
0x1.109f39e2d4c96p-1, 0x1.12f719593efbcp-1, 0x1.154c3d2f4d5e9p-1,
0x1.179eabbd899a0p-1, 0x1.19ee6b467c96ep-1, 0x1.1c3b81f713c24p-1,
0x1.1e85f5e7040d0p-1, 0x1.20cdcd192ab6dp-1, 0x1.23130d7bebf42p-1,
0x1.2555bce98f7cbp-1, 0x1.2795e1289b11ap-1, 0x1.29d37fec2b08ap-1,
0x1.2c0e9ed448e8bp-1, 0x1.2e47436e40268p-1, 0x1.307d7334f10bep-1,
0x1.32b1339121d71p-1, 0x1.34e289d9ce1d3p-1, 0x1.37117b54747b5p-1,
0x1.393e0d3562a19p-1, 0x1.3b68449fffc22p-1, 0x1.3d9026a7156fap-1,
0x1.3fb5b84d16f42p-1, 0x1.41d8fe84672aep-1, 0x1.43f9fe2f9ce67p-1,
0x1.4618bc21c5ec2p-1, 0x1.48353d1ea88dfp-1, 0x1.4a4f85db03ebbp-1,
0x1.4c679afccee39p-1, 0x1.4e7d811b75bb0p-1, 0x1.50913cc01686bp-1,
0x1.52a2d265bc5aap-1, 0x1.54b2467999497p-1, 0x1.56bf9d5b3f399p-1,
0x1.58cadb5cd7989p-1, 0x1.5ad404c359f2cp-1, 0x1.5cdb1dc6c1764p-1,
0x1.5ee02a9241675p-1, 0x1.60e32f44788d8p-1};
} // namespace __llvm_libc

3
libc/src/math/generic/common_constants.h
View File

@ -14,6 +14,9 @@ namespace __llvm_libc {
// Lookup table for (1/f) where f = 1 + n*2^(-7), n = 0..127.
extern const double ONE_OVER_F[128];
// Lookup table for log(f) = log(1 + n*2^(-7)) where n = 0..127.
extern const double LOG_F[128];
} // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_GENERIC_COMMON_CONSTANTS_H

166
libc/src/math/generic/log1pf.cpp Normal file
View File

@ -0,0 +1,166 @@
//===-- Single-precision log1p(x) function --------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "src/math/log1pf.h"
#include "common_constants.h" // Lookup table for (1/f) and log(f)
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/FPUtil/FMA.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/PolyEval.h"
#include "src/__support/common.h"
// This is an algorithm for log10(x) in single precision which is
// correctly rounded for all rounding modes.
// - An exhaustive test show that when x >= 2^45, log1pf(x) == logf(x)
// for all rounding modes.
// - When 2^(-8) <= |x| < 2^45, the sum (double(x) + 1.0) is exact,
// so we can adapt the correctly rounded algorithm of logf to compute
// log(double(x) + 1.0) correctly. For more information about the logf
// algorithm, see `libc/src/math/generic/logf.cpp`.
// - When |x| < 2^(-8), we use a degree-6 polynomial in double precision
// generated with Sollya using the following command:
// fpminimax(log(1 + x)/x, 5, [|D...|], [-2^-8; 2^-8]);
namespace __llvm_libc {
namespace internal {
// We don't need to treat denormal
INLINE_FMA static inline float log(double x) {
constexpr double LOG_2 = 0x1.62e42fefa39efp-1;
using FPBits = typename fputil::FPBits<double>;
FPBits xbits(x);
if (xbits.is_zero()) {
return static_cast<float>(fputil::FPBits<float>::neg_inf());
}
if (xbits.uintval() > FPBits::MAX_NORMAL) {
if (xbits.get_sign() && !xbits.is_nan()) {
return FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
}
return static_cast<float>(x);
}
double m = static_cast<double>(xbits.get_exponent());
// Set bits to 1.m
xbits.set_unbiased_exponent(0x3FF);
// Get the 8 highest bits, use 7 bits (excluding the implicit hidden bit) for
// lookup tables.
int f_index =
xbits.get_mantissa() >> 45; // fputil::MantissaWidth<double>::VALUE - 7
FPBits f(xbits.val);
// Clear the lowest 45 bits.
f.bits &= ~0x0000'1FFF'FFFF'FFFFULL;
double d = static_cast<double>(xbits) - static_cast<double>(f);
d *= ONE_OVER_F[f_index];
double extra_factor = fputil::fma(m, LOG_2, LOG_F[f_index]);
double r = fputil::polyeval(d, extra_factor, 0x1.fffffffffffacp-1,
-0x1.fffffffef9cb2p-2, 0x1.5555513bc679ap-2,
-0x1.fff4805ea441p-3, 0x1.930180dbde91ap-3);
return static_cast<float>(r);
}
} // namespace internal
INLINE_FMA
LLVM_LIBC_FUNCTION(float, log1pf, (float x)) {
using FPBits = typename fputil::FPBits<float>;
FPBits xbits(x);
double xd = static_cast<double>(x);
if (xbits.get_exponent() >= -8) {
// Hard-to-round cases.
switch (xbits.uintval()) {
case 0x3b9315c8U: // x = 0x1.262b9p-8f
if (fputil::get_round() != FE_UPWARD)
return 0x1.25830cp-8f;
break;
case 0x3c6eb7afU: // x = 0x1.dd6f5ep-7f
if (fputil::get_round() == FE_UPWARD)
return 0x1.d9fd86p-7f;
return 0x1.d9fd84p-7f;
case 0x41078febU: // x = 0x1.0f1fd6p+3f
if (fputil::get_round() != FE_UPWARD)
return 0x1.1fcbcep+1f;
break;
case 0x5cd69e88U: // x = 0x1.ad3d1p+58f
if (fputil::get_round() != FE_UPWARD)
return 0x1.45c146p+5f;
break;
case 0x65d890d3U: // x = 0x1.b121a6p+76f
if (fputil::get_round() == FE_TONEAREST)
return 0x1.a9a3f2p+5f;
break;
case 0x6f31a8ecU: // x = 0x1.6351d8p+95f
if (fputil::get_round() == FE_TONEAREST)
return 0x1.08b512p+6f;
break;
case 0x7a17f30aU: // x = 0x1.2fe614p+117f
if (fputil::get_round() != FE_UPWARD)
return 0x1.451436p+6f;
break;
case 0xbc4d092cU: // x = -0x1.9a1258p-7f
if (fputil::get_round() == FE_TONEAREST)
return -0x1.9ca8bep-7f;
break;
case 0xbc657728U: // x = -0x1.caee5p-7f
if (fputil::get_round() != FE_DOWNWARD)
return -0x1.ce2cccp-7f;
break;
case 0xbd1d20afU: // x = -0x1.3a415ep-5f
int round_mode = fputil::get_round();
if (round_mode == FE_UPWARD || round_mode == FE_TOWARDZERO)
return -0x1.40711p-5f;
return -0x1.407112p-5f;
}
return internal::log(xd + 1.0);
}
// Hard-to round cases.
switch (xbits.uintval()) {
case 0x35400003U: // x = 0x1.800006p-21f
if (fputil::get_round() == FE_TONEAREST)
return 0x1.7ffffep-21f;
break;
case 0x3710001bU: // x = 0x1.200036p-17f
if (fputil::get_round() == FE_TONEAREST)
return 0x1.1fffe6p-17f;
break;
case 0xb53ffffdU: // x = -0x1.7ffffap-21f
if (fputil::get_round() != FE_DOWNWARD)
return -0x1.800002p-21f;
break;
case 0xb70fffe5U: // x = -0x1.1fffcap-17f
if (fputil::get_round() != FE_DOWNWARD)
return -0x1.20001ap-17f;
break;
case 0xbb0ec8c4U: // x = -0x1.1d9188p-9f
if (fputil::get_round() == FE_TONEAREST)
return -0x1.1de14ap-9f;
break;
}
double r;
// Polymial generated with Sollya:
// > fpminimax(log(1 + x)/x, 5, [|D...|], [-2^-8; 2^-8]);
r = fputil::polyeval(xd, -0x1p-1, 0x1.5555555515551p-2, -0x1.ffffffff82bdap-3,
0x1.999b33348d3aep-3, -0x1.5556cae3adcc3p-3);
return static_cast<float>(fputil::fma(r, xd * xd, xd));
}
} // namespace __llvm_libc

48
libc/src/math/generic/logf.cpp
View File

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "src/math/logf.h"
#include "common_constants.h" // Lookup table for (1/f)
#include "common_constants.h" // Lookup table for (1/f) and log(f)
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/FPUtil/FEnvImpl.h"
#include "src/__support/FPUtil/FMA.h"
@ -49,52 +49,6 @@
namespace __llvm_libc {
// Lookup table for log(f) = log(1 + n*2^(-7)) where n = 0..127.
static constexpr double LOG_F[128] = {
0x0.0000000000000p+0, 0x1.fe02a6b106788p-8, 0x1.fc0a8b0fc03e3p-7,
0x1.7b91b07d5b11ap-6, 0x1.f829b0e783300p-6, 0x1.39e87b9febd5fp-5,
0x1.77458f632dcfcp-5, 0x1.b42dd711971bep-5, 0x1.f0a30c01162a6p-5,
0x1.16536eea37ae0p-4, 0x1.341d7961bd1d0p-4, 0x1.51b073f06183fp-4,
0x1.6f0d28ae56b4bp-4, 0x1.8c345d6319b20p-4, 0x1.a926d3a4ad563p-4,
0x1.c5e548f5bc743p-4, 0x1.e27076e2af2e5p-4, 0x1.fec9131dbeabap-4,
0x1.0d77e7cd08e59p-3, 0x1.1b72ad52f67a0p-3, 0x1.29552f81ff523p-3,
0x1.371fc201e8f74p-3, 0x1.44d2b6ccb7d1ep-3, 0x1.526e5e3a1b437p-3,
0x1.5ff3070a793d3p-3, 0x1.6d60fe719d21cp-3, 0x1.7ab890210d909p-3,
0x1.87fa06520c910p-3, 0x1.9525a9cf456b4p-3, 0x1.a23bc1fe2b563p-3,
0x1.af3c94e80bff2p-3, 0x1.bc286742d8cd6p-3, 0x1.c8ff7c79a9a21p-3,
0x1.d5c216b4fbb91p-3, 0x1.e27076e2af2e5p-3, 0x1.ef0adcbdc5936p-3,
0x1.fb9186d5e3e2ap-3, 0x1.0402594b4d040p-2, 0x1.0a324e27390e3p-2,
0x1.1058bf9ae4ad5p-2, 0x1.1675cababa60ep-2, 0x1.1c898c16999fap-2,
0x1.22941fbcf7965p-2, 0x1.2895a13de86a3p-2, 0x1.2e8e2bae11d30p-2,
0x1.347dd9a987d54p-2, 0x1.3a64c556945e9p-2, 0x1.404308686a7e3p-2,
0x1.4618bc21c5ec2p-2, 0x1.4be5f957778a0p-2, 0x1.51aad872df82dp-2,
0x1.5767717455a6cp-2, 0x1.5d1bdbf5809cap-2, 0x1.62c82f2b9c795p-2,
0x1.686c81e9b14aep-2, 0x1.6e08eaa2ba1e3p-2, 0x1.739d7f6bbd006p-2,
0x1.792a55fdd47a2p-2, 0x1.7eaf83b82afc3p-2, 0x1.842d1da1e8b17p-2,
0x1.89a3386c1425ap-2, 0x1.8f11e873662c7p-2, 0x1.947941c2116fap-2,
0x1.99d958117e08ap-2, 0x1.9f323ecbf984bp-2, 0x1.a484090e5bb0ap-2,
0x1.a9cec9a9a0849p-2, 0x1.af1293247786bp-2, 0x1.b44f77bcc8f62p-2,
0x1.b9858969310fbp-2, 0x1.beb4d9da71b7bp-2, 0x1.c3dd7a7cdad4dp-2,
0x1.c8ff7c79a9a21p-2, 0x1.ce1af0b85f3ebp-2, 0x1.d32fe7e00ebd5p-2,
0x1.d83e7258a2f3ep-2, 0x1.dd46a04c1c4a0p-2, 0x1.e24881a7c6c26p-2,
0x1.e744261d68787p-2, 0x1.ec399d2468cc0p-2, 0x1.f128f5faf06ecp-2,
0x1.f6123fa7028acp-2, 0x1.faf588f78f31ep-2, 0x1.ffd2e0857f498p-2,
0x1.02552a5a5d0fep-1, 0x1.04bdf9da926d2p-1, 0x1.0723e5c1cdf40p-1,
0x1.0986f4f573520p-1, 0x1.0be72e4252a82p-1, 0x1.0e44985d1cc8bp-1,
0x1.109f39e2d4c96p-1, 0x1.12f719593efbcp-1, 0x1.154c3d2f4d5e9p-1,
0x1.179eabbd899a0p-1, 0x1.19ee6b467c96ep-1, 0x1.1c3b81f713c24p-1,
0x1.1e85f5e7040d0p-1, 0x1.20cdcd192ab6dp-1, 0x1.23130d7bebf42p-1,
0x1.2555bce98f7cbp-1, 0x1.2795e1289b11ap-1, 0x1.29d37fec2b08ap-1,
0x1.2c0e9ed448e8bp-1, 0x1.2e47436e40268p-1, 0x1.307d7334f10bep-1,
0x1.32b1339121d71p-1, 0x1.34e289d9ce1d3p-1, 0x1.37117b54747b5p-1,
0x1.393e0d3562a19p-1, 0x1.3b68449fffc22p-1, 0x1.3d9026a7156fap-1,
0x1.3fb5b84d16f42p-1, 0x1.41d8fe84672aep-1, 0x1.43f9fe2f9ce67p-1,
0x1.4618bc21c5ec2p-1, 0x1.48353d1ea88dfp-1, 0x1.4a4f85db03ebbp-1,
0x1.4c679afccee39p-1, 0x1.4e7d811b75bb0p-1, 0x1.50913cc01686bp-1,
0x1.52a2d265bc5aap-1, 0x1.54b2467999497p-1, 0x1.56bf9d5b3f399p-1,
0x1.58cadb5cd7989p-1, 0x1.5ad404c359f2cp-1, 0x1.5cdb1dc6c1764p-1,
0x1.5ee02a9241675p-1, 0x1.60e32f44788d8p-1};
INLINE_FMA
LLVM_LIBC_FUNCTION(float, logf, (float x)) {
constexpr double LOG_2 = 0x1.62e42fefa39efp-1;

18
libc/src/math/log1pf.h Normal file
View File

@ -0,0 +1,18 @@
//===-- Implementation header for log1pf ------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_SRC_MATH_LOG1PF_H
#define LLVM_LIBC_SRC_MATH_LOG1PF_H
namespace __llvm_libc {
float log1pf(float x);
} // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LOG1PF_H

13
libc/test/src/math/CMakeLists.txt
View File

@ -1254,6 +1254,19 @@ add_fp_unittest(
libc.src.__support.FPUtil.fputil
)
add_fp_unittest(
log1pf_test
NEED_MPFR
SUITE
libc_math_unittests
SRCS
log1pf_test.cpp
DEPENDS
libc.include.math
libc.src.math.log1pf
libc.src.__support.FPUtil.fputil
)
add_subdirectory(generic)
add_subdirectory(exhaustive)
add_subdirectory(differential_testing)

11
libc/test/src/math/differential_testing/CMakeLists.txt
View File

@ -252,6 +252,17 @@ add_diff_binary(
-fno-builtin
)
add_diff_binary(
log1pf_perf
SRCS
log1pf_perf.cpp
DEPENDS
.single_input_single_output_diff
libc.src.math.log1pf
COMPILE_OPTIONS
-fno-builtin
)
add_diff_binary(
log2f_diff
SRCS

16
libc/test/src/math/differential_testing/log1pf_perf.cpp Normal file
View File

@ -0,0 +1,16 @@
//===-- Differential test for log1pf --------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "SingleInputSingleOutputDiff.h"
#include "src/math/log1pf.h"
#include <math.h>
SINGLE_INPUT_SINGLE_OUTPUT_PERF(float, __llvm_libc::log1pf, ::log1pf,
"log1pf_perf.log")

17
libc/test/src/math/exhaustive/CMakeLists.txt
View File

@ -96,6 +96,23 @@ add_fp_unittest(
-lpthread
)
add_fp_unittest(
log1pf_test
NO_RUN_POSTBUILD
NEED_MPFR
SUITE
libc_math_exhaustive_tests
SRCS
log1pf_test.cpp
DEPENDS
.exhaustive_test
libc.include.math
libc.src.math.log1pf
libc.src.__support.FPUtil.fputil
LINK_OPTIONS
-lpthread
)
add_fp_unittest(
log2f_test
NO_RUN_POSTBUILD

55
libc/test/src/math/exhaustive/log1pf_test.cpp Normal file
View File

@ -0,0 +1,55 @@
//===-- Exhaustive test for log1pf ----------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "exhaustive_test.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/math/log1pf.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h"
using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibclog1pfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
void check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding);
uint32_t bits = start;
do {
FPBits xbits(bits);
float x = float(xbits);
EXPECT_MPFR_MATCH(mpfr::Operation::Log1p, x, __llvm_libc::log1pf(x), 0.5,
rounding);
} while (bits++ < stop);
}
};
// Range: All non-negative;
static constexpr uint32_t START = 0x0000'0000U;
static constexpr uint32_t STOP = 0x7f80'0000U;
// Range: [-1, 0];
// static constexpr uint32_t START = 0x8000'0000U;
// static constexpr uint32_t STOP = 0xbf80'0000U;
static constexpr int NUM_THREADS = 16;
TEST_F(LlvmLibclog1pfExhaustiveTest, RoundNearestTieToEven) {
test_full_range(START, STOP, NUM_THREADS, mpfr::RoundingMode::Nearest);
}
TEST_F(LlvmLibclog1pfExhaustiveTest, RoundUp) {
test_full_range(START, STOP, NUM_THREADS, mpfr::RoundingMode::Upward);
}
TEST_F(LlvmLibclog1pfExhaustiveTest, RoundDown) {
test_full_range(START, STOP, NUM_THREADS, mpfr::RoundingMode::Downward);
}
TEST_F(LlvmLibclog1pfExhaustiveTest, RoundTowardZero) {
test_full_range(START, STOP, NUM_THREADS, mpfr::RoundingMode::TowardZero);
}

81
libc/test/src/math/log1pf_test.cpp Normal file
View File

@ -0,0 +1,81 @@
//===-- Unittests for log1pf ----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/math/log1pf.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h"
#include <math.h>
#include <errno.h>
#include <stdint.h>
namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibclog1pfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::log1pf(aNaN));
EXPECT_FP_EQ(inf, __llvm_libc::log1pf(inf));
EXPECT_TRUE(FPBits((__llvm_libc::log1pf(neg_inf))).is_nan());
EXPECT_FP_EQ(zero, __llvm_libc::log1pf(0.0f));
EXPECT_FP_EQ(neg_zero, __llvm_libc::log1pf(-0.0f));
EXPECT_FP_EQ(neg_inf, __llvm_libc::log1pf(-1.0f));
}
TEST(LlvmLibclog1pfTest, TrickyInputs) {
constexpr int N = 20;
constexpr uint32_t INPUTS[N] = {
0x35c00006U, /*0x1.80000cp-20f*/
0x35400003U, /*0x1.800006p-21f*/
0x3640000cU, /*0x1.800018p-19f*/
0x36c00018U, /*0x1.80003p-18f*/
0x3710001bU, /*0x1.200036p-17f*/
0x37400030U, /*0x1.80006p-17f*/
0x3770004bU, /*0x1.e00096p-17f*/
0x3b9315c8U, /*0x1.262b9p-8f*/
0x3c6eb7afU, /*0x1.dd6f5ep-7f*/
0x41078febU, /*0x1.0f1fd6p+3f*/
0x5cd69e88U, /*0x1.ad3d1p+58f*/
0x65d890d3U, /*0x1.b121a6p+76f*/
0x6f31a8ecU, /*0x1.6351d8p+95f*/
0x7a17f30aU, /*0x1.2fe614p+117f*/
0xb53ffffdU, /*-0x1.7ffffap-21f*/
0xb70fffe5U, /*-0x1.1fffcap-17f*/
0xbb0ec8c4U, /*-0x1.1d9188p-9f*/
0xbc4d092cU, /*-0x1.9a1258p-7f*/
0xbc657728U, /*-0x1.caee5p-7f*/
0xbd1d20afU, /*-0x1.3a415ep-5f*/
};
for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
__llvm_libc::log1pf(x), 0.5);
}
}
TEST(LlvmLibclog1pfTest, InFloatRange) {
constexpr uint32_t COUNT = 1000000;
constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
errno = 0;
float result = __llvm_libc::log1pf(x);
// If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its
// wider precision.
if (isnan(result) || isinf(result) || errno != 0)
continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
__llvm_libc::log1pf(x), 0.5);
}
}

8
libc/utils/MPFRWrapper/MPFRUtils.cpp
View File

@ -279,6 +279,12 @@ public:
return result;
}
MPFRNumber log1p() const {
MPFRNumber result(*this);
mpfr_log1p(result.value, value, mpfr_rounding);
return result;
}
MPFRNumber remquo(const MPFRNumber &divisor, int &quotient) {
MPFRNumber remainder(*this);
long q;
@ -510,6 +516,8 @@ unary_operation(Operation op, InputType input, unsigned int precision,
return mpfrInput.log2();
case Operation::Log10:
return mpfrInput.log10();
case Operation::Log1p:
return mpfrInput.log1p();
case Operation::Mod2PI:
return mpfrInput.mod_2pi();
case Operation::ModPIOver2:

1
libc/utils/MPFRWrapper/MPFRUtils.h
View File

@ -33,6 +33,7 @@ enum class Operation : int {
Log,
Log2,
Log10,
Log1p,
Mod2PI,
ModPIOver2,
ModPIOver4,