Fix UnitRange construction and length(r)

Author: timholy

src/FixedPointNumbers.jl

@@ -8,6 +8,8 @@ import Base: ==, <, <=, -, +, *, /, ~, isapprox,
              div, fld, rem, mod, mod1, fld1, min, max, minmax,
              rand
 
+using Base.Checked: checked_add, checked_sub
+
 using Base: @pure
 
 """

src/fixed.jl

@@ -161,6 +161,20 @@ function round(::Type{Ti}, x::Fixed{T,f}) where {Ti <: Integer, T, f}
     convert(Ti, z - Ti(y & m == rawone(x)))
 end
 
+# Range construction
+Base.unitrange_last(start::F, stop::F) where {F<:Fixed} =
+    stop >= start ? convert(F, start+floor(stop-start)) : convert(F, start+F(-1))
+
+# Range lengths
+Base.unsafe_length(r::AbstractUnitRange{F}) where {F <: Fixed{<:Union{SShorterThanInt,Int},f}} where {f} =
+    Int(reinterpret(last(r)) >> f - reinterpret(first(r)) >> f) + 1
+Base.unsafe_length(r::AbstractUnitRange{F}) where {F <: Fixed{T,f}} where {T<:Signed,f} =
+    T(reinterpret(last(r)) >> f - reinterpret(first(r)) >> f) + oneunit(T)
+Base.length(r::AbstractUnitRange{F}) where {F <: Fixed{<:SShorterThanInt,f}} where {f} =
+    Base.unsafe_length(r)
+Base.length(r::AbstractUnitRange{F}) where {F <: Fixed{T,f}} where {T<:Signed,f} =
+    checked_add(checked_sub(T(reinterpret(last(r)) >> f), T(reinterpret(first(r)) >> f)), oneunit(T))
+
 promote_rule(ft::Type{Fixed{T,f}}, ::Type{TI}) where {T,f,TI <: Integer} = Fixed{T,f}
 promote_rule(::Type{Fixed{T,f}}, ::Type{TF}) where {T,f,TF <: AbstractFloat} = TF
 promote_rule(::Type{Fixed{T,f}}, ::Type{Rational{TR}}) where {T,f,TR} = Rational{TR}

src/normed.jl

@@ -287,6 +287,16 @@ function decompose(x::Normed)
     div(reinterpret(x),g), 0, div(rawone(x),g)
 end
 
+# Range lengths
+Base.unsafe_length(r::AbstractUnitRange{N}) where {N <: Normed{<:UShorterThanInt}} =
+    Int(last(r)) - Int(first(r)) + 1
+Base.unsafe_length(r::AbstractUnitRange{N}) where {N <: Normed{T}} where {T<:Unsigned} =
+    T(last(r)) - T(first(r)) + oneunit(T)
+Base.length(r::AbstractUnitRange{N}) where {N <: Normed{<:ShorterThanInt}} =
+    Base.unsafe_length(r)
+Base.length(r::AbstractUnitRange{N}) where {N <: Normed{T}} where {T<:Integer} =
+    checked_add(checked_sub(T(last(r)), T(first(r))), oneunit(T))
+
 # Promotions
 promote_rule(::Type{T}, ::Type{Tf}) where {T <: Normed,Tf <: AbstractFloat} = promote_type(floattype(T), Tf)
 promote_rule(::Type{T}, ::Type{R}) where {T <: Normed,R <: Rational} = R

src/utilities.jl

@@ -16,6 +16,11 @@ widen1(x::Integer) = x % widen1(typeof(x))
 const ShortInts = Union{Int8, UInt8, Int16, UInt16}
 const LongInts = Union{Int64, UInt64, Int128, UInt128, BigInt}
 
+const ShorterThanInt = Int === Int32 ? ShortInts : Union{ShortInts, Int32, UInt32}
+const NotBiggerThanInt = Union{ShorterThanInt, Int, UInt}
+const SShorterThanInt = typeintersect(ShorterThanInt, Signed)
+const UShorterThanInt = typeintersect(ShorterThanInt, Unsigned)
+
 macro f32(x::Float64) # just for hexadecimal floating-point literals
     :(Float32($x))
 end

test/fixed.jl

@@ -183,6 +183,17 @@ end
     end
 end
 
+@testset "unit range" begin
+    @test length(Q1f6(-1):Q1f6(0)) == 2
+    @test collect(Q1f6(-1):Q1f6(0)) == Q1f6[-1, 0]
+    @test length(Q6f1(-64):Q6f1(63)) == 128
+    QIntW = Fixed{Int,bitwidth(Int)-1}
+    @test length(QIntW(-1):QIntW(0)) == 2
+    QInt1 = Fixed{Int,1}
+    @test length(typemin(QInt1):typemax(QInt1)-oneunit(QInt1)) == typemax(Int)
+    @test_throws OverflowError length(typemin(QInt1):typemax(QInt1))
+end
+
 @testset "reductions" begin
     a = Q0f7[0.75, 0.5]
     acmp = Float64(a[1]) + Float64(a[2])

test/normed.jl

@@ -300,17 +300,31 @@ end
     @test bswap(N0f8(0.5)) === N0f8(0.5)
     @test bswap(N0f16(0.5)) === reinterpret(N0f16, 0x0080)
     @test minmax(N0f8(0.8), N0f8(0.2)) === (N0f8(0.2), N0f8(0.8))
+end
 
-    r = reinterpret(N0f8, 0x01):reinterpret(N0f8, 0x01):reinterpret(N0f8, convert(UInt8, 48))
-    @test length(r) == 48
-    end
+@testset "unit range" begin
+    @test length(N0f8(0):N0f8(1)) == 2
+    @test collect(N0f8(0):N0f8(1)) == N0f8[0, 1]
+    @test length(N7f1(0):N7f1(255)) == 256
+    NIntW = Normed{UInt,bitwidth(UInt)}
+    @test length(NIntW(0):NIntW(1)) == 2
+    NInt1 = Normed{UInt,1}
+    @test length(NInt1(0):typemax(NInt1)-oneunit(NInt1)) == typemax(UInt)
+    @test_throws OverflowError length(NInt1(0):typemax(NInt1))
+    @test Base.unsafe_length(NInt1(0):typemax(NInt1)) == 0  # overflow
+    N64f64 = Normed{UInt128,64}
+    @test_broken length(N64f64(0):typemax(N64f64)) == UInt128(typemax(UInt64)) + 1
+end
 
-    @testset "step range" begin
+@testset "step range" begin
     counter = 0
     for x in N0f8(0):eps(N0f8):N0f8(1)
         counter += 1
     end
     @test counter == 256
+    @test length(N0f8(0):eps(N0f8):N0f8(1)) == 256
+    r = reinterpret(N0f8, 0x01):reinterpret(N0f8, 0x01):reinterpret(N0f8, convert(UInt8, 48))
+    @test length(r) == 48
 end
 
 @testset "Promotion within Normed" begin