fix type instability

Author: lucaferranti

src/intervals/intervals.jl

@@ -100,7 +100,7 @@ end
 function interval(a::T, b::S) where {T<:Real, S<:Real}
     if !is_valid_interval(a, b)
         @warn "Invalid input, empty interval is returned"
-        return emptyinterval(promote_type(T, S, Float64))
+        return emptyinterval(promote_type(T, S))
     end
 
     return Interval(a, b)
@@ -135,15 +135,15 @@ include("complex.jl")
 function ..(a::T, b::S) where {T, S}
     if !is_valid_interval(a, b)
         @warn "Invalid input, empty interval is returned"
-        return emptyinterval(promote_type(T, S, Float64))
+        return emptyinterval(promote_type(T, S))
     end
     Interval(atomic(Interval{T}, a).lo, atomic(Interval{S}, b).hi)
 end
 
 function ..(a::T, b::Irrational{S}) where {T, S}
     if !is_valid_interval(a, b)
         @warn "Invalid input, empty interval is returned"
-        return emptyinterval(promote_type(T, Irrational{S}, Float64))
+        return emptyinterval(promote_type(T, Irrational{S}))
     end
     R = promote_type(T, Irrational{S})
     Interval(atomic(Interval{R}, a).lo, R(b, RoundUp))
@@ -152,7 +152,7 @@ end
 function ..(a::Irrational{T}, b::S) where {T, S}
     if !is_valid_interval(a, b)
         @warn "Invalid input, empty interval is returned"
-        return emptyinterval(promote_type(Irrational{T}, S, Float64))
+        return emptyinterval(promote_type(Irrational{T}, S))
     end
     R = promote_type(Irrational{T}, S)
     return Interval(R(a, RoundDown), atomic(Interval{R}, b).hi)

src/intervals/special.jl

@@ -9,6 +9,7 @@ larger than the upper one."""
 emptyinterval(::Type{T}) where T<:Real = Interval{T}(Inf, -Inf)
 emptyinterval(x::Interval{T}) where T<:Real = emptyinterval(T)
 emptyinterval() = emptyinterval(precision(Interval)[1])
+emptyinterval(::Type{<:Integer}) = emptyinterval(Float64)
 const ∅ = emptyinterval(Float64)
 
 isempty(x::Interval) = x.lo == Inf && x.hi == -Inf
@@ -20,6 +21,7 @@ const ∞ = Inf
 entireinterval(::Type{T}) where T<:Real = Interval{T}(-Inf, Inf)
 entireinterval(x::Interval{T}) where T<:Real = entireinterval(T)
 entireinterval() = entireinterval(precision(Interval)[1])
+entireinterval(::Type{<:Integer}) = entireinterval(Float64)
 
 isentire(x::Interval) = x.lo == -Inf && x.hi == Inf
 isinf(x::Interval) = isentire(x)