Merge pull request #461 from lucaferranti/lf/invalid_as_empty

return empty interval and warning when an invalid input is given

Author: Kolaru

src/decorations/intervals.jl

@@ -47,7 +47,7 @@ DecoratedInterval(I::Interval{T}, d::DECORATION) where T<:AbstractFloat =
     DecoratedInterval{T}(I, d)
 
 function DecoratedInterval(a::T, b::T, d::DECORATION) where T<:Real
-    a > b && return nai(T)
+    is_valid_interval(a, b) || return nai(T)
     DecoratedInterval(Interval(a,b), d)
 end
 
@@ -63,7 +63,7 @@ DecoratedInterval(a::T, b::S, d::DECORATION) where {T<:Real, S<:Real} =
 DecoratedInterval(I::Interval) = DecoratedInterval(I, decoration(I))
 
 function DecoratedInterval(a::T, b::T) where T<:Real
-    a > b && return nai(T)
+    is_valid_interval(a, b) || return nai(T)
     DecoratedInterval(Interval(a,b))
 end
 

src/intervals/intervals.jl

@@ -25,7 +25,8 @@ struct Interval{T<:Real} <: AbstractInterval{T}
                 new(a, b)
 
             else
-                throw(ArgumentError("Interval of form [$a, $b] not allowed. Must have a ≤ b to construct interval(a, b)."))
+                @warn "Invalid input, empty interval is returned"
+                return new(T(Inf), T(-Inf))
             end
 
         end
@@ -79,20 +80,10 @@ function is_valid_interval(a::Real, b::Real)
     # println("isvalid()")
 
     if isnan(a) || isnan(b)
-        if isnan(a) && isnan(b)
-            return true
-        else
-            return false
-        end
+        return false
     end
 
-    if a > b
-        if isinf(a) && isinf(b)
-            return true  # empty interval = [∞,-∞]
-        else
-            return false
-        end
-    end
+    a > b && return false
 
     if a == Inf || b == -Inf
         return false
@@ -104,11 +95,12 @@ end
 """
     interval(a, b)
 
-`interval(a, b)` checks whether [a, b] is a valid `Interval`, which is the case if `-∞ <= a <= b <= ∞`, using the (non-exported) `is_valid_interval` function. If so, then an `Interval(a, b)` object is returned; if not, then an error is thrown.
+`interval(a, b)` checks whether [a, b] is a valid `Interval`, using the (non-exported) `is_valid_interval` function. If so, then an `Interval(a, b)` object is returned; if not, a warning is printed and the empty interval is returned.
 """
-function interval(a::Real, b::Real)
+function interval(a::T, b::S) where {T<:Real, S<:Real}
     if !is_valid_interval(a, b)
-        throw(ArgumentError("`[$a, $b]` is not a valid interval. Need `a ≤ b` to construct `interval(a, b)`."))
+        @warn "Invalid input, empty interval is returned"
+        return emptyinterval(promote_type(T, S))
     end
 
     return Interval(a, b)
@@ -141,21 +133,32 @@ include("complex.jl")
 # Syntax for intervals
 
 function ..(a::T, b::S) where {T, S}
-    interval(atomic(Interval{T}, a).lo, atomic(Interval{S}, b).hi)
+    if !is_valid_interval(a, b)
+        @warn "Invalid input, empty interval is returned"
+        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}))
+    end
     R = promote_type(T, Irrational{S})
-    interval(atomic(Interval{R}, a).lo, R(b, RoundUp))
+    Interval(atomic(Interval{R}, a).lo, R(b, RoundUp))
 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))
+    end
     R = promote_type(Irrational{T}, S)
-    return interval(R(a, RoundDown), atomic(Interval{R}, b).hi)
+    return Interval(R(a, RoundDown), atomic(Interval{R}, b).hi)
 end
 
 function ..(a::Irrational{T}, b::Irrational{S}) where {T, S}
-    R = promote_type(Irrational{T}, Irrational{S})
     return interval(a, b)
 end
 

src/intervals/macros.jl

@@ -1,20 +1,21 @@
 # This file is part of the IntervalArithmetic.jl package; MIT licensed
 
