Merge pull request #558 from OlivierHnt/1.0-conversion

1.0-dev: fully disallow conversion between non `Interval` types

Author: Kolaru

src/bisect.jl

@@ -7,12 +7,12 @@ const where_bisect = 0.49609375
 Split the interval `X` at position α; α=0.5 corresponds to the midpoint.
 Returns a tuple of the new intervals.
 """
-function bisect(X::Interval, α=where_bisect)
+function bisect(X::F, α=where_bisect) where {F<:Interval}
     @assert 0 ≤ α ≤ 1
 
     m = scaled_mid(X, α)
 
-    return (Interval(inf(X), m), Interval(m, sup(X)))
+    return (F(inf(X), m), F(m, sup(X)))
 end
 
 """
@@ -47,9 +47,9 @@ end
 Splits `x` in `n` intervals of the same diameter, which are returned
 as a vector.
 """
-function mince(x::Interval, n)
+function mince(x::F, n) where {F<:Interval}
     nodes = range(inf(x), sup(x), length = n+1)
-    return [Interval(nodes[i], nodes[i+1]) for i in 1:length(nodes)-1]
+    return [F(nodes[i], nodes[i+1]) for i in 1:length(nodes)-1]
 end
 
 """
@@ -74,4 +74,4 @@ as a vector.
         end
         nodes
     end
-end
+end

src/decorations/functions.jl

@@ -323,23 +323,22 @@ end
 
 # The function is unbounded at the bounded edges of the domain
 restricted_functions1 = Dict(
-    :log   => [0, Inf],
-    :log2  => [0, Inf],
-    :log10 => [0, Inf],
-    :atanh => [-1, 1]
+    :log   => Interval{Float64}(0.0, Inf),
+    :log2  => Interval{Float64}(0.0, Inf),
+    :log10 => Interval{Float64}(0.0, Inf),
+    :atanh => Interval{Float64}(-1.0, 1.0)
 )
 
 # The function is bounded at the bounded edge(s) of the domain
 restricted_functions2 = Dict(
-    :sqrt  => [0, Inf],
-    :asin  => [-1, 1],
-    :acos  => [-1, 1],
-    :acosh => [1, Inf]
+    :sqrt  => Interval{Float64}(0.0, Inf),
+    :asin  => Interval{Float64}(-1.0, 1.0),
+    :acos  => Interval{Float64}(-1.0, 1.0),
+    :acosh => Interval{Float64}(1.0, Inf)
 )
 
 # Define functions with restricted domains on DecoratedInterval's:
 for (f, domain) in restricted_functions1
-    domain = Interval(domain...)
     @eval function Base.$(f)(xx::DecoratedInterval{T}) where T
         x = interval(xx)
         r = $(f)(x)
@@ -350,7 +349,6 @@ for (f, domain) in restricted_functions1
 end
 
 for (f, domain) in restricted_functions2
-    domain = Interval(domain...)
     @eval function Base.$(f)(xx::DecoratedInterval{T}) where T
         x = interval(xx)
         r = $(f)(x)

src/decorations/intervals.jl

@@ -33,9 +33,10 @@ end
 
 DecoratedInterval(I::DecoratedInterval, dec::DECORATION) = DecoratedInterval(I.interval, dec)
 
-function DecoratedInterval(a::Real, b::Real, d::DECORATION)
-    is_valid_interval(a, b) || return DecoratedInterval(Interval(a,b), ill)
-    return DecoratedInterval(Interval(a,b), d)
+function DecoratedInterval(a::T, b::S, d::DECORATION) where {T<:Real, S<:Real}
+    BoundsType = promote_numtype(T, S)
+    is_valid_interval(a, b) || return DecoratedInterval(Interval{BoundsType}(a, b), ill)
+    return DecoratedInterval(Interval{BoundsType}(a, b), d)
 end
 
 DecoratedInterval(a::Real, d::DECORATION) = DecoratedInterval(a, a, d)
@@ -50,9 +51,10 @@ end
 
 DecoratedInterval(I::Interval) = DecoratedInterval{default_bound()}(I)
 
-function DecoratedInterval(a::Real, b::Real)
-    is_valid_interval(a, b) || return DecoratedInterval(Interval(a,b), ill)
-    return DecoratedInterval(Interval(a,b))
+function DecoratedInterval(a::T, b::S) where {T<:Real, S<:Real}
+    BoundsType = promote_numtype(T, S)
+    is_valid_interval(a, b) || return DecoratedInterval(Interval{BoundsType}(a, b), ill)
+    return DecoratedInterval(Interval{BoundsType}(a, b))
 end
 
 DecoratedInterval(a::Real) = DecoratedInterval(a, a)

src/display.jl

@@ -212,12 +212,12 @@ end
 
 # `String` representation of an `Interval`
 
-function basic_representation(a::Interval, format::Symbol)
+function basic_representation(a::Interval{T}, format::Symbol) where {T}
     isempty(a) && return "∅"
     sigdigits = display_params.sigdigits
     if format === :full
         # Do not use `inf(a)` to avoid -0.0
