Implement promote_rule for StaticArray to mirror Base.Array (#215)

* Implement promote_rule for StaticArray to mirror Base.Array

* Many bug fixes and several tests for SizedArray

This appears to have been badly broken during the Tuple type parameter
consolidation: Some of the constructors didn't work, and the type
parameters for SizedVector and SizedMatrix were completely broken.

* Restrict promote_rule to SArray, MArray, SizedArray

Add this restriction in analogy with the quite restricted version for
Base.Array, to avoid unwanted consequences for other static array types.

Author: c42f

src/MArray.jl

@@ -290,3 +290,7 @@ macro MArray(ex)
     end
 
 end
+
+function promote_rule(::Type{<:MArray{S,T,N,L}}, ::Type{<:MArray{S,U,N,L}}) where {S,T,U,N,L}
+    MArray{S,promote_type(T,U),N,L}
+end

src/SArray.jl

@@ -252,3 +252,7 @@ macro SArray(ex)
         error("Bad input for @SArray")
     end
 end
+
+function promote_rule(::Type{<:SArray{S,T,N,L}}, ::Type{<:SArray{S,U,N,L}}) where {S,T,U,N,L}
+    SArray{S,promote_type(T,U),N,L}
+end

src/SizedArray.jl

@@ -45,8 +45,8 @@ end
 end
 
 @inline (::Type{SizedArray{S,T,N}}){S,T,N}(x::Tuple) = SizedArray{S,T,N,N}(x)
-@inline (::Type{SizedArray{S,T}}){S,T}(x::Tuple) = SizedArray{S,T,_dims(S),_dims(S)}(x)
-@inline (::Type{SizedArray{S}}){S,T,L}(x::NTuple{L,T}) = SizedArray{S,T,_dims(S),_dims(S)}(x)
+@inline (::Type{SizedArray{S,T}}){S,T}(x::Tuple) = SizedArray{S,T,tuple_length(S),tuple_length(S)}(x)
+@inline (::Type{SizedArray{S}}){S,T,L}(x::NTuple{L,T}) = SizedArray{S,T,tuple_length(S),tuple_length(S)}(x)
 
 # Overide some problematic default behaviour
 @inline convert{SA<:SizedArray}(::Type{SA}, sa::SizedArray) = SA(sa.data)
@@ -64,17 +64,13 @@ end
 @propagate_inbounds getindex(a::SizedArray, i::Int) = getindex(a.data, i)
 @propagate_inbounds setindex!(a::SizedArray, v, i::Int) = setindex!(a.data, v, i)
 
-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)
-@inline (::Type{SizedVector{S}}){S,T,L}(x::NTuple{L,T}) = SizedArray{S,T,1,1}(x)
-@inline (::Type{Vector})(sa::SizedVector) = sa.data
-@inline convert(::Type{Vector}, sa::SizedVector) = sa.data
+SizedVector{S,T,M} = SizedArray{Tuple{S},T,1,M}
+@inline (::Type{SizedVector{S}}){S,T,M}(a::Array{T,M}) = SizedArray{Tuple{S},T,1,M}(a)
+@inline (::Type{SizedVector{S}}){S,T,L}(x::NTuple{L,T}) = SizedArray{Tuple{S},T,1,1}(x)
 
-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)
-@inline (::Type{SizedMatrix{S}}){S,T,L}(x::NTuple{L,T}) = SizedArray{S,T,2,2}(x)
-@inline (::Type{Matrix})(sa::SizedMatrix) = sa.data
-@inline convert(::Type{Matrix}, sa::SizedMatrix) = sa.data
+SizedMatrix{S1,S2,T,M} = SizedArray{Tuple{S1,S2},T,2,M}
+@inline (::Type{SizedMatrix{S1,S2}}){S1,S2,T,M}(a::Array{T,M}) = SizedArray{Tuple{S1,S2},T,2,M}(a)
+@inline (::Type{SizedMatrix{S1,S2}}){S1,S2,T,L}(x::NTuple{L,T}) = SizedArray{Tuple{S1,S2},T,2,2}(x)
 
 
 """
@@ -85,3 +81,8 @@ Creates a `SizedArray` wrapping `array` with the specified statically-known
 package.
 """
 (::Size{S}){S}(a::Array) = SizedArray{Tuple{S...}}(a)
