Support in with complex (#45) (#46)

* Support in with complex (#45)

* test open and mixed complex in

* increase coverage

* more coverage

Author: dlfivefifty

src/IntervalSets.jl

@@ -124,6 +124,11 @@ in(v, I::TypedEndpointsInterval{:open,:open}) = leftendpoint(I) < v < rightendpo
 in(v, I::TypedEndpointsInterval{:closed,:open}) = leftendpoint(I) ≤ v < rightendpoint(I)
 in(v, I::TypedEndpointsInterval{:open,:closed}) = leftendpoint(I) < v ≤ rightendpoint(I)
 
+in(v::Complex, I::TypedEndpointsInterval{:closed,:closed}) = isreal(v) && in(real(v), I)
+in(v::Complex, I::TypedEndpointsInterval{:open,:open}) = isreal(v) && in(real(v), I)
+in(v::Complex, I::TypedEndpointsInterval{:closed,:open}) = isreal(v) && in(real(v), I)
+in(v::Complex, I::TypedEndpointsInterval{:open,:closed}) = isreal(v) && in(real(v), I)
+
 in(a::AbstractInterval,                         b::TypedEndpointsInterval{:closed,:closed}) =
     (leftendpoint(a) ≥ leftendpoint(b)) & (rightendpoint(a) ≤ rightendpoint(b))
 in(a::TypedEndpointsInterval{:open,:open},      b::TypedEndpointsInterval{:open,:open}) =
@@ -176,6 +181,8 @@ function Base.OneTo{T}(i::TypedEndpointsInterval{:closed,:closed,I}) where {T<:I
     minimum(i) == 1 || throwstart(i)
     Base.OneTo{T}(maximum(i))
 end
+Base.OneTo(i::TypedEndpointsInterval{:closed,:closed,I}) where {I<:Integer} =
+    Base.OneTo{I}(i)
 UnitRange{T}(i::TypedEndpointsInterval{:closed,:closed,I}) where {T<:Integer,I<:Integer} = UnitRange{T}(minimum(i), maximum(i))
 UnitRange(i::TypedEndpointsInterval{:closed,:closed,I}) where {I<:Integer} = UnitRange{I}(i)
 range(i::TypedEndpointsInterval{:closed,:closed,I}) where {I<:Integer} = UnitRange{I}(i)

test/runtests.jl

@@ -463,6 +463,9 @@ closedendpoints(I::MyUnitInterval) = (I.isleftclosed,I.isrightclosed)
             @test Interval{:open,:closed}(i2) ∩ OpenInterval(i3) ≡ OpenInterval(i3) ∩ Interval{:open,:closed}(i2) ≡ Interval{:open,:closed}(d)
             @test Interval{:open,:closed}(i2) ∩ Interval{:closed,:open}(i3) ≡ Interval{:closed,:open}(i3) ∩ Interval{:open,:closed}(i2) ≡ d
 
+            # - intersection of custom intervals
+            @test intersect(MyUnitInterval(true,true), MyUnitInterval(false,false)) == OpenInterval(0,1)
+            @test intersect(MyUnitInterval(true,true), OpenInterval(0,1)) == OpenInterval(0,1)
 
             # - union of non-overlapping intervals
             @test_throws ArgumentError i1 ∪ i4
@@ -472,8 +475,6 @@ closedendpoints(I::MyUnitInterval) = (I.isleftclosed,I.isrightclosed)
             @test_throws ArgumentError Interval{:closed,:open}(i1) ∪ i4
             @test_throws ArgumentError Interval{:closed,:open}(i1) ∪ OpenInterval(i4)
 
-
-
             # - union of almost-overlapping intervals
             @test_throws ArgumentError i1 ∪ i5
             @test_throws ArgumentError i5 ∪ i1
@@ -577,6 +578,7 @@ closedendpoints(I::MyUnitInterval) = (I.isleftclosed,I.isrightclosed)
         @test Interval{:closed,:open}(I) === convert(Interval{:closed,:open}, I) ===
                 Interval{:closed,:open,Int}(I) === convert(Interval{:closed,:open,Int}, I)  ===
                 convert(Interval, I) === Interval(I) === Interval{:closed,:open}(0..1)
+        @test convert(AbstractInterval, I) === convert(AbstractInterval{Int}, I) === I
     end
 
     @testset "Custom typed endpoints interval" begin
@@ -597,4 +599,42 @@ closedendpoints(I::MyUnitInterval) = (I.isleftclosed,I.isrightclosed)
         @test issubset(1.1, 0.0..1.0) == false
         @test issubset(0.0, nextfloat(0.0)..1.0) == false
     end
+
+    @testset "complex in" begin
+        @test 0+im ∉ 0..2
+        @test 0+0im ∈ 0..2
+        @test 0+eps()im ∉ 0..2
+
+        @test 0+im ∉ OpenInterval(0,2)
+        @test 0+0im ∉ OpenInterval(0,2)
+        @test 1+0im ∈ OpenInterval(0,2)
+        @test 1+eps()im ∉ OpenInterval(0,2)
+
+        @test 0+im ∉ Interval{:closed,:open}(0,2)
+        @test 0+0im ∈ Interval{:closed,:open}(0,2)
+        @test 1+0im ∈ Interval{:closed,:open}(0,2)
+        @test 1+eps()im ∉ Interval{:closed,:open}(0,2)
+
+        @test 0+im ∉ Interval{:open,:closed}(0,2)
+        @test 0+0im ∉ Interval{:open,:closed}(0,2)
+        @test 1+0im ∈ Interval{:open,:closed}(0,2)
+        @test 1+eps()im ∉ Interval{:open,:closed}(0,2)
+    end
+
+    @testset "closedendpoints" begin
+        @test closedendpoints(0..1) == closedendpoints(MyClosedUnitInterval()) == (true,true)
+        @test closedendpoints(Interval{:open,:closed}(0,1)) == (false,true)
+        @test closedendpoints(Interval{:closed,:open}(0,1)) == (true,false)
+        @test closedendpoints(OpenInterval(0,1)) == (false,false)
+    end
+
+    @testset "OneTo" begin
+        @test_throws ArgumentError Base.OneTo{Int}(0..5)
+        @test_throws ArgumentError Base.OneTo(0..5)
+        @test Base.OneTo(1..5) == Base.OneTo{Int}(1..5) == Base.OneTo(5)
+    end
+
+    @testset "IteratorSize" begin
+        @test Base.IteratorSize(ClosedInterval) == Base.SizeUnknown()
+    end
 end