Merge pull request #32 from mbauman/teh/no_requires

Slim down dependencies

Author: timholy

REQUIRE

@@ -1,4 +1,3 @@
 julia 0.4
-Requires
 Iterators
 Compat

src/AxisArrays.jl

@@ -1,6 +1,6 @@
 module AxisArrays
 
-using Requires, Tuples, RangeArrays, Iterators, Compat
+using RangeArrays, Iterators, Compat
 using Compat.view
 
 export AxisArray, Axis, Interval, axisnames, axisvalues, axisdim, axes, .., atindex
@@ -11,6 +11,5 @@ include("search.jl")
 include("indexing.jl")
 include("sortedvector.jl")
 include("combine.jl")
-include("utils.jl")
 
 end

src/core.jl

@@ -1,5 +1,13 @@
 # Core types and definitions
 
+if VERSION < v"0.5.0-dev"
+    macro pure(ex)
+        esc(ex)
+    end
+else
+    using Base: @pure
+end
+
 @doc """
 Type-stable axis-specific indexing and identification with a
 parametric type.
@@ -148,8 +156,9 @@ _defaultdimname(i) = i == 1 ? (:row) : i == 2 ? (:col) : i == 3 ? (:page) : Symb
 AxisArray(A::AbstractArray, axs::Axis...) = AxisArray(A, axs)
 @generated function AxisArray{T,N,L}(A::AbstractArray{T,N}, axs::NTuple{L,Axis})
     ax = Expr(:tuple)
-    Ax = Tuples.concatenate(axs, NTuple(i->Axis{_defaultdimname(i+L),UnitRange{Int64}},N-L))
-    if !isa(axisnames(Tuples.collect(axs)...), Tuple{Vararg{Symbol}})
+    Ax = Tuple{axs.parameters...,
+               ntuple(i->Axis{_defaultdimname(i+L),UnitRange{Int64}},N-L)...}
+    if !all(x->isa(axisname(x),Symbol), axs.parameters)
         return :(throw(ArgumentError("the Axis names must be Symbols")))
     end
     for i=1:L
@@ -194,7 +203,7 @@ end
 axisdim{T,N,D,Ax,name,S}(A::Type{AxisArray{T,N,D,Ax}}, ::Type{Axis{name,S}}) = axisdim(A, Axis{name})
 function axisdim{T,N,D,Ax,name}(::Type{AxisArray{T,N,D,Ax}}, ::Type{Axis{name}})
     isa(name, Int) && return name <= N ? name : error("axis $name greater than array dimensionality $N")
-    names = axisnames(Tuples.collect(Ax)...)
+    names = axisnames(Ax)
     idx = findfirst(names, name)
     idx == 0 && error("axis $name not found in array axes $names")
     idx
@@ -230,8 +239,8 @@ Base.similar{T}(A::AxisArray{T}, S::Type, axs::Axis...) = similar(A, S, axs)
         push!(ax.args, :(axes(A, Axis{$d})))
     end
     to_delete = Int[]
-    for i=1:Tuples.length(axs)
-        a = Tuples.getindex(axs, i)
+    for i=1:length(axs.parameters)
+        a = axs.parameters[i]
         d = axisdim(A, a)
         axistype(a) <: Tuple{} && push!(to_delete, d)
         sz.args[d] = :(length(axs[$i].val))
@@ -248,15 +257,28 @@ end
 # A simple display method to include axis information. It might be nice to
 # eventually display the axis labels alongside the data array, but that is
 # much more difficult.
-@compat function Base.show{T,N}(io::IO, m::MIME"text/plain", A::AxisArray{T,N})
-    println(io, "$N-dimensional AxisArray{$T,$N,...} with axes:")
-    for (name, val) in zip(axisnames(A), axisvalues(A))
-        print(io, "    :$name, ")
-        show(IOContext(io, :limit=>true), val)
-        println(io)
+if VERSION < v"0.5.0-dev"
+    function Base.writemime{T,N}(io::IO, m::MIME"text/plain", A::AxisArray{T,N})
+        println(io, "$N-dimensional AxisArray{$T,$N,...} with axes:")
+        for (name, val) in zip(axisnames(A), axisvalues(A))
+            print(io, "    :$name, ")
+            Base.showlimited(io, val)
+            println(io)
+        end
+        print(io, "And data, a ")
+        writemime(io, m, A.data)
+    end
+else
+    function Base.show{T,N}(io::IO, m::MIME"text/plain", A::AxisArray{T,N})
+        println(io, "$N-dimensional AxisArray{$T,$N,...} with axes:")
+        for (name, val) in zip(axisnames(A), axisvalues(A))
+            print(io, "    :$name, ")
+            show(IOContext(io, :limit=>true), val)
+            println(io)
+        end
+        print(io, "And data, a ")
+        show(io, m, A.data)
     end
-    print(io, "And data, a ")
-    show(io, m, A.data)
 end
 
 # Custom methods specific to AxisArrays
@@ -268,13 +290,19 @@ end
 
 Returns the axis names of an AxisArray or list of Axises as a tuple of Symbols.
 """ ->
