Add support for Infinity.jl

Project.toml

@@ -2,15 +2,17 @@ name = "Intervals"
 uuid = "d8418881-c3e1-53bb-8760-2df7ec849ed5"
 license = "MIT"
 authors = ["Invenia Technical Computing"]
-version = "1.1.0"
+version = "1.2.0"
 
 [deps]
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+Infinity = "a303e19e-6eb4-11e9-3b09-cd9505f79100"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
 TimeZones = "f269a46b-ccf7-5d73-abea-4c690281aa53"
 
 [compat]
+Infinity = "0.1"
 RecipesBase = "0.8, 1"
 TimeZones = "0.7, 0.8, 0.9, 0.10, 0.11, 1"
 julia = "1"

src/Intervals.jl

@@ -1,6 +1,8 @@
 module Intervals
 
 using Dates
+using Infinity
+using Infinity: isposinf, isneginf
 using Printf
 using RecipesBase
 using TimeZones

src/interval.jl

@@ -71,7 +71,27 @@ struct Interval{T} <: AbstractInterval{T}
     end
 end
 
-Interval{T}(f, l, inc::Inclusivity) where T = Interval{T}(convert(T, f), convert(T, l), inc)
+isbounded(a) = !isposinf(a) && !isneginf(a)
+isunbounded(a) = !isbounded(a)
+
+function Interval{T}(f, l, inc::Inclusivity) where T
+    if (isbounded(f) && isbounded(l)) || (isunbounded(f) && isunbounded(l))
+        return Interval{T}(convert(T, f), convert(T, l), inc)
+    else
+        # If either endpoint is unbounded, we want to convert the bounded variable, and then
+        # try and promote them both to a compatable type.
+        # If T is a subset of the Infinite type, then don't try to convert at all, as trying
+        # to convert any type to Infinite will result in an error
+        if !(T <: Infinite)
+            if isbounded(f)
+                f = convert(T, f)
+            else
+                l = convert(T, l)
+            end
+        end
+        return Interval(f, l, inc)
+    end
+end
 Interval{T}(f, l, x::Bool, y::Bool) where T = Interval{T}(f, l, Inclusivity(x, y))
 Interval{T}(f, l) where T = Interval{T}(f, l, true, true)
 
@@ -161,7 +181,8 @@ end
 
 ##### ARITHMETIC #####
 
-Base.:+(a::T, b) where {T <: Interval} = T(first(a) + b, last(a) + b, inclusivity(a))
+Base.:+(a::Interval, b) = Interval(first(a) + b, last(a) + b, inclusivity(a))
+
 
 Base.:+(a, b::Interval) = b + a
 Base.:-(a::Interval, b) = a + -b
@@ -338,7 +359,14 @@ function Base.merge(a::AbstractInterval, b::AbstractInterval)
 
     left = min(LeftEndpoint(a), LeftEndpoint(b))
     right = max(RightEndpoint(a), RightEndpoint(b))
-    return Interval(left, right)
+
+    # This promotion fixes the situation where one endpoint has a type of
+    # `InfExtended{T}` yet the ∞ value is of type `Infinite`.
+    # This will cause an error when trying to `promote(left, right)`
+    return Interval(
+        promote(left.endpoint, right.endpoint)...,
+        left.included, right.included
+    )
 end
 
 ##### TIME ZONES #####

test/comparisons.jl

@@ -18,31 +18,41 @@ const INTERVAL_TYPES = [Interval, AnchoredInterval{Ending}, AnchoredInterval{Beg
     # [12]
     #     [45]
     @testset "non-overlapping" begin
-        earlier = convert(A, Interval(1, 2, true, true))
-        later = convert(B, Interval(4, 5, true, true))
-
-        @test earlier != later
-        @test !isequal(earlier, later)
-        @test hash(earlier) != hash(later)
-
-        @test isless(earlier, later)
-        @test !isless(later, earlier)
-
-        @test earlier < later
-        @test !(later < earlier)
-
-        @test earlier ≪ later
-        @test !(later ≪ earlier)
-
-        @test !issubset(earlier, later)
-        @test !issubset(later, earlier)
-
-        @test isempty(intersect(earlier, later))
-        @test_throws ArgumentError merge(earlier, later)
-        @test union([earlier, later]) == [earlier, later]
-        @test !overlaps(earlier, later)
-        @test !contiguous(earlier, later)
-        @test superset([earlier, later]) == Interval(1, 5, true, true)
+        tests = [
+            ((1, 2, true, true), (4, 5, true, true)),
+            ((-∞, 2, true, true), (4, ∞, true, true)),
+        ]
+        for (a, b) in tests
+            @show a
+            @show b
+            @show A
+            @show B
+            earlier = convert(A, Interval(a[1], a[2], a[3], a[4]))
+            later = convert(B, Interval(b[1], b[2], b[3], b[4]))
+
+            @test earlier != later
+            @test !isequal(earlier, later)
+            @test hash(earlier) != hash(later)
+
+            @test isless(earlier, later)
+            @test !isless(later, earlier)
+
+            @test earlier < later
+            @test !(later < earlier)
+
+            @test earlier ≪ later
+            @test !(later ≪ earlier)
+
+            @test !issubset(earlier, later)
+            @test !issubset(later, earlier)
+
+            @test isempty(intersect(earlier, later))
+            @test_throws ArgumentError merge(earlier, later)
+            @test union([earlier, later]) == [earlier, later]
+            @test !overlaps(earlier, later)
+            @test !contiguous(earlier, later)
+            @test superset([earlier, later]) == Interval(a[1], b[2], a[3], b[4])
+        end
     end
 
     # Compare two intervals which "touch" but both intervals do not include that point: