Implement reshape() using Size{}

 * Use the `Size` trait for performing statically sized reshapes.
 * Deprecate old methods
 * Improve SizedArray to allow a cost-free reshaped view.

Author: Andy Ferris

src/SizedArray.jl

@@ -4,36 +4,44 @@
 
 Wraps an `Array` with a static size, so to take advantage of the (faster)
 methods defined by the static array package. The size is checked once upon
-construction.
+construction to determine if the number of elements (`length`) match, but the
+array may be reshaped.
 
 (Also, `Size(dims...)(array)` acheives the same thing)
 """
-immutable SizedArray{S,T,N} <: StaticArray{T,N}
-    data::Array{T,N}
+immutable SizedArray{S,T,N,M} <: StaticArray{T,N}
+    data::Array{T,M}
 
     function SizedArray(a)
-        if size(a) != S
+        if length(a) != prod(S)
             error("Dimensions $(size(a)) don't match static size $S")
         end
         new(a)
     end
 end
 
-@inline (::Type{SizedArray{S,T}}){S,T,N}(a::Array{T,N}) = SizedArray{S,T,N}(a)
-@inline (::Type{SizedArray{S}}){S,T,N}(a::Array{T,N}) = SizedArray{S,T,N}(a)
+@inline (::Type{SizedArray{S,T,N}}){S,T,N,M}(a::Array{T,M}) = SizedArray{S,T,N,M}(a)
+@inline (::Type{SizedArray{S,T}}){S,T,M}(a::Array{T,M}) = SizedArray{S,T,_ndims(S),M}(a)
+@inline (::Type{SizedArray{S}}){S,T,M}(a::Array{T,M}) = SizedArray{S,T,_ndims(S),M}(a)
+
+# Overide some problematic default behaviour
+@inline convert{SA<:SizedArray}(::Type{SA}, sa::SizedArray) = SA(sa.data)
+
+@pure _ndims{N}(::NTuple{N,Int}) = N
 
 @pure size{S}(::Type{SizedArray{S}}) = S
 @pure size{S,T}(::Type{SizedArray{S,T}}) = S
 @pure size{S,T,N}(::Type{SizedArray{S,T,N}}) = S
+@pure size{S,T,N,M}(::Type{SizedArray{S,T,N,M}}) = S
 
-@propagate_inbounds getindex(a::SizedArray, i::Int) = getindex(a.data, i...)
-@propagate_inbounds setindex!(a::SizedArray, v, i::Int) = setindex!(a.data, v, i...)
+@propagate_inbounds getindex(a::SizedArray, i::Int) = getindex(a.data, i)
+@propagate_inbounds setindex!(a::SizedArray, v, i::Int) = setindex!(a.data, v, i)
 
-typealias SizedVector{S,T} SizedArray{S,T,1}
-@inline (::Type{SizedVector{S}}){S,T}(a::Vector{T}) = SizedArray{S,T,1}(a)
+typealias SizedVector{S,T,M} SizedArray{S,T,1,M}
+@inline (::Type{SizedVector{S}}){S,T,M}(a::Array{T,M}) = SizedArray{S,T,1,M}(a)
 
-typealias SizedMatrix{S,T} SizedArray{S,T,2}
-@inline (::Type{SizedMatrix{S}}){S,T}(a::Matrix{T}) = SizedArray{S,T,2}(a)
+typealias SizedMatrix{S,T,M} SizedArray{S,T,2,M}
+@inline (::Type{SizedMatrix{S}}){S,T,M}(a::Array{T,M}) = SizedArray{S,T,2,M}(a)
 
 
 """

src/abstractarray.jl

@@ -175,15 +175,17 @@ end
     end
 end
 
-# Reshape uses types to specify size (and also conveniently, the output type)
+# Reshape used types to specify size (and also conveniently, the output type)
 @generated function reshape{SA<:StaticArray}(a::StaticArray, ::Type{SA})
     if !(SA <: StaticVector) && length(a) != length(SA)
         error("Static array of size $(size(a)) cannot be reshaped to size $(size(SA))")
     end
 
+    Base.depwarn("Use reshape(array, Size(dims...)) rather than reshape(array, StaticArrayType)", :reshape)
+
     return quote
         $(Expr(:meta, :inline))
