change all convert methods to constructors

Author: rdeits

src/FixedPointNumbers.jl

@@ -142,12 +142,12 @@ if isdefined(Base, :r_promote)
                        Base.reducedim_initarray(A, region, oneunit(Treduce))
 else
     # Julia v0.7
-    Base.add_sum(x::FixedPoint, y::FixedPoint) = convert(Treduce, x) + convert(Treduce, y)
+    Base.add_sum(x::FixedPoint, y::FixedPoint) = Treduce(x) + Treduce(y)
     Base.reduce_empty(::typeof(Base.add_sum), ::Type{F}) where {F<:FixedPoint}  = zero(Treduce)
-    Base.reduce_first(::typeof(Base.add_sum), x::FixedPoint)   = convert(Treduce, x)
-    Base.mul_prod(x::FixedPoint, y::FixedPoint) = convert(Treduce, x) * convert(Treduce, y)
+    Base.reduce_first(::typeof(Base.add_sum), x::FixedPoint)   = Treduce(x)
+    Base.mul_prod(x::FixedPoint, y::FixedPoint) = Treduce(x) * Treduce(y)
     Base.reduce_empty(::typeof(Base.mul_prod), ::Type{F}) where {F<:FixedPoint} = one(Treduce)
-    Base.reduce_first(::typeof(Base.mul_prod), x::FixedPoint)  = convert(Treduce, x)
+    Base.reduce_first(::typeof(Base.mul_prod), x::FixedPoint)  = Treduce(x)
 end
 
 

src/fixed.jl

@@ -5,13 +5,15 @@ struct Fixed{T <: Signed,f} <: FixedPoint{T,  f}
     # constructor for manipulating the representation;
     # selected by passing an extra dummy argument
     Fixed{T, f}(i::Integer, _) where {T,f} = new{T, f}(i % T)
-    Fixed{T, f}(x) where {T,f} = convert(Fixed{T,f}, x)
-    Fixed{T, f}(x::Fixed{T,f}) where {T,f} = x
-    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))
 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::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)
 
 typechar(::Type{X}) where {X <: Fixed} = 'Q'
@@ -43,33 +45,29 @@ abs(x::Fixed{T,f}) where {T,f} = Fixed{T,f}(abs(x.i),0)
 
 
 # # conversions and promotions