-        return string("Interval(", a.lo, ", ", sup(a), ")")
+        return string("Interval{", T, "}(", a.lo, ", ", sup(a), ")")
     elseif format === :midpoint
         m = round_string(mid(a), sigdigits, RoundNearest)
         r = round_string(radius(a), sigdigits, RoundUp)
@@ -237,8 +237,8 @@ function basic_representation(a::Interval{Float32}, format::Symbol)
     sigdigits = display_params.sigdigits
     if format === :full
         # Do not use `inf(a)` to avoid -0.0
-        output = string("Interval(", a.lo, "f0, ", sup(a), "f0)")
-        return replace(replace(output, "NaNf0" => "NaN32"), "Inff0" => '∞')
+        output = string("Interval{Float32}(", a.lo, "f0, ", sup(a), "f0)")
+        return replace(replace(output, "NaNf0" => "NaN32"), "Inff0" => "Inf32")
     elseif format === :midpoint
         m = round_string(mid(a), sigdigits, RoundNearest)
         r = round_string(radius(a), sigdigits, RoundUp)
@@ -253,11 +253,11 @@ function basic_representation(a::Interval{Float32}, format::Symbol)
     end
 end
 
-function basic_representation(a::Interval{<:Rational}, format::Symbol)
+function basic_representation(a::Interval{T}, format::Symbol) where {T<:Rational}
     isempty(a) && return "∅"
     if format === :full
         # Do not use `inf(a)` to avoid -0.0
-        return string("Interval(", a.lo, ", ", sup(a), ")")
+        return string("Interval{", T, "}(", a.lo, ", ", sup(a), ")")
     elseif format === :midpoint
         return string(mid(a), " ± ", radius(a))
     else  # format === :standard

src/intervals/arithmetic/absmax.jl

@@ -23,7 +23,7 @@ Implement the `min` function of the IEEE Std 1788-2015 (Table 9.1).
 """
 function min(a::F, b::F) where {F<:Interval}
     (isempty(a) || isempty(b)) && return emptyinterval(F)
-    return F( min(inf(a), inf(b)), min(sup(a), sup(b)))
+    return F(min(inf(a), inf(b)), min(sup(a), sup(b)))
 end
 
 """
@@ -33,5 +33,5 @@ Implement the `max` function of the IEEE Std 1788-2015 (Table 9.1).
 """
 function max(a::F, b::F) where {F<:Interval}
     (isempty(a) || isempty(b)) && return emptyinterval(F)
-    return F( max(inf(a), inf(b)), max(sup(a), sup(b)))
-end
+    return F(max(inf(a), inf(b)), max(sup(a), sup(b)))
+end

src/intervals/arithmetic/basic.jl

@@ -19,8 +19,8 @@ function +(a::F, b::T) where {T, F<:Interval{T}}
     isempty(a) && return emptyinterval(F)
     return @round(F, inf(a) + b, sup(a) + b)
 end
-+(a::Interval{T}, b::S) where {T, S<:Real} = a + Interval{T}(b)
-+(b::Real, a::Interval) = a + b
++(a::Interval{T}, b::Real) where {T} = a + interval(T, b)
++(a::Real, b::Interval{T}) where {T} = b + a
 
 function +(a::F, b::F) where {F<:Interval}
     (isempty(a) || isempty(b)) && return emptyinterval(F)
@@ -50,8 +50,8 @@ function -(b::T, a::F) where {T, F<:Interval{T}}
     isempty(a) && return emptyinterval(F)
     return @round(F, b - sup(a), b - inf(a))
 end
--(a::F, b::Real) where {F<:Interval} = a - F(b)
--(a::Real, b::F) where {F<:Interval} = F(a) - b
+-(a::Interval{T}, b::Real) where {T} = a - interval(T, b)
+-(a::Real, b::Interval{T}) where {T} = interval(T, a) - b
 
 function -(a::F, b::F) where {F<:Interval}
     (isempty(a) || isempty(b)) && return emptyinterval(F)
@@ -77,18 +77,18 @@ Implement the `mul` function of the IEEE Std 1788-2015 (Table 9.1).
 
 Note: the behavior of the multiplication is flavor dependent for some edge cases.
 """
-function *(x::T, a::F) where {T<:Real, F<:Interval{T}}
+function *(a::F, b::T) where {T<:Real, F<:Interval{T}}
     isempty(a) && return emptyinterval(F)
-    (isthinzero(a) || iszero(x)) && return zero(F)
+    (isthinzero(a) || iszero(b)) && return zero(F)
 
-    if x ≥ 0.0
-        return @round(F, inf(a)*x, sup(a)*x)
+    if b ≥ 0.0
+        return @round(F, inf(a)*b, sup(a)*b)
     else
-        return @round(F, sup(a)*x, inf(a)*x)
+        return @round(F, sup(a)*b, inf(a)*b)
     end
 end
