Function pow_decimal_int

datafusion/functions/src/math/power.rs:126–188

Binary function to calculate a math power to integer exponent for scaled integer types. Formula The power for a scaled integer `b` is ```text (b * 10^(-s)) ^ e ``` However, the result should be scaled back from scale 0 to scale `s`, which is done by multiplying by `10^s`. At the end, the formula is: ```text b^e * 10^(-s * e) * 10^s = b^e / 10^(s * (e-1)) ``` Example of 2.5 ^ 4 = 39: 2.5 is repr

(base: T, scale: i8, exp: i64)

///   The unscaled result is 25^4 = 390625
///   Scale it back to 1: 390625 / 10^4 = 39
fn pow_decimal_int<T>(base: T, scale: i8, exp: i64) -> Result<T, ArrowError>
where
    T: ArrowNativeType + ArrowNativeTypeOp + ToPrimitive + NumCast + Copy,
{
    // Negative exponent: fall back to float computation
    if exp < 0 {
        return pow_decimal_float(base, scale, exp as f64);
    }

    let exp: u32 = exp.try_into().map_err(|_| {
        ArrowError::ArithmeticOverflow(format!("Unsupported exp value: {exp}"))
    })?;
    // Handle edge case for exp == 0
    // If scale < 0, 10^scale (e.g., 10^-2 = 0.01) becomes 0 in integer arithmetic.
    if exp == 0 {
        return if scale >= 0 {
            T::usize_as(10).pow_checked(scale as u32).map_err(|_| {
                ArrowError::ArithmeticOverflow(format!(
                    "Cannot make unscale factor for {scale} and {exp}"
                ))
            })
        } else {
            Ok(T::ZERO)
        };
    }
    let powered: T = base.pow_checked(exp).map_err(|_| {
        ArrowError::ArithmeticOverflow(format!("Cannot raise base {base:?} to exp {exp}"))
    })?;

    // Calculate the scale adjustment: s * (e - 1)
    // We use i64 to prevent overflow during the intermediate multiplication
    let mul_exp = (scale as i64).wrapping_mul(exp as i64 - 1);

    if mul_exp == 0 {
        return Ok(powered);
    }

    // If mul_exp is positive, we divide (standard case).
    // If mul_exp is negative, we multiply (negative scale case).
    if mul_exp > 0 {
        let div_factor: T =
            T::usize_as(10).pow_checked(mul_exp as u32).map_err(|_| {
                ArrowError::ArithmeticOverflow(format!(
                    "Cannot make div factor for {scale} and {exp}"
                ))
            })?;
        powered.div_checked(div_factor)
    } else {
        // mul_exp is negative, so we multiply by 10^(-mul_exp)
        let abs_exp = mul_exp.checked_neg().ok_or_else(|| {
            ArrowError::ArithmeticOverflow(
                "Overflow while negating scale exponent".to_string(),
            )
        })?;
        let mul_factor: T =
            T::usize_as(10).pow_checked(abs_exp as u32).map_err(|_| {
                ArrowError::ArithmeticOverflow(format!(
                    "Cannot make mul factor for {scale} and {exp}"