type stability of intermediates in conversions

Author: milankl

src/conversions.jl

@@ -11,45 +11,45 @@ Base.inttype(::Type{Posit16_1}) = Int16
 Base.inttype(::Type{Posit32}) = Int32
 
 # generic conversion to UInt/Int
-Base.unsigned(x::AbstractPosit) = reinterpret(Base.uinttype(typeof(x)),x)
-Base.signed(x::AbstractPosit) = reinterpret(Base.inttype(typeof(x)),x)
+Base.unsigned(x::AbstractPosit) = reinterpret(Base.uinttype(typeof(x)), x)
+Base.signed(x::AbstractPosit) = reinterpret(Base.inttype(typeof(x)), x)
 
 # BOOL
 for PositType in (:Posit8, :Posit16, :Posit32, :Posit16_1)
     @eval begin
             $PositType(x::Bool) = x ? one($PositType) : zero($PositType)
-            Base.promote_rule(::Type{Bool},::Type{$PositType}) = $PositType
+            Base.promote_rule(::Type{Bool}, ::Type{$PositType}) = $PositType
     end
 end
 
 # easier for development purposes
-Posit8(x::UInt8)        = reinterpret(Posit8,x)
-Posit16(x::UInt16)      = reinterpret(Posit16,x)
-Posit16_1(x::UInt16)    = reinterpret(Posit16_1,x)
-Posit32(x::UInt32)      = reinterpret(Posit32,x)
+Posit8(x::UInt8)        = reinterpret(Posit8, x)
+Posit16(x::UInt16)      = reinterpret(Posit16, x)
+Posit16_1(x::UInt16)    = reinterpret(Posit16_1, x)
+Posit32(x::UInt32)      = reinterpret(Posit32, x)
 
 # BETWEEN Posits
 # upcasting: append with zeros.
-Posit16(x::Posit8) = reinterpret(Posit16,(unsigned(x) % UInt16) << 8)
-Posit32(x::Posit8) = reinterpret(Posit32,(unsigned(x) % UInt32) << 24)
-Posit32(x::Posit16) = reinterpret(Posit32,(unsigned(x) % UInt32) << 16)
+Posit16(x::Posit8) = reinterpret(Posit16, (unsigned(x) % UInt16) << 8)
+Posit32(x::Posit8) = reinterpret(Posit32, (unsigned(x) % UInt32) << 24)
+Posit32(x::Posit16) = reinterpret(Posit32, (unsigned(x) % UInt32) << 16)
 
 # downcasting: apply round to nearest
-Posit8(x::Posit16) = posit(Posit8,x)
-Posit8(x::Posit32) = posit(Posit8,x)
-Posit16(x::Posit32) = posit(Posit16,x)
+Posit8(x::Posit16) = posit(Posit8, x)
+Posit8(x::Posit32) = posit(Posit8, x)
+Posit16(x::Posit32) = posit(Posit16, x)
 
 # conversion to and from Posit16_1 via floats as number of exponent bits changes
 Posit16_1(x::AbstractPosit) = Posit16_1(float(x))
 Posit8(x::Posit16_1) = Posit8(float(x))
 Posit16(x::Posit16_1) = Posit16(float(x))
 Posit32(x::Posit16_1) = Posit32(float(x))
 
-function posit(::Type{PositN1},x::PositN2) where {PositN1<:AbstractPosit,PositN2<:AbstractPosit}
-    return reinterpret(PositN1,bitround(Base.uinttype(PositN1),unsigned(x)))
+function posit(::Type{PositN1}, x::PositN2) where {PositN1<:AbstractPosit, PositN2<:AbstractPosit}
+    return reinterpret(PositN1, bitround(Base.uinttype(PositN1), unsigned(x)))
 end
 