-*(x::T, a::F) where {T<:Real, S, F<:Interval{S}} = Interval{S}(x) * a
-*(a::F, x::T) where {T<:Real, S, F<:Interval{S}} = x*a
+*(a::Interval{T}, b::Real) where {T} = a * interval(T, b)
+*(a::Real, b::Interval{T}) where {T} = b * a
 
 function *(a::F, b::F) where {F<:Interval}
     (isempty(a) || isempty(b)) && return emptyinterval(F)
@@ -131,18 +131,18 @@ Implement the `div` function of the IEEE Std 1788-2015 (Table 9.1).
 
 Note: the behavior of the division is flavor dependent for some edge cases.
 """
-function /(a::F, x::Real) where {F<:Interval}
+function /(a::F, b::Real) where {F<:Interval}
     isempty(a) && return emptyinterval(T)
-    iszero(x) && return div_by_thin_zero(a)
+    iszero(b) && return div_by_thin_zero(a)
 
-    if x ≥ 0.0
-        return @round(F, inf(a)/x, sup(a)/x)
+    if b ≥ 0
+        return @round(F, inf(a)/b, sup(a)/b)
     else
-        return @round(F, sup(a)/x, inf(a)/x)
+        return @round(F, sup(a)/b, inf(a)/b)
     end
 end
 
-/(x::Real, a::Interval) = x*inv(a)
+/(a::Real, b::Interval) = a * inv(b)
 
 function /(a::F, b::F) where {T, F<:Interval{T}}
     (isempty(a) || isempty(b)) && return emptyinterval(F)
@@ -255,10 +255,11 @@ Square root of an interval.
 Implement the `sqrt` function of the IEEE Std 1788-2015 (Table 9.1).
 """
 function sqrt(a::F) where {F<:Interval}
-    domain = F(0, Inf)
+    G = float(F)
+    domain = G(0, Inf)
     a = a ∩ domain
 
     isempty(a) && return a
 
-    return @round(F, sqrt(inf(a)), sqrt(sup(a)))  # `sqrt` is correctly-rounded
+    return @round(G, sqrt(inf(a)), sqrt(sup(a)))  # `sqrt` is correctly-rounded
 end

src/intervals/arithmetic/power.jl

@@ -40,7 +40,7 @@ function ^(a::F, n::Integer) where {F<:Interval{BigFloat}}
     isempty(a) && return a
     iszero(n) && return one(F)
     n == 1 && return a
-    n < 0 && isthinzero(a) && return emptyinterval(F)
+    (n < 0 && isthinzero(a)) && return emptyinterval(F)
 
     if isodd(n) # odd power
         isentire(a) && return a
@@ -98,7 +98,7 @@ function ^(a::F, x::BigFloat) where {F<:Interval{BigFloat}}
     a = a ∩ domain
     (isempty(x) || isempty(a)) && return emptyinterval(F)
 
-    xx = F(x)
+    xx = F(x, x)
 
     lo = @round(F, inf(a)^inf(xx), inf(a)^inf(xx))
     lo = (inf(lo) == Inf) ? F(prevfloat(Inf), Inf) : lo
@@ -167,20 +167,10 @@ function ^(a::F, x::Interval) where {F<:Interval{BigFloat}}
 
     (isempty(x) || isempty(a)) && return emptyinterval(F)
 
-    lo1 = a^inf(x)
-    lo2 = a^sup(x)
-    lo1 = hull(lo1, lo2)
-
-    hi1 = a^inf(x)
-    hi2 = a^sup(x)
-    hi1 = hull(hi1, hi2)
-
-    return hull(lo1, hi1)
+    return hull(a^inf(x), a^sup(x))
 end
 
-function sqr(a::Interval)
-    return a^2
-end
+sqr(a::Interval) = a^2
 
 """
     hypot(x::Interval, n::Integer)
@@ -203,13 +193,16 @@ function pow(x::F, n::Integer) where {F<:Interval}
     isempty(x) && return x
 
     if iseven(n) && 0 ∈ x
+        xmig = mig(x)
+        xmag = mag(x)
         return hull(zero(x),
-                    Base.power_by_squaring(F(mig(x)), n),
-                    Base.power_by_squaring(F(mag(x)), n)
-            )
+                    Base.power_by_squaring(F(xmig, xmig), n),
+                    Base.power_by_squaring(F(xmag, xmag), n))
     else
-      return hull( Base.power_by_squaring(F(inf(x)), n),
-                    Base.power_by_squaring(F(sup(x)), n) )
+        xinf = inf(x)
+        xsup = sup(x)
+        return hull(Base.power_by_squaring(F(xinf, xinf), n),
+                    Base.power_by_squaring(F(xsup, xsup), n))
     end
 end
 
@@ -262,7 +255,7 @@ for f in (:log, :log2, :log10)
 end
 
 function log1p(a::F) where {T, F<:Interval{T}}
-    domain = Interval{T}(-1, Inf)
+    domain = F(-1, Inf)
     a = a ∩ domain
 
     (isempty(a) || sup(a) ≤ -one(T)) && return emptyinterval(a)