Rebase on IntervalSets

Author: timholy

.travis.yml

@@ -3,7 +3,6 @@ os:
   - linux
   - osx
 julia:
-  - 0.4
   - 0.5
   - nightly
 notifications:

REQUIRE

@@ -1,4 +1,5 @@
-julia 0.4
+julia 0.5-
+IntervalSets
 Iterators
 Compat
 RangeArrays

src/AxisArrays.jl

@@ -1,9 +1,13 @@
 module AxisArrays
 
-using RangeArrays, Iterators, Compat
+using RangeArrays, Iterators, IntervalSets, Compat
 using Compat.view
 
-export AxisArray, Axis, Interval, axisnames, axisvalues, axisdim, axes, .., atindex
+export AxisArray, Axis, axisnames, axisvalues, axisdim, axes, atindex
+
+# From IntervalSets:
+export ClosedInterval, ..
+Base.@deprecate_binding Interval ClosedInterval
 
 include("core.jl")
 include("intervals.jl")

src/core.jl

@@ -117,7 +117,7 @@ Two main types of axes supported by default include:
   of elements.
 
 * Dimensional axis -- These are sorted vectors or iterators that can
-  be indexed by `Interval()`. These are commonly used for sequences of
+  be indexed by `ClosedInterval()`. These are commonly used for sequences of
   times or date-times. For regular sample rates, ranges can be used.
 
 User-defined axis types can be added along with custom indexing