-        return SA(tuple(a))
+        return SA(Tuple(a))
     end
 end
 
@@ -192,5 +194,31 @@ function reshape{SA<:StaticArray}(a::AbstractArray, ::Type{SA})
         error("Static array of size $(size(a)) cannot be reshaped to size $(size(SA))")
     end
 
+    Base.depwarn("Use reshape(array, Size(dims...)) rather than reshape(array, StaticArrayType)", :reshape)
+
     return SA((a...))
 end
+
+
+# Versions using Size{}
+@generated function reshape{S}(a::StaticArray, ::Size{S})
+    if length(a) != prod(S)
+        error("Static array of size $(size(a)) cannot be reshaped to size $S")
+    end
+
+    newtype = similar_type(a, S)
+
+    return quote
+        $(Expr(:meta, :inline))
+        return $newtype(a)
+    end
+end
+
+@generated function reshape{S}(a::Array, ::Size{S})
+    newtype = SizedArray{S, eltype(a), length(S)}
+
+    return quote
+        $(Expr(:meta, :inline))
+        return $newtype(a)
+    end
+end

test/abstractarray.jl

@@ -63,135 +63,9 @@
         @test isa(similar(sv, (3,3,3)), MArray{(3,3,3),Int,3,27})
         @test isa(similar(sv, Float64, (3,3,3)), MArray{(3,3,3),Float64,3,27})
     end
-#=
-    @testset "size and length" begin
-        vec = [1,2,3,4]
-        sv = SVector{(4,)}(vec)
-        mv = MVector{(4,)}(vec)
-
-        mat = eye(3)
-        sm = MMatrix{(3,3)}(mat)
-        mm = MMatrix{(3,3)}(mat)
-
-        @test size(sv) == size(vec)
-        @test size(mv) == size(vec)
-        @test size(sm) == size(mat)
-        @test size(mm) == size(mat)
-
-        @test size(sv,1) == size(vec,1)
-        @test size(mv,1) == size(vec,1)
-        @test size(sm,1) == size(mat,1)
-        @test size(mm,1) == size(mat,1)
-        @test size(sv,2) == size(vec,2) # Test for
-        @test size(mv,2) == size(vec,2) # trailing 1's
-        @test size(sm,2) == size(mat,2)
-        @test size(mm,2) == size(mat,2)
-
-        @test length(sv) == length(vec)
-        @test length(mv) == length(vec)
-        @test length(sm) == length(mat)
-        @test length(mm) == length(mat)
-
-        @test size(typeof(sv)) == size(vec)
-        @test size(typeof(mv)) == size(vec)
-        @test size(typeof(sm)) == size(mat)
-        @test size(typeof(mm)) == size(mat)
-
-        @test size(typeof(sv),1) == size(vec,1)
-        @test size(typeof(mv),1) == size(vec,1)
-        @test size(typeof(sm),1) == size(mat,1)
-        @test size(typeof(mm),1) == size(mat,1)
-        @test size(typeof(sv),2) == size(vec,2) # Test for
-        @test size(typeof(mv),2) == size(vec,2) # trailing 1's
-        @test size(typeof(sm),2) == size(mat,2)
-        @test size(typeof(mm),2) == size(mat,2)
-
-        @test length(typeof(sv)) == length(vec)
-        @test length(typeof(mv)) == length(vec)
-        @test length(typeof(sm)) == length(mat)
-        @test length(typeof(mm)) == length(mat)
-    end
-
-    @testset "Miscellanious introspection" begin
-        vec = [1,2,3,4]
-        sv = SVector{(4,)}(vec)
-        mv = MVector{(4,)}(vec)
-
-        @test Base.isassigned(sv, 4)    == Base.isassigned(vec, 4)
-        @test Base.isassigned(sv, 5)    == Base.isassigned(vec, 5)
-        @test Base.isassigned(sv, 2, 1) == Base.isassigned(vec, 2, 1) # test for trailing ones
-        @test Base.isassigned(mv, 4)    == Base.isassigned(vec, 4)
-        @test Base.isassigned(mv, 5)    == Base.isassigned(vec, 5)
-        @test Base.isassigned(mv, 2, 1) == Base.isassigned(vec, 2, 1)
 