+
+
+function promote_rule(::Type{<:SizedArray{S,T,N,M}}, ::Type{<:SizedArray{S,U,N,M}}) where {S,T,U,N,M}
+    SizedArray{S,promote_type(T,U),N,M}
+end

src/StaticArrays.jl

@@ -5,7 +5,7 @@ module StaticArrays
 import Base: @_inline_meta, @_propagate_inbounds_meta, @_pure_meta, @propagate_inbounds, @pure
 
 import Base: getindex, setindex!, size, similar, vec, show,
-             length, convert, promote_op, map, map!, reduce, reducedim, mapreducedim,
+             length, convert, promote_op, promote_rule, map, map!, reduce, reducedim, mapreducedim,
              mapreduce, broadcast, broadcast!, conj, transpose, ctranspose,
              hcat, vcat, ones, zeros, eye, one, cross, vecdot, reshape, fill,
              fill!, det, inv, eig, eigvals, expm, sqrtm, trace, vecnorm, norm, dot, diagm,

test/MArray.jl

@@ -132,4 +132,10 @@
 
         @test_throws BoundsError setindex!(v, 4, -1)
     end
+
+    @testset "promotion" begin
+        @test @inferred(promote_type(MVector{1,Float64}, MVector{1,BigFloat})) == MVector{1,BigFloat}
+        @test @inferred(promote_type(MVector{2,Int}, MVector{2,Float64})) === MVector{2,Float64}
+        @test @inferred(promote_type(MMatrix{2,3,Float32,6}, MMatrix{2,3,Complex{Float64},6})) === MMatrix{2,3,Complex{Float64},6}
+    end
 end

test/SArray.jl

@@ -115,4 +115,10 @@
 
         @test_throws Exception m[1] = 1
     end
+
+    @testset "promotion" begin
+        @test @inferred(promote_type(SVector{1,Float64}, SVector{1,BigFloat})) == SVector{1,BigFloat}
+        @test @inferred(promote_type(SVector{2,Int}, SVector{2,Float64})) === SVector{2,Float64}
+        @test @inferred(promote_type(SMatrix{2,3,Float32,6}, SMatrix{2,3,Complex{Float64},6})) === SMatrix{2,3,Complex{Float64},6}
+    end
 end

test/SizedArray.jl

@@ -12,12 +12,49 @@
         # Bad parameters
         @test_throws Exception SizedArray{Tuple{1},Int,2}()
         @test_throws Exception SArray{Tuple{3, 4},Int,1}()
-        
+
         # Parameter/input size mismatch
         @test_throws Exception SizedArray{Tuple{1},Int,2}([2; 3])
         @test_throws Exception SizedArray{Tuple{1},Int,2}((2, 3))
     end
 
