WIP: Fix Julia 0.7 deprecation warnings (#155)

* Fix many deprecation warnings

* Fix conversion ambiguity and import Compat.Sys

* Remove `@doc doc`

* Further deprecation fixes

* Export ⊇ for Julia 0.6.x, and avoid testing complex intervals

* Fixes broken tests in 0.6

* Update Compat version in REQUIRE

* Fix deprecation warnings in bisect

Author: lbenet

REQUIRE

@@ -4,4 +4,4 @@ StaticArrays 0.5
 FastRounding 0.0.4
 AdjacentFloats 0.0.5
 RecipesBase
-
+Compat 0.69.0

src/IntervalArithmetic.jl

@@ -8,6 +8,18 @@ import CRlibm
 using StaticArrays
 using FastRounding
 using AdjacentFloats
+using Compat
+
+if VERSION <= v"0.7.0-DEV.2004"
+    import Base: ×, dot
+    import Compat.Sys
+    export ⊇
+else
+    using Markdown
+    import Base: ⊇
+    import LinearAlgebra: ×, dot
+end
+
 
 import Base:
     +, -, *, /, //, fma,
@@ -30,7 +42,7 @@ import Base:
     parse, hash
 
 import Base:  # for IntervalBox
-    broadcast, dot, length,
+    broadcast, length,
     getindex, setindex,
     start, next, done, eltype
 
@@ -42,7 +54,7 @@ export
     emptyinterval, ∅, ∞, isempty, isinterior, isdisjoint, ⪽,
     precedes, strictprecedes, ≺, ⊂, ⊃, ⊇, contains_zero,
     entireinterval, isentire, nai, isnai, isthin, iscommon, isatomic,
-    widen, inf, sup, bisect, 
+    widen, inf, sup, bisect,
     parameters, eps, dist,
     pi_interval,
     midpoint_radius, interval_from_midpoint_radius,
@@ -77,7 +89,10 @@ export
 
 function __init__()
     setrounding(BigFloat, RoundNearest)
-    setrounding(Float64, RoundNearest)
+    if VERSION < v"0.7.0-DEV"
+        ## deprecated in 0.7
+        setrounding(Float64, RoundNearest)
+    end
 
     setprecision(Interval, 256)  # set up pi
     setprecision(Interval, Float64)

src/bisect.jl

@@ -1,7 +1,7 @@
 
 const where_bisect = 0.49609375
 
-doc"""
+"""
     bisect(X::Interval, α=0.49609375)
 
 Split the interval `X` at position α; α=0.5 corresponds to the midpoint.
@@ -15,7 +15,7 @@ function bisect(X::Interval, α=where_bisect)
     return (Interval(X.lo, m), Interval(m, X.hi))
 end
 
-doc"""
+"""
     bisect(X::IntervalBox, α=0.49609375)
 
 Bisect the `IntervalBox` `X` at position α ∈ [0,1] along its longest side.
@@ -26,7 +26,7 @@ function bisect(X::IntervalBox, α=where_bisect)
     return bisect(X, i, α)
 end
 
-doc"""
+"""
     bisect(X::IntervalBox, i::Integer, α=0.49609375)
 
 Bisect the `IntervalBox` in side number `i`.

src/display.jl

@@ -109,15 +109,15 @@ end
 function round_string(x::BigFloat, digits::Int, r::RoundingMode)
 
     lng = digits + Int32(8)
-    buf = Array{UInt8}(lng + 1)
+    @compat buf = Array{UInt8}(undef, lng + 1)
 
     lng = ccall((:mpfr_snprintf,:libmpfr), Int32,
     (Ptr{UInt8}, Culong,  Ptr{UInt8}, Int32, Ref{BigFloat}...),
     buf, lng + 1, "%.$(digits)R*g", Base.MPFR.to_mpfr(r), x)
 
     repr = unsafe_string(pointer(buf))
 
-    repr = replace(repr, "nan", "NaN")
+    @compat repr = replace(repr, "nan" => "NaN")
 
     return repr
 end
@@ -144,8 +144,8 @@ function basic_representation(a::Interval, format=nothing)
         bb = round_string(a.hi, sigfigs, RoundUp)
 
         output = "[$aa, $bb]"
-        output = replace(output, "inf", "∞")
-        output = replace(output, "Inf", "∞")
+        @compat output = replace(output, "inf" => "∞")
+        @compat output = replace(output, "Inf" => "∞")
 
     elseif format == :full
         output = "Interval($(a.lo), $(a.hi))"

src/intervals/arithmetic.jl

@@ -413,13 +413,13 @@ function diam(a::Interval{T}) where T<:Real
     @round_up(a.hi - a.lo) # cf page 64 of IEEE1788
 end
 
+# Should `radius` this yield diam(a)/2? This affects other functions!
 """
     radius(a::Interval)
 
 Return the radius of the `Interval` `a`, such that
 `a ⊆ m ± radius`, where `m = mid(a)` is the midpoint.
 """
-# Should `radius` this yield diam(a)/2? This affects other functions!
 function radius(a::Interval)
     isempty(a) && return convert(eltype(a), NaN)
     m = mid(a)

src/intervals/conversion.jl

@@ -13,8 +13,8 @@ promote_rule(::Type{BigFloat}, ::Type{Interval{T}}) where T<:Real =
 
 
 # convert methods:
-convert(::Type{Interval{T}}, x) where {T} = atomic(Interval{T}, x)
-convert(::Type{Interval{T}}, x::T) where {T} = Interval{T}(x)
+convert(::Type{Interval{T}}, x::Real) where {T} = atomic(Interval{T}, x)
+convert(::Type{Interval{T}}, x::T) where {T<:Real} = Interval{T}(x)
 convert(::Type{Interval{T}}, x::Interval{T}) where {T} = x
 convert(::Type{Interval{T}}, x::Interval) where {T} = atomic(Interval{T}, x)
 
@@ -74,7 +74,7 @@ atomic(::Type{Interval{T}}, x::T) where {T<:Integer} = Interval{T}(x)
 atomic(::Type{Interval{T}}, x::AbstractString) where T<:AbstractFloat =
     parse(Interval{T}, x)
 
-@static if is_windows()  # Windows cannot round properly
+@static if Sys.iswindows()  # Windows cannot round properly
     function atomic(::Type{Interval{T}}, x::S) where {T<:AbstractFloat, S<:Real}
         isinf(x) && return wideinterval(T(x))
 

src/intervals/macros.jl

@@ -77,7 +77,6 @@ end
 """`make_interval` does the hard work of taking expressions
 and making each literal (0.1, 1, etc.) into a corresponding interval construction,
 by calling `transform`."""
-
 function make_interval(T, expr1, expr2)
     # @show expr1, expr2
 

src/intervals/precision.jl

@@ -15,7 +15,7 @@ const parameters = IntervalParameters()
 
 ## Precision:
 
-doc"`big53` creates an equivalent `BigFloat` interval to a given `Float64` interval."
+"`big53` creates an equivalent `BigFloat` interval to a given `Float64` interval."
 function big53(a::Interval{Float64})
     setprecision(Interval, 53) do  # precision of Float64
         atomic(Interval{BigFloat}, a)

src/intervals/rounding.jl

@@ -269,7 +269,7 @@ function setrounding(::Type{Interval}, rounding_type::Symbol)
 
     path, io = mktemp()
 
-    old_stderr = STDERR
+    old_stderr = stderr
     redirect_stderr(io)
 
     _setrounding(Interval, rounding_type)

src/intervals/special.jl

@@ -58,7 +58,7 @@ function iscommon(a::Interval)
     true
 end
 
-doc"`widen(x)` widens the lowest and highest bounds of `x` to the previous and next representable floating-point numbers, respectively."
+"`widen(x)` widens the lowest and highest bounds of `x` to the previous and next representable floating-point numbers, respectively."
 widen(x::Interval{T}) where {T<:AbstractFloat} = Interval(prevfloat(x.lo), nextfloat(x.hi))
 
 """