@@ -142,8 +142,8 @@ Symbols for column headers.
 ```julia
 A = AxisArray(reshape(1:15, 5, 3), Axis{:time}(.1:.1:0.5), Axis{:col}([:a, :b, :c]))
 A[Axis{:time}(1:3)]   # equivalent to A[1:3,:]
-A[Axis{:time}(Interval(.2,.4))] # restrict the AxisArray along the time axis
-A[Interval(0.,.3), [:a, :c]]   # select an interval and two columns
+A[Axis{:time}(ClosedInterval(.2,.4))] # restrict the AxisArray along the time axis
+A[ClosedInterval(0.,.3), [:a, :c]]   # select an interval and two columns
 ```
 
 """ ->

src/indexing.jl

@@ -136,15 +136,15 @@ axisindexes(t, ax, idx) = error("cannot index $(typeof(ax)) with $(typeof(idx));
 
 # Dimensional axes may be indexed directy by their elements if Non-Real and unique
 # Maybe extend error message to all <: Numbers if Base allows it?
-axisindexes{T<:Real}(::Type{Dimensional}, ax::AbstractVector{T}, idx::T) = error("indexing by axis value is not supported for axes with $(eltype(ax)) elements; use an Interval instead")
+axisindexes{T<:Real}(::Type{Dimensional}, ax::AbstractVector{T}, idx::T) = error("indexing by axis value is not supported for axes with $(eltype(ax)) elements; use an ClosedInterval instead")
 function axisindexes(::Type{Dimensional}, ax::AbstractVector, idx)
-    idxs = searchsorted(ax, Interval(idx,idx))
+    idxs = searchsorted(ax, ClosedInterval(idx,idx))
     length(idxs) > 1 && error("more than one datapoint lies on axis value $idx; use an interval to return all values")
     idxs[1]
 end
 
 # Dimensional axes may be indexed by intervals to select a range
-axisindexes{T}(::Type{Dimensional}, ax::AbstractVector{T}, idx::Interval) = searchsorted(ax, idx)
+axisindexes{T}(::Type{Dimensional}, ax::AbstractVector{T}, idx::ClosedInterval) = searchsorted(ax, idx)
 
 # Or repeated intervals, which only work if the axis is a range since otherwise
 # there will be a non-constant number of indices in each repetition.

src/intervals.jl

@@ -1,70 +1,15 @@
-@doc """
-An Interval represents all values between and including its two endpoints.
-Intervals are parameterized by the type of its endpoints; this type must be
-a concrete leaf type that supports a partial ordering. Promoting arithmetic
-is defined for Intervals of `Number` and `Dates.AbstractTime`.
-
-### Type parameters
-
-```julia
-immutable Interval{T}
-```
-* `T` : the type of the interval's endpoints. Must be a concrete leaf type.
-
-### Constructors
-
-```julia
-Interval(a, b)
-a .. b
-```
-
-### Arguments
-
-* `a` : lower bound of the interval
-* `b` : upper bound of the interval
-
-### Examples
-
-```julia
-A = AxisArray(collect(1:20), Axis{:time}(.1:.1:2.0))
-A[Interval(0.2,0.5)]
-A[0.0 .. 0.5]
-```
-
-""" ->
-immutable Interval{T}
-    lo::T
-    hi::T
-    function Interval(lo, hi)
-        lo <= hi ? new(lo, hi) : throw(ArgumentError("lo must be less than or equal to hi"))
-    end
-end
-Interval{T}(a::T,b::T) = Interval{T}(a,b)
-# Allow promotion during construction, but only if it results in a leaf type
-function Interval{T,S}(a::T, b::S)
-    R = promote_type(T,S)
-    isleaftype(R) || throw(ArgumentError("cannot promote $a and $b to a common leaf type"))
-    Interval{R}(promote(a,b)...)
-end
-const .. = Interval
-
-Base.convert{T}(::Type{Interval}, x::T) = Interval{T}(x,x)
-Base.convert{T}(::Type{Interval{T}}, x::T) = Interval{T}(x,x)
-Base.convert{T,S}(::Type{Interval{T}}, x::S) = (y=convert(T, x); Interval{T}(y,y))
-Base.convert{T}(::Type{Interval{T}}, w::Interval) = Interval{T}(convert(T, w.lo), convert(T, w.hi))
-
 # Promotion rules for "promiscuous" types like Intervals and SIUnits, which both
 # simply wrap any Number, are often ambiguous. That is, which type should "win"
-# -- is the promotion between an SIUnit and an Interval an SIQuantity{Interval}
-# or is it an Interval{SIQuantity}? For our uses in AxisArrays, though, we can
+# -- is the promotion between an SIUnit and an ClosedInterval an SIQuantity{ClosedInterval}
+# or is it an ClosedInterval{SIQuantity}? For our uses in AxisArrays, though, we can
 # sidestep this problem by making Intervals *not* a subtype of Number. Then in
 # order for them to plug into the promotion system, we *extend* the promoting
-# operator behaviors to Union{Number, Interval}. This way other types can
+# operator behaviors to Union{Number, ClosedInterval}. This way other types can
 # similarly define their own extensions to the promoting operators without fear
 # of ambiguity -- there will simply be, e.g.,
 #
 # f(x::Number, y::Number) = f(promote(x,y)...) # in base
-# f(x::Union{Number, Interval}, y::Union{Number, Interval}) = f(promote(x,y)...)
+# f(x::Union{Number, ClosedInterval}, y::Union{Number, ClosedInterval}) = f(promote(x,y)...)
 # f(x::Union{Number, T}, y::Union{Number, T}) = f(promote(x,y)...)
 #
 # In this way, these "promiscuous" types will never interact unless explicitly
@@ -73,78 +18,71 @@ Base.convert{T}(::Type{Interval{T}}, w::Interval) = Interval{T}(convert(T, w.lo)
 # could be considered as <: Number themselves. We do this in general for any
 # supported Scalar:
 typealias Scalar Union{Number, Dates.AbstractTime}
-Base.promote_rule{T<:Scalar}(::Type{Interval{T}}, ::Type{T}) = Interval{T}
-Base.promote_rule{T,S<:Scalar}(::Type{Interval{T}}, ::Type{S}) = Interval{promote_type(T,S)}
-Base.promote_rule{T,S}(::Type{Interval{T}}, ::Type{Interval{S}}) = Interval{promote_type(T,S)}
+Base.promote_rule{T<:Scalar}(::Type{ClosedInterval{T}}, ::Type{T}) = ClosedInterval{T}
+Base.promote_rule{T,S<:Scalar}(::Type{ClosedInterval{T}}, ::Type{S}) = ClosedInterval{promote_type(T,S)}
+Base.promote_rule{T,S}(::Type{ClosedInterval{T}}, ::Type{ClosedInterval{S}}) = ClosedInterval{promote_type(T,S)}
 
 import Base: isless, <=, >=, ==, +, -, *, /, ^, //
 # TODO: Is this a total ordering? (antisymmetric, transitive, total)?
-isless(a::Interval, b::Interval) = isless(a.hi, b.lo)
+isless(a::ClosedInterval, b::ClosedInterval) = isless(a.right, b.left)
 # The default definition for <= assumes a strict total order (<=(x,y) = !(y < x))
-<=(a::Interval, b::Interval) = a.lo <= b.lo && a.hi <= b.hi
-==(a::Interval, b::Interval) = a.hi == b.hi && a.lo == b.lo
-const _interval_hash = UInt == UInt64 ? 0x1588c274e0a33ad4 : 0x1e3f7252
-Base.hash(a::Interval, h::UInt) = hash(a.lo, hash(a.hi, hash(_interval_hash, h)))
-+(a::Interval) = a
-+(a::Interval, b::Interval) = Interval(a.lo + b.lo, a.hi + b.hi)
--(a::Interval) = Interval(-a.hi, -a.lo)
--(a::Interval, b::Interval) = a + (-b)
+<=(a::ClosedInterval, b::ClosedInterval) = a.left <= b.left && a.right <= b.right
++(a::ClosedInterval) = a
++(a::ClosedInterval, b::ClosedInterval) = ClosedInterval(a.left + b.left, a.right + b.right)
+-(a::ClosedInterval) = ClosedInterval(-a.right, -a.left)
+-(a::ClosedInterval, b::ClosedInterval) = a + (-b)
 for f in (:(*), :(/), :(//))
     # For a general monotonic operator, we compute the operation over all
     # combinations of the endpoints and return the widest interval
-    @eval function $(f)(a::Interval, b::Interval)
-        w = $(f)(a.lo, b.lo)
-        x = $(f)(a.lo, b.hi)
-        y = $(f)(a.hi, b.lo)
-        z = $(f)(a.hi, b.hi)
-        Interval(min(w,x,y,z), max(w,x,y,z))
+    @eval function $(f)(a::ClosedInterval, b::ClosedInterval)
+        w = $(f)(a.left, b.left)
+        x = $(f)(a.left, b.right)
+        y = $(f)(a.right, b.left)
+        z = $(f)(a.right, b.right)
+        ClosedInterval(min(w,x,y,z), max(w,x,y,z))
     end
 end
 
-Base.in(a, b::Interval) = b.lo <= a <= b.hi
-Base.in(a::Interval, b::Interval) = b.lo <= a.lo && a.hi <= b.hi
-Base.minimum(a::Interval) = a.lo
-Base.maximum(a::Interval) = a.hi
 # Extend the promoting operators to include Intervals. The comparison operators
 # (<, <=, and ==) are a pain since they are non-promoting fallbacks that call
 # isless, !(y < x) (which is wrong), and ===. So implementing promotion with
-# Union{T, Interval} causes stack overflows for the base types. This is safer:
+# Union{T, ClosedInterval} causes stack overflows for the base types. This is safer:
 for f in (:isless, :(<=), :(>=), :(==), :(+), :(-), :(*), :(/), :(//))
     # We don't use promote here, though, because promotions can be lossy... and
     # that's particularly bad for comparisons. Just make an interval instead.
-    @eval $(f)(x::Interval, y::Scalar) = $(f)(x, y..y)
-    @eval $(f)(x::Scalar, y::Interval) = $(f)(x..x, y)
+    @eval $(f)(x::ClosedInterval, y::Scalar) = $(f)(x, y..y)
+    @eval $(f)(x::Scalar, y::ClosedInterval) = $(f)(x..x, y)
 end
 
 # And, finally, we have an Array-of-Structs to Struct-of-Arrays transform for
 # the common case where the interval is constant over many offsets:
 immutable RepeatedInterval{T,S,A} <: AbstractVector{T}
-    window::Interval{S}
+    window::ClosedInterval{S}
     offsets::A # A <: AbstractVector
 end
-RepeatedInterval{S,A<:AbstractVector}(window::Interval{S}, offsets::A) = RepeatedInterval{promote_type(Interval{S}, eltype(A)), S, A}(window, offsets)
+RepeatedInterval{S,A<:AbstractVector}(window::ClosedInterval{S}, offsets::A) = RepeatedInterval{promote_type(ClosedInterval{S}, eltype(A)), S, A}(window, offsets)
 Base.size(r::RepeatedInterval) = size(r.offsets)
 Base.linearindexing{R<:RepeatedInterval}(::Type{R}) = Base.LinearFast()
 Base.getindex(r::RepeatedInterval, i::Int) = r.window + r.offsets[i]
-+(window::Interval, offsets::AbstractVector) = RepeatedInterval(window, offsets)
-+(offsets::AbstractVector, window::Interval) = RepeatedInterval(window, offsets)
--(window::Interval, offsets::AbstractVector) = RepeatedInterval(window, -offsets)
--(offsets::AbstractVector, window::Interval) = RepeatedInterval(-window, offsets)
++(window::ClosedInterval, offsets::AbstractVector) = RepeatedInterval(window, offsets)
++(offsets::AbstractVector, window::ClosedInterval) = RepeatedInterval(window, offsets)
+-(window::ClosedInterval, offsets::AbstractVector) = RepeatedInterval(window, -offsets)
+-(offsets::AbstractVector, window::ClosedInterval) = RepeatedInterval(-window, offsets)
 
 # As a special extension to intervals, we allow specifying Intervals about a
 # particular index, which is resolved by an axis upon indexing.
 immutable IntervalAtIndex{T}
-    window::Interval{T}
+    window::ClosedInterval{T}
     index::Int
 end
-atindex(window::Interval, index::Integer) = IntervalAtIndex(window, index)
+atindex(window::ClosedInterval, index::Integer) = IntervalAtIndex(window, index)
 
 # And similarly, an AoS -> SoA transform:
 immutable RepeatedIntervalAtIndexes{T,A<:AbstractVector{Int}} <: AbstractVector{IntervalAtIndex{T}}
-    window::Interval{T}
+    window::ClosedInterval{T}
     indexes::A # A <: AbstractVector{Int}
 end
-atindex(window::Interval, indexes::AbstractVector) = RepeatedIntervalAtIndexes(window, indexes)
+atindex(window::ClosedInterval, indexes::AbstractVector) = RepeatedIntervalAtIndexes(window, indexes)
 Base.size(r::RepeatedIntervalAtIndexes) = size(r.indexes)
 Base.linearindexing{R<:RepeatedIntervalAtIndexes}(::Type{R}) = Base.LinearFast()
 Base.getindex(r::RepeatedIntervalAtIndexes, i::Int) = IntervalAtIndex(r.window, r.indexes[i])

src/search.jl

@@ -23,17 +23,17 @@ end
 # TODO: This could plug into the sorting system better, but it's fine for now
 # TODO: This needs to support Dates.
 """
