Put utility functions and macros into a new file "utilities.jl"

kimikage · kimikage · commit 3caea524e15e · 2019-12-25T19:59:13.000+09:00
diff --git a/src/FixedPointNumbers.jl b/src/FixedPointNumbers.jl
@@ -31,6 +31,9 @@ export
 # Functions
     scaledual
 
+include("utilities.jl")
+
+# reinterpretation
 reinterpret(x::FixedPoint) = x.i
 reinterpret(::Type{T}, x::FixedPoint{T,f}) where {T,f} = x.i
 
@@ -64,20 +67,6 @@ typemin(::Type{T}) where {T <: FixedPoint} = T(typemin(rawtype(T)), 0)
 floatmin(::Type{T}) where {T <: FixedPoint} = eps(T)
 floatmax(::Type{T}) where {T <: FixedPoint} = typemax(T)
 
-widen1(::Type{Int8})   = Int16
-widen1(::Type{UInt8})  = UInt16
-widen1(::Type{Int16})  = Int32
-widen1(::Type{UInt16}) = UInt32
-widen1(::Type{Int32})  = Int64
-widen1(::Type{UInt32}) = UInt64
-widen1(::Type{Int64})  = Int128
-widen1(::Type{UInt64}) = UInt128
-widen1(::Type{Int128}) = Int128
-widen1(::Type{UInt128}) = UInt128
-widen1(x::Integer) = x % widen1(typeof(x))
-
-const ShortInts = Union{Int8,UInt8,Int16,UInt16}
-const LongInts = Union{UInt64, UInt128, Int64, Int128, BigInt}
 
 """
     floattype(::Type{T})
@@ -124,7 +113,7 @@ rawtype(x::FixedPoint) = rawtype(typeof(x))
 function showtype(io::IO, ::Type{X}) where {X <: FixedPoint}
     print(io, typechar(X))
     f = nbitsfrac(X)
-    m = sizeof(X)*8-f-signbits(X)
+    m = bitwidth(X)-f-signbits(X)
     print(io, m, 'f', f)
     io
 end
@@ -188,13 +177,13 @@ scaledual(::Type{Tdual}, x::FixedPoint) where Tdual = convert(Tdual, 1/rawone(x)
 scaledual(::Type{Tdual}, x::AbstractArray{T}) where {Tdual, T <: FixedPoint} =
     convert(Tdual, 1/rawone(T)), reinterpret(rawtype(T), x)
 
-@noinline function throw_converterror(::Type{T}, x) where {T <: FixedPoint}
-    n = 2^(8*sizeof(T))
-    bitstring = sizeof(T) == 1 ? "an 8-bit" : "a $(8*sizeof(T))-bit"
+@noinline function throw_converterror(::Type{X}, x) where {X <: FixedPoint}
+    n = 2^bitwidth(X)
+    bitstring = bitwidth(X) == 8 ? "an 8-bit" : "a $(bitwidth(X))-bit"
     io = IOBuffer()
-    show(IOContext(io, :compact=>true), typemin(T)); Tmin = String(take!(io))
-    show(IOContext(io, :compact=>true), typemax(T)); Tmax = String(take!(io))
-    throw(ArgumentError("$T is $bitstring type representing $n values from $Tmin to $Tmax; cannot represent $x"))
+    show(IOContext(io, :compact=>true), typemin(X)); Xmin = String(take!(io))
+    show(IOContext(io, :compact=>true), typemax(X)); Xmax = String(take!(io))
+    throw(ArgumentError("$X is $bitstring type representing $n values from $Xmin to $Xmax; cannot represent $x"))
 end
 
 rand(::Type{T}) where {T <: FixedPoint} = reinterpret(T, rand(rawtype(T)))
diff --git a/src/fixed.jl b/src/fixed.jl
@@ -32,7 +32,7 @@ signbits(::Type{X}) where {X <: Fixed} = 1
 
 for T in (Int8, Int16, Int32, Int64)
     io = IOBuffer()
-    for f in 0:sizeof(T)*8-1
+    for f in 0:bitwidth(T)-1
         sym = Symbol(String(take!(showtype(io, Fixed{T,f}))))
         @eval begin
             const $sym = Fixed{$T,$f}
@@ -96,13 +96,13 @@ promote_rule(::Type{Fixed{T,f}}, ::Type{Rational{TR}}) where {T,f,TR} = Rational
     f = max(f1, f2)  # ensure we have enough precision
     T = promote_type(T1, T2)
     # make sure we have enough integer bits
-    i1, i2 = 8*sizeof(T1)-f1, 8*sizeof(T2)-f2  # number of integer bits for each
-    i = 8*sizeof(T)-f
+    i1, i2 = bitwidth(T1)-f1, bitwidth(T2)-f2  # number of integer bits for each
+    i = bitwidth(T)-f
     while i < max(i1, i2)
         Tw = widen1(T)
         T == Tw && break
         T = Tw
-        i = 8*sizeof(T)-f
+        i = bitwidth(T)-f
     end
     :(Fixed{$T,$f})
 end
diff --git a/src/normed.jl b/src/normed.jl
@@ -26,7 +26,7 @@ signbits(::Type{X}) where {X <: Normed} = 0
 
 for T in (UInt8, UInt16, UInt32, UInt64)
     io = IOBuffer()
-    for f in 1:sizeof(T)*8
+    for f in 1:bitwidth(T)
         sym = Symbol(String(take!(showtype(io, Normed{T,f}))))
         @eval begin
             const $sym = Normed{$T,$f}
@@ -39,7 +39,7 @@ reinterpret(::Type{Normed{T,f}}, x::T) where {T <: Unsigned,f} = Normed{T,f}(x,
 
 zero(::Type{Normed{T,f}}) where {T,f} = Normed{T,f}(zero(T),0)
 function oneunit(::Type{T}) where {T <: Normed}
-    T(typemax(rawtype(T)) >> (8*sizeof(T)-nbitsfrac(T)), 0)
+    T(typemax(rawtype(T)) >> (bitwidth(T)-nbitsfrac(T)), 0)
 end
 one(::Type{T}) where {T <: Normed} = oneunit(T)
 zero(x::Normed) = zero(typeof(x))
@@ -76,36 +76,34 @@ function _convert(::Type{U}, x::Float16) where {T, f, U <: Normed{T,f}}
     end
     return _convert(U, Float32(x))
 end
-function _convert(::Type{U}, x::Tf) where {T, f, U <: Normed{T,f}, Tf <: Union{Float32, Float64}}
-    if T == UInt128 && f == 53
-        0 <= x <= Tf(3.777893186295717e22) || throw_converterror(U, x)
+function _convert(::Type{N}, x::Tf) where {T, f, N <: Normed{T,f}, Tf <: Union{Float32, Float64}}
+    if T === UInt128 && f == 53
+        0 <= x <= Tf(3.777893186295717e22) || throw_converterror(N, x)
     else
-        0 <= x <= Tf((typemax(T)-rawone(U))/rawone(U)+1) || throw_converterror(U, x)
+        0 <= x <= Tf((typemax(T)-rawone(N))/rawone(N)+1) || throw_converterror(N, x)
     end
 
-    significand_bits = Tf == Float64 ? 52 : 23
-    if f <= (significand_bits + 1) && sizeof(T) * 8 < significand_bits
-        return reinterpret(U, unsafe_trunc(T, round(rawone(U) * x)))
+    if f <= (significand_bits(Tf) + 1) && bitwidth(T) < significand_bits(Tf)
+        return reinterpret(N, unsafe_trunc(T, round(rawone(N) * x)))
     end
     # cf. the implementation of `frexp`
-    Tw = f < sizeof(T) * 8 ? T : widen1(T)
-    bits = sizeof(Tw) * 8 - 1
-    xu = reinterpret(Tf == Float64 ? UInt64 : UInt32, x)
-    k = Int(xu >> significand_bits)
-    k == 0 && return zero(U) # neglect subnormal numbers
-    significand = xu | (one(xu) << significand_bits)
-    yh = unsafe_trunc(Tw, significand) << (bits - significand_bits)
-    exponent_bias = Tf == Float64 ? 1023 : 127
-    ex = exponent_bias - k + bits - f
+    Tw = f < bitwidth(T) ? T : widen1(T)
+    bits = bitwidth(Tw) - 1
+    xu = reinterpret(Unsigned, x)
+    k = Int(xu >> significand_bits(Tf))
+    k == 0 && return zero(N) # neglect subnormal numbers
+    significand = xu | (one(xu) << significand_bits(Tf))
+    yh = unsafe_trunc(Tw, significand) << (bits - significand_bits(Tf))
+    ex = exponent_bias(Tf) - k + bits - f
     yi = bits >= f ? yh - (yh >> f) : yh
     if ex <= 0
-        ex == 0 && return reinterpret(U, unsafe_trunc(T, yi))
-        ex != -1 || signbit(signed(yi)) && return typemax(U)
-        return reinterpret(U, unsafe_trunc(T, yi + yi))
+        ex == 0 && return reinterpret(N, unsafe_trunc(T, yi))
+        ex != -1 || signbit(signed(yi)) && return typemax(N)
+        return reinterpret(N, unsafe_trunc(T, yi + yi))
     end
-    ex > bits && return reinterpret(U, ex == bits + 1 ? one(T) : zero(T))
+    ex > bits && return reinterpret(N, ex == bits + 1 ? one(T) : zero(T))
     yi += one(Tw)<<((ex - 1) & bits) # RoundNearestTiesUp
-    return reinterpret(U, unsafe_trunc(T, yi >> (ex & bits)))
+    return reinterpret(N, unsafe_trunc(T, yi >> (ex & bits)))
 end
 
 rem(x::T, ::Type{T}) where {T <: Normed} = x
@@ -115,14 +113,6 @@ rem(x::Float16, ::Type{T}) where {T <: Normed} = rem(Float32(x), T)  # avoid ove
 
 float(x::Normed) = convert(floattype(x), x)
 
-macro f32(x::Float64) # just for hexadecimal floating-point literals
-    :(Float32($x))
-end
-macro exp2(n)
-     :(_exp2(Val($(esc(n)))))
-end
-_exp2(::Val{N}) where {N} = exp2(N)
-
 # for Julia v1.0, which does not fold `div_float` before inlining
 inv_rawone(x) = (@generated) ? (y = 1.0 / rawone(x); :($y)) : 1.0 / rawone(x)
 
@@ -275,7 +265,7 @@ function round(x::Normed{T,f}) where {T,f}
             Normed{T,f}(y+oneunit(Normed{T,f})) : y
 end
 function ceil(x::Normed{T,f}) where {T,f}
-    k = 8*sizeof(T)-f
+    k = bitwidth(T)-f
     mask = (typemax(T)<<k)>>k
     y = trunc(x)
     return convert(T, reinterpret(x)-reinterpret(y)) & (mask)>0 ?
@@ -324,13 +314,13 @@ end
     f = max(f1, f2)  # ensure we have enough precision
     T = promote_type(T1, T2)
     # make sure we have enough integer bits
-    i1, i2 = 8*sizeof(T1)-f1, 8*sizeof(T2)-f2  # number of integer bits for each
-    i = 8*sizeof(T)-f
+    i1, i2 = bitwidth(T1)-f1, bitwidth(T2)-f2  # number of integer bits for each
+    i = bitwidth(T)-f
     while i < max(i1, i2)
         Tw = widen1(T)
         T == Tw && break
         T = Tw
-        i = 8*sizeof(T)-f
+        i = bitwidth(T)-f
     end
     :(Normed{$T,$f})
 end
diff --git a/src/utilities.jl b/src/utilities.jl
@@ -0,0 +1,31 @@
+# utility functions and macros, which are independent of `FixedPoint`
+bitwidth(T::Type) = 8sizeof(T)
+
+widen1(::Type{Int8})    = Int16
+widen1(::Type{UInt8})   = UInt16
+widen1(::Type{Int16})   = Int32
+widen1(::Type{UInt16})  = UInt32
+widen1(::Type{Int32})   = Int64
+widen1(::Type{UInt32})  = UInt64
+widen1(::Type{Int64})   = Int128
+widen1(::Type{UInt64})  = UInt128
+widen1(::Type{Int128})  = Int128
+widen1(::Type{UInt128}) = UInt128
+widen1(x::Integer) = x % widen1(typeof(x))
+
+const ShortInts = Union{Int8, UInt8, Int16, UInt16}
+const LongInts = Union{Int64, UInt64, Int128, UInt128, BigInt}
+
+macro f32(x::Float64) # just for hexadecimal floating-point literals
+    :(Float32($x))
+end
+macro exp2(n)
+     :(_exp2(Val($(esc(n)))))
+end
+_exp2(::Val{N}) where {N} = exp2(N)
+
+# these are defined in julia/float.jl or julia/math.jl, but not exported
+significand_bits(::Type{Float32}) = 23
+significand_bits(::Type{Float64}) = 52
+exponent_bias(::Type{Float32}) = 127
+exponent_bias(::Type{Float64}) = 1023
diff --git a/test/fixed.jl b/test/fixed.jl
@@ -1,4 +1,5 @@
 using FixedPointNumbers, Test
+using FixedPointNumbers: bitwidth
 
 function test_op(fun::F, ::Type{T}, fx, fy, fxf, fyf, tol) where {F,T}
     # Make sure that the result is representable
@@ -164,7 +165,7 @@ end
                  (Int64, 63))
         tmax = typemax(Fixed{T, f})
         @test tmax == BigInt(typemax(T)) / BigInt(2)^f
-        tol = (tmax + BigFloat(1.0)) / (sizeof(T) * 8)
+        tol = (tmax + BigFloat(1.0)) / bitwidth(T)
         for x in range(-1, stop=BigFloat(tmax)-tol, length=50)
             @test abs(Fixed{T, f}(x) - x) <= tol
         end
diff --git a/test/normed.jl b/test/normed.jl
@@ -1,4 +1,5 @@
 using FixedPointNumbers, Test
+using FixedPointNumbers: bitwidth
 
 @testset "reinterpret" begin
     @test reinterpret(N0f8, 0xa2).i  === 0xa2
@@ -106,7 +107,7 @@ end
     # issue 102
     for T in (UInt8, UInt16, UInt32, UInt64, UInt128)
         for Tf in (Float16, Float32, Float64)
-            @testset "Normed{$T,$f}(::$Tf)" for f = 1:sizeof(T)*8
+            @testset "Normed{$T,$f}(::$Tf)" for f = 1:bitwidth(T)
                 U = Normed{T,f}
                 r = FixedPointNumbers.rawone(U)
 
@@ -123,7 +124,7 @@ end
                 isinf(input_upper) && continue # for Julia v0.7
                 @test reinterpret(U(input_upper)) == T(min(round(BigFloat(input_upper) * r), typemax(T)))
 
-                input_exp2 = Tf(exp2(sizeof(T) * 8 - f))
+                input_exp2 = Tf(exp2(bitwidth(T) - f))
                 isinf(input_exp2) && continue
                 @test reinterpret(U(input_exp2)) == T(input_exp2) * r
             end
@@ -143,7 +144,7 @@ end
 
     for Tf in (Float16, Float32, Float64)
         @testset "$Tf(::Normed{$Ti})" for Ti in (UInt8, UInt16)
-            @testset "$Tf(::Normed{$Ti,$f})" for f = 1:(sizeof(Ti)*8)
+            @testset "$Tf(::Normed{$Ti,$f})" for f = 1:bitwidth(Ti)
                 T = Normed{Ti,f}
                 float_err = 0.0
                 for i = typemin(Ti):typemax(Ti)
@@ -156,7 +157,7 @@ end
             end
         end
         @testset "$Tf(::Normed{$Ti})" for Ti in (UInt32, UInt64, UInt128)
-            @testset "$Tf(::Normed{$Ti,$f})" for f = 1:(sizeof(Ti)*8)
+            @testset "$Tf(::Normed{$Ti,$f})" for f = 1:bitwidth(Ti)
                 T = Normed{Ti,f}
                 error_count = 0
                 for i in vcat(Ti(0x00):Ti(0xFF), (typemax(Ti)-0xFF):typemax(Ti))
