Merge pull request #80 from JuliaArrays/mb/constructor2

AxisArray constructor improvements

Author: mbauman

src/core.jl

@@ -160,34 +160,40 @@ immutable AxisArray{T,N,D,Ax} <: AbstractArray{T,N}
     axes::Ax # Ax<:NTuple{N, Axis}, but with specialized Axis{...} types
     (::Type{AxisArray{T,N,D,Ax}}){T,N,D,Ax}(data::AbstractArray{T,N}, axs::Tuple{Vararg{Axis,N}}) = new{T,N,D,Ax}(data, axs)
 end
-#
-_defaultdimname(i) = i == 1 ? (:row) : i == 2 ? (:col) : i == 3 ? (:page) : Symbol(:dim_, i)
 
-default_axes(A::AbstractArray) = _default_axes(A, indices(A), ())
-_default_axes{T,N}(A::AbstractArray{T,N}, inds, axs::NTuple{N,Axis}) = axs
-@inline _default_axes{T,N,M}(A::AbstractArray{T,N}, inds, axs::NTuple{M,Axis}) =
-    _default_axes(A, inds, (axs..., _nextaxistype(axs)(inds[M+1])))
+# Helper functions: Default axis names (if not provided)
+_defaultdimname(i) = i == 1 ? (:row) : i == 2 ? (:col) : i == 3 ? (:page) : Symbol(:dim_, i)
 # Why doesn't @pure work here?
 @generated function _nextaxistype{M}(axs::NTuple{M,Axis})
     name = _defaultdimname(M+1)
     :(Axis{$(Expr(:quote, name))})
 end
 
-AxisArray(A::AbstractArray, axs::Axis...) = AxisArray(A, axs)
-function AxisArray{T,N}(A::AbstractArray{T,N}, axs::NTuple{N,Axis})
-    checksizes(axs, _size(A)) || throw(ArgumentError("the length of each axis must match the corresponding size of data"))
-    checknames(axisnames(axs...)...)
-    AxisArray{T,N,typeof(A),typeof(axs)}(A, axs)
-end
-function AxisArray{L}(A::AbstractArray, axs::NTuple{L,Axis})
-    newaxs = _default_axes(A, indices(A), axs)
-    AxisArray(A, newaxs)
-end
+"""
+    default_axes(A::AbstractArray)
+    default_axes(A::AbstractArray, axs)
 
+Return a tuple of Axis objects that appropriately index into the array A.
+
+The optional second argument can take a tuple of vectors or axes, which will be
+wrapped with the appropriate axis name, and it will ensure no axis goes beyond
+the dimensionality of the array A.
+"""
+@inline default_axes(A::AbstractArray, args=indices(A)) = _default_axes(A, args, ())
+_default_axes{T,N}(A::AbstractArray{T,N}, args::Tuple{}, axs::NTuple{N,Axis}) = axs
+_default_axes{T,N}(A::AbstractArray{T,N}, args::Tuple{Any, Vararg{Any}}, axs::NTuple{N,Axis}) = throw(ArgumentError("too many axes provided"))
+_default_axes{T,N}(A::AbstractArray{T,N}, args::Tuple{Axis, Vararg{Any}}, axs::NTuple{N,Axis}) = throw(ArgumentError("too many axes provided"))
+@inline _default_axes{T,N}(A::AbstractArray{T,N}, args::Tuple{}, axs::Tuple) =
+    _default_axes(A, args, (axs..., _nextaxistype(axs)(indices(A, length(axs)+1))))
+@inline _default_axes{T,N}(A::AbstractArray{T,N}, args::Tuple{Any, Vararg{Any}}, axs::Tuple) =
+    _default_axes(A, Base.tail(args), (axs..., _nextaxistype(axs)(args[1])))
+@inline _default_axes{T,N}(A::AbstractArray{T,N}, args::Tuple{Axis, Vararg{Any}}, axs::Tuple) =
+    _default_axes(A, Base.tail(args), (axs..., args[1]))
+
+# Axis consistency checks — ensure sizes match and the names are unique
 @inline checksizes(axs, sz) =
     (length(axs[1]) == sz[1]) & checksizes(tail(axs), tail(sz))
 checksizes(::Tuple{}, sz) = true
-
 @inline function checknames(name::Symbol, names...)
     matches = false
     for n in names
@@ -199,10 +205,18 @@ end
 checknames(name, names...) = throw(ArgumentError("the Axis names must be Symbols"))
 checknames() = ()
 
-# Simple non-type-stable constructors to specify just the name or axis values
+# The primary AxisArray constructors — specify an array to wrap and the axes
+AxisArray(A::AbstractArray, vects::Union{AbstractVector, Axis}...) = AxisArray(A, vects)
+AxisArray(A::AbstractArray, vects::Tuple{Vararg{Union{AbstractVector, Axis}}}) = AxisArray(A, default_axes(A, vects))
+function AxisArray{T,N}(A::AbstractArray{T,N}, axs::NTuple{N,Axis})
+    checksizes(axs, _size(A)) || throw(ArgumentError("the length of each axis must match the corresponding size of data"))
+    checknames(axisnames(axs...)...)
+    AxisArray{T,N,typeof(A),typeof(axs)}(A, axs)
+end
+
+# Simple non-type-stable constructors to specify names as symbols
 AxisArray(A::AbstractArray) = AxisArray(A, ()) # Disambiguation
 AxisArray(A::AbstractArray, names::Symbol...)         = (inds = indices(A); AxisArray(A, ntuple(i->Axis{names[i]}(inds[i]), length(names))))