-    unsafe_searchsorted(a::Range, I::Interval)
+    unsafe_searchsorted(a::Range, I::ClosedInterval)
 
 Return the indices of the range that fall within an interval without checking
 bounds, possibly extrapolating outside the range if needed.
 """
-function unsafe_searchsorted(a::Range, I::Interval)
-    unsafe_searchsortedfirst(a, I.lo):unsafe_searchsortedlast(a, I.hi)
+function unsafe_searchsorted(a::Range, I::ClosedInterval)
+    unsafe_searchsortedfirst(a, I.left):unsafe_searchsortedlast(a, I.right)
 end
 # Base only specializes searching ranges by Numbers; so optimize for Intervals
-function Base.searchsorted(a::Range, I::Interval)
-    searchsortedfirst(a, I.lo):searchsortedlast(a, I.hi)
+function Base.searchsorted(a::Range, I::ClosedInterval)
+    searchsortedfirst(a, I.left):searchsortedlast(a, I.right)
 end
 
 if VERSION > v"0.5.0-dev+4557"

src/sortedvector.jl

@@ -10,7 +10,7 @@ Indexing that would unsort the data is prohibited. A SortedVector is a
 Dimensional axis, and no checking is done to ensure that the data is
 sorted. Duplicate values are allowed.
 
-A SortedVector axis can be indexed with an Interval, with a value, or
+A SortedVector axis can be indexed with an ClosedInterval, with a value, or
 with a vector of values. Use of a SortedVector{Tuple} axis allows
 indexing similar to the hierarchical index of the Python Pandas
 package or the R data.table package.
@@ -30,7 +30,7 @@ SortedVector(x::AbstractVector)
 ```julia
 v = SortedVector(collect([1.; 10.; 10:15.]))
 A = AxisArray(reshape(1:16, 8, 2), v, [:a, :b])
-A[Interval(8.,12.), :]
+A[ClosedInterval(8.,12.), :]
 A[1., :]
 A[10., :]
 
@@ -44,8 +44,8 @@ A[:b, :]
 A[[:a,:c], :]
 A[(:a,:x), :]
 A[(:a,:x,:x), :]
-A[Interval(:a,:b), :]
-A[Interval((:a,:x),(:b,:x)), :]
+A[ClosedInterval(:a,:b), :]
+A[ClosedInterval((:a,:x),(:b,:x)), :]
 ```
 
 """ ->
