chore: remove FromReal/ToReal/ToInteger conversions

Author: zhjwpku

src/iceberg/util/decimal.cc

@@ -519,322 +519,6 @@ constexpr std::array<double, 2 * kPrecomputedPowersOfTen + 1> kDoublePowersOfTen
     1e56,  1e57,  1e58,  1e59,  1e60,  1e61,  1e62,  1e63,  1e64,  1e65,  1e66,  1e67,
     1e68,  1e69,  1e70,  1e71,  1e72,  1e73,  1e74,  1e75,  1e76};
 
-// ceil(log2(10 ^ k)) for k in [0...76]
-constexpr std::array<int32_t, 76 + 1> kCeilLog2PowersOfTen = {
-    0,   4,   7,   10,  14,  17,  20,  24,  27,  30,  34,  37,  40,  44,  47,  50,
-    54,  57,  60,  64,  67,  70,  74,  77,  80,  84,  87,  90,  94,  97,  100, 103,
-    107, 110, 113, 117, 120, 123, 127, 130, 133, 137, 140, 143, 147, 150, 153, 157,
-    160, 163, 167, 170, 173, 177, 180, 183, 187, 190, 193, 196, 200, 203, 206, 210,
-    213, 216, 220, 223, 226, 230, 233, 236, 240, 243, 246, 250, 253};
-
-template <typename Real>
-struct RealTraits {};
-
-template <>
-struct RealTraits<float> {
-  static constexpr const float* powers_of_ten() { return kFloatPowersOfTen.data(); }
-
-  static constexpr float two_to_64(float x) { return x * 1.8446744e+19f; }
-
-  static constexpr int32_t kMantissaBits = 24;
-  // ceil(log10(2 ^ kMantissaBits))
-  static constexpr int32_t kMantissaDigits = 8;
-  // Integers between zero and kMaxPreciseInteger can be precisely represented
-  static constexpr uint64_t kMaxPreciseInteger = (1ULL << kMantissaBits) - 1;
-};
-
-template <>
-struct RealTraits<double> {
-  static constexpr const double* powers_of_ten() { return kDoublePowersOfTen.data(); }
-
-  static constexpr double two_to_64(double x) { return x * 1.8446744073709552e+19; }
-
-  static constexpr int32_t kMantissaBits = 53;
-  // ceil(log10(2 ^ kMantissaBits))
-  static constexpr int32_t kMantissaDigits = 16;
-  // Integers between zero and kMaxPreciseInteger can be precisely represented
-  static constexpr uint64_t kMaxPreciseInteger = (1ULL << kMantissaBits) - 1;
-};
-
-struct DecimalRealConversion {
-  // Return 10**exp, with a fast lookup, assuming `exp` is within bounds
-  template <typename Real>
-  static Real PowerOfTen(int32_t exp) {
-    constexpr int32_t N = kPrecomputedPowersOfTen;
-    ICEBERG_DCHECK(exp >= -N && exp <= N, "");
-    return RealTraits<Real>::powers_of_ten()[N + exp];
-  }
-
-  // Return 10**exp, with a fast lookup if possible
-  template <typename Real>
-  static Real LargePowerOfTen(int32_t exp) {
-    constexpr int32_t N = kPrecomputedPowersOfTen;
-    if (exp >= -N && exp <= N) {
-      return RealTraits<Real>::powers_of_ten()[N + exp];
-    } else {
-      return std::pow(static_cast<Real>(10.0), static_cast<Real>(exp));
-    }
-  }
-
-  static constexpr int32_t kMaxPrecision = Decimal::kMaxPrecision;
-  static constexpr int32_t kMaxScale = Decimal::kMaxScale;
-
-  static constexpr auto& DecimalPowerOfTen(int32_t exp) {
-    ICEBERG_DCHECK(exp >= 0 && exp <= kMaxPrecision, "");
-    return kDecimal128PowersOfTen[exp];
-  }
-
-  // Right shift positive `x` by positive `bits`, rounded half to even
-  static Decimal RoundedRightShift(const Decimal& x, int32_t bits) {
-    if (bits == 0) {
-      return x;
-    }
-    int64_t result_hi = x.high();
-    uint64_t result_lo = x.low();
-    uint64_t shifted = 0;
-    while (bits >= 64) {
-      // Retain the information that set bits were shifted right.
-      // This is important to detect an exact half.
-      shifted = result_lo | (shifted > 0);
-      result_lo = result_hi;
-      result_hi >>= 63;  // for sign
-      bits -= 64;
-    }
-    if (bits > 0) {
-      shifted = (result_lo << (64 - bits)) | (shifted > 0);
-      result_lo >>= bits;
-      result_lo |= static_cast<uint64_t>(result_hi) << (64 - bits);
-      result_hi >>= bits;
-    }
-    // We almost have our result, but now do the rounding.
-    constexpr uint64_t kHalf = 0x8000000000000000ULL;
-    if (shifted > kHalf) {
-      // Strictly more than half => round up
-      result_lo += 1;
-      result_hi += (result_lo == 0);
-    } else if (shifted == kHalf) {
-      // Exactly half => round to even
-      if ((result_lo & 1) != 0) {
-        result_lo += 1;
-        result_hi += (result_lo == 0);
-      }
-    } else {
-      // Strictly less than half => round down
-    }
-    return Decimal{result_hi, result_lo};
-  }
-
-  template <typename Real>
-  static Result<Decimal> FromPositiveRealApprox(Real real, int32_t precision,
-                                                int32_t scale) {
-    // Approximate algorithm that operates in the FP domain (thus subject
-    // to precision loss).
-    const auto x = std::nearbyint(real * PowerOfTen<Real>(scale));
-    const auto max_abs = PowerOfTen<Real>(precision);
-    if (x <= -max_abs || x >= max_abs) {
-      return Invalid("Cannot convert {} to Decimal(precision = {}, scale = {}): overflow",
-                     real, precision, scale);
-    }
-
-    // Extract high and low bits
-    const auto high = std::floor(std::ldexp(x, -64));
-    const auto low = x - std::ldexp(high, 64);
-
-    ICEBERG_DCHECK(high >= 0, "");
-    ICEBERG_DCHECK(high < 9.223372036854776e+18, "");  // 2**63
-    ICEBERG_DCHECK(low >= 0, "");
-    ICEBERG_DCHECK(low < 1.8446744073709552e+19, "");  // 2**64
-    return Decimal(static_cast<int64_t>(high), static_cast<uint64_t>(low));
-  }
-
-  template <typename Real>
-  static Result<Decimal> FromPositiveReal(Real real, int32_t precision, int32_t scale) {
-    constexpr int32_t kMantissaBits = RealTraits<Real>::kMantissaBits;
-    constexpr int32_t kMantissaDigits = RealTraits<Real>::kMantissaDigits;
-
-    // Problem statement: construct the Decimal with the value
-    // closest to `real * 10^scale`.
-    if (scale < 0) {
-      // Negative scales are not handled below, fall back to approx algorithm
-      return FromPositiveRealApprox(real, precision, scale);
-    }
-
-    // 1. Check that `real` is within acceptable bounds.
-    const Real limit = PowerOfTen<Real>(precision - scale);
-    if (real > limit) {
-      // Checking the limit early helps ensure the computations below do not
-      // overflow.
-      // NOTE: `limit` is allowed here as rounding can make it smaller than
-      // the theoretical limit (for example, 1.0e23 < 10^23).
-      return Invalid("Cannot convert {} to Decimal(precision = {}, scale = {}): overflow",
-                     real, precision, scale);
-    }
-
-    // 2. Losslessly convert `real` to `mant * 2**k`
-    int32_t binary_exp = 0;
-    const Real real_mant = std::frexp(real, &binary_exp);
-    // `real_mant` is within 0.5 and 1 and has M bits of precision.
-    // Multiply it by 2^M to get an exact integer.
-    const auto mant = static_cast<uint64_t>(std::ldexp(real_mant, kMantissaBits));
-    const int32_t k = binary_exp - kMantissaBits;
-    // (note that `real = mant * 2^k`)
-
-    // 3. Start with `mant`.
-    // We want to end up with `real * 10^scale` i.e. `mant * 2^k * 10^scale`.
-    Decimal x(mant);
-
-    if (k < 0) {
-      // k < 0 (i.e. binary_exp < kMantissaBits), is probably the common case
-      // when converting to decimal. It implies right-shifting by -k bits,
-      // while multiplying by 10^scale. We also must avoid overflow (losing
-      // bits on the left) and precision loss (losing bits on the right).
-      int32_t right_shift_by = -k;
-      int32_t mul_by_ten_to = scale;
-
-      // At this point, `x` has kMantissaDigits significant digits but it can
-      // fit kMaxPrecision (excluding sign). We can therefore multiply by up
-      // to 10^(kMaxPrecision - kMantissaDigits).
-      constexpr int32_t kSafeMulByTenTo = kMaxPrecision - kMantissaDigits;
-
-      if (mul_by_ten_to <= kSafeMulByTenTo) {
-        // Scale is small enough, so we can do it all at once.
-        x *= DecimalPowerOfTen(mul_by_ten_to);
-        x = RoundedRightShift(x, right_shift_by);
-      } else {
-        // Scale is too large, we cannot multiply at once without overflow.
-        // We use an iterative algorithm which alternately shifts left by
-        // multiplying by a power of ten, and shifts right by a number of bits.
-
-        // First multiply `x` by as large a power of ten as possible
-        // without overflowing.
-        x *= DecimalPowerOfTen(kSafeMulByTenTo);
-        mul_by_ten_to -= kSafeMulByTenTo;
-
-        // `x` now has full precision. However, we know we'll only
-        // keep `precision` digits at the end. Extraneous bits/digits
-        // on the right can be safely shifted away, before multiplying
-        // again.
-        // NOTE: if `precision` is the full precision then the algorithm will
-        // lose the last digit. If `precision` is almost the full precision,
-        // there can be an off-by-one error due to rounding.
-        const int32_t mul_step = std::max(1, kMaxPrecision - precision);
-
-        // The running exponent, useful to compute by how much we must
-        // shift right to make place on the left before the next multiply.
-        int32_t total_exp = 0;
-        int32_t total_shift = 0;
-        while (mul_by_ten_to > 0 && right_shift_by > 0) {
-          const int32_t exp = std::min(mul_by_ten_to, mul_step);
-          total_exp += exp;
-          // The supplementary right shift required so that
-          // `x * 10^total_exp / 2^total_shift` fits in the decimal.
-          ICEBERG_DCHECK(static_cast<size_t>(total_exp) < sizeof(kCeilLog2PowersOfTen),
-                         "");
-          const int32_t bits =
-              std::min(right_shift_by, kCeilLog2PowersOfTen[total_exp] - total_shift);
-          total_shift += bits;
-          // Right shift to make place on the left, then multiply
-          x = RoundedRightShift(x, bits);
-          right_shift_by -= bits;
-          // Should not overflow thanks to the precautions taken
-          x *= DecimalPowerOfTen(exp);
-          mul_by_ten_to -= exp;
-        }
-        if (mul_by_ten_to > 0) {
-          x *= DecimalPowerOfTen(mul_by_ten_to);
-        }
-        if (right_shift_by > 0) {
-          x = RoundedRightShift(x, right_shift_by);
-        }
-      }
-    } else {
-      // k >= 0 implies left-shifting by k bits and multiplying by 10^scale.
-      // The order of these operations therefore doesn't matter. We know
-      // we won't overflow because of the limit check above, and we also
-      // won't lose any significant bits on the right.
-      x *= DecimalPowerOfTen(scale);
-      x <<= k;
-    }
-
-    // Rounding might have pushed `x` just above the max precision, check again
-    if (!x.FitsInPrecision(precision)) {
-      return Invalid("Cannot convert {} to Decimal(precision = {}, scale = {}): overflow",
-                     real, precision, scale);
-    }
-    return x;
-  }
-
-  template <typename Real>
-  static Real ToRealPositiveNoSplit(const Decimal& decimal, int32_t scale) {
-    Real x = RealTraits<Real>::two_to_64(static_cast<Real>(decimal.high()));
-    x += static_cast<Real>(decimal.low());
-    x *= LargePowerOfTen<Real>(-scale);
-    return x;
-  }
-
-  /// An approximate conversion from Decimal to Real that guarantees:
-  /// 1. If the decimal is an integer, the conversion is exact.
-  /// 2. If the number of fractional digits is <= RealTraits<Real>::kMantissaDigits (e.g.
-  ///    8 for float and 16 for double), the conversion is within 1 ULP of the exact
-  ///    value.
-  /// 3. Otherwise, the conversion is within 2^(-RealTraits<Real>::kMantissaDigits+1)
-  ///    (e.g. 2^-23 for float and 2^-52 for double) of the exact value.
-  /// Here "exact value" means the closest representable value by Real.
-  template <typename Real>
-  static Real ToRealPositive(const Decimal& decimal, int32_t scale) {
-    if (scale <= 0 ||
-        (decimal.high() == 0 && decimal.low() <= RealTraits<Real>::kMaxPreciseInteger)) {
-      // No need to split the decimal if it is already an integer (scale <= 0) or if it
-      // can be precisely represented by Real
-      return ToRealPositiveNoSplit<Real>(decimal, scale);
-    }
-
-    // Split decimal into whole and fractional parts to avoid precision loss
-    auto s = decimal.GetWholeAndFraction(scale);
-    ICEBERG_DCHECK(s, "Decimal::GetWholeAndFraction failed");
-
-    Real whole = ToRealPositiveNoSplit<Real>(s->first, 0);
-    Real fraction = ToRealPositiveNoSplit<Real>(s->second, scale);
-
-    return whole + fraction;
-  }
-
-  template <typename Real>
-  static Result<Decimal> FromReal(Real value, int32_t precision, int32_t scale) {
-    ICEBERG_DCHECK(precision >= 1 && precision <= kMaxPrecision, "");
-    ICEBERG_DCHECK(scale >= -kMaxScale && scale <= kMaxScale, "");
-
-    if (!std::isfinite(value)) {
-      return InvalidArgument("Cannot convert {} to Decimal", value);
-    }
-
-    if (value == 0) {
-      return Decimal{};
-    }
-
-    if (value < 0) {
-      ICEBERG_ASSIGN_OR_RAISE(auto decimal, FromPositiveReal(-value, precision, scale));
-      return decimal.Negate();
-    } else {
-      return FromPositiveReal(value, precision, scale);
-    }
-  }
-
-  template <typename Real>
-  static Real ToReal(const Decimal& decimal, int32_t scale) {
-    ICEBERG_DCHECK(scale >= -kMaxScale && scale <= kMaxScale, "");
-
-    if (decimal.IsNegative()) {
-      // Convert the absolute value to avoid precision loss
-      auto abs = decimal;
-      abs.Negate();
-      return -ToRealPositive<Real>(abs, scale);
-    } else {
-      return ToRealPositive<Real>(decimal, scale);
-    }
-  }
-};
-
 // Helper function used by Decimal::FromBigEndian
 static inline uint64_t UInt64FromBigEndian(const uint8_t* bytes, int32_t length) {
   // We don't bounds check the length here because this is called by
@@ -869,21 +553,6 @@ static bool RescaleWouldCauseDataLoss(const Decimal& value, int32_t delta_scale,
 
 }  // namespace
 
-Result<Decimal> Decimal::FromReal(float x, int32_t precision, int32_t scale) {
-  return DecimalRealConversion::FromReal(x, precision, scale);
-}
-
-Result<Decimal> Decimal::FromReal(double x, int32_t precision, int32_t scale) {
-  return DecimalRealConversion::FromReal(x, precision, scale);
-}
-
-Result<std::pair<Decimal, Decimal>> Decimal::GetWholeAndFraction(int32_t scale) const {
-  ICEBERG_DCHECK(scale >= 0 && scale <= kMaxScale, "");
-
-  Decimal multiplier(kDecimal128PowersOfTen[scale]);
-  return Divide(multiplier);
-}
-
 Result<Decimal> Decimal::FromBigEndian(const uint8_t* bytes, int32_t length) {
   static constexpr int32_t kMinDecimalBytes = 1;
   static constexpr int32_t kMaxDecimalBytes = 16;
@@ -966,14 +635,6 @@ bool Decimal::FitsInPrecision(int32_t precision) const {
   return Decimal::Abs(*this) < kDecimal128PowersOfTen[precision];
 }
 
-float Decimal::ToFloat(int32_t scale) const {
-  return DecimalRealConversion::ToReal<float>(*this, scale);
-}
-
-double Decimal::ToDouble(int32_t scale) const {
-  return DecimalRealConversion::ToReal<double>(*this, scale);
-}
-
 std::array<uint8_t, Decimal::kByteWidth> Decimal::ToBytes() const {
   std::array<uint8_t, kByteWidth> out{{0}};
   std::memcpy(out.data(), &data_, kByteWidth);