Minor tweaks and fixes to static LU

* _lu() dispatch on `Size`
* Fix permutation to have `Int` eltype.

Author: c42f

src/lu.jl

@@ -1,26 +1,28 @@
 # LU decomposition
 function lu(A::StaticMatrix, pivot::Union{Type{Val{false}},Type{Val{true}}}=Val{true})
-    L,U,p = _lu(A, pivot)
+    L,U,p = _lu(Size(A), A, pivot)
     (L,U,p)
 end
 
 # For the square version, return explicit lower and upper triangular matrices.
 # We would do this for the rectangular case too, but Base doesn't support that.
 function lu(A::StaticMatrix{N,N}, pivot::Union{Type{Val{false}},Type{Val{true}}}=Val{true}) where {N}
-    L,U,p = _lu(A, pivot)
+    L,U,p = _lu(Size(A), A, pivot)
     (LowerTriangular(L), UpperTriangular(U), p)
 end
 
 
-@inline function _lu(A::StaticMatrix, pivot)
+@inline function _lu(::Size{S}, A::StaticMatrix, pivot) where {S}
     # For now, just call through to Base.
     # TODO: statically sized LU without allocations!
     f = lufact(Matrix(A), pivot)
     T = eltype(A)
+    # Trick to get the output eltype - can't rely on the result of f[:L] as
+    # it's not type inferrable.
     T2 = typeof((one(T)*zero(T) + zero(T))/one(T))
     L = similar_type(A, T2, Size(Size(A)[1], diagsize(A)))(f[:L])
     U = similar_type(A, T2, Size(diagsize(A), Size(A)[2]))(f[:U])
-    p = similar_type(A, Size(Size(A)[1]))(f[:p])
+    p = similar_type(A, Int, Size(Size(A)[1]))(f[:p])
     (L,U,p)
 end
 

test/lu.jl

@@ -3,14 +3,14 @@ using StaticArrays, Base.Test
 @testset "LU decomposition" begin
     # Square case
     m22 = @SMatrix [1 2; 3 4]
-    @inferred(lu(m22))
+    @test @inferred(lu(m22)) isa Tuple{LowerTriangular{Float64,SMatrix{2,2,Float64,4}}, UpperTriangular{Float64,SMatrix{2,2,Float64,4}}, SVector{2,Int}}
     @test lu(m22)[1]::LowerTriangular{<:Any,<:StaticMatrix} ≊ lu(Matrix(m22))[1]
     @test lu(m22)[2]::UpperTriangular{<:Any,<:StaticMatrix} ≊ lu(Matrix(m22))[2]
     @test lu(m22)[3]::StaticVector ≊ lu(Matrix(m22))[3]
 
     # Rectangular case
     m23 = @SMatrix Float64[3 9 4; 6 6 2]
-    @inferred lu(m23)
+    @test @inferred(lu(m23)) isa Tuple{SMatrix{2,2,Float64,4}, SMatrix{2,3,Float64,6}, SVector{2,Int}}
     @test lu(m23)[1] ≊ lu(Matrix(m23))[1]
     @test lu(m23)[2] ≊ lu(Matrix(m23))[2]
     @test lu(m23)[3] ≊ lu(Matrix(m23))[3]