@@ -102,8 +102,8 @@ _isless(t1, t2::Tuple) = _isless((t1,),t2)
 # only define comparisons against Numbers and Dates. We're able to do this on
 # our own local function... doing this directly on isless itself would be
 # fraught with trouble.
-_isless(a::Interval, b::Interval) = _isless(a.hi, b.lo)
-_isless(t1::Interval, t2::Tuple) = _isless(t1, Interval(t2,t2))
-_isless(t1::Tuple, t2::Interval) = _isless(Interval(t1,t1), t2)
-_isless(a::Interval, b) = _isless(a, Interval(b,b))
-_isless(a, b::Interval) = _isless(Interval(a,a), b)
+_isless(a::ClosedInterval, b::ClosedInterval) = _isless(a.right, b.left)
+_isless(t1::ClosedInterval, t2::Tuple) = _isless(t1, ClosedInterval(t2,t2))
+_isless(t1::Tuple, t2::ClosedInterval) = _isless(ClosedInterval(t1,t1), t2)
+_isless(a::ClosedInterval, b) = _isless(a, ClosedInterval(b,b))
+_isless(a, b::ClosedInterval) = _isless(ClosedInterval(a,a), b)

test/indexing.jl

@@ -8,9 +8,9 @@ D[1,1,1,1,1] = 10
 @test A == A.data
 @test A[:,:,:] == A[Axis{:row}(:)] == A[Axis{:col}(:)] == A[Axis{:page}(:)] == A.data[:,:,:]
 # Test UnitRange slices