-"""The `@interval` macro is the main method to create an interval.
-It converts each expression into a narrow interval that is guaranteed to contain the true value passed by the user in the one or two expressions passed to it.
+"""The `@interval` macro converts an expression into a narrow interval that is guaranteed to contain the true value of the expression.
 When passed two expressions, it takes the hull of the resulting intervals
 to give a guaranteed containing interval.
 
 Examples:
 ```
-    @interval(0.1)
-
-    @interval(0.1, 0.2)
-
-    @interval(1/3, 1/6)
+    @interval sin(0.1) + cos(0.2)
+```
 
-    @interval(1/3^2)
+is equivalent to
 ```
+    sin(0.1..0.1) + cos(0.2..0.2)
+```
+
+NOTE! `@interval` should be used only to create intervals from an expression, as in the example
+before. To construct an interval from single numbers, the `..` is preferred, e.g. `0.1..0.2`
 """
 macro interval(expr1)
     make_interval(:(parameters.precision_type), expr1, ())

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)

test/decoration_tests/decoration_tests.jl

@@ -54,6 +54,15 @@ let b
     b = @decorated 3 4
 
     @test dist(a, b) == 2.0
+
+    # invalid input
+    @test isnai(@decorated(3, 1, com))
+    @test isnai(@decorated(3, 1))
+    @test isnai(@decorated(Inf, Inf))
+    @test isnai(@decorated(-Inf, -Inf))
+    @test isnai(@decorated(NaN, 3))
+    @test isnai(@decorated(3, NaN))
+    @test isnai(@decorated(NaN, NaN))
 end
 
 @testset "Convert string to DecoratedInterval" begin

test/interval_tests/consistency.jl

@@ -39,7 +39,9 @@ setprecision(Interval, Float64)
         @test @biginterval(1, Inf) == Interval{BigFloat}(1.0, Inf)
         @test @biginterval(-Inf, 1) == Interval{BigFloat}(-Inf, 1.0)
         @test @interval(-Inf, Inf) == entireinterval(Float64)
+        @test entireinterval(Int) == entireinterval(Float64)
         @test emptyinterval(Rational{Int}) == ∅
+        @test emptyinterval(Int) == ∅
 
         @test 1 == zero(a)+one(b)
         @test Interval(0,1) + emptyinterval(a) == emptyinterval(a)
@@ -380,10 +382,10 @@ setprecision(Interval, Float64)
         @test interval(1, 2) == Interval(1, 2)
 
         @test inf(Interval(3, 2)) == 3
-        @test_throws ArgumentError interval(3, 2)
+        @test_logs (:warn,) @test isempty(interval(3, 2))
 
         @test sup(Interval(Inf, Inf)) == Inf
-        @test_throws ArgumentError interval(Inf, Inf)
+        @test_logs (:warn,) @test isempty(interval(Inf, Inf))
 
     end
 

test/interval_tests/construction.jl

@@ -69,20 +69,20 @@ const eeuler = Base.MathConstants.e
 
     # Disallowed conversions with a > b
 
-    @test_throws ArgumentError interval(2, 1)
-    @test_throws ArgumentError interval(big(2), big(1))
-    @test_throws ArgumentError interval(BigInt(1), 1//10)
-    @test_throws ArgumentError interval(1, 0.1)
-    @test_throws ArgumentError interval(big(1), big(0.1))
-
-    @test_throws ArgumentError @interval(2, 1)
-    @test_throws ArgumentError @interval(big(2), big(1))
-    @test_throws ArgumentError @interval(big(1), 1//10)
-    @test_throws ArgumentError @interval(1, 0.1)
-    @test_throws ArgumentError @interval(big(1), big(0.1))
-    @test_throws ArgumentError interval(Inf)
-    @test_throws ArgumentError interval(-Inf, -Inf)
-    @test_throws ArgumentError interval(Inf, Inf)
+    @test_logs (:warn,) @test isempty(interval(2, 1))
+    @test_logs (:warn,) @test isempty(interval(big(2), big(1)))
+    @test_logs (:warn,) @test isempty(interval(BigInt(1), 1//10))
+    @test_logs (:warn,) @test isempty(interval(1, 0.1))
+    @test_logs (:warn,) @test isempty(interval(big(1), big(0.1)))
+
+    @test_logs (:warn,) @test isempty(@interval(2, 1))
+    @test_logs (:warn,) @test isempty(@interval(big(2), big(1)))
+    @test_logs (:warn,) @test isempty(@interval(big(1), 1//10))
+    @test_logs (:warn,) @test isempty(@interval(1, 0.1))
+    @test_logs (:warn,) @test isempty(@interval(big(1), big(0.1)))
+    @test_logs (:warn,) @test isempty(interval(Inf))
+    @test_logs (:warn,) @test isempty(interval(-Inf, -Inf))
+    @test_logs (:warn,) @test isempty(interval(Inf, Inf))
 
     # Conversion to Interval without type
     @test convert(Interval, 1) == Interval(1.0)
@@ -237,10 +237,12 @@ end
     a = big(0.1)..2
     @test typeof(a) == Interval{BigFloat}
 
-    @test_throws ArgumentError 2..1
-    @test_throws ArgumentError π..1
-    @test_throws ArgumentError π..eeuler
-    @test_throws ArgumentError 4..π
+    @test_logs (:warn, ) @test isempty(2..1)
+    @test_logs (:warn, ) @test isempty(π..1)
+    @test_logs (:warn, ) @test isempty(π..eeuler)
+    @test_logs (:warn, ) @test isempty(4..π)
+    @test_logs (:warn, ) @test isempty(NaN..3)
+    @test_logs (:warn, ) @test isempty(3..NaN)
     @test 1..π == Interval(1, π)
 end
 
@@ -292,9 +294,10 @@ end
 end
 
 # issue 192:
-@testset "Disallow a single NaN in an interval" begin
-    @test_throws ArgumentError interval(NaN, 2)
-    @test_throws ArgumentError interval(Inf, NaN)
+@testset "Disallow NaN in an interval" begin
+    @test_logs (:warn, ) @test isempty(interval(NaN, 2))
+    @test_logs (:warn, ) @test isempty(interval(Inf, NaN))
+    @test_logs (:warn, ) @test isempty(interval(NaN, NaN))
 end
 
 # issue 206:
@@ -342,7 +345,7 @@ end
 end
 
 @testset "a..b with a > b" begin
-    @test_throws ArgumentError 3..2
+    @test_logs (:warn,) @test isempty(3..2)
 end
 
 @testset "Hashing of Intervals" begin
@@ -374,7 +377,7 @@ import IntervalArithmetic: force_interval
     @test force_interval(4, Inf) == Interval(4, Inf)
     @test force_interval(Inf, 4) == Interval(4, Inf)
     @test force_interval(Inf, -Inf) == Interval(-Inf, Inf)
-    @test_throws ArgumentError force_interval(NaN, 3)
+    @test_logs (:warn,) @test isempty(force_interval(NaN, 3))
 end
 
 @testset "Zero interval" begin

test/interval_tests/numeric.jl

@@ -11,7 +11,7 @@ setprecision(Interval, Float64)
     y = 4..5
     a = 3
     b = 12
-    
+
     @test sqrt(sum(x.^2 .+ y.^2)) == 5..13
 
     for i in 1:20
@@ -24,7 +24,7 @@ setprecision(Interval, Float64)
     end
 
     a = 4
-    b = 5 
+    b = 5
     for i in 1:20
         @test y.+i == (a+i)..(b+i)
     end
@@ -115,7 +115,7 @@ end
     @test Interval(1,2) ^ -3 == Interval(1/8, 1.0)
     @test Interval(0,3) ^ -3 == @interval(1/27, Inf)
     @test Interval(-1,2) ^ -3 == entireinterval()
-    @test_throws ArgumentError interval(-1, -2) ^ -3  # wrong way round
+    @test_logs (:warn, ) @test isempty(interval(-1, -2) ^ -3)
     @test Interval(-3,2) ^ (3//1) == Interval(-27, 8)
     @test Interval(0.0) ^ 1.1 == Interval(0, 0)
     @test Interval(0.0) ^ 0.0 == emptyinterval()
@@ -432,4 +432,4 @@ end
     @test nthroot(Interval{BigFloat}(-27, 27), -3) == Interval{BigFloat}(-Inf, Inf)
     @test nthroot(Interval{BigFloat}(-81, -16), -4) == ∅
     @test nthroot(Interval{BigFloat}(-81, -16), 1) == Interval{BigFloat}(-81, -16)
-end 
+end