[libc-commits] [libc] [libc][NFC] Integrate `quick_mul`, `quick_add`, `multiply_add`, `pow_n` and `mul_pow_2` as `friend` functions in `DyadicFloat` (PR #89373)
via libc-commits
libc-commits at lists.llvm.org
Fri Apr 19 04:33:15 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-libc
Author: Guillaume Chatelet (gchatelet)
<details>
<summary>Changes</summary>
---
Patch is 25.11 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/89373.diff
11 Files Affected:
- (modified) libc/src/__support/FPUtil/dyadic_float.h (+107-114)
- (modified) libc/src/__support/float_to_string.h (+4-4)
- (modified) libc/src/math/generic/exp.cpp (+9-12)
- (modified) libc/src/math/generic/exp10.cpp (+9-12)
- (modified) libc/src/math/generic/exp2.cpp (+8-10)
- (modified) libc/src/math/generic/expm1.cpp (+10-14)
- (modified) libc/src/math/generic/log.cpp (+8-8)
- (modified) libc/src/math/generic/log10.cpp (+7-7)
- (modified) libc/src/math/generic/log1p.cpp (+13-13)
- (modified) libc/src/math/generic/log2.cpp (+6-6)
- (modified) libc/src/math/generic/log_range_reduction.h (+3-3)
``````````diff
diff --git a/libc/src/__support/FPUtil/dyadic_float.h b/libc/src/__support/FPUtil/dyadic_float.h
index 12a69228d36c7b..a40e9feb6c82fb 100644
--- a/libc/src/__support/FPUtil/dyadic_float.h
+++ b/libc/src/__support/FPUtil/dyadic_float.h
@@ -200,129 +200,122 @@ template <size_t Bits> struct DyadicFloat {
return new_mant;
}
-};
-// Quick add - Add 2 dyadic floats with rounding toward 0 and then normalize the
-// output:
-// - Align the exponents so that:
-// new a.exponent = new b.exponent = max(a.exponent, b.exponent)
-// - Add or subtract the mantissas depending on the signs.
-// - Normalize the result.
-// The absolute errors compared to the mathematical sum is bounded by:
-// | quick_add(a, b) - (a + b) | < MSB(a + b) * 2^(-Bits + 2),
-// i.e., errors are up to 2 ULPs.
-// Assume inputs are normalized (by constructors or other functions) so that we
-// don't need to normalize the inputs again in this function. If the inputs are
-// not normalized, the results might lose precision significantly.
-template <size_t Bits>
-LIBC_INLINE constexpr DyadicFloat<Bits> quick_add(DyadicFloat<Bits> a,
- DyadicFloat<Bits> b) {
- if (LIBC_UNLIKELY(a.mantissa.is_zero()))
- return b;
- if (LIBC_UNLIKELY(b.mantissa.is_zero()))
- return a;
-
- // Align exponents
- if (a.exponent > b.exponent)
- b.shift_right(a.exponent - b.exponent);
- else if (b.exponent > a.exponent)
- a.shift_right(b.exponent - a.exponent);
-
- DyadicFloat<Bits> result;
-
- if (a.sign == b.sign) {
- // Addition
- result.sign = a.sign;
- result.exponent = a.exponent;
- result.mantissa = a.mantissa;
- if (result.mantissa.add_overflow(b.mantissa)) {
- // Mantissa addition overflow.
- result.shift_right(1);
- result.mantissa.val[DyadicFloat<Bits>::MantissaType::WORD_COUNT - 1] |=
- (uint64_t(1) << 63);
+ // Quick add - Add 2 dyadic floats with rounding toward 0 and then normalize
+ // the output:
+ // - Align the exponents so that:
+ // new a.exponent = new b.exponent = max(a.exponent, b.exponent)
+ // - Add or subtract the mantissas depending on the signs.
+ // - Normalize the result.
+ // The absolute errors compared to the mathematical sum is bounded by:
+ // | quick_add(a, b) - (a + b) | < MSB(a + b) * 2^(-Bits + 2),
+ // i.e., errors are up to 2 ULPs.
+ // Assume inputs are normalized (by constructors or other functions) so that
+ // we don't need to normalize the inputs again in this function. If the
+ // inputs are not normalized, the results might lose precision significantly.
+ LIBC_INLINE friend constexpr DyadicFloat quick_add(DyadicFloat a,
+ DyadicFloat b) {
+ if (LIBC_UNLIKELY(a.mantissa.is_zero()))
+ return b;
+ if (LIBC_UNLIKELY(b.mantissa.is_zero()))
+ return a;
+
+ // Align exponents
+ if (a.exponent > b.exponent)
+ b.shift_right(a.exponent - b.exponent);
+ else if (b.exponent > a.exponent)
+ a.shift_right(b.exponent - a.exponent);
+
+ DyadicFloat result;
+
+ if (a.sign == b.sign) {
+ // Addition
+ result.sign = a.sign;
+ result.exponent = a.exponent;
+ result.mantissa = a.mantissa;
+ if (result.mantissa.add_overflow(b.mantissa)) {
+ // Mantissa addition overflow.
+ result.shift_right(1);
+ result.mantissa.val[DyadicFloat::MantissaType::WORD_COUNT - 1] |=
+ (uint64_t(1) << 63);
+ }
+ // Result is already normalized.
+ return result;
}
- // Result is already normalized.
- return result;
+
+ // Subtraction
+ if (a.mantissa >= b.mantissa) {
+ result.sign = a.sign;
+ result.exponent = a.exponent;
+ result.mantissa = a.mantissa - b.mantissa;
+ } else {
+ result.sign = b.sign;
+ result.exponent = b.exponent;
+ result.mantissa = b.mantissa - a.mantissa;
+ }
+
+ return result.normalize();
}
- // Subtraction
- if (a.mantissa >= b.mantissa) {
- result.sign = a.sign;
- result.exponent = a.exponent;
- result.mantissa = a.mantissa - b.mantissa;
- } else {
- result.sign = b.sign;
- result.exponent = b.exponent;
- result.mantissa = b.mantissa - a.mantissa;
+ // Quick Mul - Slightly less accurate but efficient multiplication of 2 dyadic
+ // floats with rounding toward 0 and then normalize the output:
+ // result.exponent = a.exponent + b.exponent + Bits,
+ // result.mantissa = quick_mul_hi(a.mantissa + b.mantissa)
+ // ~ (full product a.mantissa * b.mantissa) >> Bits.
+ // The errors compared to the mathematical product is bounded by:
+ // 2 * errors of quick_mul_hi = 2 * (UInt<Bits>::WORD_COUNT - 1) in ULPs.
+ // Assume inputs are normalized (by constructors or other functions) so that
+ // we don't need to normalize the inputs again in this function. If the
+ // inputs are not normalized, the results might lose precision significantly.
+ LIBC_INLINE friend constexpr DyadicFloat quick_mul(DyadicFloat a,
+ DyadicFloat b) {
+ DyadicFloat result;
+ result.sign = (a.sign != b.sign) ? Sign::NEG : Sign::POS;
+ result.exponent = a.exponent + b.exponent + int(Bits);
+
+ if (!(a.mantissa.is_zero() || b.mantissa.is_zero())) {
+ result.mantissa = a.mantissa.quick_mul_hi(b.mantissa);
+ // Check the leading bit directly, should be faster than using clz in
+ // normalize().
+ if (result.mantissa.val[DyadicFloat::MantissaType::WORD_COUNT - 1] >>
+ 63 ==
+ 0)
+ result.shift_left(1);
+ } else {
+ result.mantissa = (typename DyadicFloat::MantissaType)(0);
+ }
+ return result;
}
- return result.normalize();
-}
-
-// Quick Mul - Slightly less accurate but efficient multiplication of 2 dyadic
-// floats with rounding toward 0 and then normalize the output:
-// result.exponent = a.exponent + b.exponent + Bits,
-// result.mantissa = quick_mul_hi(a.mantissa + b.mantissa)
-// ~ (full product a.mantissa * b.mantissa) >> Bits.
-// The errors compared to the mathematical product is bounded by:
-// 2 * errors of quick_mul_hi = 2 * (UInt<Bits>::WORD_COUNT - 1) in ULPs.
-// Assume inputs are normalized (by constructors or other functions) so that we
-// don't need to normalize the inputs again in this function. If the inputs are
-// not normalized, the results might lose precision significantly.
-template <size_t Bits>
-LIBC_INLINE constexpr DyadicFloat<Bits> quick_mul(DyadicFloat<Bits> a,
- DyadicFloat<Bits> b) {
- DyadicFloat<Bits> result;
- result.sign = (a.sign != b.sign) ? Sign::NEG : Sign::POS;
- result.exponent = a.exponent + b.exponent + int(Bits);
-
- if (!(a.mantissa.is_zero() || b.mantissa.is_zero())) {
- result.mantissa = a.mantissa.quick_mul_hi(b.mantissa);
- // Check the leading bit directly, should be faster than using clz in
- // normalize().
- if (result.mantissa.val[DyadicFloat<Bits>::MantissaType::WORD_COUNT - 1] >>
- 63 ==
- 0)
- result.shift_left(1);
- } else {
- result.mantissa = (typename DyadicFloat<Bits>::MantissaType)(0);
+ // Simple polynomial approximation.
+ LIBC_INLINE friend constexpr DyadicFloat multiply_add(const DyadicFloat &a,
+ const DyadicFloat &b,
+ const DyadicFloat &c) {
+ return quick_add(c, quick_mul(a, b));
}
- return result;
-}
-
-// Simple polynomial approximation.
-template <size_t Bits>
-LIBC_INLINE constexpr DyadicFloat<Bits>
-multiply_add(const DyadicFloat<Bits> &a, const DyadicFloat<Bits> &b,
- const DyadicFloat<Bits> &c) {
- return quick_add(c, quick_mul(a, b));
-}
-
-// Simple exponentiation implementation for printf. Only handles positive
-// exponents, since division isn't implemented.
-template <size_t Bits>
-LIBC_INLINE constexpr DyadicFloat<Bits> pow_n(DyadicFloat<Bits> a,
- uint32_t power) {
- DyadicFloat<Bits> result = 1.0;
- DyadicFloat<Bits> cur_power = a;
-
- while (power > 0) {
- if ((power % 2) > 0) {
- result = quick_mul(result, cur_power);
+
+ // Simple exponentiation implementation for printf. Only handles positive
+ // exponents, since division isn't implemented.
+ LIBC_INLINE constexpr DyadicFloat pow_n(uint32_t power) const {
+ DyadicFloat result = 1.0;
+ DyadicFloat cur_power = *this;
+
+ while (power > 0) {
+ if ((power % 2) > 0) {
+ result = quick_mul(result, cur_power);
+ }
+ power = power >> 1;
+ cur_power = quick_mul(cur_power, cur_power);
}
- power = power >> 1;
- cur_power = quick_mul(cur_power, cur_power);
+ return result;
}
- return result;
-}
-
-template <size_t Bits>
-LIBC_INLINE constexpr DyadicFloat<Bits> mul_pow_2(DyadicFloat<Bits> a,
- int32_t pow_2) {
- DyadicFloat<Bits> result = a;
- result.exponent += pow_2;
- return result;
-}
+
+ LIBC_INLINE constexpr DyadicFloat mul_pow_2(int32_t pow_2) const {
+ DyadicFloat result = *this;
+ result.exponent += pow_2;
+ return result;
+ }
+};
} // namespace LIBC_NAMESPACE::fputil
diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h
index 09b13324f25bbd..94504838f04613 100644
--- a/libc/src/__support/float_to_string.h
+++ b/libc/src/__support/float_to_string.h
@@ -244,10 +244,10 @@ LIBC_INLINE UInt<MID_INT_SIZE> get_table_positive_df(int exponent, size_t i) {
false, -276, FIVE_EXP_MINUS_NINE_MANT);
if (i > 0) {
- fputil::DyadicFloat<INT_SIZE> fives = fputil::pow_n(FIVE_EXP_MINUS_NINE, i);
+ fputil::DyadicFloat<INT_SIZE> fives = FIVE_EXP_MINUS_NINE.pow_n(i);
num = fives;
}
- num = mul_pow_2(num, shift_amount);
+ num = num.mul_pow_2(shift_amount);
// Adding one is part of the formula.
UInt<INT_SIZE> int_num = static_cast<UInt<INT_SIZE>>(num) + 1;
@@ -349,10 +349,10 @@ LIBC_INLINE UInt<MID_INT_SIZE> get_table_negative_df(int exponent, size_t i) {
TEN_EXP_NINE_MANT);
if (i > 0) {
- fputil::DyadicFloat<INT_SIZE> tens = fputil::pow_n(TEN_EXP_NINE, i);
+ fputil::DyadicFloat<INT_SIZE> tens = TEN_EXP_NINE.pow_n(i);
num = tens;
}
- num = mul_pow_2(num, shift_amount);
+ num = num.mul_pow_2(shift_amount);
UInt<INT_SIZE> int_num = static_cast<UInt<INT_SIZE>>(num);
if (int_num > MOD_SIZE) {
diff --git a/libc/src/math/generic/exp.cpp b/libc/src/math/generic/exp.cpp
index 3d060bcbd3be30..24ad81fcbea405 100644
--- a/libc/src/math/generic/exp.cpp
+++ b/libc/src/math/generic/exp.cpp
@@ -126,25 +126,22 @@ Float128 exp_f128(double x, double kd, int idx1, int idx2) {
double t2 = kd * MLOG_2_EXP2_M12_MID_30; // exact
double t3 = kd * MLOG_2_EXP2_M12_LO; // Error < 2^-133
- Float128 dx = fputil::quick_add(
- Float128(t1), fputil::quick_add(Float128(t2), Float128(t3)));
+ Float128 dx = quick_add(Float128(t1), quick_add(Float128(t2), Float128(t3)));
// TODO: Skip recalculating exp_mid1 and exp_mid2.
- Float128 exp_mid1 =
- fputil::quick_add(Float128(EXP2_MID1[idx1].hi),
- fputil::quick_add(Float128(EXP2_MID1[idx1].mid),
- Float128(EXP2_MID1[idx1].lo)));
+ Float128 exp_mid1 = quick_add(
+ Float128(EXP2_MID1[idx1].hi),
+ quick_add(Float128(EXP2_MID1[idx1].mid), Float128(EXP2_MID1[idx1].lo)));
- Float128 exp_mid2 =
- fputil::quick_add(Float128(EXP2_MID2[idx2].hi),
- fputil::quick_add(Float128(EXP2_MID2[idx2].mid),
- Float128(EXP2_MID2[idx2].lo)));
+ Float128 exp_mid2 = quick_add(
+ Float128(EXP2_MID2[idx2].hi),
+ quick_add(Float128(EXP2_MID2[idx2].mid), Float128(EXP2_MID2[idx2].lo)));
- Float128 exp_mid = fputil::quick_mul(exp_mid1, exp_mid2);
+ Float128 exp_mid = quick_mul(exp_mid1, exp_mid2);
Float128 p = poly_approx_f128(dx);
- Float128 r = fputil::quick_mul(exp_mid, p);
+ Float128 r = quick_mul(exp_mid, p);
r.exponent += static_cast<int>(kd) >> 12;
diff --git a/libc/src/math/generic/exp10.cpp b/libc/src/math/generic/exp10.cpp
index a4ae41407112bd..4dddd50ada6b22 100644
--- a/libc/src/math/generic/exp10.cpp
+++ b/libc/src/math/generic/exp10.cpp
@@ -126,25 +126,22 @@ Float128 exp10_f128(double x, double kd, int idx1, int idx2) {
double t2 = kd * MLOG10_2_EXP2_M12_MID_32; // exact
double t3 = kd * MLOG10_2_EXP2_M12_LO; // Error < 2^-144
- Float128 dx = fputil::quick_add(
- Float128(t1), fputil::quick_add(Float128(t2), Float128(t3)));
+ Float128 dx = quick_add(Float128(t1), quick_add(Float128(t2), Float128(t3)));
// TODO: Skip recalculating exp_mid1 and exp_mid2.
- Float128 exp_mid1 =
- fputil::quick_add(Float128(EXP2_MID1[idx1].hi),
- fputil::quick_add(Float128(EXP2_MID1[idx1].mid),
- Float128(EXP2_MID1[idx1].lo)));
+ Float128 exp_mid1 = quick_add(
+ Float128(EXP2_MID1[idx1].hi),
+ quick_add(Float128(EXP2_MID1[idx1].mid), Float128(EXP2_MID1[idx1].lo)));
- Float128 exp_mid2 =
- fputil::quick_add(Float128(EXP2_MID2[idx2].hi),
- fputil::quick_add(Float128(EXP2_MID2[idx2].mid),
- Float128(EXP2_MID2[idx2].lo)));
+ Float128 exp_mid2 = quick_add(
+ Float128(EXP2_MID2[idx2].hi),
+ quick_add(Float128(EXP2_MID2[idx2].mid), Float128(EXP2_MID2[idx2].lo)));
- Float128 exp_mid = fputil::quick_mul(exp_mid1, exp_mid2);
+ Float128 exp_mid = quick_mul(exp_mid1, exp_mid2);
Float128 p = poly_approx_f128(dx);
- Float128 r = fputil::quick_mul(exp_mid, p);
+ Float128 r = quick_mul(exp_mid, p);
r.exponent += static_cast<int>(kd) >> 12;
diff --git a/libc/src/math/generic/exp2.cpp b/libc/src/math/generic/exp2.cpp
index 1a2fa3feb83e54..48ebb41a328be6 100644
--- a/libc/src/math/generic/exp2.cpp
+++ b/libc/src/math/generic/exp2.cpp
@@ -114,21 +114,19 @@ Float128 exp2_f128(double x, int hi, int idx1, int idx2) {
Float128 dx = Float128(x);
// TODO: Skip recalculating exp_mid1 and exp_mid2.
- Float128 exp_mid1 =
- fputil::quick_add(Float128(EXP2_MID1[idx1].hi),
- fputil::quick_add(Float128(EXP2_MID1[idx1].mid),
- Float128(EXP2_MID1[idx1].lo)));
+ Float128 exp_mid1 = quick_add(
+ Float128(EXP2_MID1[idx1].hi),
+ quick_add(Float128(EXP2_MID1[idx1].mid), Float128(EXP2_MID1[idx1].lo)));
- Float128 exp_mid2 =
- fputil::quick_add(Float128(EXP2_MID2[idx2].hi),
- fputil::quick_add(Float128(EXP2_MID2[idx2].mid),
- Float128(EXP2_MID2[idx2].lo)));
+ Float128 exp_mid2 = quick_add(
+ Float128(EXP2_MID2[idx2].hi),
+ quick_add(Float128(EXP2_MID2[idx2].mid), Float128(EXP2_MID2[idx2].lo)));
- Float128 exp_mid = fputil::quick_mul(exp_mid1, exp_mid2);
+ Float128 exp_mid = quick_mul(exp_mid1, exp_mid2);
Float128 p = poly_approx_f128(dx);
- Float128 r = fputil::quick_mul(exp_mid, p);
+ Float128 r = quick_mul(exp_mid, p);
r.exponent += hi;
diff --git a/libc/src/math/generic/expm1.cpp b/libc/src/math/generic/expm1.cpp
index 574c4b9aaf39f7..f1a2a70697b6c5 100644
--- a/libc/src/math/generic/expm1.cpp
+++ b/libc/src/math/generic/expm1.cpp
@@ -148,34 +148,30 @@ Float128 expm1_f128(double x, double kd, int idx1, int idx2) {
double t2 = kd * MLOG_2_EXP2_M12_MID_30; // exact
double t3 = kd * MLOG_2_EXP2_M12_LO; // Error < 2^-133
- Float128 dx = fputil::quick_add(
- Float128(t1), fputil::quick_add(Float128(t2), Float128(t3)));
+ Float128 dx = quick_add(Float128(t1), quick_add(Float128(t2), Float128(t3)));
// TODO: Skip recalculating exp_mid1 and exp_mid2.
- Float128 exp_mid1 =
- fputil::quick_add(Float128(EXP2_MID1[idx1].hi),
- fputil::quick_add(Float128(EXP2_MID1[idx1].mid),
- Float128(EXP2_MID1[idx1].lo)));
+ Float128 exp_mid1 = quick_add(
+ Float128(EXP2_MID1[idx1].hi),
+ quick_add(Float128(EXP2_MID1[idx1].mid), Float128(EXP2_MID1[idx1].lo)));
- Float128 exp_mid2 =
- fputil::quick_add(Float128(EXP2_MID2[idx2].hi),
- fputil::quick_add(Float128(EXP2_MID2[idx2].mid),
- Float128(EXP2_MID2[idx2].lo)));
+ Float128 exp_mid2 = quick_add(
+ Float128(EXP2_MID2[idx2].hi),
+ quick_add(Float128(EXP2_MID2[idx2].mid), Float128(EXP2_MID2[idx2].lo)));
- Float128 exp_mid = fputil::quick_mul(exp_mid1, exp_mid2);
+ Float128 exp_mid = quick_mul(exp_mid1, exp_mid2);
int hi = static_cast<int>(kd) >> 12;
Float128 minus_one{Sign::NEG, -127 - hi,
0x80000000'00000000'00000000'00000000_u128};
- Float128 exp_mid_m1 = fputil::quick_add(exp_mid, minus_one);
+ Float128 exp_mid_m1 = quick_add(exp_mid, minus_one);
Float128 p = poly_approx_f128(dx);
// r = exp_mid * (1 + dx * P) - 1
// = (exp_mid - 1) + (dx * exp_mid) * P
- Float128 r =
- fputil::multiply_add(fputil::quick_mul(exp_mid, dx), p, exp_mid_m1);
+ Float128 r = multiply_add(quick_mul(exp_mid, dx), p, exp_mid_m1);
r.exponent += hi;
diff --git a/libc/src/math/generic/log.cpp b/libc/src/math/generic/log.cpp
index 6de0d90be80e11..3674fcdfd94cf2 100644
--- a/libc/src/math/generic/log.cpp
+++ b/libc/src/math/generic/log.cpp
@@ -714,19 +714,19 @@ constexpr Float128 BIG_COEFFS[3]{
double log_accurate(int e_x, int index, double m_x) {
Float128 e_x_f128(static_cast<float>(e_x));
- Float128 sum = fputil::quick_mul(LOG_2, e_x_f128);
- sum = fputil::quick_add(sum, LOG_TABLE.step_1[index]);
+ Float128 sum = quick_mul(LOG_2, e_x_f128);
+ sum = quick_add(sum, LOG_TABLE.step_1[index]);
Float128 v_f128 = log_range_reduction(m_x, LOG_TABLE, sum);
- sum = fputil::quick_add(sum, v_f128);
+ sum = quick_add(sum, v_f128);
// Polynomial approximation
- Float128 p = fputil::quick_mul(v_f128, BIG_COEFFS[0]);
- p = fputil::quick_mul(v_f128, fputil::quick_add(p, BIG_COEFFS[1]));
- p = fputil::quick_mul(v_f128, fputil::quick_add(p, BIG_COEFFS[2]));
- p = fputil::quick_mul(v_f128, p);
+ Float128 p = quick_mul(v_f128, BIG_COEFFS[0]);
+ p = quick_mul(v_f128, quick_add(p, BIG_COEFFS[1]));
+ p = quick_mul(v_f128, quick_add(p, BIG_COEFFS[2]));
+ p = quick_mul(v_f128, p);
- Float128 r = fputil::quick_add(sum, p);
+ Float128 r = quick_add(sum, p);
return static_cast<double>(r);
}
diff --git a/libc/src/math/generic/log10.cpp b/libc/src/math/generic/log10.cpp
index fb839c111e6a0f..515faab8d5e668 100644
--- a/libc/src/math/generic/log10.cpp
+++ b/libc/src/math/generic/log10.cpp
@@ -717,18 +717,18 @@ constexpr Float128 BIG_COEFFS[4]{
double log10_accurate(int e_x, int index, double m_x) {
Float128 e_x_f128(static_cast<float>(e_x));
- Float128 sum = fputil::quick_mul(LOG10_2, e_x_f128);
- sum = fputil::quick_add(sum, LOG10_TABLE.step_1[index]);
+ Float128 sum = quick_mul(LOG10_2, e_x_f128);
+ sum = quick_add(sum, LOG10_TABLE.step_1[index]);
Float128 v_f128 = log_range_reduction(m_x, LOG10_TABLE, sum);
// Polynomial approximation
- Float128 p = fputil::quick_mul(v_f128, BIG_COEFFS[0]);
- p = fputil::quick_mul(v_f128, fputil::quick_add(p, BIG_COEFFS[1]));
- p = fputil::quick_mul(v_f128, fputil::quick_add(p, BIG_COEFFS[2]));
- p = fputil::quick_mul(v_f128, fputil::quick_add(p, BIG_COEFFS[3]));
+ Float128 p = quick_mul(v_f128, BIG_COEFFS[0]);
+ p = quick_mul(v_f128, quick_add(p, BIG_COEFFS[1]));
+ p = quick_mul(v_f128, quick_add(p, BIG_COEFFS[2]));
+ p = quick_mul(v_f128, quick_add(p, BIG_COEFFS[3]));
- Float128 r = fputil::quick_add(sum, p);
+ Float128 r = quick_add(sum, p);
return static_cast<double>(r);
}
diff --git a/libc/src/math/generic/log1p.cpp b/libc/src/math/generic/log1p.cpp
index 2b187080a057b4..ce33d9ed035f76 100644
--- a/libc/src/math/generic/log1p.cpp
+++ b/libc/src/math/generic/log1p.cpp
@@ -824,11 +824,11 @@ constexpr Float128 BIG_COEFFS[4]{
LIBC_INLINE double log1p_accurat...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/89373
More information about the libc-commits
mailing list