extend Base.decompose so hashing and comparison to rationals work (#44)

* extend Base.decompose so hashing works

* add tests of rational comparisons

Author: RalphAS

src/Quadmath.jl

@@ -11,7 +11,7 @@ import Base: (*), +, -, /,  <, <=, ==, ^, convert,
           acos, acosh, asin, asinh, atan, atanh, cosh, cos, sincos,
           exp, expm1, log, log2, log10, log1p, sin, sinh, sqrt,
           tan, tanh,
-          ceil, floor, trunc, round, fma,
+          ceil, floor, trunc, round, fma, decompose,
           copysign, flipsign, max, min, hypot, abs,
           ldexp, frexp, modf, nextfloat, typemax, typemin, eps,
           isinf, isnan, isfinite, isinteger,
@@ -564,6 +564,17 @@ promote_rule(::Type{Float128}, ::Type{<:Integer}) = Float128
 #widen(::Type{Float64}) = Float128
 widen(::Type{Float128}) = BigFloat
 
+function decompose(x::Float128)::Tuple{Int128, Int, Int}
+    isnan(x) && return 0, 0, 0
+    isinf(x) && return ifelse(x < 0, -1, 1), 0, 0
+    n = reinterpret(UInt128, x)
+    s = (n & significand_mask(Float128)) % Int128
+    e = ((n & exponent_mask(Float128)) >> 112) % Int
+    s |= Int128(e != 0) << 112
+    d = ifelse(signbit(x), -1, 1)
+    s, e - 16495 + (e == 0), d
+end
+
 function Random.rand(rng::AbstractRNG, s::Random.SamplerTrivial{Random.CloseOpen01{Float128}})
     u = rand(rng, UInt128)
     x = (reinterpret(Float128, u & Base.significand_mask(Float128)

test/hashing.jl

@@ -0,0 +1,50 @@
+# extend hashing tests from Julia Base to Float128
+
+hashtypes = Any[
+    Bool,
+    Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Float32, Float64, Float128,
+    Rational{Int8}, Rational{UInt8}, Rational{Int16}, Rational{UInt16},
+    Rational{Int32}, Rational{UInt32}, Rational{Int64}, Rational{UInt64}
+]
+hashvals = vcat(
+    typemin(Int64),
+    -Int64(maxintfloat(Float64)) .+ Int64[-4:1;],
+    typemin(Int32),
+    -Integer(maxintfloat(Float32)) .+ (-4:1),
+    -2:2,
+    Integer(maxintfloat(Float32)) .+ (-1:4),
+    typemax(Int32),
+    Int64(maxintfloat(Float64)) .+ Int64[-1:4;],
+    typemax(Int64),
+)
+
+function coerce(T::Type, x)
+    if T<:Rational
+        convert(T, coerce(typeof(numerator(zero(T))), x))
+    elseif !(T<:Integer)
+        convert(T, x)
+    else
+        x % T
+    end
+end
+
+@testset "hash 0,1" begin
+  for x = hashvals,
+      a = coerce(Float128, x)
+      @test hash(a,zero(UInt)) == invoke(hash, Tuple{Real, UInt}, a, zero(UInt))
+      @test hash(a,one(UInt)) == invoke(hash, Tuple{Real, UInt}, a, one(UInt))
+  end
+end
+
+@testset "hashing" begin
+  for T = hashtypes,
+    S = hashtypes,
+    x = hashvals,
+    a = coerce(T, x),
+    b = coerce(S, x)
+    T == Float128 || S == Float128 || continue # other types are not our problem
+    #println("$(typeof(a)) $a")
+    #println("$(typeof(b)) $b")
+    @test isequal(a,b) == (hash(a)==hash(b))
+  end
+end

test/runtests.jl

@@ -180,6 +180,54 @@ end
     @test abs((2*Float128(MathConstants.golden) - 1)^2 - 5) < 5 * tiny
 end
 
+@testset "rationals" begin
+    @test Float128(0.5) == 1//2
+    # onetenth = 1/Float128(10)
+    # apparently identical, but do the same as Base test:
+    onetenth = parse(Float128, "0.1")
+    @test onetenth != 1//10
+    # bias + log2(1/8):
+    a = Int128(1) << 115
+    # rounding as indicated by BigFloat:
+    @test onetenth == (a ÷ 10 + 1) // a
+    @test Inf128 == 1//0
+    @test -Inf128 == -1//0
+    fm = floatmin(Float128)
+    @test fm != 1//(BigInt(2)^16382+1)
+    @test fm == 1//(BigInt(2)^16382)
+    @test fm != 1//(BigInt(2)^16382-1)
+    @test fm/2 != 1//(BigInt(2)^16383+1)
+    @test fm/2 == 1//(BigInt(2)^16383)
+    @test fm/2 != 1//(BigInt(2)^16383-1)
+    tiny = nextfloat(Float128(0.0))
+    @test tiny != 1//(BigInt(2)^16494+1)
+    @test tiny == 1//(BigInt(2)^16494)
+    @test tiny != 1//(BigInt(2)^16494-1)
+
+    onethird = 1/Float128(3)
+    onefifth = 1/Float128(5)
+    @test onethird < 1//3
+    @test !(1//3 < onethird)
+    @test -onethird < 1//3
+    @test -onethird > -1//3
+    @test onethird > -1//3
+    @test onefifth > 1//5
+    @test 1//3 < Inf128
+    @test 0//1 < Inf128
+    @test 1//0 == Inf128
+    @test -1//0 == -Inf128
+    @test -1//0 != Inf128
+    @test 1//0 != -Inf128
+    @test !(1//0 < Inf128)
+    Zero = Float128(0)
+    fnan = Zero / Zero
+    @test !(1//3 < fnan)
+    @test !(1//3 == fnan)
+    @test !(1//3 > fnan)
+end
+
+include("hashing.jl")
+
 include("specfun.jl")
 
 include("printf.jl")