-axisnames{T,N,D,Ax}(::AxisArray{T,N,D,Ax})       = axisnames(Tuples.collect(Ax)...)
-axisnames{T,N,D,Ax}(::Type{AxisArray{T,N,D,Ax}}) = axisnames(Tuples.collect(Ax)...)
+axisnames{T,N,D,Ax}(::AxisArray{T,N,D,Ax})       = _axisnames(Ax)
+axisnames{T,N,D,Ax}(::Type{AxisArray{T,N,D,Ax}}) = _axisnames(Ax)
+axisnames{Ax<:Tuple{Vararg{Axis}}}(::Type{Ax})   = _axisnames(Ax)
+@pure _axisnames(Ax) = axisnames(Ax.parameters...)
 axisnames() = ()
 axisnames{name  }(::Axis{name},         B::Axis...) = tuple(name, axisnames(B...)...)
 axisnames{name  }(::Type{Axis{name}},   B::Type...) = tuple(name, axisnames(B...)...)
 axisnames{name,T}(::Type{Axis{name,T}}, B::Type...) = tuple(name, axisnames(B...)...)
 
+axisname{name,T}(::Type{Axis{name,T}}) = name
+axisname{name  }(::Type{Axis{name  }}) = name
+axisname(ax::Axis) = axisname(typeof(ax))
+
 @doc """
     axisvalues(A::AxisArray)           -> (AbstractVector...)
     axisvalues(ax::Axis...)            -> (AbstractVector...)

src/indexing.jl

@@ -198,7 +198,7 @@ end
             push!(ex.args, :(I[$i]))
         elseif I[i] <: AbstractArray{Bool}
             push!(ex.args, :(find(I[$i])))
-        elseif i <= Tuples.length(Ax)
+        elseif i <= length(Ax.parameters)
             push!(ex.args, :(axisindexes(A.axes[$i], I[$i])))
         else
             push!(ex.args, :(error("dimension ", $i, " does not have an axis to index")))

src/search.jl

@@ -36,6 +36,16 @@ function Base.searchsorted(a::Range, I::Interval)
     searchsortedfirst(a, I.lo):searchsortedlast(a, I.hi)
 end
 
+if VERSION > v"0.5.0-dev+4557"
+    # When running with "--check-bounds=yes" (like on Travis), the bounds-check isn't elided
+    @inline function Base.unsafe_getindex{T}(r::FloatRange{T}, i::Integer)
+        convert(T, (r.start + (i-1)*r.step)/r.divisor)
+    end
+    @inline function Base.unsafe_getindex(r::FloatRange, s::OrdinalRange)
+        FloatRange(r.start + (first(s)-1)*r.step, step(s)*r.step, length(s), r.divisor)
+    end
+end
+
 function unsafe_searchsortedlast{T<:Number}(a::Range{T}, x::Number)
     step(a) == 0 && throw(ArgumentError("ranges with a zero step are unsupported"))
     n = round(Integer,(x-first(a))/step(a))+1

src/utils.jl

@@ -58,28 +58,34 @@ H = similar(A, Float64, 1,1,1)
 A = AxisArray(1:3)
 @test A.data == 1:3
 @test axisnames(A) == (:row,)
+VERSION >= v"0.5.0-dev" && @inferred(axisnames(A))
 @test axisvalues(A) == (1:3,)
 A = AxisArray(reshape(1:16, 2,2,2,2))
 @test A.data == reshape(1:16, 2,2,2,2)
 @test axisnames(A) == (:row,:col,:page,:dim_4)
+VERSION >= v"0.5.0-dev" && @inferred(axisnames(A))
 @test axisvalues(A) == (1:2, 1:2, 1:2, 1:2)
 # Just axis names
 A = AxisArray(1:3, :a)
 @test A.data == 1:3
 @test axisnames(A) == (:a,)
+VERSION >= v"0.5.0-dev" && @inferred(axisnames(A))
 @test axisvalues(A) == (1:3,)
 A = AxisArray([1 3; 2 4], :a)
 @test A.data == [1 3; 2 4]
 @test axisnames(A) == (:a, :col)
+VERSION >= v"0.5.0-dev" && @inferred(axisnames(A))
 @test axisvalues(A) == (1:2, 1:2)
 # Just axis values
 A = AxisArray(1:3, .1:.1:.3)
 @test A.data == 1:3
 @test axisnames(A) == (:row,)
+VERSION >= v"0.5.0-dev" && @inferred(axisnames(A))
 @test axisvalues(A) == (.1:.1:.3,)
 A = AxisArray(reshape(1:16, 2,2,2,2), .5:.5:1)
 @test A.data == reshape(1:16, 2,2,2,2)
 @test axisnames(A) == (:row,:col,:page,:dim_4)
+VERSION >= v"0.5.0-dev" && @inferred(axisnames(A))
 @test axisvalues(A) == (.5:.5:1, 1:2, 1:2, 1:2)
 
 # Test axisdim

test/core.jl

@@ -7,3 +7,5 @@ include("indexing.jl")
 include("sortedvector.jl")
 include("search.jl")
 include("combine.jl")
+
+nothing