Remove ambiguous set functionalities

Author: OlivierHnt

ext/IntervalArithmeticForwardDiffExt.jl

@@ -25,6 +25,8 @@ Base.promote_rule(::Type{Dual{T, V, N}}, ::Type{ExactReal{S}}) where {S<:Real, T
 
 Base.:(==)(x::Interval, y::Dual) = x == value(y)
 Base.:(==)(x::Dual, y::Interval) = value(x) == y
+Base.:<(x::Interval, y::Dual) = x < value(y)
+Base.:<(x::Dual, y::Interval) = value(x) < y
 
 function Base.:(^)(x::Dual{Txy,<:Interval}, y::Dual{Txy,<:Interval}) where {Txy}
     vx, vy = value(x), value(y)

src/intervals/real_interface.jl

@@ -108,32 +108,32 @@ end
 Base.isempty(::Interval) =
     throw(ArgumentError("`isempty` is purposely not supported for intervals. See instead `isempty_interval`"))
 
-# Base.isfinite(::Interval) = # also returned when calling `isinf`
-#     throw(ArgumentError("`isfinite` is purposely not supported for intervals. See instead `isbounded`"))
+Base.isfinite(::Interval) = # also returned when calling `isinf`
+    throw(ArgumentError("`isfinite` is purposely not supported for intervals. See instead `isbounded`"))
 
 Base.isnan(::Interval) =
     throw(ArgumentError("`isnan` is purposely not supported for intervals. See instead `isnai`"))
 
-# Base.intersect(::Interval) =
-#     throw(ArgumentError("`intersect` is purposely not supported for intervals. See instead `intersect_interval`"))
-
-# Base.union!(::BitSet, ::Interval) = # needed to resolve ambiguity
-#     throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
-# Base.union!(::AbstractSet, ::Interval) = # also returned when calling `intersect`, `symdiff` with intervals
-#     throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
-# Base.union!(::AbstractVector{S}, ::Interval) where {S} =
-#     throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
-# Base.union!(::AbstractVector{S}, ::Interval, ::Any, ::Any...) where {S} =
-#     throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
-# Base.union!(::AbstractVector{S}, ::Interval, ::Interval, ::Any...) where {S} =
-#     throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
-# Base.union!(::AbstractVector{S}, ::Any, ::Interval, ::Any...) where {S} =
-#     throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
-
-# Base.setdiff(::Interval) =
-#     throw(ArgumentError("`setdiff` is purposely not supported for intervals. See instead `interiordiff`"))
-# Base.setdiff!(::AbstractSet, ::Interval) =
-#     throw(ArgumentError("`setdiff!` is purposely not supported for intervals. See instead `interiordiff`"))
+Base.intersect(::Interval) =
+    throw(ArgumentError("`intersect` is purposely not supported for intervals. See instead `intersect_interval`"))
+
+Base.union!(::BitSet, ::Interval) = # needed to resolve ambiguity
+    throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
+Base.union!(::AbstractSet, ::Interval) = # also returned when calling `intersect`, `symdiff` with intervals
+    throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
+Base.union!(::AbstractVector{S}, ::Interval) where {S} =
+    throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
+Base.union!(::AbstractVector{S}, ::Interval, ::Any, ::Any...) where {S} =
+    throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
+Base.union!(::AbstractVector{S}, ::Interval, ::Interval, ::Any...) where {S} =
+    throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
+Base.union!(::AbstractVector{S}, ::Any, ::Interval, ::Any...) where {S} =
+    throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`"))
+
+Base.setdiff(::Interval) =
+    throw(ArgumentError("`setdiff` is purposely not supported for intervals. See instead `interiordiff`"))
+Base.setdiff!(::AbstractSet, ::Interval) =
+    throw(ArgumentError("`setdiff!` is purposely not supported for intervals. See instead `interiordiff`"))
 
 # pointwise equality
 

test/interval_tests/consistency.jl

@@ -369,10 +369,10 @@
         @test x < y
         @test isdisjoint(x, y)
         @test !issubset(x, y)
-        @test !issetequal(x, y)
+        @test_throws ArgumentError !issetequal(x, y)
         @test x ∉ y
         @test_throws ArgumentError isempty(x)
-        @test_throws MethodError isfinite(x)
+        @test_throws ArgumentError isfinite(x)
         @test_throws ArgumentError isnan(x)
         @test isinteger(x)
         @test !isinteger(interval(1.2, 1.9))