1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// Double-precision implementation of log1pf.
11///
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIBC_SRC___SUPPORT_MATH_LOG1PF_DOUBLE_EVAL_H
15#define LLVM_LIBC_SRC___SUPPORT_MATH_LOG1PF_DOUBLE_EVAL_H
16
17#include "src/__support/FPUtil/FEnvImpl.h"
18#include "src/__support/FPUtil/FPBits.h"
19#include "src/__support/FPUtil/except_value_utils.h"
20#include "src/__support/FPUtil/multiply_add.h"
21#include "src/__support/common.h"
22#include "src/__support/macros/config.h"
23#include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
24#include "src/__support/macros/properties/cpu_features.h"
25#include "src/__support/math/acoshf_utils.h"
26
27// This is an algorithm for log(1+x) in single precision which is
28// correctly rounded for all rounding modes.
29// - An exhaustive test show that when x >= 2^45, log1pf(x) == logf(x)
30// for all rounding modes.
31// - When 2^(-6) <= |x| < 2^45, the sum (double(x) + 1.0) is exact,
32// so we can adapt the correctly rounded algorithm of logf to compute
33// log(double(x) + 1.0) correctly. For more information about the logf
34// algorithm, see `libc/src/math/generic/logf.cpp`.
35// - When |x| < 2^(-6), we use a degree-8 polynomial in double precision
36// generated with Sollya using the following command:
37// fpminimax(log(1 + x)/x, 7, [|D...|], [-2^-6; 2^-6]);
38
39namespace LIBC_NAMESPACE_DECL {
40namespace math {
41namespace double_eval {
42
43LIBC_INLINE float log1pf(float x) {
44 using FPBits = typename fputil::FPBits<float>;
45 FPBits xbits(x);
46 uint32_t x_u = xbits.uintval();
47 uint32_t x_a = x_u & 0x7fff'ffffU;
48 double xd = static_cast<double>(x);
49
50 if (x_a <= 0x3c80'0000U) {
51 // |x| <= 2^-6.
52#ifndef LIBC_MATH_HAS_SKIP_ACCURATE_PASS
53 // Hard-to round cases.
54 switch (x_u) {
55 case 0x3540'0003U: // x = 0x1.800006p-21f
56 return fputil::round_result_slightly_down(value_rn: 0x1.7ffffep-21f);
57 case 0x3710'001bU: // x = 0x1.200036p-17f
58 return fputil::round_result_slightly_down(value_rn: 0x1.1fffe6p-17f);
59 case 0xb53f'fffdU: // x = -0x1.7ffffap-21
60 return fputil::round_result_slightly_down(value_rn: -0x1.800002p-21f);
61 case 0xb70f'ffe5U: // x = -0x1.1fffcap-17
62 return fputil::round_result_slightly_down(value_rn: -0x1.20001ap-17f);
63 case 0xbb0e'c8c4U: // x = -0x1.1d9188p-9
64 return fputil::round_result_slightly_up(value_rn: -0x1.1de14ap-9f);
65 }
66#endif // !LIBC_MATH_HAS_SKIP_ACCURATE_PASS
67
68 // Polynomial generated by Sollya with:
69 // > P = fpminimax(log(1 + x)/x, 7, [|D...|], [-2^-6; 2^-6]);
70 // > dirtyinfnorm((log(1 + x) - x*P)/log(1 + x), [-2^-6, 2^-6]);
71 // 0x1.1447755e54a327941f7db7316f8dcd7cf33d15ffp-58
72 constexpr double COEFFS[7] = {-0x1.0000000000000p-1, 0x1.5555555556aadp-2,
73 -0x1.000000000181ap-2, 0x1.999998998124ep-3,
74 -0x1.55555452e2a2bp-3, 0x1.24adb8cde4aa7p-3,
75 -0x1.0019db915ef6fp-3};
76
77 double xsq = xd * xd;
78 double c0 = fputil::multiply_add(x: xd, y: COEFFS[1], z: COEFFS[0]);
79 double c1 = fputil::multiply_add(x: xd, y: COEFFS[3], z: COEFFS[2]);
80 double c2 = fputil::multiply_add(x: xd, y: COEFFS[5], z: COEFFS[4]);
81 double x4 = xsq * xsq;
82 double d0 = fputil::multiply_add(x: xsq, y: c1, z: c0);
83 double d1 = fputil::multiply_add(x: xsq, y: COEFFS[6], z: c2);
84 double d2 = fputil::multiply_add(x: x4, y: d1, z: d0);
85 double r = fputil::multiply_add(x: xsq, y: d2, z: xd);
86
87 return static_cast<float>(r);
88 }
89
90 // Use log1p(x) = log(1 + x) for |x| > 2^-6;
91
92 // Check for exceptional cases.
93 if (x_a >= 0x3f80'0000) {
94 // |x| >= 1.
95 if (LIBC_UNLIKELY(x_u >= 0x7f80'0000)) {
96 // x is inf, nan, or x <= -1.
97 if (x == -1.0f) {
98 // x = -1
99 fputil::set_errno_if_required(ERANGE);
100 fputil::raise_except_if_required(FE_DIVBYZERO);
101 return FPBits::inf(sign: Sign::NEG).get_val();
102 }
103 if (xbits.is_signaling_nan() || x < 1.0f) {
104 // x is signaling NaNs or x < -1
105 if (x < 1.0f)
106 fputil::set_errno_if_required(EDOM);
107 fputil::raise_except_if_required(FE_INVALID);
108 return fputil::FPBits<float>::quiet_nan().get_val();
109 }
110 // x is +inf or quiet NaN
111 return x;
112 }
113#ifndef LIBC_MATH_HAS_SKIP_ACCURATE_PASS
114 // Filter hard-to-round cases:
115 if (LIBC_UNLIKELY(x >= 0x1.30bf04p+43f)) {
116 switch (x_u) {
117 case 0x5518'5f82U: // x = 0x1.30bf04p+43f
118 return fputil::round_result_slightly_up(value_rn: 0x1.dfac9p+4f);
119 case 0x5cd6'9e88U: // x = 0x1.ad3d1p+58f
120 return fputil::round_result_slightly_up(value_rn: 0x1.45c146p+5f);
121 case 0x5ee8'984eU: // x = 0x1.d1309cp+62f
122 return fputil::round_result_slightly_up(value_rn: 0x1.5c9442p+5f);
123 case 0x65d8'90d3U: // x = 0x1.b121a6p+76f
124 return fputil::round_result_slightly_down(value_rn: 0x1.a9a3f2p+5f);
125 case 0x6f31'a8ecU: // x = 0x1.6351d8p+95f
126 return fputil::round_result_slightly_down(value_rn: 0x1.08b512p+6f);
127 case 0x7a17'f30aU: // x = 0x1.2fe614p+117f
128 return fputil::round_result_slightly_up(value_rn: 0x1.451436p+6f);
129#ifndef LIBC_TARGET_CPU_HAS_FMA_DOUBLE
130 case 0x58f1'9e31U: // x = 0x1.e33c62p+50f
131 return fputil::round_result_slightly_down(value_rn: 0x1.1a576cp+5f);
132 case 0x665e'7ca6U: // x = 0x1.bcf94cp+77f
133 return fputil::round_result_slightly_up(value_rn: 0x1.af66cp+5f);
134 case 0x79e7'ec37U: // x = 0x1.cfd86ep+116f
135 return fputil::round_result_slightly_up(value_rn: 0x1.43ff6ep+6f);
136#endif // LIBC_TARGET_CPU_HAS_FMA_DOUBLE
137 }
138 }
139 } else {
140 if (LIBC_UNLIKELY(x_u == 0x3efd'81adU)) // x = 0x1.fb035ap-2f
141 return fputil::round_result_slightly_up(value_rn: 0x1.9bddc2p-2f);
142#endif // !LIBC_MATH_HAS_SKIP_ACCURATE_PASS
143 }
144
145 double r = acoshf_internal::log_eval(x: xd + 1.0);
146 return static_cast<float>(r);
147}
148
149} // namespace double_eval
150} // namespace math
151} // namespace LIBC_NAMESPACE_DECL
152
153#endif // LLVM_LIBC_SRC___SUPPORT_MATH_LOG1PF_DOUBLE_EVAL_H
154