Clean traits and identities up

This changes the exception type of `one(Q0f7)` etc. from `InexactError` to `ArgumentError`.

Author: kimikage

src/FixedPointNumbers.jl

@@ -37,6 +37,10 @@ include("utilities.jl")
 reinterpret(x::FixedPoint) = x.i
 reinterpret(::Type{T}, x::FixedPoint{T,f}) where {T,f} = x.i
 
+# static parameters
+nbitsfrac(::Type{X}) where {T, f, X <: FixedPoint{T,f}} = f
+rawtype(::Type{X}) where {T, X <: FixedPoint{T}} = T
+
 # construction using the (approximate) intended value, i.e., N0f8
 *(x::Real, ::Type{X}) where {X<:FixedPoint} = X(x)
 
@@ -61,7 +65,17 @@ end
 # predicates
 isinteger(x::FixedPoint{T,f}) where {T,f} = (x.i&(1<<f-1)) == 0
 
+# identities
+zero(::Type{X}) where {X <: FixedPoint} = X(zero(rawtype(X)), 0)
+oneunit(::Type{X}) where {X <: FixedPoint} = X(rawone(X), 0)
+one(::Type{X}) where {X <: FixedPoint} = oneunit(X)
+
+# 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)
+
 # traits
+sizeof(::Type{X}) where {X <: FixedPoint} = sizeof(rawtype(X))
+eps(::Type{X}) where {X <: FixedPoint} = X(oneunit(rawtype(X)), 0)
 typemax(::Type{T}) where {T <: FixedPoint} = T(typemax(rawtype(T)), 0)
 typemin(::Type{T}) where {T <: FixedPoint} = T(typemin(rawtype(T)), 0)
 floatmin(::Type{T}) where {T <: FixedPoint} = eps(T)
@@ -95,18 +109,25 @@ floattype(::Type{T}) where {T <: Real} = T # fallback
 floattype(::Type{T}) where {T <: Union{ShortInts, Bool}} = Float32
 floattype(::Type{T}) where {T <: Integer} = Float64
 floattype(::Type{T}) where {T <: LongInts} = BigFloat
-floattype(::Type{FixedPoint{T,f}}) where {T <: ShortInts,f} = Float32
-floattype(::Type{FixedPoint{T,f}}) where {T <: Integer,f} = Float64
-floattype(::Type{FixedPoint{T,f}}) where {T <: LongInts,f} = BigFloat
-floattype(::Type{F}) where {F <: FixedPoint} = floattype(supertype(F))
-floattype(x::FixedPoint) = floattype(typeof(x))
-
-nbitsfrac(::Type{FixedPoint{T,f}}) where {T <: Integer,f} = f
-nbitsfrac(::Type{F}) where {F <: FixedPoint} = nbitsfrac(supertype(F))
+floattype(::Type{X}) where {T <: ShortInts, X <: FixedPoint{T}} = Float32
+floattype(::Type{X}) where {T <: Integer, X <: FixedPoint{T}} = Float64
+floattype(::Type{X}) where {T <: LongInts, X <: FixedPoint{T}} = BigFloat
 
-rawtype(::Type{FixedPoint{T,f}}) where {T <: Integer,f} = T
-rawtype(::Type{F}) where {F <: FixedPoint} = rawtype(supertype(F))
-rawtype(x::FixedPoint) = rawtype(typeof(x))
+for f in (:zero, :oneunit, :one, :eps, :rawone, :rawtype, :floattype)
+    @eval begin
+        $f(x::FixedPoint) = $f(typeof(x))
+    end
+end
+for f in (:div, :fld, :fld1)
+    @eval begin
+        $f(x::X, y::X) where {X <: FixedPoint} = $f(x.i, y.i)
+    end
+end
+for f in (:rem, :mod, :mod1, :min, :max)
+    @eval begin
+        $f(x::X, y::X) where {X <: FixedPoint} = X($f(x.i, y.i), 0)
+    end
+end
 
 # Printing. These are used to generate type-symbols, so we need them
 # before we include any files.
