Move SVD into its own file for clarity

Author: c42f

src/StaticArrays.jl

@@ -96,6 +96,7 @@ include("sqrtm.jl")
 include("cholesky.jl")
 include("deque.jl")
 include("io.jl")
+include("svd.jl")
 
 include("FixedSizeArrays.jl")
 include("ImmutableArrays.jl")

src/linalg.jl

@@ -340,40 +340,3 @@ end
 # TODO
 
 #--------------------------------------------------
-# SVD
-# We need our own SVD factorization struct, as Base.LinAlg.SVD assumes
-# Base.Vector for `S`, and that the `U` and `Vt` have the same
-struct SVD{T,TU,TS,TVt} <: Factorization{T}
-    U::TU
-    S::TS
-    Vt::TVt
-end
-SVD(U::AbstractArray{T}, S::AbstractVector, Vt::AbstractArray{T}) where {T} = SVD{T,typeof(U),typeof(S),typeof(Vt)}(U, S, Vt)
-
-getindex(::SVD, ::Symbol) = error("In order to avoid type instability, StaticArrays.SVD doesn't support indexing the output of svdfact with a symbol.  Instead, you can access the fields of the factorization directly as f.U, f.S, and f.Vt")
-
-# Return the "diagonal size" of a matrix - the minimum of the two dimensions
-@generated function diagsize(A::StaticMatrix{N,M}) where {N,M}
-    :($(min(N,M)))
-end
-
-function svdvals!(A::StaticMatrix)
-    sv = svdvals!(Matrix(A))
-    similar_type(A, eltype(sv), Size(diagsize(A)))(sv)
-end
-
-function svdfact(A::StaticMatrix)
-    # "Thin" SVD only for now.
-    f = svdfact(Matrix(A))
-    U = similar_type(A, eltype(f.U), Size(Size(A)[1], diagsize(A)))(f.U)
-    S = similar_type(A, Size(diagsize(A)))(f.S)
-    Vt = similar_type(A, eltype(f.Vt), Size(diagsize(A), Size(A)[2]))(f.Vt)
-    SVD(U,S,Vt)
-end
-
-function svd(A::StaticMatrix)
-    # Need our own version of `svd()`, as `Base` passes the `thin` argument
-    # which makes the resulting dimensions uninferrable.
-    f = svdfact(A)
-    (f.U, f.S, f.Vt')
-end

src/svd.jl

@@ -0,0 +1,38 @@
+# Singular Value Decomposition
+
+# We need our own SVD factorization struct, as Base.LinAlg.SVD assumes
+# Base.Vector for `S`, and that the `U` and `Vt` have the same
+struct SVD{T,TU,TS,TVt} <: Factorization{T}
+    U::TU
+    S::TS
+    Vt::TVt
+end
+SVD(U::AbstractArray{T}, S::AbstractVector, Vt::AbstractArray{T}) where {T} = SVD{T,typeof(U),typeof(S),typeof(Vt)}(U, S, Vt)
+
+getindex(::SVD, ::Symbol) = error("In order to avoid type instability, StaticArrays.SVD doesn't support indexing the output of svdfact with a symbol.  Instead, you can access the fields of the factorization directly as f.U, f.S, and f.Vt")
+
+# Return the "diagonal size" of a matrix - the minimum of the two dimensions
+@generated function diagsize(A::StaticMatrix{N,M}) where {N,M}
+    :($(min(N,M)))
+end
+
+function svdvals!(A::StaticMatrix)
+    sv = svdvals!(Matrix(A))
+    similar_type(A, eltype(sv), Size(diagsize(A)))(sv)
+end
+
+function svdfact(A::StaticMatrix)
+    # "Thin" SVD only for now.
+    f = svdfact(Matrix(A))
+    U = similar_type(A, eltype(f.U), Size(Size(A)[1], diagsize(A)))(f.U)
+    S = similar_type(A, Size(diagsize(A)))(f.S)
+    Vt = similar_type(A, eltype(f.Vt), Size(diagsize(A), Size(A)[2]))(f.Vt)
+    SVD(U,S,Vt)
+end
+
+function svd(A::StaticMatrix)
+    # Need our own version of `svd()`, as `Base` passes the `thin` argument
+    # which makes the resulting dimensions uninferrable.
+    f = svdfact(A)
+    (f.U, f.S, f.Vt')
+end