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

@@ -43,6 +43,9 @@ function rawone(::Type{Fixed{T,f}}) where {T, f}
     f >= bitwidth(T)-1 && throw_converterror(Fixed{T,f}, 1)
     oneunit(T) << f
 end
+function rawminusone(::Type{Fixed{T,f}}) where {T, f}
+    (-oneunit(T)) << f
+end
 
 # unchecked arithmetic
 
@@ -85,6 +88,27 @@ end
 (::Type{TR})(x::Fixed{T,f}) where {TR <: Rational,T,f} =
     TR(x.i>>f + (x.i&(1<<f-1))//(one(widen1(T))<<f))
 
+# The following are needed for range construction
+function round(x::Fixed{T,f}, ::RoundingMode{:Down}) where {T,f}
+    mask = abs(rawminusone(Fixed{T,f}) + oneunit(T))
+    xraw = reinterpret(x)
+    return Fixed{T,f}((xraw & ~mask) + (signbit(xraw) & (xraw & mask) != 0 ? rawminusone(Fixed{T,f}) : zero(xraw)), 0)
+end
+Base.unitrange_last(start::T, stop::T) where {T<:Fixed} =
+    ifelse(stop >= start, convert(T,start+floor(stop-start)),
+                          convert(T,start+T(-1)))
+
+
+# Range lengths
+Base.unsafe_length(r::AbstractUnitRange{X}) where {X <: Fixed{<:Union{SShorterThanInt,Int},f}} where {f} =
+    Int(reinterpret(last(r)) >> f - reinterpret(first(r)) >> f) + 1
+Base.unsafe_length(r::AbstractUnitRange{X}) where {X <: Fixed{T,f}} where {T<:Signed,f} =
+    T(reinterpret(last(r)) >> f - reinterpret(first(r)) >> f) + oneunit(T)
+Base.length(r::AbstractUnitRange{X}) where {X <: Fixed{<:SShorterThanInt,f}} where {f} =
+    Base.unsafe_length(r)
+Base.length(r::AbstractUnitRange{X}) where {X <: 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

@@ -275,6 +275,16 @@ function decompose(x::Normed)
     div(reinterpret(x),g), 0, div(rawone(x),g)
 end
 
+# Range lengths
+Base.unsafe_length(r::AbstractUnitRange{X}) where {X <: Normed{<:UShorterThanInt}} =
+    Int(last(r)) - Int(first(r)) + 1
+Base.unsafe_length(r::AbstractUnitRange{X}) where {X <: Normed{T}} where {T<:Unsigned} =
+    T(last(r)) - T(first(r)) + oneunit(T)
+Base.length(r::AbstractUnitRange{X}) where {X <: Normed{<:ShorterThanInt}} =
+    Base.unsafe_length(r)
+Base.length(r::AbstractUnitRange{X}) where {X <: 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

@@ -111,6 +111,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)-1
+    @test length(typemin(QInt1):typemax(QInt1)) == typemax(Int)
+end
+
 @testset "reductions" begin
     F8 = Fixed{Int8,8}
     a = F8[0.498, 0.1]

test/normed.jl

@@ -295,17 +295,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