[libc-commits] [libc] [libc][math] Switch log1pf to use the same log_eval from inverse hyperbolic functions. (PR #188388)
via libc-commits
libc-commits at lists.llvm.org
Tue Mar 24 17:47:37 PDT 2026
https://github.com/lntue created https://github.com/llvm/llvm-project/pull/188388
- Switch log1pf to use the same log_eval from inverse hyperbolic functions.
- Optimize log_eval to use the same range reduction scheme as double precision log
- Reduce the table size needed for log range reduction.
- This lower the overall latency of log1pf and inverse hyperbolic functions.
>From 505d881f3eb471c32b40020ed28544d895362ff0 Mon Sep 17 00:00:00 2001
From: Tue Ly <lntue.h at gmail.com>
Date: Wed, 25 Mar 2026 00:38:10 +0000
Subject: [PATCH] [libc][math] Switch log1pf to use the same log_eval from
inverse hyperbolic functions.
- Optimize log_eval to use the same range reduction scheme as double precision log
- Reduce the table size needed for log range reduction.
- This lower the overall latency of log1pf and inverse hyperbolic functions.
---
libc/src/__support/math/CMakeLists.txt | 2 +-
.../__support/math/acosh_float_constants.h | 159 ++++++--------
libc/src/__support/math/acoshf.h | 106 ++++++---
libc/src/__support/math/acoshf_utils.h | 68 ++++--
libc/src/__support/math/asinhf.h | 71 +++++--
libc/src/__support/math/atanhf.h | 2 +-
libc/src/__support/math/log1pf.h | 201 ++++++++----------
libc/test/src/math/acoshf_test.cpp | 7 +-
libc/test/src/math/asinhf_test.cpp | 8 +-
libc/test/src/math/log1pf_test.cpp | 5 +-
10 files changed, 346 insertions(+), 283 deletions(-)
diff --git a/libc/src/__support/math/CMakeLists.txt b/libc/src/__support/math/CMakeLists.txt
index c3ffa2f79dd3e..47e1f61be590b 100644
--- a/libc/src/__support/math/CMakeLists.txt
+++ b/libc/src/__support/math/CMakeLists.txt
@@ -2812,7 +2812,7 @@ add_header_library(
HDRS
log1pf.h
DEPENDS
- .common_constants
+ .acoshf_utils
libc.src.__support.FPUtil.except_value_utils
libc.src.__support.FPUtil.fenv_impl
libc.src.__support.FPUtil.fma
diff --git a/libc/src/__support/math/acosh_float_constants.h b/libc/src/__support/math/acosh_float_constants.h
index f27e126099c7c..46aa34c05e01b 100644
--- a/libc/src/__support/math/acosh_float_constants.h
+++ b/libc/src/__support/math/acosh_float_constants.h
@@ -16,97 +16,76 @@ namespace LIBC_NAMESPACE_DECL {
namespace acoshf_internal {
-// Lookup table for (1/f) where f = 1 + n*2^(-7), n = 0..127.
-LIBC_INLINE_VAR constexpr double ONE_OVER_F[128] = {
- 0x1.0000000000000p+0, 0x1.fc07f01fc07f0p-1, 0x1.f81f81f81f820p-1,
- 0x1.f44659e4a4271p-1, 0x1.f07c1f07c1f08p-1, 0x1.ecc07b301ecc0p-1,
- 0x1.e9131abf0b767p-1, 0x1.e573ac901e574p-1, 0x1.e1e1e1e1e1e1ep-1,
- 0x1.de5d6e3f8868ap-1, 0x1.dae6076b981dbp-1, 0x1.d77b654b82c34p-1,
- 0x1.d41d41d41d41dp-1, 0x1.d0cb58f6ec074p-1, 0x1.cd85689039b0bp-1,
- 0x1.ca4b3055ee191p-1, 0x1.c71c71c71c71cp-1, 0x1.c3f8f01c3f8f0p-1,
- 0x1.c0e070381c0e0p-1, 0x1.bdd2b899406f7p-1, 0x1.bacf914c1bad0p-1,
- 0x1.b7d6c3dda338bp-1, 0x1.b4e81b4e81b4fp-1, 0x1.b2036406c80d9p-1,
- 0x1.af286bca1af28p-1, 0x1.ac5701ac5701bp-1, 0x1.a98ef606a63bep-1,
- 0x1.a6d01a6d01a6dp-1, 0x1.a41a41a41a41ap-1, 0x1.a16d3f97a4b02p-1,
- 0x1.9ec8e951033d9p-1, 0x1.9c2d14ee4a102p-1, 0x1.999999999999ap-1,
- 0x1.970e4f80cb872p-1, 0x1.948b0fcd6e9e0p-1, 0x1.920fb49d0e229p-1,
- 0x1.8f9c18f9c18fap-1, 0x1.8d3018d3018d3p-1, 0x1.8acb90f6bf3aap-1,
- 0x1.886e5f0abb04ap-1, 0x1.8618618618618p-1, 0x1.83c977ab2beddp-1,
- 0x1.8181818181818p-1, 0x1.7f405fd017f40p-1, 0x1.7d05f417d05f4p-1,
- 0x1.7ad2208e0ecc3p-1, 0x1.78a4c8178a4c8p-1, 0x1.767dce434a9b1p-1,
- 0x1.745d1745d1746p-1, 0x1.724287f46debcp-1, 0x1.702e05c0b8170p-1,
- 0x1.6e1f76b4337c7p-1, 0x1.6c16c16c16c17p-1, 0x1.6a13cd1537290p-1,
- 0x1.6816816816817p-1, 0x1.661ec6a5122f9p-1, 0x1.642c8590b2164p-1,
- 0x1.623fa77016240p-1, 0x1.6058160581606p-1, 0x1.5e75bb8d015e7p-1,
- 0x1.5c9882b931057p-1, 0x1.5ac056b015ac0p-1, 0x1.58ed2308158edp-1,
- 0x1.571ed3c506b3ap-1, 0x1.5555555555555p-1, 0x1.5390948f40febp-1,
- 0x1.51d07eae2f815p-1, 0x1.5015015015015p-1, 0x1.4e5e0a72f0539p-1,
- 0x1.4cab88725af6ep-1, 0x1.4afd6a052bf5bp-1, 0x1.49539e3b2d067p-1,
- 0x1.47ae147ae147bp-1, 0x1.460cbc7f5cf9ap-1, 0x1.446f86562d9fbp-1,
- 0x1.42d6625d51f87p-1, 0x1.4141414141414p-1, 0x1.3fb013fb013fbp-1,
- 0x1.3e22cbce4a902p-1, 0x1.3c995a47babe7p-1, 0x1.3b13b13b13b14p-1,
- 0x1.3991c2c187f63p-1, 0x1.3813813813814p-1, 0x1.3698df3de0748p-1,
- 0x1.3521cfb2b78c1p-1, 0x1.33ae45b57bcb2p-1, 0x1.323e34a2b10bfp-1,
- 0x1.30d190130d190p-1, 0x1.2f684bda12f68p-1, 0x1.2e025c04b8097p-1,
- 0x1.2c9fb4d812ca0p-1, 0x1.2b404ad012b40p-1, 0x1.29e4129e4129ep-1,
- 0x1.288b01288b013p-1, 0x1.27350b8812735p-1, 0x1.25e22708092f1p-1,
- 0x1.2492492492492p-1, 0x1.23456789abcdfp-1, 0x1.21fb78121fb78p-1,
- 0x1.20b470c67c0d9p-1, 0x1.1f7047dc11f70p-1, 0x1.1e2ef3b3fb874p-1,
- 0x1.1cf06ada2811dp-1, 0x1.1bb4a4046ed29p-1, 0x1.1a7b9611a7b96p-1,
- 0x1.19453808ca29cp-1, 0x1.1811811811812p-1, 0x1.16e0689427379p-1,
- 0x1.15b1e5f75270dp-1, 0x1.1485f0e0acd3bp-1, 0x1.135c81135c811p-1,
- 0x1.12358e75d3033p-1, 0x1.1111111111111p-1, 0x1.0fef010fef011p-1,
- 0x1.0ecf56be69c90p-1, 0x1.0db20a88f4696p-1, 0x1.0c9714fbcda3bp-1,
- 0x1.0b7e6ec259dc8p-1, 0x1.0a6810a6810a7p-1, 0x1.0953f39010954p-1,
- 0x1.0842108421084p-1, 0x1.073260a47f7c6p-1, 0x1.0624dd2f1a9fcp-1,
- 0x1.05197f7d73404p-1, 0x1.0410410410410p-1, 0x1.03091b51f5e1ap-1,
- 0x1.0204081020408p-1, 0x1.0101010101010p-1};
+// Look up table for log range reduction:
+// r(0) = 1
+// r(63) = 0.5
+// > for i from 1 to 62 do {
+// r = 2^-7 * ceil(2^7 * (1 - 2^-7) / (1 + i * 2^-6));
+// print(r, ",");
+// };
+LIBC_INLINE_VAR constexpr double R_LOG[64] = {
+ 0x1.0p+0, 0x1.f8p-1, 0x1.fp-1, 0x1.e8p-1, 0x1.ep-1, 0x1.d8p-1, 0x1.d4p-1,
+ 0x1.ccp-1, 0x1.c4p-1, 0x1.cp-1, 0x1.b8p-1, 0x1.b4p-1, 0x1.acp-1, 0x1.a8p-1,
+ 0x1.a4p-1, 0x1.9cp-1, 0x1.98p-1, 0x1.94p-1, 0x1.9p-1, 0x1.88p-1, 0x1.84p-1,
+ 0x1.8p-1, 0x1.7cp-1, 0x1.78p-1, 0x1.74p-1, 0x1.7p-1, 0x1.6cp-1, 0x1.68p-1,
+ 0x1.64p-1, 0x1.6p-1, 0x1.5cp-1, 0x1.58p-1, 0x1.54p-1, 0x1.5p-1, 0x1.4cp-1,
+ 0x1.4cp-1, 0x1.48p-1, 0x1.44p-1, 0x1.4p-1, 0x1.3cp-1, 0x1.3cp-1, 0x1.38p-1,
+ 0x1.34p-1, 0x1.3p-1, 0x1.3p-1, 0x1.2cp-1, 0x1.28p-1, 0x1.28p-1, 0x1.24p-1,
+ 0x1.2p-1, 0x1.2p-1, 0x1.1cp-1, 0x1.1cp-1, 0x1.18p-1, 0x1.14p-1, 0x1.14p-1,
+ 0x1.1p-1, 0x1.1p-1, 0x1.0cp-1, 0x1.0cp-1, 0x1.08p-1, 0x1.08p-1, 0x1.04p-1,
+ 0x1.0p-1};
-// Lookup table for log(f) = log(1 + n*2^(-7)) where n = 0..127.
-LIBC_INLINE_VAR 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};
+// Compensated constants for exact logarithm range reduction when FMA is not
+// available.
+// Generated by Sollya with the formula: CD[i] = RD[i]*(1 + i*2^-6) - 1
+// for RD[i] defined on the table above.
+LIBC_INLINE_VAR constexpr double C_LOG[64] = {
+ 0.0, -0x1p-12, -0x1p-10, -0x1.2p-9, -0x1p-8, -0x1.9p-8,
+ -0x1p-12, -0x1.bp-9, -0x1.cp-8, -0x1p-9, -0x1.ap-8, -0x1.1p-9,
+ -0x1.ep-8, -0x1.ep-9, -0x1p-12, -0x1.b8p-8, -0x1p-8, -0x1.6p-10,
+ 0x1p-10, -0x1.dp-8, -0x1.6p-8, -0x1p-8, -0x1.6p-9, -0x1.cp-10,
+ -0x1p-10, -0x1p-11, -0x1p-12, -0x1p-12, -0x1p-11, -0x1p-10,
+ -0x1.cp-10, -0x1.6p-9, -0x1p-8, -0x1.6p-8, -0x1.dp-8, 0x1.9p-9,
+ 0x1p-10, -0x1.6p-10, -0x1p-8, -0x1.b8p-8, 0x1.8p-9, -0x1p-12,
+ -0x1.ep-9, -0x1.ep-8, 0x1p-9, -0x1.1p-9, -0x1.ap-8, 0x1.6p-9,
+ -0x1p-9, -0x1.cp-8, 0x1p-9, -0x1.bp-9, 0x1.6p-8, -0x1p-12,
+ -0x1.9p-8, 0x1.3p-9, -0x1p-8, 0x1.2p-8, -0x1.2p-9, 0x1.88p-8,
+ -0x1p-10, 0x1.dp-8, -0x1p-12, -0x1.0p-7};
+
+// Lookup table for log(r) = log(1 + n*2^(-7)) where n = 0..127.
+LIBC_INLINE_VAR constexpr double LOG_R[64] = {
+ 0x0.0000000000000p+0, 0x1.0205658935847p-6,
+ 0x1.0415d89e74444p-5, 0x1.894aa149fb343p-5,
+ 0x1.08598b59e3a07p-4, 0x1.4d3115d207eacp-4,
+ 0x1.700d30aeac0e1p-4, 0x1.b6ac88dad5b1cp-4,
+ 0x1.fe89139dbd566p-4, 0x1.1178e8227e47cp-3,
+ 0x1.365fcb0159016p-3, 0x1.4913d8333b561p-3,
+ 0x1.6f0128b756abcp-3, 0x1.823c16551a3c2p-3,
+ 0x1.95a5adcf7017fp-3, 0x1.bd087383bd8adp-3,
+ 0x1.d1037f2655e7bp-3, 0x1.e530effe71012p-3,
+ 0x1.f991c6cb3b379p-3, 0x1.1178e8227e47cp-2,
+ 0x1.1bf99635a6b95p-2, 0x1.269621134db92p-2,
+ 0x1.314f1e1d35ce4p-2, 0x1.3c25277333184p-2,
+ 0x1.4718dc271c41bp-2, 0x1.522ae0738a3d8p-2,
+ 0x1.5d5bddf595f3p-2, 0x1.68ac83e9c6a14p-2,
+ 0x1.741d876c67bb1p-2, 0x1.7fafa3bd8151cp-2,
+ 0x1.8b639a88b2df5p-2, 0x1.973a3431356aep-2,
+ 0x1.a33440224fa79p-2, 0x1.af5295248cddp-2,
+ 0x1.bb9611b80e2fbp-2, 0x1.bb9611b80e2fbp-2,
+ 0x1.c7ff9c74554c9p-2, 0x1.d490246defa6bp-2,
+ 0x1.e148a1a2726cep-2, 0x1.ee2a156b413e5p-2,
+ 0x1.ee2a156b413e5p-2, 0x1.fb358af7a4884p-2,
+ 0x1.04360be7603adp-1, 0x1.0ae76e2d054fap-1,
+ 0x1.0ae76e2d054fap-1, 0x1.11af823c75aa8p-1,
+ 0x1.188ee40f23ca6p-1, 0x1.188ee40f23ca6p-1,
+ 0x1.1f8635fc61659p-1, 0x1.269621134db92p-1,
+ 0x1.269621134db92p-1, 0x1.2dbf557b0df43p-1,
+ 0x1.2dbf557b0df43p-1, 0x1.35028ad9d8c86p-1,
+ 0x1.3c6080c36bfb5p-1, 0x1.3c6080c36bfb5p-1,
+ 0x1.43d9ff2f923c5p-1, 0x1.43d9ff2f923c5p-1,
+ 0x1.4b6fd6f970c1fp-1, 0x1.4b6fd6f970c1fp-1,
+ 0x1.5322e26867857p-1, 0x1.5322e26867857p-1,
+ 0x1.5af405c3649ep-1, 0.0};
} // namespace acoshf_internal
diff --git a/libc/src/__support/math/acoshf.h b/libc/src/__support/math/acoshf.h
index acc6fde1378de..d59d0588be734 100644
--- a/libc/src/__support/math/acoshf.h
+++ b/libc/src/__support/math/acoshf.h
@@ -12,6 +12,7 @@
#include "acoshf_utils.h"
#include "src/__support/FPUtil/FEnvImpl.h"
#include "src/__support/FPUtil/FPBits.h"
+#include "src/__support/FPUtil/except_value_utils.h"
#include "src/__support/FPUtil/multiply_add.h"
#include "src/__support/FPUtil/sqrt.h"
#include "src/__support/macros/config.h"
@@ -35,46 +36,83 @@ LIBC_INLINE constexpr float acoshf(float x) {
return FPBits_t::quiet_nan().get_val();
}
-#ifndef LIBC_MATH_HAS_SKIP_ACCURATE_PASS
uint32_t x_u = xbits.uintval();
- if (LIBC_UNLIKELY(x_u >= 0x4f8ffb03)) {
- if (LIBC_UNLIKELY(xbits.is_inf_or_nan()))
+ double x_d = static_cast<double>(x);
+
+ if (LIBC_UNLIKELY(x_u >= 0x4580'0000U)) {
+ // x >= 2^12.
+ if (LIBC_UNLIKELY(xbits.is_inf_or_nan())) {
+ if (xbits.is_signaling_nan()) {
+ fputil::raise_except_if_required(FE_INVALID);
+ return FPBits_t::quiet_nan().get_val();
+ }
return x;
+ }
- // Helper functions to set results for exceptional cases.
- auto round_result_slightly_down = [](float r) -> float {
- volatile float tmp = r;
- tmp = tmp - 0x1.0p-25f;
- return tmp;
- };
- auto round_result_slightly_up = [](float r) -> float {
- volatile float tmp = r;
- tmp = tmp + 0x1.0p-25f;
- return tmp;
- };
-
- switch (x_u) {
- case 0x4f8ffb03: // x = 0x1.1ff606p32f
- return round_result_slightly_up(0x1.6fdd34p4f);
- case 0x5c569e88: // x = 0x1.ad3d1p57f
- return round_result_slightly_up(0x1.45c146p5f);
- case 0x5e68984e: // x = 0x1.d1309cp61f
- return round_result_slightly_up(0x1.5c9442p5f);
- case 0x655890d3: // x = 0x1.b121a6p75f
- return round_result_slightly_down(0x1.a9a3f2p5f);
- case 0x6eb1a8ec: // x = 0x1.6351d8p94f
- return round_result_slightly_down(0x1.08b512p6f);
- case 0x7997f30a: // x = 0x1.2fe614p116f
- return round_result_slightly_up(0x1.451436p6f);
+ // acosh(x) = log(x + sqrt(x^2 - 1))
+ // For large x:
+ // log(x + sqrt(x^2 - 1)) = log(2x) + log((x + sqrt(x^2 - 1)) / (2x)).
+ // Let U = (x + sqrt(x^2 - 1))/(2x).
+ // Then U = 1 - (x - sqrt(x^2 - 1))/(2x)
+ // = 1 - (1 - sqrt(1 - 1/x^2))/2
+ // = 1 - (1/2) * (1/(2x^2) + 1/(8x^4) + ...)
+ // = 1 - 1/(2x)^2 - 1/(2x)^4 - ...
+ // Hence log(U) = log(1 - 1/(2x)^2 - 1/(2x)^4 - ...)
+ // = -(1/(2x)^2 - 1/(2x)^4 - ...) -
+ // - (1/(2x)^2 - 1/(2x)^4 - ...)^2/2 - ...
+ // ~ -1/(2x)^2 - 1/(2x^4) - ...
+ // For x >= 2^12:
+ // acosh(x) ~ log(2x) - 1/(2x)^2.
+ // > g = log(2*x) + 1/(4 * x^2);
+ // > dirtyinfnorm((acosh(x) - g)/acosh(x), [2^12, 2^20]);
+ // 0x1.54eb81b0c0df3c9bf68c149748e507fa136e2294fp-55
+ //
+ // For x >= 2^25, 1/(2x)^2 <= 2^-54. So we just need log(2x).
+
+ double y = 2.0 * x_d;
+
+ if (x_u <= 0x4c80'0000U) {
+ // x <= 2^26
+#ifndef LIBC_MATH_HAS_SKIP_ACCURATE_PASS
+ if (LIBC_UNLIKELY(x_u == 0x45dc'6414U)) // x = 0x1.b8c828p12f
+ return fputil::round_result_slightly_up(0x1.31bcb6p3f);
+#endif // LIBC_MATH_HAS_SKIP_ACCURATE_PASS
+ double y_inv = 0.5 / x_d;
+ fputil::multiply_add(y_inv, -y_inv, log_eval(y));
+
+ } else {
+// x > 2^26
+#ifndef LIBC_MATH_HAS_SKIP_ACCURATE_PASS
+ switch (x_u) {
+ case 0x4c803f2c: // x = 0x1.007e58p26f
+ return fputil::round_result_slightly_down(0x1.2b786cp4f);
+ case 0x4f8ffb03: // x = 0x1.1ff606p32f
+ return fputil::round_result_slightly_up(0x1.6fdd34p4f);
+ case 0x5c569e88: // x = 0x1.ad3d1p57f
+ return fputil::round_result_slightly_up(0x1.45c146p5f);
+ case 0x5e68984e: // x = 0x1.d1309cp61f
+ return fputil::round_result_slightly_up(0x1.5c9442p5f);
+ case 0x655890d3: // x = 0x1.b121a6p75f
+ return fputil::round_result_slightly_down(0x1.a9a3f2p5f);
+ case 0x6eb1a8ec: // x = 0x1.6351d8p94f
+ return fputil::round_result_slightly_down(0x1.08b512p6f);
+ case 0x7997f30a: // x = 0x1.2fe614p116f
+ return fputil::round_result_slightly_up(0x1.451436p6f);
+#ifndef LIBC_TARGET_CPU_HAS_FMA_DOUBLE
+ case 0x65de7ca6: // x = 0x1.bcf94cp76f
+ return fputil::round_result_slightly_up(0x1.af66cp5f);
+ case 0x7967ec37: // x = 0x1.cfd86ep115f
+ return fputil::round_result_slightly_up(0x1.43ff6ep6f);
+#endif // !LIBC_TARGET_CPU_HAS_FMA_DOUBLE
+ }
+#endif // !LIBC_MATH_HAS_SKIP_ACCURATE_PASS
}
+
+ return static_cast<float>(log_eval(y));
}
-#else
- if (LIBC_UNLIKELY(xbits.is_inf_or_nan()))
- return x;
-#endif // !LIBC_MATH_HAS_SKIP_ACCURATE_PASS
- double x_d = static_cast<double>(x);
- // acosh(x) = log(x + sqrt(x^2 - 1))
+ // For 1 < x < 2^12, we use the formula:
+ // acosh(x) = log(x + sqrt(x^2 - 1))
return static_cast<float>(log_eval(
x_d + fputil::sqrt<double>(fputil::multiply_add(x_d, x_d, -1.0))));
}
diff --git a/libc/src/__support/math/acoshf_utils.h b/libc/src/__support/math/acoshf_utils.h
index 48af06bf63ac6..8a8e2caccc765 100644
--- a/libc/src/__support/math/acoshf_utils.h
+++ b/libc/src/__support/math/acoshf_utils.h
@@ -68,38 +68,64 @@ LIBC_INLINE LIBC_CONSTEXPR double log_eval(double x) {
#else // Accurate evaluation.
LIBC_INLINE LIBC_CONSTEXPR double log_eval(double x) {
+ constexpr double LOG_2 = 0x1.62e42fefa39efp-1;
+
// For x = 2^ex * (1 + mx)
// log(x) = ex * log(2) + log(1 + mx)
- using FPB = fputil::FPBits<double>;
- FPB bs(x);
+ using FPBits = fputil::FPBits<double>;
+ FPBits x_bits(x);
+ uint64_t x_u = x_bits.uintval();
+
+ // log(x) = log(2^x_e * x_m)
+ // = x_e * log(2) + log(x_m)
- double ex = static_cast<double>(bs.get_exponent());
+ // Range reduction for log(x_m):
+ // For each x_m, we would like to find r such that:
+ // -2^-7 <= r * x_m - 1 < 2^-6
+ int shifted = static_cast<int>(x_u >> (FPBits::FRACTION_LEN - 6));
+ int index = shifted & 0x3F;
+ double r = R_LOG[index];
- // p1 is the leading 7 bits of mx, i.e.
- // p1 * 2^(-7) <= m_x < (p1 + 1) * 2^(-7).
- int p1 = static_cast<int>(bs.get_mantissa() >> (FPB::FRACTION_LEN - 7));
+ // Add unbiased exponent. Add an extra 1 if the 8 leading fractional bits are
+ // all 1's.
+ int x_e = static_cast<int>((x_u + (1ULL << (FPBits::FRACTION_LEN - 6))) >>
+ FPBits::FRACTION_LEN) -
+ FPBits::EXP_BIAS;
+ double e_x = static_cast<double>(x_e);
- // Set bs to (1 + (mx - p1*2^(-7))
- bs.set_uintval(bs.uintval() & (FPB::FRACTION_MASK >> 7));
- bs.set_biased_exponent(FPB::EXP_BIAS);
- // dx = (mx - p1*2^(-7)) / (1 + p1*2^(-7)).
- double dx = (bs.get_val() - 1.0) * ONE_OVER_F[p1];
+ double r_hi = fputil::multiply_add(e_x, LOG_2, LOG_R[index]);
+
+ // Set m = 1.mantissa.
+ uint64_t x_m = (x_u & FPBits::FRACTION_MASK) | FPBits::one().uintval();
+ double m = FPBits(x_m).get_val();
+
+ double dx;
+
+ // Perform exact range reduction
+#ifdef LIBC_TARGET_CPU_HAS_FMA_DOUBLE
+ dx = fputil::multiply_add(r, m, -1.0); // exact
+#else
+ uint64_t c_m = x_m & 0x3FFF'C000'0000'0000ULL;
+ double c = FPBits(c_m).get_val();
+ dx = fputil::multiply_add(r, m - c, C_LOG[index]); // exact
+#endif // LIBC_TARGET_CPU_HAS_FMA_DOUBLE
// Minimax polynomial of log(1 + dx) generated by Sollya with:
- // > P = fpminimax(log(1 + x)/x, 6, [|D...|], [0, 2^-7]);
- // > dirtyinfnorm((log(1 + x) - x*P)/log(1 + x), [0, 2^-7]);
- // 0x1.14533565e96ea7635d108d0bcaf9458c3308a138dp-65
- const double COEFFS[6] = {-0x1.ffffffffffffcp-2, 0x1.5555555552ddep-2,
- -0x1.ffffffefe562dp-3, 0x1.9999817d3a50fp-3,
- -0x1.554317b3f67a5p-3, 0x1.1dc5c45e09c18p-3};
+ // > P = fpminimax(log(1 + x)/x, 6, [|1, D...|], [-2^-7, 2^-6]);
+ // > dirtyinfnorm((log(1 + x) - x*P)/log(1 + x), [-2^-7, 2^-6]);
+ // 0x1.6e853e8864f29a6f10d50698ee6ef972a79d3a487p-54
+ constexpr double COEFFS[6] = {-0x1.ffffffffffe03p-2, 0x1.55555555395f9p-2,
+ -0x1.0000001be5329p-2, 0x1.9999c1bf8c3afp-3,
+ -0x1.554f0ba9cee4bp-3, 0x1.1d94cd56b72d7p-3};
+
double dx2 = dx * dx;
double c1 = fputil::multiply_add(dx, COEFFS[1], COEFFS[0]);
double c2 = fputil::multiply_add(dx, COEFFS[3], COEFFS[2]);
double c3 = fputil::multiply_add(dx, COEFFS[5], COEFFS[4]);
-
- double p = fputil::polyeval(dx2, dx, c1, c2, c3);
- double result =
- fputil::multiply_add(ex, /*log(2)*/ 0x1.62e42fefa39efp-1, LOG_F[p1] + p);
+ double dx4 = dx2 * dx2;
+ double d1 = fputil::multiply_add(dx2, c1, r_hi + dx);
+ double d2 = fputil::multiply_add(dx2, c3, c2);
+ double result = fputil::multiply_add(dx4, d2, d1);
return result;
}
diff --git a/libc/src/__support/math/asinhf.h b/libc/src/__support/math/asinhf.h
index b08d30b97b9f1..e420eae221c3e 100644
--- a/libc/src/__support/math/asinhf.h
+++ b/libc/src/__support/math/asinhf.h
@@ -29,7 +29,7 @@ LIBC_INLINE constexpr float asinhf(float x) {
uint32_t x_abs = xbits.abs().uintval();
// |x| <= 2^-3
- if (LIBC_UNLIKELY(x_abs <= 0x3e80'0000U)) {
+ if (LIBC_UNLIKELY(x_abs <= 0x3e00'0000U)) {
// |x| <= 2^-26
if (LIBC_UNLIKELY(x_abs <= 0x3280'0000U)) {
return static_cast<float>(LIBC_UNLIKELY(x_abs == 0)
@@ -37,21 +37,30 @@ LIBC_INLINE constexpr float asinhf(float x) {
: (x - 0x1.5555555555555p-3 * x * x * x));
}
+ // Generated by Sollya with:
+ // > P = fpminimax(asinh(x)/x, [|0, 2, 4, 6, 8, 10, 12|], [|1, D...|],
+ // [0, 2^-3]);
+ // > dirtyinfnorm((asinh(x) - x*P)/asinh(x), [0, 2^-3]);
+ // 0x1.ee29e366e2913deff32ed8fa17f94bfe277a5babbp-62
+ constexpr double COEFFS[] = {
+ -0x1.555555555551ap-3, 0x1.333333330f782p-4, -0x1.6db6dafa7f405p-5,
+ 0x1.f1c67120a7cf1p-6, -0x1.6e4b0e52674d3p-6, 0x1.10450cf441118p-6,
+ };
+
double x_d = x;
double x_sq = x_d * x_d;
- // Generated by Sollya with:
- // > P = fpminimax(asinh(x)/x, [|0, 2, 4, 6, 8, 10, 12, 14, 16|], [|D...|],
- // [0, 2^-2]);
- double p = fputil::polyeval(
- x_sq, 0.0, -0x1.555555555551ep-3, 0x1.3333333325495p-4,
- -0x1.6db6db5a7622bp-5, 0x1.f1c70f82928c6p-6, -0x1.6e893934266b7p-6,
- 0x1.1c0b41d3fbe78p-6, -0x1.c0f47810b3c4fp-7, 0x1.2c8602690143dp-7);
- return static_cast<float>(fputil::multiply_add(x_d, p, x_d));
+ double c0 = fputil::multiply_add(x_sq, COEFFS[1], COEFFS[0]);
+ double c1 = fputil::multiply_add(x_sq, COEFFS[3], COEFFS[2]);
+ double c2 = fputil::multiply_add(x_sq, COEFFS[5], COEFFS[4]);
+ double x_4 = x_sq * x_sq;
+ double x_3 = x_d * x_sq;
+ double p = fputil::polyeval(x_4, c0, c1, c2);
+ return static_cast<float>(fputil::multiply_add(x_3, p, x_d));
}
- const double SIGN[2] = {1.0, -1.0};
+ constexpr double SIGN[2] = {1.0, -1.0};
double x_sign = SIGN[x_u >> 31];
- double x_d = x;
+ double x_a = static_cast<double>(FPBits_t(x_abs).get_val());
#ifndef LIBC_MATH_HAS_SKIP_ACCURATE_PASS
// Helper functions to set results for exceptional cases.
@@ -64,8 +73,10 @@ LIBC_INLINE constexpr float asinhf(float x) {
static_cast<float>(x_sign) * 0x1.0p-24f);
};
- if (LIBC_UNLIKELY(x_abs >= 0x4bdd'65a5U)) {
- if (LIBC_UNLIKELY(xbits.is_inf_or_nan())) {
+ if (LIBC_UNLIKELY(x_abs >= 0x4b80'0000U)) {
+ // |x| >= 2^24
+ // We can approximate asinh(x) = sign(x) * log(2 * |x|).
+ if (LIBC_UNLIKELY(x_abs >= FPBits_t::inf().uintval())) {
if (xbits.is_signaling_nan()) {
fputil::raise_except_if_required(FE_INVALID);
return FPBits_t::quiet_nan().get_val();
@@ -86,15 +97,30 @@ LIBC_INLINE constexpr float asinhf(float x) {
return round_result_slightly_up(0x1.45c146p5f);
case 0x5e68984e: // |x| = 0x1.d1309cp61f
return round_result_slightly_up(0x1.5c9442p5f);
+ case 0x62f7a05a: // |x| = 0x1.ef40b4p70f
+ return round_result_slightly_up(0x1.8efc9ap5f);
case 0x655890d3: // |x| = 0x1.b121a6p75f
return round_result_slightly_down(0x1.a9a3f2p5f);
case 0x65de7ca6: // |x| = 0x1.bcf94cp76f
return round_result_slightly_up(0x1.af66cp5f);
case 0x6eb1a8ec: // |x| = 0x1.6351d8p94f
return round_result_slightly_down(0x1.08b512p6f);
+ case 0x76be09de: // |x| = 0x1.7c13bcp110f
+ return round_result_slightly_up(0x1.35569p6f);
case 0x7997f30a: // |x| = 0x1.2fe614p116f
return round_result_slightly_up(0x1.451436p6f);
+#ifndef LIBC_TARGET_CPU_HAS_FMA_DOUBLE
+ case 0x7967ec37: // |x| = 0x1.cfd86ep115f
+ return round_result_slightly_up(0x1.43ff6ep6f);
+ case 0x58719e31: // |x| = 0x1.e33c62p49f
+ return round_result_slightly_down(0x1.1a576cp5f);
+ case 0x71699003: // |x| = 0x1.d32006p99f
+ return round_result_slightly_up(0x1.17aa2p6f);
+#endif // !LIBC_TARGET_CPU_HAS_FMA_DOUBLE
}
+
+ return static_cast<float>(x_sign * log_eval(2.0 * x_a));
+
} else {
// Exceptional cases when x < 2^24.
if (LIBC_UNLIKELY(x_abs == 0x45abaf26)) {
@@ -105,17 +131,28 @@ LIBC_INLINE constexpr float asinhf(float x) {
// |x| = 0x1.a5209p20f
return round_result_slightly_down(0x1.e1b92p3f);
}
+#ifndef LIBC_TARGET_CPU_HAS_FMA_DOUBLE
+ if (LIBC_UNLIKELY(x_abs == 0x45e19b90)) {
+ // |x| = 0x1.c3372p12f
+ return round_result_slightly_down(0x1.327c5cp3f);
+ }
+#endif // !LIBC_TARGET_CPU_HAS_FMA_DOUBLE
}
#else
- if (LIBC_UNLIKELY(xbits.is_inf_or_nan()))
+ if (LIBC_UNLIKELY(x_abs >= FPBits_t::inf().uintval())) {
+ if (xbits.is_signaling_nan()) {
+ fputil::raise_except_if_required(FE_INVALID);
+ return FPBits_t::quiet_nan().get_val();
+ }
+
return x;
+ }
#endif // !LIBC_MATH_HAS_SKIP_ACCURATE_PASS
// asinh(x) = log(x + sqrt(x^2 + 1))
return static_cast<float>(
- x_sign * log_eval(fputil::multiply_add(
- x_d, x_sign,
- fputil::sqrt<double>(fputil::multiply_add(x_d, x_d, 1.0)))));
+ x_sign * log_eval(x_a + fputil::sqrt<double>(
+ fputil::multiply_add(x_a, x_a, 1.0))));
}
} // namespace math
diff --git a/libc/src/__support/math/atanhf.h b/libc/src/__support/math/atanhf.h
index 607bc51e73709..16d46994e2705 100644
--- a/libc/src/__support/math/atanhf.h
+++ b/libc/src/__support/math/atanhf.h
@@ -66,7 +66,7 @@ LIBC_INLINE constexpr float atanhf(float x) {
return static_cast<float>(fputil::multiply_add(xdbl, pe, xdbl));
}
double xdbl = x;
- return static_cast<float>(0.5 * log_eval((xdbl + 1.0) / (xdbl - 1.0)));
+ return static_cast<float>(0.5 * log_eval((1.0 + xdbl) / (1.0 - x)));
}
} // namespace math
diff --git a/libc/src/__support/math/log1pf.h b/libc/src/__support/math/log1pf.h
index 6cee597e92273..aa816992c7110 100644
--- a/libc/src/__support/math/log1pf.h
+++ b/libc/src/__support/math/log1pf.h
@@ -9,7 +9,6 @@
#ifndef LLVM_LIBC_SRC___SUPPORT_MATH_LOG1PF_H
#define LLVM_LIBC_SRC___SUPPORT_MATH_LOG1PF_H
-#include "common_constants.h" // Lookup table for (1/f) and log(f)
#include "src/__support/FPUtil/FEnvImpl.h"
#include "src/__support/FPUtil/FMA.h"
#include "src/__support/FPUtil/FPBits.h"
@@ -20,7 +19,7 @@
#include "src/__support/macros/config.h"
#include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
#include "src/__support/macros/properties/cpu_features.h"
-#include "src/__support/math/acosh_float_constants.h"
+#include "src/__support/math/acoshf_utils.h"
// This is an algorithm for log10(x) in single precision which is
// correctly rounded for all rounding modes.
@@ -38,56 +37,6 @@ namespace LIBC_NAMESPACE_DECL {
namespace math {
-namespace log1pf_internal {
-
-// We don't need to treat denormal and 0
-LIBC_INLINE float log(double x) {
- using namespace acoshf_internal;
- using namespace common_constants_internal;
- constexpr double LOG_2 = 0x1.62e42fefa39efp-1;
-
- using FPBits = typename fputil::FPBits<double>;
- FPBits xbits(x);
-
- uint64_t x_u = xbits.uintval();
-
- if (LIBC_UNLIKELY(x_u > FPBits::max_normal().uintval())) {
- if (xbits.is_neg() && !xbits.is_nan()) {
- fputil::set_errno_if_required(EDOM);
- fputil::raise_except_if_required(FE_INVALID);
- return fputil::FPBits<float>::quiet_nan().get_val();
- }
- return static_cast<float>(x);
- }
-
- double m = static_cast<double>(xbits.get_exponent());
-
- // Get the 8 highest bits, use 7 bits (excluding the implicit hidden bit) for
- // lookup tables.
- int f_index = static_cast<int>(xbits.get_mantissa() >>
- (fputil::FPBits<double>::FRACTION_LEN - 7));
-
- // Set bits to 1.m
- xbits.set_biased_exponent(0x3FF);
- FPBits f = xbits;
-
- // Clear the lowest 45 bits.
- f.set_uintval(f.uintval() & ~0x0000'1FFF'FFFF'FFFFULL);
-
- double d = xbits.get_val() - f.get_val();
- d *= ONE_OVER_F[f_index];
-
- double extra_factor = fputil::multiply_add(m, LOG_2, LOG_F[f_index]);
-
- double r = fputil::polyeval(d, extra_factor, 0x1.fffffffffffacp-1,
- -0x1.fffffffef9cb2p-2, 0x1.5555513bc679ap-2,
- -0x1.fff4805ea441p-3, 0x1.930180dbde91ap-3);
-
- return static_cast<float>(r);
-}
-
-} // namespace log1pf_internal
-
LIBC_INLINE static float log1pf(float x) {
using FPBits = typename fputil::FPBits<float>;
FPBits xbits(x);
@@ -95,79 +44,101 @@ LIBC_INLINE static float log1pf(float x) {
uint32_t x_a = x_u & 0x7fff'ffffU;
double xd = static_cast<double>(x);
- // Use log1p(x) = log(1 + x) for |x| > 2^-6;
- if (x_a > 0x3c80'0000U) {
+ if (x_a <= 0x3c80'0000U) {
+ // |x| <= 2^-6.
#ifndef LIBC_MATH_HAS_SKIP_ACCURATE_PASS
- // Hard-to-round cases.
+ // Hard-to round cases.
switch (x_u) {
- case 0x41078febU: // x = 0x1.0f1fd6p3
- return fputil::round_result_slightly_up(0x1.1fcbcep1f);
- case 0x5cd69e88U: // x = 0x1.ad3d1p+58f
- return fputil::round_result_slightly_up(0x1.45c146p+5f);
- case 0x65d890d3U: // x = 0x1.b121a6p+76f
- return fputil::round_result_slightly_down(0x1.a9a3f2p+5f);
- case 0x6f31a8ecU: // x = 0x1.6351d8p+95f
- return fputil::round_result_slightly_down(0x1.08b512p+6f);
- case 0x7a17f30aU: // x = 0x1.2fe614p+117f
- return fputil::round_result_slightly_up(0x1.451436p+6f);
- case 0xbd1d20afU: // x = -0x1.3a415ep-5f
- return fputil::round_result_slightly_up(-0x1.407112p-5f);
- case 0xbf800000U: // x = -1.0
- fputil::set_errno_if_required(ERANGE);
- fputil::raise_except_if_required(FE_DIVBYZERO);
- return FPBits::inf(Sign::NEG).get_val();
-#ifndef LIBC_TARGET_CPU_HAS_FMA_DOUBLE
- case 0x4cc1c80bU: // x = 0x1.839016p+26f
- return fputil::round_result_slightly_down(0x1.26fc04p+4f);
- case 0x5ee8984eU: // x = 0x1.d1309cp+62f
- return fputil::round_result_slightly_up(0x1.5c9442p+5f);
- case 0x665e7ca6U: // x = 0x1.bcf94cp+77f
- return fputil::round_result_slightly_up(0x1.af66cp+5f);
- case 0x79e7ec37U: // x = 0x1.cfd86ep+116f
- return fputil::round_result_slightly_up(0x1.43ff6ep+6f);
-#endif // LIBC_TARGET_CPU_HAS_FMA_DOUBLE
- }
-#else
- if (x == -1.0f) {
- fputil::set_errno_if_required(ERANGE);
- fputil::raise_except_if_required(FE_DIVBYZERO);
- return FPBits::inf(Sign::NEG).get_val();
+ case 0x3540'0003U: // x = 0x1.800006p-21f
+ return fputil::round_result_slightly_down(0x1.7ffffep-21f);
+ case 0x3710'001bU: // x = 0x1.200036p-17f
+ return fputil::round_result_slightly_down(0x1.1fffe6p-17f);
+ case 0xb53f'fffdU: // x = -0x1.7ffffap-21
+ return fputil::round_result_slightly_down(-0x1.800002p-21f);
+ case 0xb70f'ffe5U: // x = -0x1.1fffcap-17
+ return fputil::round_result_slightly_down(-0x1.20001ap-17f);
+ case 0xbb0e'c8c4U: // x = -0x1.1d9188p-9
+ return fputil::round_result_slightly_up(-0x1.1de14ap-9f);
}
#endif // !LIBC_MATH_HAS_SKIP_ACCURATE_PASS
- return log1pf_internal::log(xd + 1.0);
+ // Polymial generated by Sollya with:
+ // > P = fpminimax(log(1 + x)/x, 7, [|D...|], [-2^-6; 2^-6]);
+ // > dirtyinfnorm((log(1 + x) - x*P)/log(1 + x), [-2^-6, 2^-6]);
+ // 0x1.1447755e54a327941f7db7316f8dcd7cf33d15ffp-58
+ constexpr double COEFFS[7] = {-0x1.0000000000000p-1, 0x1.5555555556aadp-2,
+ -0x1.000000000181ap-2, 0x1.999998998124ep-3,
+ -0x1.55555452e2a2bp-3, 0x1.24adb8cde4aa7p-3,
+ -0x1.0019db915ef6fp-3};
+
+ double xsq = xd * xd;
+ double c0 = fputil::multiply_add(xd, COEFFS[1], COEFFS[0]);
+ double c1 = fputil::multiply_add(xd, COEFFS[3], COEFFS[2]);
+ double c2 = fputil::multiply_add(xd, COEFFS[5], COEFFS[4]);
+ double x4 = xsq * xsq;
+ double d0 = fputil::multiply_add(xsq, c1, c0);
+ double d1 = fputil::multiply_add(xsq, COEFFS[6], c2);
+ double d2 = fputil::multiply_add(x4, d1, d0);
+ double r = fputil::multiply_add(xsq, d2, xd);
+
+ return static_cast<float>(r);
}
- // |x| <= 2^-6.
+ // Use log1p(x) = log(1 + x) for |x| > 2^-6;
+
+ if (x_a >= 0x3f80'0000) {
+ // |x| >= 1.
+ if (LIBC_UNLIKELY(x_a >= 0x7f80'0000)) {
+ // x is inf, nan, or x <= -1.
+ if (x == -1.0f) {
+ // x = -1
+ fputil::set_errno_if_required(ERANGE);
+ fputil::raise_except_if_required(FE_DIVBYZERO);
+ return FPBits::inf(Sign::NEG).get_val();
+ }
+ if (xbits.is_signaling_nan() || x < 1.0f) {
+ // x is signaling NaNs or x < -1
+ if (x < 1.0f)
+ fputil::set_errno_if_required(EDOM);
+ fputil::raise_except_if_required(FE_INVALID);
+ return fputil::FPBits<float>::quiet_nan().get_val();
+ }
+ // x is +inf or quiet NaN
+ return x;
+ }
#ifndef LIBC_MATH_HAS_SKIP_ACCURATE_PASS
- // Hard-to round cases.
- switch (x_u) {
- case 0x35400003U: // x = 0x1.800006p-21f
- return fputil::round_result_slightly_down(0x1.7ffffep-21f);
- case 0x3710001bU: // x = 0x1.200036p-17f
- return fputil::round_result_slightly_down(0x1.1fffe6p-17f);
- case 0xb53ffffdU: // x = -0x1.7ffffap-21
- return fputil::round_result_slightly_down(-0x1.800002p-21f);
- case 0xb70fffe5U: // x = -0x1.1fffcap-17
- return fputil::round_result_slightly_down(-0x1.20001ap-17f);
- case 0xbb0ec8c4U: // x = -0x1.1d9188p-9
- return fputil::round_result_slightly_up(-0x1.1de14ap-9f);
- }
+ // Filter hard-to-round cases:
+ if (LIBC_UNLIKELY(x >= 0x1.30bf04p+43f)) {
+ switch (x_u) {
+ case 0x5518'5f82U: // x = 0x1.30bf04p+43f
+ return fputil::round_result_slightly_up(0x1.dfac9p+4f);
+ case 0x5cd6'9e88U: // x = 0x1.ad3d1p+58f
+ return fputil::round_result_slightly_up(0x1.45c146p+5f);
+ case 0x5ee8'984eU: // x = 0x1.d1309cp+62f
+ return fputil::round_result_slightly_up(0x1.5c9442p+5f);
+ case 0x65d8'90d3U: // x = 0x1.b121a6p+76f
+ return fputil::round_result_slightly_down(0x1.a9a3f2p+5f);
+ case 0x6f31'a8ecU: // x = 0x1.6351d8p+95f
+ return fputil::round_result_slightly_down(0x1.08b512p+6f);
+ case 0x7a17'f30aU: // x = 0x1.2fe614p+117f
+ return fputil::round_result_slightly_up(0x1.451436p+6f);
+#ifndef LIBC_TARGET_CPU_HAS_FMA_DOUBLE
+ case 0x58f1'9e31U: // x = 0x1.e33c62p+50f
+ return fputil::round_result_slightly_down(0x1.1a576cp+5f);
+ case 0x665e'7ca6U: // x = 0x1.bcf94cp+77f
+ return fputil::round_result_slightly_up(0x1.af66cp+5f);
+ case 0x79e7'ec37U: // x = 0x1.cfd86ep+116f
+ return fputil::round_result_slightly_up(0x1.43ff6ep+6f);
+#endif // LIBC_TARGET_CPU_HAS_FMA_DOUBLE
+ }
+ }
+ } else {
+ if (LIBC_UNLIKELY(x_u == 0x3efd'81adU)) // x = 0x1.fb035ap-2f
+ return fputil::round_result_slightly_up(0x1.9bddc2p-2f);
#endif // !LIBC_MATH_HAS_SKIP_ACCURATE_PASS
+ }
- // Polymial generated by Sollya with:
- // > fpminimax(log(1 + x)/x, 7, [|D...|], [-2^-6; 2^-6]);
- const double COEFFS[7] = {-0x1.0000000000000p-1, 0x1.5555555556aadp-2,
- -0x1.000000000181ap-2, 0x1.999998998124ep-3,
- -0x1.55555452e2a2bp-3, 0x1.24adb8cde4aa7p-3,
- -0x1.0019db915ef6fp-3};
-
- double xsq = xd * xd;
- double c0 = fputil::multiply_add(xd, COEFFS[1], COEFFS[0]);
- double c1 = fputil::multiply_add(xd, COEFFS[3], COEFFS[2]);
- double c2 = fputil::multiply_add(xd, COEFFS[5], COEFFS[4]);
- double r = fputil::polyeval(xsq, xd, c0, c1, c2, COEFFS[6]);
-
+ double r = acoshf_internal::log_eval(xd + 1.0);
return static_cast<float>(r);
}
diff --git a/libc/test/src/math/acoshf_test.cpp b/libc/test/src/math/acoshf_test.cpp
index d846e484a3d6e..45900aed18b32 100644
--- a/libc/test/src/math/acoshf_test.cpp
+++ b/libc/test/src/math/acoshf_test.cpp
@@ -56,19 +56,24 @@ TEST_F(LlvmLibcAcoshfTest, InFloatRange) {
}
TEST_F(LlvmLibcAcoshfTest, SpecificBitPatterns) {
- constexpr int N = 12;
+ constexpr int N = 17;
constexpr uint32_t INPUTS[N] = {
0x3f800000, // x = 1.0f
0x45abaf26, // x = 0x1.575e4cp12f
+ 0x45dc6414, // x = 0x1.b8c828p12f
0x49d29048, // x = 0x1.a5209p20f
0x4bdd65a5, // x = 0x1.bacb4ap24f
0x4c803f2c, // x = 0x1.007e58p26f
0x4f8ffb03, // x = 0x1.1ff606p32f
0x5c569e88, // x = 0x1.ad3d1p57f
0x5e68984e, // x = 0x1.d1309cp61f
+ 0x62f7a05a, // x = 0x1.ef40b4p70f
0x655890d3, // x = 0x1.b121a6p75f
0x65de7ca6, // x = 0x1.bcf94cp76f
0x6eb1a8ec, // x = 0x1.6351d8p94f
+ 0x71699003, // x = 0x1.d32006p99f
+ 0x76be09de, // x = 0x1.7c13bcp110f
+ 0x7967ec37, // x = 0x1.cfd86ep115f
0x7997f30a, // x = 0x1.2fe614p116f
};
diff --git a/libc/test/src/math/asinhf_test.cpp b/libc/test/src/math/asinhf_test.cpp
index c3c43eb931c0c..361362bac3f8a 100644
--- a/libc/test/src/math/asinhf_test.cpp
+++ b/libc/test/src/math/asinhf_test.cpp
@@ -57,18 +57,24 @@ TEST_F(LlvmLibcAsinhfTest, InFloatRange) {
}
TEST_F(LlvmLibcAsinhfTest, SpecificBitPatterns) {
- constexpr int N = 11;
+ constexpr int N = 17;
constexpr uint32_t INPUTS[N] = {
0x45abaf26, // |x| = 0x1.575e4cp12f
+ 0x45e19b90, // |x| = 0x1.c3372p12f
0x49d29048, // |x| = 0x1.a5209p20f
0x4bdd65a5, // |x| = 0x1.bacb4ap24f
0x4c803f2c, // |x| = 0x1.007e58p26f
0x4f8ffb03, // |x| = 0x1.1ff606p32f
+ 0x58719e31, // |x| = 0x1.e33c62p49f
0x5c569e88, // |x| = 0x1.ad3d1p57f
0x5e68984e, // |x| = 0x1.d1309cp61f
+ 0x62f7a05a, // |x| = 0x1.ef40b4p70f
0x655890d3, // |x| = 0x1.b121a6p75f
0x65de7ca6, // |x| = 0x1.bcf94cp76f
0x6eb1a8ec, // |x| = 0x1.6351d8p94f
+ 0x71699003, // |x| = 0x1.d32006p99f
+ 0x76be09de, // |x| = 0x1.7c13bcp110f
+ 0x7967ec37, // |x| = 0x1.cfd86ep115f
0x7997f30a, // |x| = 0x1.2fe614p116f
};
diff --git a/libc/test/src/math/log1pf_test.cpp b/libc/test/src/math/log1pf_test.cpp
index ef61f5ae41b1a..b3ac3dbf3ae08 100644
--- a/libc/test/src/math/log1pf_test.cpp
+++ b/libc/test/src/math/log1pf_test.cpp
@@ -36,7 +36,7 @@ TEST_F(LlvmLibcLog1pfTest, SpecialNumbers) {
}
TEST_F(LlvmLibcLog1pfTest, TrickyInputs) {
- constexpr int N = 27;
+ constexpr int N = 28;
constexpr uint32_t INPUTS[N] = {
0x35c00006U, /*0x1.80000cp-20f*/
0x35400003U, /*0x1.800006p-21f*/
@@ -51,6 +51,7 @@ TEST_F(LlvmLibcLog1pfTest, TrickyInputs) {
0x3efd81adU, /*0x1.fb035ap-2f*/
0x41078febU, /*0x1.0f1fd6p+3f*/
0x4cc1c80bU, /*0x1.839016p+26f*/
+ 0x55185f82U, /*0x1.30bf04p+43f*/
0x5cd69e88U, /*0x1.ad3d1p+58f*/
0x5ee8984eU, /*0x1.d1309cp+62f*/
0x65d890d3U, /*0x1.b121a6p+76f*/
@@ -81,6 +82,6 @@ TEST_F(LlvmLibcLog1pfTest, InFloatRange) {
if (FPBits(v).is_nan() || FPBits(v).is_inf())
continue;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
- LIBC_NAMESPACE::log1pf(x), 0.5);
+ LIBC_NAMESPACE::log1pf(x), TOLERANCE + 0.5);
}
}
More information about the libc-commits
mailing list