-@test A[1:2,:,:] == A.data[1:2,:,:] == A[Axis{:row}(1:2)]  == A[Axis{1}(1:2)] == A[Axis{:row}(Interval(-Inf,Inf))] == A[[true,true],:,:]
-@test A[:,1:2,:] == A.data[:,1:2,:] == A[Axis{:col}(1:2)]  == A[Axis{2}(1:2)] == A[Axis{:col}(Interval(0.0, .25))] == A[:,[true,true,false],:]
-@test A[:,:,1:2] == A.data[:,:,1:2] == A[Axis{:page}(1:2)] == A[Axis{3}(1:2)] == A[Axis{:page}(Interval(-1., .22))] == A[:,:,[true,true,false,false]]
+@test A[1:2,:,:] == A.data[1:2,:,:] == A[Axis{:row}(1:2)]  == A[Axis{1}(1:2)] == A[Axis{:row}(ClosedInterval(-Inf,Inf))] == A[[true,true],:,:]
+@test A[:,1:2,:] == A.data[:,1:2,:] == A[Axis{:col}(1:2)]  == A[Axis{2}(1:2)] == A[Axis{:col}(ClosedInterval(0.0, .25))] == A[:,[true,true,false],:]
+@test A[:,:,1:2] == A.data[:,:,1:2] == A[Axis{:page}(1:2)] == A[Axis{3}(1:2)] == A[Axis{:page}(ClosedInterval(-1., .22))] == A[:,:,[true,true,false,false]]
 # Test scalar slices
 @test A[2,:,:] == A.data[2,:,:] == A[Axis{:row}(2)]
 @test A[:,2,:] == A.data[:,2,:] == A[Axis{:col}(2)]
