Only allow Interval{T} as a raw constructor

Author: OlivierHnt

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

@@ -339,7 +339,7 @@ restricted_functions2 = Dict(
 
 # Define functions with restricted domains on DecoratedInterval's:
 for (f, domain) in restricted_functions1
-    domain = Interval(domain...)
+    domain = interval(domain...)
     @eval function Base.$(f)(xx::DecoratedInterval{T}) where T
         x = interval(xx)
         r = $(f)(x)
@@ -350,7 +350,7 @@ for (f, domain) in restricted_functions1
 end
 
 for (f, domain) in restricted_functions2
-    domain = Interval(domain...)
+    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,25 @@ 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_type(default_bound(), T, S)
+    is_valid_interval(a, b) || return DecoratedInterval(Interval{BoundsType}(a, b), ill)
+    return DecoratedInterval(Interval{BoundsType}(a, b), d)
+end
+function DecoratedInterval(a::T, b::S, d::DECORATION) where {T<:AbstractFloat, S<:Real}
+    BoundsType = promote_type(T, S)
+    is_valid_interval(a, b) || return DecoratedInterval(Interval{BoundsType}(a, b), ill)
+    return DecoratedInterval(Interval{BoundsType}(a, b), d)
+end
+function DecoratedInterval(a::T, b::S, d::DECORATION) where {T<:Real, S<:AbstractFloat}
+    BoundsType = promote_type(T, S)
+    is_valid_interval(a, b) || return DecoratedInterval(Interval{BoundsType}(a, b), ill)
+    return DecoratedInterval(Interval{BoundsType}(a, b), d)
+end
+function DecoratedInterval(a::T, b::S, d::DECORATION) where {T<:AbstractFloat, S<:AbstractFloat}
+    BoundsType = promote_type(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 +66,25 @@ 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_type(default_bound(), T, S)
+    is_valid_interval(a, b) || return DecoratedInterval(Interval{BoundsType}(a, b), ill)
+    return DecoratedInterval(Interval{BoundsType}(a, b))
+end
+function DecoratedInterval(a::T, b::S) where {T<:AbstractFloat, S<:Real}
+    BoundsType = promote_type(T, S)
+    is_valid_interval(a, b) || return DecoratedInterval(Interval{BoundsType}(a, b), ill)
+    return DecoratedInterval(Interval{BoundsType}(a, b))
+end
+function DecoratedInterval(a::T, b::S) where {T<:Real, S<:AbstractFloat}
+    BoundsType = promote_type(T, S)
+    is_valid_interval(a, b) || return DecoratedInterval(Interval{BoundsType}(a, b), ill)
+    return DecoratedInterval(Interval{BoundsType}(a, b))
+end
+function DecoratedInterval(a::T, b::S) where {T<:AbstractFloat, S<:AbstractFloat}
+    BoundsType = promote_type(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/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)

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)