-function bitround(::Type{UIntN1},ui::UIntN2) where {UIntN1<:Unsigned,UIntN2<:Unsigned}
+function bitround(::Type{UIntN1}, ui::UIntN2) where {UIntN1<:Unsigned, UIntN2<:Unsigned}
     Δbits = bitsize(UIntN2) - bitsize(UIntN1)     # difference in bits
 
     # ROUND TO NEAREST, tie to even: create ulp/2 = ..007ff.. or ..0080..
@@ -72,36 +72,36 @@ Posit32(x::Signed) = Posit32(Float64(x))
 Base.Int(x::AbstractPosit) = Int(Float64(x))
 
 # promotions
-Base.promote_rule(::Type{Int},::Type{T}) where {T<:AbstractPosit} = T
+Base.promote_rule(::Type{Int}, ::Type{T}) where {T<:AbstractPosit} = T
 
 # FROM FLOATS
-Posit8(x::T) where {T<:Base.IEEEFloat} = posit(Posit8,x)
-Posit16(x::T) where {T<:Base.IEEEFloat} = posit(Posit16,x)
-Posit16_1(x::T) where {T<:Base.IEEEFloat} = posit(Posit16_1,x)
-Posit32(x::T) where {T<:Base.IEEEFloat} = posit(Posit32,x)
+Posit8(x::T) where {T<:Base.IEEEFloat} = posit(Posit8, x)
+Posit16(x::T) where {T<:Base.IEEEFloat} = posit(Posit16, x)
+Posit16_1(x::T) where {T<:Base.IEEEFloat} = posit(Posit16_1, x)
+Posit32(x::T) where {T<:Base.IEEEFloat} = posit(Posit32, x)
 
-function posit(::Type{PositN},x::FloatN) where {PositN<:AbstractPosit,FloatN<:Base.IEEEFloat}
+function posit(::Type{PositN}, x::FloatN) where {PositN<:AbstractPosit, FloatN<:Base.IEEEFloat}
 
     UIntN = Base.uinttype(FloatN)           # unsigned integer corresponding to FloatN
     IntN = Base.inttype(FloatN)             # signed integer corresponding to FloatN
-    ui = reinterpret(UIntN,x)               # reinterpret input
+    ui = reinterpret(UIntN, x)              # reinterpret input
 
     # extract exponent bits and shift to tail, then remove bias
     e = (ui & Base.exponent_mask(FloatN)) >> Base.significand_bits(FloatN)
-    e = reinterpret(IntN,e) - IntN(Base.exponent_bias(FloatN))
+    e = reinterpret(IntN, e) - IntN(Base.exponent_bias(FloatN))
     signbit_e = signbit(e)                  # sign of exponent     
     k = e >> Base.exponent_bits(PositN)     # k-value for useed^k in posits
 
     # ASSEMBLE POSIT REGIME, EXPONENT, MANTISSA
-    # get posit exponent_bits and shift to starting from bitposition 3 (they'll be shifted in later)
-    exponent_bits = e & Base.exponent_mask(PositN)
+    # get posit exponent_bits and shift to starting from bitposition 3 (they'll be shifted in later)
+    exponent_bits = signed(e & Base.exponent_mask(PositN))
     exponent_bits <<= bitsize(FloatN)-2-Base.exponent_bits(PositN)
 
     # create 01000... (for |x|<1) or 10000... (|x| > 1)
-    regime_bits = reinterpret(IntN,Base.sign_mask(FloatN) >> signbit_e)
+    regime_bits = reinterpret(IntN, Base.sign_mask(FloatN) >> signbit_e)
 
     # extract mantissa bits and push to behind exponent rre..emm... (regime still hasn't been shifted)
-    mantissa = reinterpret(IntN,ui & Base.significand_mask(FloatN))             
+    mantissa = reinterpret(IntN, ui & Base.significand_mask(FloatN))             
     mantissa <<= Base.exponent_bits(FloatN) - Base.exponent_bits(PositN) - 1
 
     # combine regime, exponent, mantissa and arithmetic bitshift for 11..110em or 00..001em