-        @test Base.linearindexing(sv) == Base.LinearFast()
-        @test Base.linearindexing(mv) == Base.LinearFast()
-        @test Base.linearindexing(typeof(sv)) == Base.LinearFast()
-        @test Base.linearindexing(typeof(mv)) == Base.LinearFast()
+    @testset "reshape" begin
+        @test reshape(SVector(1,2,3,4), Size(2,2)) === SMatrix{2,2}(1,2,3,4)
+        @test reshape([1,2,3,4], Size(2,2))::SizedArray{(2,2),Int,2,1} == [1 3; 2 4]
     end
-
-    @testset "similar and similar_type" begin
-        vec = [1,2,3,4]
-        sv = SVector{(4,)}(vec)
-        mv = MVector{(4,)}(vec)
-
-        @test_throws Exception similar(sv)
-        @test typeof(similar(mv)) == typeof(mv)
-        @test_inferred similar(mv)
-        @test_throws Exception similar(sv, Float64)
-        @test typeof(similar(mv, Float64)) <: MVector{(4,),Float64}
-        @test_inferred similar(mv, Float64)
-        @test_throws Exception similar(sv, (2,2))
-        @test_throws Exception similar(mv, (2,2))
-        @test_throws Exception similar(sv, Float64, (2,2))
-        @test_throws Exception similar(mv, Float64, (2,2))
-        @test_throws Exception similar(sv, Val{(2,2)})
-        @test typeof(similar(mv, Val{(2,2)})) <: MArray{(2,2),Int}
-        @test_inferred similar(mv, Val{(2,2)})
-        @test_throws Exception similar(sv, Float64, Val{(2,2)})
-        @test typeof(similar(mv, Float64, Val{(2,2)})) <: MArray{(2,2),Float64}
-        @test_inferred similar(mv, Float64, Val{(2,2)})
-
-        @test similar_type(sv) == typeof(sv)
-        @test_inferred similar_type(sv)
-        @test similar_type(mv) == typeof(mv)
-        @test_inferred similar_type(mv)
-        @test similar_type(sv, Float64) == SArray{(4,),Float64,1,NTuple{4,Float64}}
-        @test_inferred similar_type(sv, Float64)
-        @test similar_type(mv, Float64) == MArray{(4,),Float64,1,NTuple{4,Float64}}
-        @test_inferred similar_type(mv, Float64)
-        @test_throws Exception similar_type(sv, (2,2))
-        @test_throws Exception similar_type(mv, (2,2))
-        @test_throws Exception similar_type(sv, Float64, (2,2))
-        @test_throws Exception similar_type(mv, Float64, (2,2))
-        @test similar_type(sv, Val{(2,2)}) == SArray{(2,2),Int,2,NTuple{4,Int}}
-        @test_inferred similar_type(sv, Val{(2,2)})
-        @test similar_type(mv, Val{(2,2)}) == MArray{(2,2),Int,2,NTuple{4,Int}}
-        @test_inferred similar_type(mv, Val{(2,2)})
-        @test similar_type(sv, Float64, Val{(2,2)}) == SArray{(2,2),Float64,2,NTuple{4,Float64}}
-        @test_inferred similar_type(sv, Float64, Val{(2,2)})
-        @test similar_type(mv, Float64, Val{(2,2)}) == MArray{(2,2),Float64,2,NTuple{4,Float64}}
-        @test_inferred similar_type(mv, Float64, Val{(2,2)})
-    end
-
-    @testset "reshape and permutedims" begin
-        vec = [4,5,6,7]
-        sv = SVector{(4,)}(vec)
-        mv = MVector{(4,)}(vec)
-
-        mat = reshape(vec,(2,2))
-        sm = SMatrix{(2,2)}(mat)
-        mm = MMatrix{(2,2)}(mat)
-
-        @test reshape(sv, Val{(2,2)}) === sm
-        @test_inferred reshape(sv, Val{(2,2)})
-        @test reshape(mv, Val{(2,2)}) == mm
-        @test_inferred reshape(mv, Val{(2,2)})
-        @test isa(reshape(mv, Val{(2,2)}), MMatrix)
-        @test_throws Exception reshape(sv, (2,2)) == sm
-        @test_throws Exception reshape(sv, (2,2)) == sm
-
-    end
-
-    =#
 end