+    @testset "Outer Constructors" begin
+        # From Array
+        @test @inferred(SizedArray{Tuple{2},Float64,1}([1,2]))::SizedArray{Tuple{2},Float64,1,1} == [1.0, 2.0]
+        @test @inferred(SizedArray{Tuple{2},Float64}([1,2]))::SizedArray{Tuple{2},Float64,1,1} == [1.0, 2.0]
+        @test @inferred(SizedArray{Tuple{2}}([1,2]))::SizedArray{Tuple{2},Int,1,1} == [1,2]
+        @test @inferred(SizedArray{Tuple{2,2}}([1 2;3 4]))::SizedArray{Tuple{2,2},Int,2,2} == [1 2; 3 4]
+        # From Array, reshaped
+        @test @inferred(SizedArray{Tuple{2,2}}([1,2,3,4]))::SizedArray{Tuple{2,2},Int,2,1} == [1 3; 2 4]
+        # Uninitialized
+        @test @inferred(SizedArray{Tuple{2,2},Int,2}()) isa SizedArray{Tuple{2,2},Int,2,2}
+        @test @inferred(SizedArray{Tuple{2,2},Int}()) isa SizedArray{Tuple{2,2},Int,2,2}
+
+        # From Tuple
+        @test @inferred(SizedArray{Tuple{2},Float64,1}((1,2)))::SizedArray{Tuple{2},Float64,1,1} == [1.0, 2.0]
+        @test @inferred(SizedArray{Tuple{2},Float64}((1,2)))::SizedArray{Tuple{2},Float64,1,1} == [1.0, 2.0]
+        @test @inferred(SizedArray{Tuple{2}}((1,2)))::SizedArray{Tuple{2},Int,1,1} == [1,2]
+        @test @inferred(SizedArray{Tuple{2,2}}((1,2,3,4)))::SizedArray{Tuple{2,2},Int,2,2} == [1 3; 2 4]
+    end
+
+    @testset "SizedVector and SizedMatrix" begin
+        @test @inferred(SizedVector{2}([1,2]))::SizedArray{Tuple{2},Int,1,1} == [1,2]
+        @test @inferred(SizedVector{2}((1,2)))::SizedArray{Tuple{2},Int,1,1} == [1,2]
+        # Reshaping
+        @test @inferred(SizedVector{2}([1 2]))::SizedArray{Tuple{2},Int,1,2} == [1,2]
+        # Back to Vector
+        @test Vector(SizedVector{2}((1,2))) == [1,2]
+        @test convert(Vector, SizedVector{2}((1,2))) == [1,2]
+
+        @test @inferred(SizedMatrix{2,2}([1 2; 3 4]))::SizedArray{Tuple{2,2},Int,2,2} == [1 2; 3 4]
+        # Reshaping
+        @test @inferred(SizedMatrix{2,2}([1,2,3,4]))::SizedArray{Tuple{2,2},Int,2,1} == [1 3; 2 4]
+        @test @inferred(SizedMatrix{2,2}((1,2,3,4)))::SizedArray{Tuple{2,2},Int,2,2} == [1 3; 2 4]
+        # Back to Matrix
+        @test Matrix(SizedMatrix{2,2}([1 2;3 4])) == [1 2; 3 4]
+        @test convert(Matrix, SizedMatrix{2,2}([1 2;3 4])) == [1 2; 3 4]
+    end
+
     # setindex
     sa = SizedArray{Tuple{2}, Int, 1}([3, 4])
     sa[1] = 2
@@ -32,4 +69,10 @@
         @test Matrix(SMatrix{2,2}((1,2,3,4))) == [1 3; 2 4]
         @test convert(Matrix, SMatrix{2,2}((1,2,3,4))) == [1 3; 2 4]
     end
+
+    @testset "promotion" begin
+        @test @inferred(promote_type(SizedVector{1,Float64,1}, SizedVector{1,BigFloat,1})) == SizedVector{1,BigFloat,1}
+        @test @inferred(promote_type(SizedVector{2,Int,1}, SizedVector{2,Float64,1})) === SizedVector{2,Float64,1}
+        @test @inferred(promote_type(SizedMatrix{2,3,Float32,2}, SizedMatrix{2,3,Complex{Float64},2})) === SizedMatrix{2,3,Complex{Float64},2}
+    end
 end

test/abstractarray.jl

@@ -69,14 +69,14 @@
         @test @inferred(vec(SMatrix{2, 2}([1 2; 3 4])))::SVector{4,Int} == [1, 3, 2, 4]
         @test @inferred(copy(SMatrix{2, 2}([1 2; 3 4]))) == [1 2; 3 4]
     end
-    
+
     @testset "full" begin
         m_a = randn(2,2)
         m_a = m_a*m_a.'
         m = SMatrix{2,2}(m_a)
         @test @inferred(full(Symmetric(m))) == m_a
         @test @inferred(full(Symmetric(m, :L))) == m_a
-        
+
         m_a = randn(2,2) + im*randn(2,2)
         m_a = m_a*m_a'
         m = SMatrix{2,2}(m_a)