1//===-- Implementation header for lgammaf -----------------------*- C++ -*-===//
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#ifndef LLVM_LIBC_SRC___SUPPORT_MATH_LGAMMAF_H
10#define LLVM_LIBC_SRC___SUPPORT_MATH_LGAMMAF_H
11
12#include "hdr/errno_macros.h"
13#include "hdr/fenv_macros.h"
14#include "hdr/stdint_proxy.h"
15#include "src/__support/FPUtil/FEnvImpl.h"
16#include "src/__support/FPUtil/FPBits.h"
17#include "src/__support/FPUtil/NearestIntegerOperations.h"
18#include "src/__support/FPUtil/cast.h"
19#include "src/__support/FPUtil/except_value_utils.h"
20#include "src/__support/FPUtil/is_integer.h"
21#include "src/__support/FPUtil/multiply_add.h"
22#include "src/__support/macros/attributes.h"
23#include "src/__support/macros/config.h"
24#include "src/__support/macros/optimization.h"
25#include "src/__support/math/gamma_util.h"
26#include "src/__support/math/log.h"
27
28namespace LIBC_NAMESPACE_DECL {
29
30namespace math {
31
32namespace lgammaf_internal {
33
34// P_M2(d), d = t - 1.5, approximates lgamma(t)/((t-1)(t-2)) on [1, 2].
35// Degree 18 centered-monomial coefficients from a 250-bit Chebyshev fit,
36// max relative error 2^-51.6
37LIBC_INLINE double lgamma_m2_poly(double d) {
38 constexpr double POLY_M2[19] = {
39 0x1.eeb95b094c191p-2, -0x1.2aed059bd613dp-3, 0x1.01af62a292eb9p-4,
40 -0x1.007aa83cc458bp-5, 0x1.13342351db068p-6, -0x1.34dbda42244dep-7,
41 0x1.64f066cf96646p-8, -0x1.a5033bab00972p-9, 0x1.f814855fdfeb8p-10,
42 -0x1.31418be9f2e14p-10, 0x1.7510b1d1fa536p-11, -0x1.caccf4395927bp-12,
43 0x1.1c0d19e4fef05p-12, -0x1.67d43c4be68f7p-13, 0x1.c3d6281f9ac35p-14,
44 -0x1.dd9e09255e712p-15, 0x1.2550c8f33e895p-15, -0x1.6cd0f980284cbp-15,
45 0x1.dbd1c21b8dfa7p-16};
46 double d2 = d * d, d4 = d2 * d2, d8 = d4 * d4, d16 = d8 * d8;
47 double p01 = fputil::multiply_add(x: d, y: POLY_M2[1], z: POLY_M2[0]);
48 double p23 = fputil::multiply_add(x: d, y: POLY_M2[3], z: POLY_M2[2]);
49 double p45 = fputil::multiply_add(x: d, y: POLY_M2[5], z: POLY_M2[4]);
50 double p67 = fputil::multiply_add(x: d, y: POLY_M2[7], z: POLY_M2[6]);
51 double p89 = fputil::multiply_add(x: d, y: POLY_M2[9], z: POLY_M2[8]);
52 double p1011 = fputil::multiply_add(x: d, y: POLY_M2[11], z: POLY_M2[10]);
53 double p1213 = fputil::multiply_add(x: d, y: POLY_M2[13], z: POLY_M2[12]);
54 double p1415 = fputil::multiply_add(x: d, y: POLY_M2[15], z: POLY_M2[14]);
55 double p1617 = fputil::multiply_add(x: d, y: POLY_M2[17], z: POLY_M2[16]);
56 double q03 = fputil::multiply_add(x: d2, y: p23, z: p01);
57 double q47 = fputil::multiply_add(x: d2, y: p67, z: p45);
58 double q811 = fputil::multiply_add(x: d2, y: p1011, z: p89);
59 double q1215 = fputil::multiply_add(x: d2, y: p1415, z: p1213);
60 double q1618 = fputil::multiply_add(x: d2, y: POLY_M2[18], z: p1617);
61 double r07 = fputil::multiply_add(x: d4, y: q47, z: q03);
62 double r815 = fputil::multiply_add(x: d4, y: q1215, z: q811);
63 double s015 = fputil::multiply_add(x: d8, y: r815, z: r07);
64 return fputil::multiply_add(x: d16, y: q1618, z: s015);
65}
66
67} // namespace lgammaf_internal
68
69LIBC_INLINE float lgammaf(float x) {
70 using namespace gamma_internal;
71 using namespace lgammaf_internal;
72 using FPBits = fputil::FPBits<float>;
73
74 FPBits xbits(x);
75 uint32_t x_abs = xbits.abs().uintval();
76
77 // NaN / Inf
78 if (LIBC_UNLIKELY(x_abs >= 0x7f800000u)) {
79 if (x_abs == 0x7f800000u)
80 return FPBits::inf().get_val();
81 if (xbits.is_signaling_nan()) {
82 fputil::raise_except_if_required(FE_INVALID);
83 return FPBits::quiet_nan().get_val();
84 }
85 return x;
86 }
87
88 // +/- 0 -> +Inf pole
89 if (LIBC_UNLIKELY(x_abs == 0)) {
90 fputil::raise_except_if_required(FE_DIVBYZERO);
91 fputil::set_errno_if_required(ERANGE);
92 return FPBits::inf().get_val();
93 }
94
95 // Negative integers and lgamma(1) = lgamma(2) = 0.
96 if (LIBC_UNLIKELY(fputil::is_integer(x))) {
97 if (xbits.is_neg()) {
98 fputil::raise_except_if_required(FE_DIVBYZERO);
99 fputil::set_errno_if_required(ERANGE);
100 return FPBits::inf().get_val();
101 }
102 if (x_abs == 0x3f800000u || x_abs == 0x40000000u)
103 return FPBits::zero().get_val();
104 }
105
106 double xd = fputil::cast<double>(x);
107 double abs_xd = xd < 0.0 ? -xd : xd;
108 double lgamma_val;
109
110 // For very tiny |x| (< 2^-23), use the truncated Laurent series:
111 // lgamma(x) = -log(x) - gamma*x + O(x^2) for tiny x > 0
112 // lgamma(-y) = -log(y) + gamma*y + O(y^2) for tiny y > 0
113 // Even though gamma*|x| < 2^-25 is below 1 float ULP of |result|, it tips
114 // rounding at boundary cases. The x^2 term is at most gamma*2^-46 << 2^-50.
115 if (x_abs < 0x34000000u) { // |x| < 2^-23
116 constexpr fputil::ExceptValues<float, 4> LGAMMAF_EXCEPTS_TINY{.values: {
117 // input, toward-zero result, RU, RD, RN
118 {.input: 0x9b7679ffu, .rnd_towardzero_result: 0x4247c72cu, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 1},
119 {.input: 0x9e88452du, .rnd_towardzero_result: 0x4236bd8bu, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 1},
120 {.input: 0xa77a8e47u, .rnd_towardzero_result: 0x42052b94u, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 1},
121 {.input: 0xb0e17820u, .rnd_towardzero_result: 0x41a1d37bu, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 0},
122 }};
123 if (auto r = LGAMMAF_EXCEPTS_TINY.lookup(x_bits: xbits.uintval());
124 LIBC_UNLIKELY(r.has_value()))
125 return r.value();
126 constexpr double EULER_GAMMA = 0x1.2788cfc6fb619p-1;
127 double sign_corr = xbits.is_neg() ? EULER_GAMMA : -EULER_GAMMA;
128 return fputil::cast<float>(
129 x: fputil::multiply_sub(x: sign_corr, y: abs_xd, z: math::log(x: abs_xd)));
130 }
131
132 if (x_abs < 0x3f290000u) {
133 if (xbits.is_neg()) {
134 // Small negative: x in (-0.66015625, -2^-23). Degree-25 monomial fit
135 // of g(x) = (lgamma(x) + log(-x)) / x (smooth on [-0.66, 0]), then
136 // lgamma(x) = x*g(x) - log(-x). d = x - MID is exact.
137 constexpr double MID_SN = -0x1.5200000000000p-2;
138 constexpr double POLY_SN[26] = {
139 -0x1.cf99908bbb1d7p-1, 0x1.386ced0346de0p+0, -0x1.d0b4c2d337e0fp-1,
140 0x1.db2dcaaa022a9p-1, -0x1.1188790a072bap+0, 0x1.4e50420966212p+0,
141 -0x1.a787465391482p+0, 0x1.12d6375bce19ep+1, -0x1.6b05729f76a9cp+1,
142 0x1.e602a94d73479p+1, -0x1.48d5f84ddbdefp+2, 0x1.c0e7f7d05fe6dp+2,
143 -0x1.34d52338a0d93p+3, 0x1.ab7e04eff787dp+3, -0x1.2724d2ace1c81p+4,
144 0x1.9b17bee5ae20ap+4, -0x1.34beabd4deff5p+5, 0x1.bc510ff62dcf0p+5,
145 -0x1.7406b7594b6ddp+5, 0x1.b97b7265194a1p+5, -0x1.5e2ba44fee700p+8,
146 0x1.18310d7d43c46p+9, 0x1.59472c8ca4419p+9, -0x1.2a61147e20ef1p+10,
147 -0x1.7cfcf784946edp+11, 0x1.2436ec1277b00p+12};
148 double d = xd - MID_SN;
149 double d2 = d * d, d4 = d2 * d2, d8 = d4 * d4, d16 = d8 * d8;
150 double p01 = fputil::multiply_add(x: d, y: POLY_SN[1], z: POLY_SN[0]);
151 double p23 = fputil::multiply_add(x: d, y: POLY_SN[3], z: POLY_SN[2]);
152 double p45 = fputil::multiply_add(x: d, y: POLY_SN[5], z: POLY_SN[4]);
153 double p67 = fputil::multiply_add(x: d, y: POLY_SN[7], z: POLY_SN[6]);
154 double p89 = fputil::multiply_add(x: d, y: POLY_SN[9], z: POLY_SN[8]);
155 double p1011 = fputil::multiply_add(x: d, y: POLY_SN[11], z: POLY_SN[10]);
156 double p1213 = fputil::multiply_add(x: d, y: POLY_SN[13], z: POLY_SN[12]);
157 double p1415 = fputil::multiply_add(x: d, y: POLY_SN[15], z: POLY_SN[14]);
158 double p1617 = fputil::multiply_add(x: d, y: POLY_SN[17], z: POLY_SN[16]);
159 double p1819 = fputil::multiply_add(x: d, y: POLY_SN[19], z: POLY_SN[18]);
160 double p2021 = fputil::multiply_add(x: d, y: POLY_SN[21], z: POLY_SN[20]);
161 double p2223 = fputil::multiply_add(x: d, y: POLY_SN[23], z: POLY_SN[22]);
162 double p2425 = fputil::multiply_add(x: d, y: POLY_SN[25], z: POLY_SN[24]);
163 double q03 = fputil::multiply_add(x: d2, y: p23, z: p01);
164 double q47 = fputil::multiply_add(x: d2, y: p67, z: p45);
165 double q811 = fputil::multiply_add(x: d2, y: p1011, z: p89);
166 double q1215 = fputil::multiply_add(x: d2, y: p1415, z: p1213);
167 double q1619 = fputil::multiply_add(x: d2, y: p1819, z: p1617);
168 double q2023 = fputil::multiply_add(x: d2, y: p2223, z: p2021);
169 double r07 = fputil::multiply_add(x: d4, y: q47, z: q03);
170 double r815 = fputil::multiply_add(x: d4, y: q1215, z: q811);
171 double r1623 = fputil::multiply_add(x: d4, y: q2023, z: q1619);
172 double s015 = fputil::multiply_add(x: d8, y: r815, z: r07);
173 double s1625 = fputil::multiply_add(x: d8, y: p2425, z: r1623);
174 double poly_g = fputil::multiply_add(x: d16, y: s1625, z: s015);
175 // lgamma(x) = x*g(x) - log(-x) with single rounding via FMA.
176 lgamma_val = fputil::multiply_sub(x: xd, y: poly_g, z: math::log(x: abs_xd));
177 } else {
178 // x = 0x1.f8a754p-9f
179 if (LIBC_UNLIKELY(xbits.uintval() == 0x3b7c53aau))
180 return fputil::round_result_slightly_up(value_rn: 0x1.63acc2p+2f);
181 // Small: t = x < 0.66015625. Degree-17 monomial fit of
182 // h(t) = (lgamma(t) + log(t)) / t (smooth on [0, 0.66]).
183 // d = t - MID is exact.
184 constexpr double MID_S = 0x1.5200000000000p-2;
185 constexpr double POLY_S[18] = {
186 -0x1.5dcd7586bfd88p-2, 0x1.3f88851c787c3p-1, -0x1.cdfaca3081737p-3,
187 0x1.cfac7b321198bp-4, -0x1.0939a239f89b2p-4, 0x1.44cddc5f52a43p-5,
188 -0x1.9e4cc54acdcebp-6, 0x1.0f61691962355p-6, -0x1.6a429a6c89071p-7,
189 0x1.ea573d148429cp-8, -0x1.4f6ad0c206ae6p-8, 0x1.cedaf9fc19cb5p-9,
190 -0x1.42333c4e88f7dp-9, 0x1.c2a0e3ffc858fp-10, -0x1.32153d4cb9316p-10,
191 0x1.add42f56d3c7ap-11, -0x1.972ff2b1a91edp-11, 0x1.25f56c66e3049p-11};
192 double d = abs_xd - MID_S;
193 double d2 = d * d, d4 = d2 * d2, d8 = d4 * d4, d16 = d8 * d8;
194 double p01 = fputil::multiply_add(x: d, y: POLY_S[1], z: POLY_S[0]);
195 double p23 = fputil::multiply_add(x: d, y: POLY_S[3], z: POLY_S[2]);
196 double p45 = fputil::multiply_add(x: d, y: POLY_S[5], z: POLY_S[4]);
197 double p67 = fputil::multiply_add(x: d, y: POLY_S[7], z: POLY_S[6]);
198 double p89 = fputil::multiply_add(x: d, y: POLY_S[9], z: POLY_S[8]);
199 double p1011 = fputil::multiply_add(x: d, y: POLY_S[11], z: POLY_S[10]);
200 double p1213 = fputil::multiply_add(x: d, y: POLY_S[13], z: POLY_S[12]);
201 double p1415 = fputil::multiply_add(x: d, y: POLY_S[15], z: POLY_S[14]);
202 double p1617 = fputil::multiply_add(x: d, y: POLY_S[17], z: POLY_S[16]);
203 double q03 = fputil::multiply_add(x: d2, y: p23, z: p01);
204 double q47 = fputil::multiply_add(x: d2, y: p67, z: p45);
205 double q811 = fputil::multiply_add(x: d2, y: p1011, z: p89);
206 double q1215 = fputil::multiply_add(x: d2, y: p1415, z: p1213);
207 double r07 = fputil::multiply_add(x: d4, y: q47, z: q03);
208 double r815 = fputil::multiply_add(x: d4, y: q1215, z: q811);
209 double s015 = fputil::multiply_add(x: d8, y: r815, z: r07);
210 double poly_h = fputil::multiply_add(x: d16, y: p1617, z: s015);
211 // poly_val - log(abs_xd) with single rounding via FMA.
212 lgamma_val = fputil::multiply_sub(x: abs_xd, y: poly_h, z: math::log(x: abs_xd));
213 }
214 } else if (x_abs < 0x3f800000u) {
215 if (xbits.is_neg()) {
216 // x in (-1, -0.66015625]: Gamma(x) = Gamma(x+2)/(x(x+1)), so
217 // lgamma(x) = x(x+1)*P_M2(x+0.5) - log(-x(x+1)). x+0.5 and x+1 are
218 // exact (Sterbenz); x(x+1) = (t-1)(t-2) is the M2 prefactor.
219 double w = xd * (xd + 1.0);
220 double poly = lgamma_m2_poly(d: xd + 0.5);
221 lgamma_val = fputil::multiply_sub(x: w, y: poly, z: lg_ln(x: -w));
222 } else {
223 // M1: t in [0.66015625, 1.0). lgamma(t) = (t-1) * P_M1(d), d = t - MID.
224 // Degree-14 monomial fit of lgamma(t)/(t-1), max error 2^-51.3.
225 constexpr double MID_M1 = 0x1.a900000000000p-1;
226 constexpr double POLY_M1[15] = {
227 -0x1.75cb89aad8dc7p-1, 0x1.f958114ec790dp-1, -0x1.2b968b172a05cp-1,
228 0x1.eaf0e2c8dc49fp-2, -0x1.c6efb493bfadfp-2, 0x1.c0a621f0e593ep-2,
229 -0x1.cb2416349da49p-2, 0x1.e19328033256dp-2, -0x1.010d0c64743f5p-1,
230 0x1.162e14c80bdc9p-1, -0x1.3034dec6eb9a3p-1, 0x1.4ca601da8405ep-1,
231 -0x1.70f73638718d4p-1, 0x1.ded7569ab5a36p-1, -0x1.0fdd39040adfbp+0};
232 double d = abs_xd - MID_M1;
233 double d2 = d * d, d4 = d2 * d2, d8 = d4 * d4;
234 double p01 = fputil::multiply_add(x: d, y: POLY_M1[1], z: POLY_M1[0]);
235 double p23 = fputil::multiply_add(x: d, y: POLY_M1[3], z: POLY_M1[2]);
236 double p45 = fputil::multiply_add(x: d, y: POLY_M1[5], z: POLY_M1[4]);
237 double p67 = fputil::multiply_add(x: d, y: POLY_M1[7], z: POLY_M1[6]);
238 double p89 = fputil::multiply_add(x: d, y: POLY_M1[9], z: POLY_M1[8]);
239 double p1011 = fputil::multiply_add(x: d, y: POLY_M1[11], z: POLY_M1[10]);
240 double p1213 = fputil::multiply_add(x: d, y: POLY_M1[13], z: POLY_M1[12]);
241 double q03 = fputil::multiply_add(x: d2, y: p23, z: p01);
242 double q47 = fputil::multiply_add(x: d2, y: p67, z: p45);
243 double q811 = fputil::multiply_add(x: d2, y: p1011, z: p89);
244 double q1214 = fputil::multiply_add(x: d2, y: POLY_M1[14], z: p1213);
245 double r07 = fputil::multiply_add(x: d4, y: q47, z: q03);
246 double r814 = fputil::multiply_add(x: d4, y: q1214, z: q811);
247 double poly = fputil::multiply_add(x: d8, y: r814, z: r07);
248 lgamma_val = (abs_xd - 1.0) * poly;
249 }
250 } else if (x_abs < 0x40000000u) {
251 if (xbits.is_neg()) {
252 // x in (-2, -1): Gamma(x) = Gamma(x+3)/(x(x+1)(x+2)), so
253 // lgamma(x) = (x+1)(x+2)*P_M2(x+1.5) - log(x(x+1)(x+2)). The shifts
254 // are exact (Sterbenz); (x+1)(x+2) = (t-1)(t-2) is the M2 prefactor.
255 double u = (xd + 1.0) * (xd + 2.0);
256 double poly = lgamma_m2_poly(d: xd + 1.5);
257 lgamma_val = fputil::multiply_sub(x: u, y: poly, z: lg_ln(x: xd * u));
258 } else {
259 // M2: t in [1.0, 2.0). lgamma(t) = (t-1)*(t-2) * P_M2(t - 1.5).
260 double d = abs_xd - 0x1.8p+0;
261 lgamma_val = (abs_xd - 1.0) * (abs_xd - 2.0) * lgamma_m2_poly(d);
262 }
263 } else if (x_abs < 0x4057e000u) {
264 // M3: t in [2.0, 3.373046875). lgamma(t) = (t-2) * P_M3(d), d = t - MID.
265 // Degree-15 monomial fit of lgamma(t)/(t-2), max error 2^-49.7.
266 constexpr double MID_M3 = 0x1.57e0000000000p+1;
267 constexpr double POLY_M3[16] = {
268 0x1.3c4e36a0b4775p-1, 0x1.01f945be1325fp-2, -0x1.4203a95730c77p-5,
269 0x1.227f82db7c7a1p-7, -0x1.32f092b6ec5a3p-9, 0x1.61df821ae7829p-11,
270 -0x1.aed17eeca55e6p-13, 0x1.100a8e7dcd62cp-14, -0x1.609aa16f960a0p-16,
271 0x1.d1e293fa801bbp-18, -0x1.38b436ce1b3b9p-19, 0x1.a838eec563338p-21,
272 -0x1.1a6a9cf4aee4bp-22, 0x1.8387c2a068b06p-24, -0x1.5ee6ae8c133f7p-25,
273 0x1.f195cf3f4b24ep-27};
274 if (!xbits.is_neg()) {
275 double d = abs_xd - MID_M3;
276 double d2 = d * d, d4 = d2 * d2, d8 = d4 * d4;
277 double p01 = fputil::multiply_add(x: d, y: POLY_M3[1], z: POLY_M3[0]);
278 double p23 = fputil::multiply_add(x: d, y: POLY_M3[3], z: POLY_M3[2]);
279 double p45 = fputil::multiply_add(x: d, y: POLY_M3[5], z: POLY_M3[4]);
280 double p67 = fputil::multiply_add(x: d, y: POLY_M3[7], z: POLY_M3[6]);
281 double p89 = fputil::multiply_add(x: d, y: POLY_M3[9], z: POLY_M3[8]);
282 double p1011 = fputil::multiply_add(x: d, y: POLY_M3[11], z: POLY_M3[10]);
283 double p1213 = fputil::multiply_add(x: d, y: POLY_M3[13], z: POLY_M3[12]);
284 double p1415 = fputil::multiply_add(x: d, y: POLY_M3[15], z: POLY_M3[14]);
285 double q03 = fputil::multiply_add(x: d2, y: p23, z: p01);
286 double q47 = fputil::multiply_add(x: d2, y: p67, z: p45);
287 double q811 = fputil::multiply_add(x: d2, y: p1011, z: p89);
288 double q1215 = fputil::multiply_add(x: d2, y: p1415, z: p1213);
289 double r07 = fputil::multiply_add(x: d4, y: q47, z: q03);
290 double r815 = fputil::multiply_add(x: d4, y: q1215, z: q811);
291 double poly = fputil::multiply_add(x: d8, y: r815, z: r07);
292 lgamma_val = (abs_xd - 2.0) * poly;
293 } else {
294 // Near the regular lgamma zero at x ~= -2.7475: subtractive cancellation
295 // in the reflection formula kills precision. Use a Taylor expansion
296 // centered at the zero. Range bits in (0x402f95c2, 0x40301b93).
297 // Coefficients adopted from CORE-MATH (Sibidanov, 2023).
298 if (LIBC_UNLIKELY(x_abs > 0x402f95c2u && x_abs < 0x40301b93u)) {
299 double h = (xd + 0x1.5fb410a1bd901p+1) - 0x1.a19a96d2e6f85p-54;
300 constexpr double C[8] = {-0x1.ea12da904b18cp+0, 0x1.3267f3c265a54p+3,
301 -0x1.4185ac30cadb3p+4, 0x1.f504accc3f2e4p+5,
302 -0x1.8588444c679b4p+7, 0x1.43740491dc22p+9,
303 -0x1.12400ea23f9e6p+11, 0x1.dac829f365795p+12};
304 double h2 = h * h, h4 = h2 * h2;
305 double p01 = fputil::multiply_add(x: h, y: C[1], z: C[0]);
306 double p23 = fputil::multiply_add(x: h, y: C[3], z: C[2]);
307 double p45 = fputil::multiply_add(x: h, y: C[5], z: C[4]);
308 double p67 = fputil::multiply_add(x: h, y: C[7], z: C[6]);
309 double p03 = fputil::multiply_add(x: h2, y: p23, z: p01);
310 double p47 = fputil::multiply_add(x: h2, y: p67, z: p45);
311 lgamma_val = h * fputil::multiply_add(x: h4, y: p47, z: p03);
312 } else if (LIBC_UNLIKELY(x_abs > 0x401ceccbu && x_abs < 0x401d95cau)) {
313 // Near the regular lgamma zero at x ~= -2.3614: same issue
314 double h = (xd + 0x1.3a7fc9600f86cp+1) + 0x1.55f64f98af8dp-55;
315 constexpr double C[7] = {0x1.83fe966af535fp+0, 0x1.36eebb002f61ap+2,
316 0x1.694a60589a0b3p+0, 0x1.1718d7aedb0b5p+3,
317 0x1.733a045eca0d3p+2, 0x1.8d4297421205bp+4,
318 0x1.7feea5fb29965p+4};
319 double h2 = h * h, h4 = h2 * h2;
320 double p01 = fputil::multiply_add(x: h, y: C[1], z: C[0]);
321 double p23 = fputil::multiply_add(x: h, y: C[3], z: C[2]);
322 double p45 = fputil::multiply_add(x: h, y: C[5], z: C[4]);
323 double p46 = fputil::multiply_add(x: h2, y: C[6], z: p45);
324 double p03 = fputil::multiply_add(x: h2, y: p23, z: p01);
325 lgamma_val = h * fputil::multiply_add(x: h4, y: p46, z: p03);
326 } else if (LIBC_UNLIKELY(x_abs > 0x40492009u && x_abs < 0x404940efu)) {
327 // Near the regular lgamma zero at x ~= -3.1431: same issue
328 double h = (xd + 0x1.9260dbc9e59afp+1) + 0x1.f717cd335a7b3p-53;
329 constexpr double C[7] = {0x1.f20a65f2fac55p+2, 0x1.9d4d297715105p+4,
330 0x1.c1137124d5b21p+6, 0x1.267203d24de38p+9,
331 0x1.99a63399a0b44p+11, 0x1.2941214faaf0cp+14,
332 0x1.bb912c0c9cdd1p+16};
333 double h2 = h * h, h4 = h2 * h2;
334 double p01 = fputil::multiply_add(x: h, y: C[1], z: C[0]);
335 double p23 = fputil::multiply_add(x: h, y: C[3], z: C[2]);
336 double p45 = fputil::multiply_add(x: h, y: C[5], z: C[4]);
337 double p46 = fputil::multiply_add(x: h2, y: C[6], z: p45);
338 double p03 = fputil::multiply_add(x: h2, y: p23, z: p01);
339 lgamma_val = h * fputil::multiply_add(x: h4, y: p46, z: p03);
340 } else {
341 // x in (-3.373, -2): Gamma(x) = Gamma(x+5)/(x(x+1)(x+2)(x+3)(x+4)),
342 // t = x+5 in (1.627, 3), so lgamma(x) = (x+3)*Q_M3N(d) - log|prod|
343 // with d = x + 2.6865234375 (exact). Q_M3N is a degree-17 monomial
344 // fit of lgamma(t)/(t-2) on [1.627, 3]; the (t-2) = x+3 prefactor
345 // removes the lgamma zero at t = 2.
346 constexpr double POLY_M3N[18] = {
347 0x1.091ff92b41f07p-1, 0x1.245eed13c42b0p-2,
348 -0x1.a6c3cf8a165cfp-5, 0x1.bc8d19a3ade02p-7,
349 -0x1.1231651010470p-8, 0x1.710f57a2abe2bp-10,
350 -0x1.061ddab9ab12cp-11, 0x1.81edb077ed799p-13,
351 -0x1.235fbc13dbf04p-14, 0x1.c02e6f8fb5dbfp-16,
352 -0x1.5d75e6a94d352p-17, 0x1.1384596ce083dp-18,
353 -0x1.b8da81a716039p-20, 0x1.61ac57fe0e288p-21,
354 -0x1.077101d536ad8p-22, 0x1.a59e2356ba870p-24,
355 -0x1.0cfcf8f102a43p-24, 0x1.c141a51f827f1p-26};
356 double d = xd + 0x1.57ep+1;
357 double d2 = d * d, d4 = d2 * d2, d8 = d4 * d4, d16 = d8 * d8;
358 double p01 = fputil::multiply_add(x: d, y: POLY_M3N[1], z: POLY_M3N[0]);
359 double p23 = fputil::multiply_add(x: d, y: POLY_M3N[3], z: POLY_M3N[2]);
360 double p45 = fputil::multiply_add(x: d, y: POLY_M3N[5], z: POLY_M3N[4]);
361 double p67 = fputil::multiply_add(x: d, y: POLY_M3N[7], z: POLY_M3N[6]);
362 double p89 = fputil::multiply_add(x: d, y: POLY_M3N[9], z: POLY_M3N[8]);
363 double p1011 = fputil::multiply_add(x: d, y: POLY_M3N[11], z: POLY_M3N[10]);
364 double p1213 = fputil::multiply_add(x: d, y: POLY_M3N[13], z: POLY_M3N[12]);
365 double p1415 = fputil::multiply_add(x: d, y: POLY_M3N[15], z: POLY_M3N[14]);
366 double p1617 = fputil::multiply_add(x: d, y: POLY_M3N[17], z: POLY_M3N[16]);
367 double q03 = fputil::multiply_add(x: d2, y: p23, z: p01);
368 double q47 = fputil::multiply_add(x: d2, y: p67, z: p45);
369 double q811 = fputil::multiply_add(x: d2, y: p1011, z: p89);
370 double q1215 = fputil::multiply_add(x: d2, y: p1415, z: p1213);
371 double r07 = fputil::multiply_add(x: d4, y: q47, z: q03);
372 double r815 = fputil::multiply_add(x: d4, y: q1215, z: q811);
373 double s015 = fputil::multiply_add(x: d8, y: r815, z: r07);
374 double poly = fputil::multiply_add(x: d16, y: p1617, z: s015);
375 double pa = xd * (xd + 1.0);
376 double pb = (xd + 2.0) * (xd + 3.0);
377 double prod = (pa * pb) * (xd + 4.0);
378 double aprod = prod < 0.0 ? -prod : prod;
379 lgamma_val = fputil::multiply_sub(x: xd + 3.0, y: poly, z: lg_ln(x: aprod));
380 }
381 }
382 } else {
383 // Large: |x| >= 3.373046875. Stirling + Bernoulli correction.
384 // lgamma(x) = (x-0.5)*log(x) - x + log(2*pi)/2 + (1/x)*P(1/x^2)
385 // = (x-0.5)*(log(x)-1) + STIR_CONST + (1/x)*P(1/x^2)
386 // STIR_CONST = log(2*pi)/2 - 0.5.
387 // For huge positive x, lgamma(x) overflows float.
388 if (LIBC_UNLIKELY(!xbits.is_neg() && x >= 0x1.895f1cp+121f))
389 return fputil::set_overflow<float>();
390
391 // No cancellation in (x-0.5)*(log(x)-1): log(x)-1 > 0.2 on this range.
392 // Relative error ~2^-48; anything closer to a rounding boundary is in
393 // the exceptional cases tables below.
394 double lz = lg_ln(x: abs_xd);
395 double xm = abs_xd - 0.5;
396 lgamma_val = fputil::multiply_add(x: xm, y: lz - 1.0, z: 0x1.acfe390c97d69p-2);
397
398 // For |x| >= 2^20 the 1/(12x) correction is below ~2^-47 of the result;
399 // skip it and the 1/x divide.
400 if (x_abs < 0x49800000u) {
401 double inv_x = 1.0 / abs_xd;
402 double inv_x2 = inv_x * inv_x;
403 if (x_abs > 0x44fa0000u) {
404 constexpr fputil::ExceptValues<float, 3> LGAMMAF_EXCEPTS_BERN2{.values: {
405 // input, toward-zero result, RU, RD, RN
406 {.input: 0x46541516u, .rnd_towardzero_result: 0x47e1c01bu, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 0},
407 {.input: 0x46b16323u, .rnd_towardzero_result: 0x48483adeu, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 1},
408 {.input: 0xc6f7e151u, .rnd_towardzero_result: 0xc89116deu, .rnd_upward_offset: 0, .rnd_downward_offset: 1, .rnd_tonearest_offset: 0},
409 }};
410 if (auto r = LGAMMAF_EXCEPTS_BERN2.lookup(x_bits: xbits.uintval());
411 LIBC_UNLIKELY(r.has_value()))
412 return r.value();
413 // |x| > 2000 -> 2-term BERN2.
414 constexpr double BERN2[2] = {0x1.5555555555555p-4,
415 -0x1.6c16bfb7c65a8p-9};
416 lgamma_val += inv_x * fputil::multiply_add(x: inv_x2, y: BERN2[1], z: BERN2[0]);
417 } else if (x_abs > 0x42920000u) {
418 // Exceptional cases of this range.
419 constexpr fputil::ExceptValues<float, 2> LGAMMAF_EXCEPTS_BERN4{.values: {
420 // input, toward-zero result, RU, RD, RN
421 {.input: 0x449acf07u, .rnd_towardzero_result: 0x45ecd680u, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 1},
422 {.input: 0xc33139a3u, .rnd_towardzero_result: 0xc43991afu, .rnd_upward_offset: 0, .rnd_downward_offset: 1, .rnd_tonearest_offset: 0},
423 }};
424 if (auto r = LGAMMAF_EXCEPTS_BERN4.lookup(x_bits: xbits.uintval());
425 LIBC_UNLIKELY(r.has_value()))
426 return r.value();
427 // |x| > 73 -> 4-term BERN4.
428 constexpr double BERN4[4] = {
429 0x1.5555555555555p-4, -0x1.6c16c16c15f75p-9, 0x1.a01a00593b36fp-11,
430 -0x1.37e91273668efp-11};
431 double inv_x4 = inv_x2 * inv_x2;
432 double p01 = fputil::multiply_add(x: inv_x2, y: BERN4[1], z: BERN4[0]);
433 double p23 = fputil::multiply_add(x: inv_x2, y: BERN4[3], z: BERN4[2]);
434 lgamma_val += inv_x * fputil::multiply_add(x: inv_x4, y: p23, z: p01);
435 } else {
436 // Exceptional cases of this range.
437 constexpr fputil::ExceptValues<float, 3> LGAMMAF_EXCEPTS_B10{.values: {
438 // input, toward-zero result, RU, RD, RN
439 {.input: 0x42468b59u, .rnd_towardzero_result: 0x430f25a7u, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 0},
440 {.input: 0xc0c82481u, .rnd_towardzero_result: 0xc0b2a995u, .rnd_upward_offset: 0, .rnd_downward_offset: 1, .rnd_tonearest_offset: 1},
441 {.input: 0xc134eb14u, .rnd_towardzero_result: 0xc1875615u, .rnd_upward_offset: 0, .rnd_downward_offset: 1, .rnd_tonearest_offset: 0},
442 }};
443 if (auto r = LGAMMAF_EXCEPTS_B10.lookup(x_bits: xbits.uintval());
444 LIBC_UNLIKELY(r.has_value()))
445 return r.value();
446 // |x| in (3.373, 73]: degree-10 monomial fit of
447 // h(s) = stir_resid(1/sqrt(s)) / sqrt(s), s = 1/x^2, on [0, 0.088];
448 // correction = h(s) * (1/x). Max error 2^-53.2.
449 constexpr double MID_B10 = 0x1.6880000000000p-5;
450 constexpr double POLY_B10[11] = {
451 0x1.54d6b78cee955p-4, -0x1.635a5fb0cdf9fp-9,
452 0x1.7b5253f44b255p-11, -0x1.f32907e7a7adap-12,
453 0x1.1f269b6438739p-11, -0x1.e95dc64c5042cp-11,
454 0x1.17ebce09c49a7p-9, -0x1.91599e7728747p-8,
455 0x1.5a01e1f07b127p-6, -0x1.90e956754bc6ap-4,
456 0x1.dfbed80c6f035p-2};
457 double u = inv_x2 - MID_B10;
458 double u2 = u * u, u4 = u2 * u2, u8 = u4 * u4;
459 double p01 = fputil::multiply_add(x: u, y: POLY_B10[1], z: POLY_B10[0]);
460 double p23 = fputil::multiply_add(x: u, y: POLY_B10[3], z: POLY_B10[2]);
461 double p45 = fputil::multiply_add(x: u, y: POLY_B10[5], z: POLY_B10[4]);
462 double p67 = fputil::multiply_add(x: u, y: POLY_B10[7], z: POLY_B10[6]);
463 double p89 = fputil::multiply_add(x: u, y: POLY_B10[9], z: POLY_B10[8]);
464 double q03 = fputil::multiply_add(x: u2, y: p23, z: p01);
465 double q47 = fputil::multiply_add(x: u2, y: p67, z: p45);
466 double q810 = fputil::multiply_add(x: u2, y: POLY_B10[10], z: p89);
467 double r07 = fputil::multiply_add(x: u4, y: q47, z: q03);
468 double poly = fputil::multiply_add(x: u8, y: q810, z: r07);
469 lgamma_val += inv_x * poly;
470 }
471 } else {
472 constexpr fputil::ExceptValues<float, 6> LGAMMAF_EXCEPTS_HUGE{.values: {
473 // input, toward-zero result, RU, RD, RN
474 {.input: 0x4f3f94c0u, .rnd_towardzero_result: 0x517a24a2u, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 1},
475 {.input: 0x50522f52u, .rnd_towardzero_result: 0x5292ee5du, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 1},
476 {.input: 0x65fca09fu, .rnd_towardzero_result: 0x68cead59u, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 1},
477 {.input: 0x716e5dd5u, .rnd_towardzero_result: 0x747e2bb9u, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 0},
478 {.input: 0x77ac5674u, .rnd_towardzero_result: 0x7acf27b2u, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 1},
479 {.input: 0x7943def8u, .rnd_towardzero_result: 0x7c7232d7u, .rnd_upward_offset: 1, .rnd_downward_offset: 0, .rnd_tonearest_offset: 0},
480 }};
481 if (auto r = LGAMMAF_EXCEPTS_HUGE.lookup(x_bits: xbits.uintval());
482 LIBC_UNLIKELY(r.has_value()))
483 return r.value();
484 }
485
486 if (xbits.is_neg()) {
487 // Reflection: lgamma(x) = log(pi) - lgamma(|x|) - log(|x|) -
488 // log(|sin(pi*frac_x)|). Reusing the already-computed lz = log(|x|)
489 // keeps the multiply out of the serial sinpi -> log chain.
490 double frac_x = xd - fputil::floor(x: xd);
491 lgamma_val = (0x1.250d048e7a1bdp+0 - lgamma_val) - lz;
492 lgamma_val -= lg_ln(x: lg_sinpi(x: frac_x));
493 }
494 }
495
496 float result = fputil::cast<float>(x: lgamma_val);
497 if (LIBC_UNLIKELY(FPBits(result).is_inf())) {
498 fputil::raise_overflow_except_if_required<float>();
499 fputil::set_errno_if_required(ERANGE);
500 }
501 return result;
502}
503
504} // namespace math
505
506} // namespace LIBC_NAMESPACE_DECL
507
508#endif // LLVM_LIBC_SRC___SUPPORT_MATH_LGAMMAF_H
509