Merge pull request #241 from araujoms/deadcode3

remove remaining dead code

Author: JeffreySarnoff

src/extras/misc.jl

@@ -5,10 +5,6 @@
                                                                                                   (32.5 sig bits must match)
 
 =#
-releps(::Type{Float64}) = ldexp(0.5, -31)
-releps(::Type{Float32}) = ldexp(inv(sqrt(2.0f0)), -17)
-releps(::Type{Double64}) = ldexp(0.5, -62)
-releps(::Type{Double32}) = ldexp(inv(sqrt(2.0f0)), -34)
 
 function Base.isapprox(x::DoubleFloat{T}, y::Real; atol::Real=0.0, rtol::Real=Base.rtoldefault(HI(x),y,atol), nans::Bool=false) where {T<:IEEEFloat}
     return isapprox(x, DoubleFloat{T}(y), atol=atol, rtol=rtol, nans=nans)
@@ -44,11 +40,6 @@ function Base.clamp(x::T, lo::DoubleFloat{T}, hi::DoubleFloat{T}) where {T}
      return lo
 end
 
-abs2(x::DoubleFloat{T}) where {T} =
-    let absx = abs(x)
-        absx * absx
-    end
-
 # for compatibility with old or unrevised outside linalg functions
 function Base.:(+)(v::Vector{DoubleFloat{T}}, x::T) where {T}
     return v .+ x

src/type/intraconstructors.jl

@@ -47,47 +47,3 @@ function Double64(x::T) where {T<:Signed}
         throw(DomainError("$x"))
     end
 end
-
-
-
-#=
-
-e.g. DoubleFloat{Float16}(65519.0) does not work properly in these
-
-function Double32(x::Double64)
-    hi64, lo64 = HILO(x)
-    hi64a = reinterpret(Float64, (reinterpret(UInt64, hi64) & 0xFFFFFFFF00000000))
-    hi64b = hi64 - hi64a
-    lo64a = reinterpret(Float64, (reinterpret(UInt64, lo64) & 0xFFFFFFFF00000000))
-    lo64b = lo64 - lo64b
-    hi32a, hi32b = Float32(hi64a), Float32(hi64b)
-    lo32a, lo32b = Float32(lo64a), Float32(lo64b)
-    hi32, lo32 = two_hilo_sum(hi32a, hi32b, lo32a, lo32b)
-    return Double32(hi32, lo32)
-end
-
-function Double16(x::Double64)
-    hi64, lo64 = HILO(x)
-    hi64a = reinterpret(Float64, (reinterpret(UInt64, hi64) & 0xFFFFFFFF00000000))
-    hi64b = hi64 - hi64a
-    lo64a = reinterpret(Float64, (reinterpret(UInt64, lo64) & 0xFFFFFFFF00000000))
-    lo64b = lo64 - lo64b
-    hi16a, hi16b = Float16(hi64a), Float16(hi64b)
-    lo16a, lo16b = Float16(lo64a), Float16(lo64b)
-    hi16, lo16 = two_hilo_sum(hi16a, hi16b, lo16a, lo16b)
-    return Double16(hi16, lo16)
-end
-
-function Double16(x::Double32)
-    hi32, lo32 = HILO(x)
-    hi32a = reinterpret(Float32, (reinterpret(UInt32, hi32) & 0xFFFF0000))
-    hi32b = hi32 - hi32a
-    lo32a = reinterpret(Float32, (reinterpret(UInt32, lo32) & 0xFFFF0000))
-    lo32b = lo32 - lo32b
-    hi16a, hi16b = Float16(hi64a), Float16(hi64b)
-    lo16a, lo16b = Float16(lo64a), Float16(lo64b)
-    hi16, lo16 = two_hilo_sum(hi16a, hi16b, lo16a, lo16b)
-    return Double16(hi16, lo16)
-end
-
-=#

src/type/predicates.jl

@@ -133,6 +133,3 @@ iseven(x::DoubleFloat{T}) where {T<:IEEEFloat} =
     else
        false
     end
-
-iseven(x::T) where {T<:IEEEFloat} = isinteger(x) && iseven(BigInt(x))
-isodd(x::T) where {T<:IEEEFloat} = isinteger(x) && isodd(BigInt(x))

src/type/string.jl

@@ -54,55 +54,3 @@ function stringtyped(x::Complex{DoubleFloat{Float16}})
     str = string("ComplexDF16(", stringtyped(rea), ", ", stringtyped(imag(x)), ")")
     return str
 end
-
-#= NOT NEEDED
-    
-"""
-    BigFloatBits(::IEEEType)
-
-significand bit precision for BigFloat when converting from DoubleFloat{IEEEType} into a string
-""" BigFloatBits
-
-"""
-    BigFloatDigits(::IEEEType)
-
-significant digits of BigFloat when converting to DoubleFloat{IEEEType} from a string
-""" BigFloatDigits
-
-# Float63 -> 106, Float32 -> 48, Float16 -> 22
-minprecdblfloat(::Type{T}) where {T<:IEEEFloat} = 
-    (trailing_ones(Base.significand_mask(T))+1)*2
-
-
-#=
-  The effective precision of some DoubleFloat{T} may be larger than this
-     where all bits betweeen the lsb of the HI oart and Lthe msb of the lo part
-     are 0b0 and there are more than 22 zero bits interposed for eg Double64.
-  When a DoubleFloat is the result of an arithmetic operation between DoubleFloats,
-     the effective precision is almost never expected be larger than this.
-=#
-# Float63 -> 128, Float32 -> 58, Float16 -> 27
-lrgprecdblfloat(::Type{T}) where {T<:IEEEFloat} = 
-    Int(ceil(Int, minprecdblfloat(T) * 1.2))
-
-bigfloatbits(::Type{T}) where {T<:IEEEFloat} =
-    nextpow(2, (trailing_ones(Base.significand_mask(T))+1)*2) - 1
-
-BigFloatBits(::Type{Float64}) = 127 # bigfloatbits(Float64)
-BigFloatBits(::Type{Float32}) =  63 # bigfloatbits(Float32)
-BigFloatBits(::Type{Float16}) =  31 # bigfloatbits(Float16)
-
-BigFloatDigits(::Type{Float64}) = 35 # bigfloatbits(Float64)
-BigFloatDigits(::Type{Float32}) = 16 # bigfloatbits(Float32)
-BigFloatDigits(::Type{Float16}) =  8 # bigfloatbits(Float16)
-
-#= old
-@inline BigFloatBits(::Type{Float64}) = 512
-@inline BigFloatBits(::Type{Float32}) = 256
-@inline BigFloatBits(::Type{Float16}) = 128
-@inline BigFloatDigits(::Type{Float64}) = 35
-@inline BigFloatDigits(::Type{Float32}) = 18
-@inline BigFloatDigits(::Type{Float16}) =  9
-=#
-
-=#