-AxisArray(A::AbstractArray, vects::AbstractVector...) = AxisArray(A, ntuple(i->Axis{_defaultdimname(i)}(vects[i]), length(vects)))
 function AxisArray{T,N}(A::AbstractArray{T,N}, names::NTuple{N,Symbol}, steps::NTuple{N,Number}, offsets::NTuple{N,Number}=map(zero, steps))
     axs = ntuple(i->Axis{names[i]}(range(offsets[i], steps[i], size(A,i))), N)
     AxisArray(A, axs...)

test/core.jl

@@ -1,6 +1,7 @@
-A = AxisArray(reshape(1:24, 2,3,4), .1:.1:.2, .1:.1:.3, .1:.1:.4)
+A = @inferred(AxisArray(reshape(1:24, 2,3,4), .1:.1:.2, .1:.1:.3, .1:.1:.4))
 @test_throws ArgumentError AxisArray(reshape(1:24, 2,3,4), .1:.1:.1, .1:.1:.3, .1:.1:.4)
 @test_throws ArgumentError AxisArray(reshape(1:24, 2,3,4), .1:.1:.1, .1:.1:.3)
+@test_throws ArgumentError AxisArray(reshape(1:24, 2,3,4), .1:.1:.2, .1:.1:.3, .1:.1:.4, 1:1)
 @test parent(A) === reshape(1:24, 2,3,4)
 # Test iteration
 for (a,b) in zip(A, A.data)
@@ -40,7 +41,7 @@ for perm in ((:col, :row, :page), (:col, :page, :row),
 end
 @test axisnames(permutedims(A, (:col,)))  == (:col, :row, :page)
 @test axisnames(permutedims(A, (:page,))) == (:page, :row, :col)
-A2 = AxisArray(reshape(1:15, 3, 5))
+A2 = @inferred(AxisArray(reshape(1:15, 3, 5)))
 A1 = AxisArray(1:5, :t)
 for f in (transpose, ctranspose)
     @test f(A2).data == f(A2.data)
@@ -100,12 +101,12 @@ A = AxisArray([1 3; 2 4], :a)
 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)
+A = @inferred(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)
+A = @inferred(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))
@@ -129,17 +130,22 @@ B = AxisArray([1 4; 2 5; 3 6], (:x, :y), (0.2, 100), (-3,14))
 @test AxisArrays.HasAxes(A)   == AxisArrays.HasAxes{true}()
 @test AxisArrays.HasAxes([1]) == AxisArrays.HasAxes{false}()
 
-# Test axisdim
 @test_throws ArgumentError AxisArray(reshape(1:24, 2,3,4),
                                      Axis{1}(.1:.1:.2),
                                      Axis{2}(1//10:1//10:3//10),
                                      Axis{3}(["a", "b", "c", "d"])) # Axis need to be symbols
+@test_throws ArgumentError AxisArray(reshape(1:24, 2,3,4),
+                                     Axis{:x}(.1:.1:.2),
+                                     Axis{:y}(1//10:1//10:3//10),
+                                     Axis{:z}(["a", "b", "c", "d"]),
+                                     Axis{:_}(1:1)) # Too many Axes
 
-A = AxisArray(reshape(1:24, 2,3,4),
+A = @inferred(AxisArray(reshape(1:24, 2,3,4),
               Axis{:x}(.1:.1:.2),
               Axis{:y}(1//10:1//10:3//10),
-              Axis{:z}(["a", "b", "c", "d"]))
+              Axis{:z}(["a", "b", "c", "d"])))
 
+# Test axisdim
 @test axisdim(A, Axis{:x}) == axisdim(A, Axis{:x}()) == 1
 @test axisdim(A, Axis{:y}) == axisdim(A, Axis{:y}()) == 2
 @test axisdim(A, Axis{:z}) == axisdim(A, Axis{:z}()) == 3
@@ -176,7 +182,7 @@ T = A[AxisArrays.Axis{:x}]
 
 # Test Timetype axis construction
 dt, vals = DateTime(2010, 1, 2, 3, 40), randn(5,2)
-A = AxisArray(vals, Axis{:Timestamp}(dt-Dates.Hour(2):Dates.Hour(1):dt+Dates.Hour(2)), Axis{:Cols}([:A, :B]))
+A = @inferred(AxisArray(vals, Axis{:Timestamp}(dt-Dates.Hour(2):Dates.Hour(1):dt+Dates.Hour(2)), Axis{:Cols}([:A, :B])))
 @test A[:, :A].data == vals[:, 1]
 @test A[dt, :].data == vals[3, :]
 
@@ -229,7 +235,7 @@ map!(*, A2, A, A)
 
 # Reductions (issue #55)
 A = AxisArray(collect(reshape(1:15,3,5)), :y, :x)
-B = AxisArray(collect(reshape(1:15,3,5)), Axis{:y}(0.1:0.1:0.3), Axis{:x}(10:10:50))
+B = @inferred(AxisArray(collect(reshape(1:15,3,5)), Axis{:y}(0.1:0.1:0.3), Axis{:x}(10:10:50)))
 for C in (A, B)
     for op in (sum, minimum)  # together, cover both reduced_indices and reduced_indices0
         axv = axisvalues(C)