@@ -40,37 +40,37 @@ D[1,1,1,1,1] = 10
 B = AxisArray(reshape(1:15, 5,3), .1:.1:0.5, [:a, :b, :c])
 
 # Test indexing by Intervals
-@test B[Interval(0.0,  0.5), :] == B[Interval(0.0,  0.5)] == B[:,:]
-@test B[Interval(0.0,  0.3), :] == B[Interval(0.0,  0.3)] == B[1:3,:]
-@test B[Interval(0.15, 0.3), :] == B[Interval(0.15, 0.3)] == B[2:3,:]
-@test B[Interval(0.2,  0.5), :] == B[Interval(0.2,  0.5)] == B[2:end,:]
-@test B[Interval(0.2,  0.6), :] == B[Interval(0.2,  0.6)] == B[2:end,:]
+@test B[ClosedInterval(0.0,  0.5), :] == B[ClosedInterval(0.0,  0.5)] == B[:,:]
+@test B[ClosedInterval(0.0,  0.3), :] == B[ClosedInterval(0.0,  0.3)] == B[1:3,:]
+@test B[ClosedInterval(0.15, 0.3), :] == B[ClosedInterval(0.15, 0.3)] == B[2:3,:]
+@test B[ClosedInterval(0.2,  0.5), :] == B[ClosedInterval(0.2,  0.5)] == B[2:end,:]
+@test B[ClosedInterval(0.2,  0.6), :] == B[ClosedInterval(0.2,  0.6)] == B[2:end,:]
 
 # Test Categorical indexing
 @test B[:, :a] == B[:,1]
 @test B[:, :c] == B[:,3]
 @test B[:, [:a]] == B[:,[1]]
 @test B[:, [:a,:c]] == B[:,[1,3]]
 
