Revert "power uses Float64 exponents for integers (#53967)"

This reverts commit fe073c4.

Author: KristofferC

base/math.jl

@@ -1189,10 +1189,6 @@ function modf(x::T) where T<:IEEEFloat
     return (rx, ix)
 end
 
-@inline function use_power_by_squaring(n::Integer)
-    -2^12 <= n <= 3 * 2^13
-end
-
 # @constprop aggressive to help the compiler see the switch between the integer and float
 # variants for callers with constant `y`
 @constprop :aggressive function ^(x::Float64, y::Float64)
@@ -1205,33 +1201,24 @@ end
         y = sign(y)*0x1.8p62
     end
     yint = unsafe_trunc(Int64, y) # This is actually safe since julia freezes the result
-    yisint = y == yint
-    if yisint
-        yint == 0 && return 1.0
-        use_power_by_squaring(yint) && return @noinline pow_body(x, yint)
-    end
-    2*xu==0 && return abs(y)*Inf*(!(y>0)) # if x === +0.0 or -0.0 (Inf * false === 0.0)
-    s = 1
-    if x < 0
-        !yisint && throw_exp_domainerror(x) # y isn't an integer
-        s = ifelse(isodd(yint), -1, 1)
-    end
-    !isfinite(x) && return copysign(x,s)*(y>0 || isnan(x))           # x is inf or NaN
-    return copysign(pow_body(abs(x), y), s)
-end
-
-@assume_effects :foldable @noinline function pow_body(x::Float64, y::Float64)
-    xu = reinterpret(UInt64, x)
+    y == yint && return @noinline x^yint
+    2*xu==0 && return abs(y)*Inf*(!(y>0)) # if x==0
+    x<0 && throw_exp_domainerror(x) # |y| is small enough that y isn't an integer
+    !isfinite(x) && return x*(y>0 || isnan(x))           # x is inf or NaN
     if xu < (UInt64(1)<<52) # x is subnormal
         xu = reinterpret(UInt64, x * 0x1p52) # normalize x
         xu &= ~sign_mask(Float64)
         xu -= UInt64(52) << 52 # mess with the exponent
     end
-    logxhi,logxlo = _log_ext(xu)
+    return pow_body(xu, y)
+end
+
+@inline function pow_body(xu::UInt64, y::Float64)
+    logxhi,logxlo = Base.Math._log_ext(xu)
     xyhi, xylo = two_mul(logxhi,y)
     xylo = muladd(logxlo, y, xylo)
     hi = xyhi+xylo
-    return @inline Base.Math.exp_impl(hi, xylo-(hi-xyhi), Val(:ℯ))
+    return Base.Math.exp_impl(hi, xylo-(hi-xyhi), Val(:ℯ))
 end
 
 @constprop :aggressive function ^(x::T, y::T) where T <: Union{Float16, Float32}
@@ -1255,29 +1242,12 @@ end
     return T(exp2(log2(abs(widen(x))) * y))
 end
 
+# compensated power by squaring
 @constprop :aggressive @inline function ^(x::Float64, n::Integer)
-    x^clamp(n, Int64)
-end
-@constprop :aggressive @inline function ^(x::Float64, n::Int64)
     n == 0 && return one(x)
-    if use_power_by_squaring(n)
-        return pow_body(x, n)
-    else
-        s = ifelse(x < 0 && isodd(n), -1.0, 1.0)
-        x = abs(x)
-        y = float(n)
-        if y == n
-            return copysign(pow_body(x, y), s)
-        else
-            n2 = n % 1024
-            y = float(n - n2)
-            return pow_body(x, y) * copysign(pow_body(x, n2), s)
-        end
-    end
+    return pow_body(x, n)
 end
 
-# compensated power by squaring
-# this method is only reliable for -2^20 < n < 2^20 (cf. #53881 #53886)
 @assume_effects :terminates_locally @noinline function pow_body(x::Float64, n::Integer)
     y = 1.0
     xnlo = ynlo = 0.0

base/special/exp.jl

@@ -252,7 +252,7 @@ end
             twopk = (k + UInt64(53)) << 52
             return reinterpret(T, twopk + reinterpret(UInt64, small_part))*0x1p-53
         end
-        k == 1024 && return (small_part * 2.0) * 0x1p1023
+        # k == 1024 && return (small_part * 2.0) * 0x1p1023
     end
     twopk = Int64(k) << 52
     return reinterpret(T, twopk + reinterpret(Int64, small_part))

test/math.jl

@@ -1453,25 +1453,6 @@ end
     # two cases where we have observed > 1 ULP in the past
     @test 0.0013653274095082324^-97.60372292227069 == 4.088393948750035e279
     @test 8.758520413376658e-5^70.55863059215994 == 5.052076767078296e-287
-
-    # issue #53881
-    c53881 = 2.2844135865398217e222 # check correctness within 2 ULPs
-    @test prevfloat(1.0) ^ -Int64(2)^62 ≈ c53881 atol=2eps(c53881)
-    @test 2.0 ^ typemin(Int) == 0.0
-    @test (-1.0) ^ typemin(Int) == 1.0
-    Z = Int64(2)
-    E = prevfloat(1.0)
-    @test E ^ (-Z^54) ≈ 7.38905609893065
-    @test E ^ (-Z^62) ≈ 2.2844135865231613e222
-    @test E ^ (-Z^63) == Inf
-    @test abs(E ^ (Z^62-1) * E ^ (-Z^62+1) - 1) <= eps(1.0)
-    n, x = -1065564664, 0.9999997040311492
-    @test abs(x^n - Float64(big(x)^n)) / eps(x^n) == 0 # ULPs
-    @test E ^ (big(2)^100 + 1) == 0
-    @test E ^ 6705320061009595392 == nextfloat(0.0)
-    n = Int64(1024 / log2(E))
-    @test E^n == Inf
-    @test E^float(n) == Inf
 end
 
 @testset "special function `::Real` fallback shouldn't recur without bound, issue #57789" begin