Method RoundedRightShift

cpp/src/arrow/util/decimal.cc:1308–1353

Right shift positive `x` by positive `bits`, rounded half to even

  // Right shift positive `x` by positive `bits`, rounded half to even
  static Decimal256 RoundedRightShift(Decimal256 x, int bits) {
    if (bits == 0) {
      return x;
    }
    const int cross_word_shift = bits / 64;
    if (cross_word_shift >= Decimal256::kNumWords) {
      return Decimal256();
    }
    const uint32_t in_word_shift = bits % 64;
    const auto array_le = x.little_endian_array();
    Decimal256::WordArray shifted_le{};
    uint64_t shifted_out = 0;
    // Iterate from LSW to MSW
    for (int i = 0; i < cross_word_shift; ++i) {
      // Retain the information that non-zero bits were shifted out.
      // This is important for half-to-even rounding.
      shifted_out = (shifted_out > 0) | array_le[i];
    }
    if (in_word_shift != 0) {
      const uint64_t carry_bits = array_le[cross_word_shift] << (64 - in_word_shift);
      shifted_out = (shifted_out > 0) | (shifted_out >> in_word_shift) | carry_bits;
    }
    for (int i = cross_word_shift; i < Decimal256::kNumWords; ++i) {
      shifted_le[i - cross_word_shift] = array_le[i] >> in_word_shift;
      if (in_word_shift != 0 && i + 1 < Decimal256::kNumWords) {
        const uint64_t carry_bits = array_le[i + 1] << (64 - in_word_shift);
        shifted_le[i - cross_word_shift] |= carry_bits;
      }
    }
    auto result = Decimal256(Decimal256::LittleEndianArray, shifted_le);

    // We almost have our result, but now do the rounding.
    constexpr uint64_t kHalf = 0x8000000000000000ULL;
    if (shifted_out > kHalf) {
      // Strictly more than half => round up
      result += 1;
    } else if (shifted_out == kHalf) {
      // Exactly half => round to even
      if ((result.low_bits() & 1) != 0) {
        result += 1;
      }
    } else {
      // Strictly less than half => round down
    }
    return result;
  }

  template <typename Real>
  static Result<Decimal256> FromPositiveRealApprox(Real real, int32_t precision,