-@test B[Axis{:row}(Interval(0.15, 0.3))] == B[2:3,:]
+@test B[Axis{:row}(ClosedInterval(0.15, 0.3))] == B[2:3,:]
 
 A = AxisArray(reshape(1:256, 4,4,4,4), Axis{:d1}(.1:.1:.4), Axis{:d2}(1//10:1//10:4//10), Axis{:d3}(["1","2","3","4"]), Axis{:d4}([:a, :b, :c, :d]))
 ax1 = axes(A)[1]
 @test A[Axis{:d1}(2)] == A[ax1(2)]
-@test A.data[1:2,:,:,:] == A[Axis{:d1}(Interval(.1,.2))]       == A[Interval(.1,.2),:,:,:]       == A[Interval(.1,.2),:,:,:,1]       == A[Interval(.1,.2)]
-@test A.data[:,1:2,:,:] == A[Axis{:d2}(Interval(1//10,2//10))] == A[:,Interval(1//10,2//10),:,:] == A[:,Interval(1//10,2//10),:,:,1] == A[:,Interval(1//10,2//10)]
+@test A.data[1:2,:,:,:] == A[Axis{:d1}(ClosedInterval(.1,.2))]       == A[ClosedInterval(.1,.2),:,:,:]       == A[ClosedInterval(.1,.2),:,:,:,1]       == A[ClosedInterval(.1,.2)]
+@test A.data[:,1:2,:,:] == A[Axis{:d2}(ClosedInterval(1//10,2//10))] == A[:,ClosedInterval(1//10,2//10),:,:] == A[:,ClosedInterval(1//10,2//10),:,:,1] == A[:,ClosedInterval(1//10,2//10)]
 @test A.data[:,:,1:2,:] == A[Axis{:d3}(["1","2"])]             == A[:,:,["1","2"],:]             == A[:,:,["1","2"],:,1]             == A[:,:,["1","2"]]
 @test A.data[:,:,:,1:2] == A[Axis{:d4}([:a,:b])]               == A[:,:,:,[:a,:b]]               == A[:,:,:,[:a,:b],1]
 
 A = AxisArray(reshape(1:32, 2, 2, 2, 2, 2), .1:.1:.2, .1:.1:.2, .1:.1:.2, [:a, :b], [:c, :d])
-@test A[Interval(.15, .25), Interval(.05, .15), Interval(.15, .25), :a] == A.data[2:2, 1:1, 2:2, 1, :]
+@test A[ClosedInterval(.15, .25), ClosedInterval(.05, .15), ClosedInterval(.15, .25), :a] == A.data[2:2, 1:1, 2:2, 1, :]
 @test A[Axis{:dim_5}(2)] == A.data[:, :, :, :, 2]
 
 # Test vectors
 v = AxisArray(collect(.1:.1:10.0), .1:.1:10.0)
 @test v[Colon()] === v
 @test v[:] == v.data[:] == v[Axis{:row}(:)]
-@test v[3:8] == v.data[3:8] == v[Interval(.25,.85)] == v[Axis{:row}(3:8)] == v[Axis{:row}(Interval(.22,.88))]
+@test v[3:8] == v.data[3:8] == v[ClosedInterval(.25,.85)] == v[Axis{:row}(3:8)] == v[Axis{:row}(ClosedInterval(.22,.88))]
 
 # Test repeated intervals
 A = AxisArray([1:100 -1:-1:-100], .1:.1:10.0, [:c1, :c2])

test/intervals.jl

@@ -82,6 +82,6 @@ d[0x1 .. 0x2] = 3
 @test !(0.1 .. 0.2 <= 2//10)
 
 # Conversion and construction:
-@test 1 .. 2 === Interval(1, 2) === Interval{Int}(1.0, 2.0) === Interval{Int}(1.0 .. 2.0)
-@test 1.0 .. 2.0 === Interval(1.0, 2) === Interval{Float64}(1, 2) === Interval{Float64}(1 .. 2)
-@test 1 .. 1 === Interval(1, 1) === Interval(1) === Interval{Int}(1) === Interval{Int}(1.0, 1.0) === Interval{Int}(1.0)
+@test 1 .. 2 === ClosedInterval(1, 2) === ClosedInterval{Int}(1.0, 2.0) === ClosedInterval{Int}(1.0 .. 2.0)
+@test 1.0 .. 2.0 === ClosedInterval(1.0, 2) === ClosedInterval{Float64}(1, 2) === ClosedInterval{Float64}(1 .. 2)
+@test 1 .. 1 === ClosedInterval(1, 1) === ClosedInterval{Int}(1.0, 1.0)