Fix deprecations

Author: femtocleaner[bot]

src/FixedPointNumbers.jl

@@ -105,16 +105,14 @@ function show(io::IO, x::FixedPoint{T,f}) where {T,f}
     showtype(io, typeof(x))
 end
 const _log2_10 = 3.321928094887362
-showcompact(io::IO, x::FixedPoint{T,f}) where {T,f} = show(io, round(convert(Float64,x), digits=ceil(Int,f/_log2_10)))
-
-if VERSION >= v"0.7.0-DEV.1790"
-    function Base.showarg(io::IO, a::Array{T}, toplevel) where {T<:FixedPoint}
-        toplevel || print(io, "::")
-        print(io, "Array{")
-        showtype(io, T)
-        print(io, ",$(ndims(a))}")
-        toplevel && print(io, " with eltype ", T)
-    end
+showcompact(io::IO, x::FixedPoint{T,f}) where {T,f} = show(io, round(convert(Float64,x), digits=ceil(Int, digits=f/_log2_10)))
+
+function Base.showarg(io::IO, a::Array{T}, toplevel) where {T<:FixedPoint}
+    toplevel || print(io, "::")
+    print(io, "Array{")
+    showtype(io, T)
+    print(io, ",$(ndims(a))}")
+    toplevel && print(io, " with eltype ", T)
 end
 
 include("fixed.jl")

src/fixed.jl

@@ -10,8 +10,8 @@ end
 Fixed{T, f}(x::AbstractChar) where {T,f} = throw(ArgumentError("Fixed cannot be constructed from a Char"))
 Fixed{T, f}(x::Complex) where {T,f} = Fixed{T, f}(convert(real(typeof(x)), x))
 Fixed{T, f}(x::Base.TwicePrecision) where {T,f} = Fixed{T, f}(convert(Float64, x))
-Fixed{T,f}(x::Integer) where {T,f} = Fixed{T,f}(round(T, convert(widen1(T),x)<<f),0)
-Fixed{T,f}(x::AbstractFloat) where {T,f} = Fixed{T,f}(round(T, trunc(widen1(T),x)<<f + rem(x,1)*(one(widen1(T))<<f)),0)
+Fixed{T,f}(x::Integer) where {T,f} = Fixed{T,f}(round(T, digits=convert(widen1(T),x)<<f),0)
+Fixed{T,f}(x::AbstractFloat) where {T,f} = Fixed{T,f}(round(T, digits=trunc(widen1(T), digits=x)<<f + rem(x,1)*(one(widen1(T))<<f)),0)
 Fixed{T,f}(x::Rational) where {T,f} = Fixed{T,f}(x.num)/Fixed{T,f}(x.den)
 
 reinterpret(::Type{Fixed{T,f}}, x::T) where {T <: Signed,f} = Fixed{T,f}(x, 0)

src/normed.jl

@@ -114,10 +114,10 @@ function ceil(x::Normed{T,f}) where {T,f}
             Normed{T,f}(y+oneunit(Normed{T,f})) : y
 end
 
-trunc(::Type{T}, x::Normed) where {T <: Integer} = convert(T, div(reinterpret(x), rawone(x)))
-round(::Type{T}, x::Normed) where {T <: Integer} = round(T, reinterpret(x)/rawone(x))
-floor(::Type{T}, x::Normed) where {T <: Integer} = trunc(T, x)
- ceil(::Type{T}, x::Normed) where {T <: Integer} =  ceil(T, reinterpret(x)/rawone(x))
+trunc(::Type{T}, digits=x::Normed) where {T <: Integer} = convert(T, div(reinterpret(x), rawone(x)))
+round(::Type{T}, digits=x::Normed) where {T <: Integer} = round(T, digits=reinterpret(x)/rawone(x))
+floor(::Type{T}, digits=x::Normed) where {T <: Integer} = trunc(T, digits=x)
+ ceil(::Type{T}, digits=x::Normed) where {T <: Integer} =  ceil(T, digits=reinterpret(x)/rawone(x))
 
 isfinite(x::Normed) = true
 isnan(x::Normed) = false

test/normed.jl

@@ -176,11 +176,11 @@ function testtrunc(inc::T) where {T}
             end
             @test typeof(floor(x)) == T
             @test floor(x) == floor(xf)
-            @test trunc(Int,x) == trunc(Int,xf)
-            @test round(Int,x) == round(Int,xf)
-            @test floor(Int,x) == floor(Int,xf)
+            @test trunc(Int, digits=x) == trunc(Int, digits=xf)
+            @test round(Int, digits=x) == round(Int, digits=xf)
+            @test floor(Int, digits=x) == floor(Int, digits=xf)
             if cxf < tm
-                @test ceil(Int,x) == ceil(Int,xf)
+                @test ceil(Int, digits=x) == ceil(Int, digits=xf)
             end
         catch err
             println("Failed on x = ", x, ", xf = ", xf)