@@ -110,14 +110,15 @@ function posit(::Type{PositN},x::FloatN) where {PositN<:AbstractPosit,FloatN<:Ba
     regime_exponent_mantissa &= ~Base.sign_mask(FloatN)     # remove possible sign bit from arith shift
 
     # round to nearest of the result
-    p_rounded = bitround(Base.uinttype(PositN),reinterpret(UIntN,regime_exponent_mantissa))
+    p_rounded = bitround(Base.uinttype(PositN), unsigned(regime_exponent_mantissa))
 
     # no under or overflow rounding mode
     max_k = (Base.exponent_bias(FloatN) >> Base.exponent_bits(PositN)) + 1
     p_rounded -= Base.inttype(PositN)(sign(k)*(bitsize(PositN) <= abs(k) < max_k))
 
     p_rounded = signbit(x) ? -p_rounded : p_rounded         # two's complement for negative numbers
-    return reinterpret(PositN,p_rounded)
+    
+    return reinterpret(PositN, p_rounded)
 end
 
 ## TO FLOATS
@@ -134,12 +135,12 @@ Base.Float64(x::AbstractPosit) = float(Float64,x)
 
 # The dynamic range of Float16 is smaller than Posit8/16/32
 # for correct rounding convert first to Float32/64
-Base.Float16(x::Posit8) = Float16(float(Float32,x))
-Base.Float16(x::Posit16) = Float16(float(Float32,x))
-Base.Float16(x::Posit16_1) = Float16(float(Float32,x))
-Base.Float16(x::Posit32) = Float16(float(Float64,x))
+Base.Float16(x::Posit8) = Float16(float(Float32, x))
+Base.Float16(x::Posit16) = Float16(float(Float32, x))
+Base.Float16(x::Posit16_1) = Float16(float(Float32, x))
+Base.Float16(x::Posit32) = Float16(float(Float64, x))
 
-function Base.float(::Type{FloatN},x::PositN) where {FloatN<:Base.IEEEFloat,PositN<:AbstractPosit}
+function Base.float(::Type{FloatN}, x::PositN) where {FloatN<:Base.IEEEFloat, PositN<:AbstractPosit}
 
     UIntN = Base.uinttype(FloatN)           # corresponding UInt for floattype
     n_bits = bitsize(PositN)                # number of bits in posit format
@@ -164,20 +165,20 @@ function Base.float(::Type{FloatN},x::PositN) where {FloatN<:Base.IEEEFloat,Posi
 
     # ASSEMBLE FLOAT EXPONENT
     # useed^k * 2^e = 2^(2^n_exponent_bits*k+e), ie get k-value from number of regime bits,
-    # << n_exponent_bits for *2^exponent_bits, add exponent bits and Float exponent bias (=15,127,1023)
+    # << n_exponent_bits for *2^exponent_bits, add exponent bits and Float exponent bias (=15,127,1023)
     k = (-1+2sign_exponent)*n_regimebits - sign_exponent
     exponent = ((k << Base.exponent_bits(PositN)) + exponent_bits + Base.exponent_bias(FloatN)) % UIntN
     exponent <<= Base.significand_bits(FloatN)
 
     # set exponent (and 1st mantissa bit) to NaN for NaR inputs
     # set exponent to 0 for zero(Posit8) input
-    nan_ui = reinterpret(UIntN,nan(FloatN))
+    nan_ui = reinterpret(UIntN, nan(FloatN))
     exponent = n_regimebits == n_bits ? (signbitx ? nan_ui : zero(exponent)) : exponent
 
     # assemble sign, exponent and mantissa bits
     sign = signbitx*Base.sign_mask(FloatN)
     f = sign | exponent | mantissa		    # concatenate sign, exponent and mantissa
-    return reinterpret(FloatN,f)
+    return reinterpret(FloatN, f)
 end
 
 # BIGFLOAT