Some generalizations for non-1 indices

Author: timholy

src/core.jl

@@ -61,8 +61,12 @@ Base.getindex(A::Axis, i...) = A.val[i...]
 Base.unsafe_getindex(A::Axis, i...) = Base.unsafe_getindex(A, i...)
 Base.eltype{_,T}(::Type{Axis{_,T}}) = eltype(T)
 Base.size(A::Axis) = size(A.val)
+Base.indices(A::Axis) = indices(A.val)
+Base.indices(A::Axis, d) = indices(A.val, d)
 Base.length(A::Axis) = length(A.val)
 @compat (A::Axis{name}){name}(i) = Axis{name}(i)
+Base.convert{name,T}(::Type{Axis{name,T}}, ax::Axis{name,T}) = ax
+Base.convert{name,T}(::Type{Axis{name,T}}, ax::Axis{name}) = Axis{name}(convert(T, ax.val))
 
 @doc """
 An AxisArray is an AbstractArray that wraps another AbstractArray and
@@ -95,11 +99,12 @@ AxisArray(A::AbstractArray, vectors::AbstractVector...)
 * `A::AbstractArray` : the wrapped array data
 * `axes` or `names` or `vectors` : dimensional information for the wrapped array
 
-The dimensional information may be passed in one of three ways and is entirely
-optional. When the axis name or value is missing for a dimension, a default is
-substituted. The default axis names for dimensions `(1, 2, 3, 4, 5, ...)` are
-`(:row, :col, :page, :dim_4, :dim_5, ...)`. The default axis values are the
-integer unit ranges: `1:size(A, d)` for each missing dimension `d`.
+The dimensional information may be passed in one of three ways and is
+entirely optional. When the axis name or value is missing for a
+dimension, a default is substituted. The default axis names for
+dimensions `(1, 2, 3, 4, 5, ...)` are `(:row, :col, :page, :dim_4,
+:dim_5, ...)`. The default axis values are `indices(A, d)` for each
+missing dimension `d`.
 
 ### Indexing
 
@@ -166,12 +171,12 @@ AxisArray(A::AbstractArray, axs::Axis...) = AxisArray(A, axs)
         push!(ax.args, :(axs[$i]))
     end
     for i=L+1:N
-        push!(ax.args, :(Axis{_defaultdimname($i)}(1:size(A, $i))))
+        push!(ax.args, :(Axis{_defaultdimname($i)}(indices(A, $i))))
     end
     quote
         for i = 1:length(axs)
             checkaxis(axs[i].val)
-            if length(axs[i].val) != size(A, i)
+            if _length(axs[i].val) != _size(A, i)
                 throw(ArgumentError("the length of each axis must match the corresponding size of data"))
             end
         end
@@ -183,7 +188,7 @@ AxisArray(A::AbstractArray, axs::Axis...) = AxisArray(A, axs)
 end
 # Simple non-type-stable constructors to specify just the name or axis values
 AxisArray(A::AbstractArray) = AxisArray(A, ()) # Disambiguation
-AxisArray(A::AbstractArray, names::Symbol...)         = AxisArray(A, ntuple(i->Axis{names[i]}(1:size(A, i)), length(names)))
+AxisArray(A::AbstractArray, names::Symbol...)         = AxisArray(A, map((name,ind)->Axis{name}(ind), names, indices(A)))
 AxisArray(A::AbstractArray, vects::AbstractVector...) = AxisArray(A, ntuple(i->Axis{_defaultdimname(i)}(vects[i]), length(vects)))
 
 # Axis definitions
@@ -214,6 +219,9 @@ end
 Base.size(A::AxisArray) = size(A.data)
 Base.size(A::AxisArray, Ax::Axis) = size(A.data, axisdim(A, Ax))
 Base.size{Ax<:Axis}(A::AxisArray, ::Type{Ax}) = size(A.data, axisdim(A, Ax))
+Base.indices(A::AxisArray) = indices(A.data)
+Base.indices(A::AxisArray, Ax::Axis) = indices(A.data, axisdim(A, Ax))
+Base.indices{Ax<:Axis}(A::AxisArray, ::Type{Ax}) = indices(A.data, axisdim(A, Ax))
 Base.linearindexing(A::AxisArray) = Base.linearindexing(A.data)
 Base.convert{T,N}(::Type{Array{T,N}}, A::AxisArray{T,N}) = convert(Array{T,N}, A.data)
 # Similar is tricky. If we're just changing the element type, it can stay as an
@@ -233,25 +241,25 @@ Base.similar{T}(A::AxisArray{T}, S::Type, dims::Tuple{Vararg{Int}}) = similar(A.
 Base.similar{T}(A::AxisArray{T}, axs::Axis...) = similar(A, T, axs)
 Base.similar{T}(A::AxisArray{T}, S::Type, axs::Axis...) = similar(A, S, axs)
 @generated function Base.similar{T,N}(A::AxisArray{T,N}, S::Type, axs::Tuple{Vararg{Axis}})
-    sz = Expr(:tuple)
+    inds = Expr(:tuple)
     ax = Expr(:tuple)
     for d=1:N
-        push!(sz.args, :(size(A, Axis{$d})))
+        push!(inds.args, :(indices(A, Axis{$d})))
         push!(ax.args, :(axes(A, Axis{$d})))
     end
     to_delete = Int[]
     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))
+        inds.args[d] = :(indices(axs[$i].val, 1))
         ax.args[d] = :(axs[$i])
     end
     sort!(to_delete)
-    deleteat!(sz.args, to_delete)
+    deleteat!(inds.args, to_delete)
     deleteat!(ax.args, to_delete)
     quote
-        d = similar(A.data, S, $sz)
+        d = similar(A.data, S, $inds)
         AxisArray(d, $ax)
     end
 end
@@ -356,3 +364,10 @@ function checkaxis(::Type{Categorical}, ax)
         push!(seen, elt)
     end
 end
+
+_length(A::AbstractArray) = length(linearindices(A))
+_length(A) = length(A)
+_size(A::AbstractArray) = map(length, indices(A))
+_size(A) = size(A)
+_size(A::AbstractArray, d) = length(indices(A, d))
+_size(A, d) = size(A, d)

src/indexing.jl

@@ -78,7 +78,7 @@ end
             push!(newaxes, :($(Axis{names[d]})(A.axes[$d].val[J[$d]])))
         elseif I[d] <: AbstractArray
             for i=1:ndims(I[d])
-                push!(newaxes, :($(Axis{Symbol(names[d], "_", i)})(1:size(I[$d], $i))))
+                push!(newaxes, :($(Axis{Symbol(names[d], "_", i)})(indices(I[$d], $i))))
             end
         end
     end

src/sortedvector.jl

@@ -63,6 +63,7 @@ Base.getindex(v::SortedVector, idx::AbstractVector) =
 Base.length(v::SortedVector) = length(v.data)
 Base.size(v::SortedVector) = size(v.data)
 Base.size(v::SortedVector, i) = size(v.data, i)
+Base.indices(v::SortedVector) = indices(v.data)
 
 axistrait(::SortedVector) = Dimensional
 checkaxis(::SortedVector) = nothing

test/REQUIRE

@@ -0,0 +1 @@
+OffsetArrays

test/core.jl

@@ -115,7 +115,14 @@ A = AxisArray(reshape(1:24, 2,3,4),
 @test hash(Axis{:row}()) != hash(Axis{:col}())
 @test hash(Axis{:x}(1:3)) == hash(Axis{:x}(Base.OneTo(3)))
 @test AxisArrays.axistype(Axis{1}(1:2)) == typeof(1:2)
+@test AxisArrays.axistype(Axis{1,UInt32}) == UInt32
 @test axisnames(Axis{1}, Axis{2}, Axis{3}) == (1,2,3)
+@test Axis{:row}(2:7)[4] == 5
+@test eltype(Axis{:row}(1.0:1.0:3.0)) == Float64
+@test size(Axis{:row}(2:7)) === (6,)
+@test indices(Axis{:row}(2:7)) === (Base.OneTo(6),)
+@test indices(Axis{:row}(-1:1), 1) === Base.OneTo(3)
+@test length(Axis{:col}(-1:2)) === 4
 
 # Test Timetype axis construction
 dt, vals = DateTime(2010, 1, 2, 3, 40), randn(5,2)
@@ -125,3 +132,16 @@ A = AxisArray(vals, Axis{:Timestamp}(dt-Dates.Hour(2):Dates.Hour(1):dt+Dates.Hou
 
 # Simply run the display method to ensure no stupid errors
 @compat show(IOBuffer(),MIME("text/plain"),A)
+
+# With unconventional indices
+import OffsetArrays  # import rather than using because OffsetArrays has a deprecation for ..
+A = AxisArray(OffsetArrays.OffsetArray([5,3,4], -1:1), :x)
+@test axes(A) == (Axis{:x}(-1:1),)
+@test A[-1] == 5
+A[0] = 12
+@test A.data[0] == 12
+@test indices(A) == (-1:1,)
+@test linearindices(A) == -1:1
+A = AxisArray(OffsetArrays.OffsetArray(rand(4,5), -1:2, 5:9), :x, :y)
+@test indices(A) == (-1:2, 5:9)
+@test linearindices(A) == 1:20