-convert(::Type{Fixed{T,f}}, x::Integer) where {T,f} = Fixed{T,f}(round(T, convert(widen1(T),x)<<f),0)
-convert(::Type{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)
-convert(::Type{Fixed{T,f}}, x::Rational) where {T,f} = Fixed{T,f}(x.num)/Fixed{T,f}(x.den)
 
 rem(x::Integer, ::Type{Fixed{T,f}}) where {T,f} = Fixed{T,f}(rem(x,T)<<f,0)
 rem(x::Real,    ::Type{Fixed{T,f}}) where {T,f} = Fixed{T,f}(rem(Integer(trunc(x)),T)<<f + rem(Integer(round(rem(x,1)*(one(widen1(T))<<f))),T),0)
 
-# convert{T,f}(::Type{AbstractFloat}, x::Fixed{T,f}) = convert(floattype(x), x)
 float(x::Fixed) = convert(floattype(x), x)
 
-convert(::Type{BigFloat}, x::Fixed{T,f}) where {T,f} =
-    convert(BigFloat,x.i>>f) + convert(BigFloat,x.i&(one(widen1(T))<<f - 1))/convert(BigFloat,one(widen1(T))<<f)
-convert(::Type{TF}, x::Fixed{T,f}) where {TF <: AbstractFloat,T,f} =
-    convert(TF,x.i>>f) + convert(TF,x.i&(one(widen1(T))<<f - 1))/convert(TF,one(widen1(T))<<f)
+Base.BigFloat(x::Fixed{T,f}) where {T,f} =
+    BigFloat(x.i>>f) + BigFloat(x.i&(one(widen1(T))<<f - 1))/BigFloat(one(widen1(T))<<f)
+(::Type{TF})(x::Fixed{T,f}) where {TF <: AbstractFloat,T,f} =
+    TF(x.i>>f) + TF(x.i&(one(widen1(T))<<f - 1))/TF(one(widen1(T))<<f)
 
-convert(::Type{Bool}, x::Fixed{T,f}) where {T,f} = x.i!=0
-function convert(::Type{Integer}, x::Fixed{T,f}) where {T,f}
+Base.Bool(x::Fixed{T,f}) where {T,f} = x.i!=0
+function Base.Integer(x::Fixed{T,f}) where {T,f}
     isinteger(x) || throw(InexactError())
-    convert(Integer, x.i>>f)
+    Integer(x.i>>f)
 end
-function convert(::Type{TI}, x::Fixed{T,f}) where {TI <: Integer,T,f}
+function (::Type{TI})(x::Fixed{T,f}) where {TI <: Integer,T,f}
     isinteger(x) || throw(InexactError())
-    convert(TI, x.i>>f)
+    TI(x.i>>f)
 end
 
-convert(::Type{TR}, x::Fixed{T,f}) where {TR <: Rational,T,f} =
-    convert(TR, x.i>>f + (x.i&(1<<f-1))//(one(widen1(T))<<f))
+(::Type{TR})(x::Fixed{T,f}) where {TR <: Rational,T,f} =
+    TR(x.i>>f + (x.i&(1<<f-1))//(one(widen1(T))<<f))
 
 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

src/normed.jl

@@ -5,13 +5,13 @@ struct Normed{T<:Unsigned,f} <: FixedPoint{T,f}
     i::T
 
     Normed{T, f}(i::Integer,_) where {T,f} = new{T, f}(i%T)   # for setting by raw representation
-    Normed{T, f}(x) where {T,f} = convert(Normed{T,f}, x)
-    Normed{T, f}(x::Normed{T,f}) where {T,f} = x
-    Normed{T, f}(x::AbstractChar) where {T,f} = throw(ArgumentError("Normed cannot be constructed from a Char"))
-    Normed{T, f}(x::Complex) where {T,f} = Normed{T, f}(convert(real(typeof(x)), x))
-    Normed{T, f}(x::Base.TwicePrecision) where {T,f} = Normed{T, f}(convert(Float64, x))
 end
 
+Normed{T, f}(x::AbstractChar) where {T,f} = throw(ArgumentError("Normed cannot be constructed from a Char"))
+Normed{T, f}(x::Complex) where {T,f} = Normed{T, f}(convert(real(typeof(x)), x))
+Normed{T, f}(x::Base.TwicePrecision) where {T,f} = Normed{T, f}(convert(Float64, x))
+Normed{T1,f}(x::Normed{T2,f}) where {T1 <: Unsigned,T2 <: Unsigned,f} = Normed{T1,f}(convert(T1, x.i), 0)
+
 typechar(::Type{X}) where {X <: Normed} = 'N'
 signbits(::Type{X}) where {X <: Normed} = 0
 
@@ -38,17 +38,16 @@ one(x::Normed) = oneunit(x)
 rawone(v) = reinterpret(one(v))
 
 # Conversions
-convert(::Type{U}, x::U) where {U <: Normed} = x
-convert(::Type{Normed{T1,f}}, x::Normed{T2,f}) where {T1 <: Unsigned,T2 <: Unsigned,f} = Normed{T1,f}(convert(T1, x.i), 0)
-function convert(::Type{Normed{T,f}}, x::Normed{T2}) where {T <: Unsigned,T2 <: Unsigned,f}
+function Normed{T,f}(x::Normed{T2}) where {T <: Unsigned,T2 <: Unsigned,f}
     U = Normed{T,f}
     y = round((rawone(U)/rawone(x))*reinterpret(x))
     (0 <= y) & (y <= typemax(T)) || throw_converterror(U, x)
     reinterpret(U, _unsafe_trunc(T, y))
 end
-convert(::Type{U}, x::Real) where {U <: Normed} = _convert(U, rawtype(U), x)
+N0f16(x::N0f8) = reinterpret(N0f16, convert(UInt16, 0x0101*reinterpret(x)))
+
+(::Type{U})(x::Real) where {U <: Normed} = _convert(U, rawtype(U), x)
 
-convert(::Type{N0f16}, x::N0f8) = reinterpret(N0f16, convert(UInt16, 0x0101*reinterpret(x)))
 function _convert(::Type{U}, ::Type{T}, x) where {U <: Normed,T}
     y = round(widen1(rawone(U))*x)
     (0 <= y) & (y <= typemax(T)) || throw_converterror(U, x)
@@ -61,7 +60,7 @@ _convert(::Type{U}, ::Type{UInt128}, x::Float16) where {U <: Normed} =
     _convert(U, UInt128, Float32(x))
 function _convert(::Type{U}, ::Type{UInt128}, x) where {U <: Normed}
     y = round(rawone(U)*x)   # for UInt128, we can't widen
-    (0 <= y) & (y <= typemax(UInt128)) & (x <= convert(Float64, typemax(U))) || throw_converterror(U, x)
+    (0 <= y) & (y <= typemax(UInt128)) & (x <= Float64(typemax(U))) || throw_converterror(U, x)
     U(_unsafe_trunc(UInt128, y), 0)
 end
 
@@ -70,19 +69,18 @@ rem(x::Normed, ::Type{T}) where {T <: Normed} = reinterpret(T, _unsafe_trunc(raw
 rem(x::Real, ::Type{T}) where {T <: Normed} = reinterpret(T, _unsafe_trunc(rawtype(T), round(rawone(T)*x)))
 rem(x::Float16, ::Type{T}) where {T <: Normed} = rem(Float32(x), T)  # avoid overflow
 
-# convert(::Type{AbstractFloat}, x::Normed) = convert(floattype(x), x)
 float(x::Normed) = convert(floattype(x), x)
 
-convert(::Type{BigFloat}, x::Normed) = reinterpret(x)*(1/BigFloat(rawone(x)))
-function convert(::Type{T}, x::Normed) where {T <: AbstractFloat}
+Base.BigFloat(x::Normed) = reinterpret(x)*(1/BigFloat(rawone(x)))
+function (::Type{T})(x::Normed) where {T <: AbstractFloat}
     y = reinterpret(x)*(one(rawtype(x))/convert(T, rawone(x)))
     convert(T, y)  # needed for types like Float16 which promote arithmetic to Float32
 end
-convert(::Type{Bool}, x::Normed) = x == zero(x) ? false : true
-convert(::Type{Integer}, x::Normed) = convert(Integer, x*1.0)
-convert(::Type{T}, x::Normed) where {T <: Integer} = convert(T, x*(1/oneunit(T)))
-convert(::Type{Rational{Ti}}, x::Normed) where {Ti <: Integer} = convert(Ti, reinterpret(x))//convert(Ti, rawone(x))
-convert(::Type{Rational}, x::Normed) = reinterpret(x)//rawone(x)
+Base.Bool(x::Normed) = x == zero(x) ? false : true
+Base.Integer(x::Normed) = convert(Integer, x*1.0)
+(::Type{T})(x::Normed) where {T <: Integer} = convert(T, x*(1/oneunit(T)))
+Base.Rational{Ti}(x::Normed) where {Ti <: Integer} = convert(Ti, reinterpret(x))//convert(Ti, rawone(x))
+Base.Rational(x::Normed) = reinterpret(x)//rawone(x)
 
 # Traits
 abs(x::Normed) = x

test/fixed.jl

@@ -92,13 +92,13 @@ end
 @testset "reductions" begin
 F8 = Fixed{Int8,8}
 a = F8[0.498, 0.1]
-acmp = convert(Float64, a[1]) + convert(Float64, a[2])
+acmp = Float64(a[1]) + Float64(a[2])
 @test sum(a) == acmp
 @test sum(a, dims=1) == [acmp]
 
 F6 = Fixed{Int8,6}
 a = F6[1.2, 1.4]
-acmp = convert(Float64, a[1])*convert(Float64, a[2])
+acmp = Float64(a[1])*Float64(a[2])
 @test prod(a) == acmp
 @test prod(a, dims=1) == [acmp]
 end
@@ -162,7 +162,7 @@ for (T, f) in ((Int8, 7),
     tmax = typemax(Fixed{T, f})
     @test tmax == BigInt(typemax(T)) / BigInt(2)^f
     tol = (tmax + BigFloat(1.0)) / (sizeof(T) * 8)
-    for x in range(-1, stop=convert(BigFloat, tmax)-tol, length=50)
+    for x in range(-1, stop=BigFloat(tmax)-tol, length=50)
         @test abs(Fixed{T, f}(x) - x) <= tol
     end
 end

test/normed.jl

@@ -307,7 +307,7 @@ a = N0f8[reinterpret(N0f8, 0xff), reinterpret(N0f8, 0xff)]
 @test sum(a, dims=1) == [2.0]
 
 a = N2f14[3.2, 2.4]
-acmp = convert(Float64, a[1])*convert(Float64, a[2])
+acmp = Float64(a[1])*Float64(a[2])
 @test prod(a) == acmp
 @test prod(a, dims=1) == [acmp]
 end