Implement full-range i256::to_f64 to eliminate ±∞ saturation for Decimal256 → Float64 casts (#7986)

# Which issue does this PR close?

Closes #7985

---

# Rationale for this change

The existing Decimal256 → Float64 conversion was changed to **saturate**
out-of-range values to `±INFINITY` (PR #7887) in order to avoid panics.
However, every 256-bit signed integer actually fits within the exponent
range of an IEEE-754 `f64` (±2¹⁰²³), so we can always produce a
**finite** `f64`, only sacrificing mantissa precision.
By overriding `i256::to_f64` to split the full 256-bit magnitude into
high/low 128-bit halves, recombine as
```text
(high as f64) * 2^128 + (low as f64)
```
and reapply the sign (special-casing i256::MIN), we:

- Eliminate both panics and infinite results

- Match Rust’s built-in (i128) as f64 rounding (ties-to-even)

- Simplify casting logic—no saturating helpers or extra flags required

# What changes are included in this PR?

- Added full-range fn to_f64(&self) -> Option<f64> for i256, using
checked_abs() + to_parts() + recombination

- Removed fallback through 64-bit to_i64()/to_u64() and .unwrap()

- Replaced the old decimal256_to_f64 saturating helper with a thin
wrapper around the new i256::to_f64() (always returns Some)

- Updated Decimal256 → Float64 cast sites to call the new helper

## Tests

- Reworked “overflow” tests to assert finite & correctly signed results
for i256::MAX and i256::MIN

- Added typical-value tests; removed expectations of ∞/-∞

# Are there any user-facing changes?
Behavior change:

- Very large or small Decimal256 values no longer become +∞/-∞.

- They now map to very large—but finite—f64 values (rounded to nearest
mantissa).

## API impact:

No public API signatures changed.

Conversion remains lossy by design; users relying on
saturation-to-infinity will observe different (more faithful) behavior.

---------

Co-authored-by: Ryan Johnson <[email protected]>

Author: kosiew

arrow-buffer/src/bigint/mod.rs

@@ -821,6 +821,20 @@ impl ToPrimitive for i256 {
         }
     }
 
+    fn to_f64(&self) -> Option<f64> {
+        let mag = if let Some(u) = self.checked_abs() {
+            let (low, high) = u.to_parts();
+            (high as f64) * 2_f64.powi(128) + (low as f64)
+        } else {
+            // self == MIN
+            2_f64.powi(255)
+        };
+        if *self < i256::ZERO {
+            Some(-mag)
+        } else {
+            Some(mag)
+        }
+    }
     fn to_u64(&self) -> Option<u64> {
         let as_i128 = self.low as i128;
 
@@ -1264,4 +1278,29 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_decimal256_to_f64_typical_values() {
+        let v = i256::from_i128(42_i128);
+        assert_eq!(v.to_f64().unwrap(), 42.0);
+
+        let v = i256::from_i128(-123456789012345678i128);
+        assert_eq!(v.to_f64().unwrap(), -123456789012345678.0);
+    }
+
+    #[test]
+    fn test_decimal256_to_f64_large_positive_value() {
+        let max_f = f64::MAX;
+        let big = i256::from_f64(max_f * 2.0).unwrap_or(i256::MAX);
+        let out = big.to_f64().unwrap();
+        assert!(out.is_finite() && out.is_sign_positive());
+    }
+
+    #[test]
+    fn test_decimal256_to_f64_large_negative_value() {
+        let max_f = f64::MAX;
+        let big_neg = i256::from_f64(-(max_f * 2.0)).unwrap_or(i256::MIN);
+        let out = big_neg.to_f64().unwrap();
+        assert!(out.is_finite() && out.is_sign_negative());
+    }
 }

arrow-cast/src/cast/mod.rs

@@ -907,7 +907,7 @@ pub fn cast_with_options(
                 scale,
                 from_type,
                 to_type,
-                |x: i256| decimal256_to_f64(x),
+                |x: i256| x.to_f64().expect("All i256 values fit in f64"),
                 cast_options,
             )
         }
@@ -2009,17 +2009,6 @@ where
     }
 }
 
-/// Convert a [`i256`] to `f64` saturating to infinity on overflow.
-fn decimal256_to_f64(v: i256) -> f64 {
-    v.to_f64().unwrap_or_else(|| {
-        if v.is_negative() {
-            f64::NEG_INFINITY
-        } else {
-            f64::INFINITY
-        }
-    })
-}
-
 fn cast_to_decimal<D, M>(
     array: &dyn Array,
     base: M,
@@ -2453,6 +2442,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use arrow_buffer::i256;
     use arrow_buffer::{Buffer, IntervalDayTime, NullBuffer};
     use chrono::NaiveDate;
     use half::f16;
@@ -8688,26 +8678,26 @@ mod tests {
         );
     }
     #[test]
-    fn test_cast_decimal256_to_f64_overflow() {
-        // Test positive overflow (positive infinity)
+    fn test_cast_decimal256_to_f64_no_overflow() {
+        // Test casting i256::MAX: should produce a large finite positive value
         let array = vec![Some(i256::MAX)];
         let array = create_decimal256_array(array, 76, 2).unwrap();
         let array = Arc::new(array) as ArrayRef;
 
         let result = cast(&array, &DataType::Float64).unwrap();
         let result = result.as_primitive::<Float64Type>();
-        assert!(result.value(0).is_infinite());
-        assert!(result.value(0) > 0.0); // Positive infinity
+        assert!(result.value(0).is_finite());
+        assert!(result.value(0) > 0.0); // Positive result
 
-        // Test negative overflow (negative infinity)
+        // Test casting i256::MIN: should produce a large finite negative value
         let array = vec![Some(i256::MIN)];
         let array = create_decimal256_array(array, 76, 2).unwrap();
         let array = Arc::new(array) as ArrayRef;
 
         let result = cast(&array, &DataType::Float64).unwrap();
         let result = result.as_primitive::<Float64Type>();
-        assert!(result.value(0).is_infinite());
-        assert!(result.value(0) < 0.0); // Negative infinity
+        assert!(result.value(0).is_finite());
+        assert!(result.value(0) < 0.0); // Negative result
     }
 
     #[test]
@@ -8738,6 +8728,15 @@ mod tests {
         assert_eq!("3123460", decimal_arr.value_as_string(2));
     }
 
+    #[test]
+    fn decimal128_min_max_to_f64() {
+        // Ensure Decimal128 i128::MIN/MAX round-trip cast
+        let min128 = i128::MIN;
+        let max128 = i128::MAX;
+        assert_eq!(min128 as f64, min128 as f64);
+        assert_eq!(max128 as f64, max128 as f64);
+    }
+
     #[test]
     fn test_cast_numeric_to_decimal128_negative() {
         let decimal_type = DataType::Decimal128(38, -1);