@@ -136,10 +157,6 @@ include("normed.jl")
 include("deprecations.jl")
 const UF = (N0f8, N6f10, N4f12, N2f14, N0f16)
 
-eps(::Type{T}) where {T <: FixedPoint} = T(oneunit(rawtype(T)),0)
-eps(::T) where {T <: FixedPoint} = eps(T)
-sizeof(::Type{T}) where {T <: FixedPoint} = sizeof(rawtype(T))
-
 # Promotions for reductions
 const Treduce = Float64
 Base.add_sum(x::FixedPoint, y::FixedPoint) = Treduce(x) + Treduce(y)
@@ -150,17 +167,6 @@ Base.reduce_empty(::typeof(Base.mul_prod), ::Type{F}) where {F<:FixedPoint} = on
 Base.reduce_first(::typeof(Base.mul_prod), x::FixedPoint)  = Treduce(x)
 
 
-for f in (:div, :fld, :fld1)
-    @eval begin
-        $f(x::T, y::T) where {T <: FixedPoint} = $f(reinterpret(x),reinterpret(y))
-    end
-end
-for f in (:rem, :mod, :mod1, :min, :max)
-    @eval begin
-        $f(x::T, y::T) where {T <: FixedPoint} = T($f(reinterpret(x),reinterpret(y)),0)
-    end
-end
-
 """
     sd, ad = scaledual(s::Number, a)
 

src/fixed.jl

@@ -41,6 +41,11 @@ for T in (Int8, Int16, Int32, Int64)
     end
 end
 
+function rawone(::Type{Fixed{T,f}}) where {T, f}
+    f >= bitwidth(T)-1 && throw_converterror(Fixed{T,f}, 1)
+    oneunit(T) << f
+end
+
 # basic operators
 -(x::Fixed{T,f}) where {T,f} = Fixed{T,f}(-x.i,0)
 abs(x::Fixed{T,f}) where {T,f} = Fixed{T,f}(abs(x.i),0)

src/normed.jl

@@ -37,15 +37,9 @@ end
 
 reinterpret(::Type{Normed{T,f}}, x::T) where {T <: Unsigned,f} = Normed{T,f}(x, 0)
 
-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)) >> (bitwidth(T)-nbitsfrac(T)), 0)
+function rawone(::Type{Normed{T,f}}) where {T <: Unsigned, f}
+    typemax(T) >> (bitwidth(T) - f)
 end
-one(::Type{T}) where {T <: Normed} = oneunit(T)
-zero(x::Normed) = zero(typeof(x))
-oneunit(x::Normed) =  one(typeof(x))
-one(x::Normed) = oneunit(x)
-rawone(v) = reinterpret(one(v))
 
 # Conversions
 function Normed{T,f}(x::Normed{T2}) where {T <: Unsigned,T2 <: Unsigned,f}
@@ -113,8 +107,6 @@ rem(x::Float16, ::Type{T}) where {T <: Normed} = rem(Float32(x), T)  # avoid ove
 
 float(x::Normed) = convert(floattype(x), x)
 
-# 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)
 
 function (::Type{T})(x::Normed) where {T <: AbstractFloat}
     # The following optimization for constant division may cause rounding errors.

test/fixed.jl

@@ -50,6 +50,14 @@ function test_fixed(::Type{T}, f) where {T}
     end
 end
 
+@testset "inexactness" begin
+    @test_throws InexactError Q0f7(-2)
+    # TODO: change back to InexactError when it allows message strings
+    @test_throws ArgumentError one(Q0f15)
+    @test_throws ArgumentError oneunit(Q0f31)
+    @test_throws ArgumentError one(Fixed{Int8,8})
+end
+
 @testset "conversion" begin
     @test isapprox(convert(Fixed{Int8,7}, 0.8), 0.797, atol=0.001)
     @test isapprox(convert(Fixed{Int8,7}, 0.9), 0.898, atol=0.001)