Update to Julia v0.7 (#9)

* update to Julia v0.7

* update CI to v0.7

Author: RalphAS

.travis.yml

@@ -4,12 +4,14 @@ os:
   - linux
   - osx
 julia:
-  - 0.5
-  - 0.6
+  - 0.7
   - nightly
 notifications:
   email: false
-# uncomment the following lines to override the default test script
-#script:
-#  - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
-#  - julia -e 'Pkg.clone(pwd()); Pkg.build("GenericSVD"); Pkg.test("GenericSVD"; coverage=true)'
+
+script:
+  - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
+  - julia --color=yes -e 'using InteractiveUtils; versioninfo(); import Pkg; Pkg.clone(pwd()); Pkg.build("GenericSVD")'
+  - julia --color=yes --check-bounds=yes -e 'import Pkg; Pkg.test("GenericSVD"; coverage=true)'
+after_success:
+  - julia -e 'import Pkg; cd(Pkg.dir("GenericSVD")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(process_folder()); Codecov.submit(process_folder())'

REQUIRE

@@ -1 +1 @@
-julia 0.5
+julia 0.7-beta

appveyor.yml

@@ -1,9 +1,7 @@
 environment:
   matrix:
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.5/julia-0.5-latest-win32.exe"
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.5/julia-0.5-latest-win64.exe"
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.7/julia-0.7-latest-win32.exe"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.7/julia-0.7-latest-win64.exe"
   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
 
@@ -20,6 +18,11 @@ notifications:
 
 install:
   - ps: "[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12"
+# if there's a newer build queued for the same PR, cancel this one
+  - ps: if ($env:APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER -ne ((Invoke-RestMethod `
+        https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | `
+        Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { `
+        throw "There are newer queued builds for this pull request, failing early." }
 # Download most recent Julia Windows binary
   - ps: (new-object net.webclient).DownloadFile(
         $env:JULIA_URL,
@@ -30,8 +33,8 @@ install:
 build_script:
 # Need to convert from shallow to complete for Pkg.clone to work
   - IF EXIST .git\shallow (git fetch --unshallow)
-  - C:\projects\julia\bin\julia -e "versioninfo();
+  - C:\projects\julia\bin\julia -e "using InteractiveUtils; versioninfo(); import Pkg;
       Pkg.clone(pwd(), \"GenericSVD\"); Pkg.build(\"GenericSVD\")"
 
 test_script:
-  - C:\projects\julia\bin\julia --check-bounds=yes -e "Pkg.test(\"GenericSVD\")"
+  - C:\projects\julia\bin\julia --check-bounds=yes -e "import Pkg; Pkg.test(\"GenericSVD\")"

src/GenericSVD.jl

@@ -1,25 +1,35 @@
 __precompile__(true)
 module GenericSVD
-
-import Base: SVD
+using LinearAlgebra
+import LinearAlgebra: SVD, svd!
 
 include("utils.jl")
 include("bidiagonalize.jl")
 
-Base.svdfact!(X::AbstractMatrix; thin=true) = generic_svdfact!(X; thin=thin)
-Base.svdvals!(X::AbstractMatrix) = generic_svdvals!(X)
+function svd!(X::AbstractMatrix; full::Bool=false, thin::Union{Bool,Nothing} = nothing)
+    if thin != nothing
+        @warn "obsolete keyword thin in generic svd!"
+        thinx = thin
+    else
+        thinx = !full
+    end
+    generic_svdfact!(X; thin=thinx)
+end
+
+LinearAlgebra.svdvals!(X::AbstractMatrix) = generic_svdvals!(X)
 
 function generic_svdfact!(X::AbstractMatrix; sorted=true, thin=true)
     m,n = size(X)
-    t =false
-    if m < n
+    wide = m < n
+    if wide
         m,n = n,m
         X = X'
-        t = true
     end
     B,P = bidiagonalize_tall!(X)
-    U,Vt = full(P,thin=thin)
+    U,Vt = unpack(P,thin=thin)
     U,S,Vt = svd!(B,U,Vt)
+    # as of Julia v0.7 we need to revert a mysterious transpose here
+    Vt=Vt'
     for i = 1:n
         if signbit(S[i])
             S[i] = -S[i]
@@ -29,12 +39,12 @@ function generic_svdfact!(X::AbstractMatrix; sorted=true, thin=true)
         end
     end
     if sorted
-        I = sortperm(S,rev=true)
-        S = S[I]
-        U = U[:,I]
-        Vt = Vt[I,:]
+        Idx = sortperm(S,rev=true)
+        S = S[Idx]
+        U = U[:,Idx]
+        Vt = Vt[Idx,:]
     end
-    t ? SVD(Vt',S,U') : SVD(U,S,Vt)
+    wide ? SVD(Vt',S,U') : SVD(U,S,Vt)
 end
 
 function generic_svdvals!(X::AbstractMatrix; sorted=true)
@@ -43,7 +53,7 @@ function generic_svdvals!(X::AbstractMatrix; sorted=true)
         X = X'
     end
     B,P = bidiagonalize_tall!(X)
-    S = svd!(B)[2]
+    S = svd!(B)
     for i = eachindex(S)
         if signbit(S[i])
             S[i] = -S[i]
@@ -95,7 +105,7 @@ This proceeds by iteratively finding the lowest strictly-bidiagonal submatrix, i
 ```
 then applying a Golub-Kahan QR iteration.
 """
-function svd!{T<:Real}(B::Bidiagonal{T}, U=nothing, Vt=nothing, ɛ=eps(T))
+function svd!(B::Bidiagonal{T}, U=nothing, Vt=nothing, ɛ=eps(T)) where T <: Real
     n = size(B, 1)
     if n == 1
         @goto done
@@ -143,13 +153,22 @@ function svd!{T<:Real}(B::Bidiagonal{T}, U=nothing, Vt=nothing, ɛ=eps(T))
             # use singular value closest to sqrt of final element of B'*B
             h = hypot(d₂,e)
             shift = abs(s₁-h) < abs(s₂-h) ? s₁ : s₂
+            # avoid infinite loop
+            if !all(isfinite.(B))
+                (U == nothing) && return B.dv+NaN
+                return SVD(U .+ NaN, B.dv .+ NaN, Vt .+ NaN)
+            end
             svd_gk!(B, U, Vt, n₁, n₂, shift)
         end
     else
         throw(ArgumentError("lower bidiagonal version not implemented yet"))
     end
     @label done
-    U, B.dv, Vt
+    if U == nothing
+        return B.dv
+    else
+        return SVD(U, B.dv, Vt)
+    end
 end
 
 
@@ -170,7 +189,7 @@ function svd_zerodiag_row!(U,B,n₁,n₂)
         dᵢ = B.dv[i]
 
         G,r = givens(dᵢ,e,i,n₁)
-        A_mul_Bc!(U,G)
+        rmul!(U,adjoint(G))
         B.dv[i] = r # -G.s*e + G.c*dᵢ
 
         if i < n₂
@@ -199,7 +218,7 @@ function svd_zerodiag_col!(B,Vt,n₁,n₂)
         dᵢ = B.dv[i]
 
         G,r = givens(dᵢ,e,i,n₂)
-        A_mul_B!(G,Vt)
+        lmul!(G,Vt)
 
         B.dv[i] = r # G.c*dᵢ + G.s*e
 
@@ -214,13 +233,13 @@ end
 
 
 """
-    svd_gk!{T<:Real}(B::Bidiagonal{T},U,Vt,n₁,n₂,shift)
+    svd_gk!(B::Bidiagonal{T},U,Vt,n₁,n₂,shift) where T <: Real
 
 Applies a Golub-Kahan SVD step (an implicit QR with shift) to the submatrix `B[n₁:n₂,n₁:n₂]`, applying the inverse transformations to `U` and `Vt` (preserving `U*B*Vt`).
 
 A Givens rotation is applied to the top 2x2 matrix, and the resulting "bulge" is "chased" down the diagonal to the bottom of the matrix.
 """
-function svd_gk!{T<:Real}(B::Bidiagonal{T},U,Vt,n₁,n₂,shift)
+function svd_gk!(B::Bidiagonal{T},U,Vt,n₁,n₂,shift) where T <: Real
 
     if istriu(B)
 
@@ -229,7 +248,7 @@ function svd_gk!{T<:Real}(B::Bidiagonal{T},U,Vt,n₁,n₂,shift)
         d₂′ = B.dv[n₁+1]
 
         G, r = givens(d₁′ - abs2(shift)/d₁′, e₁′, n₁, n₁+1)
-        A_mul_B!(G, Vt)
+        lmul!(G,Vt)
 
         #  [d₁,e₁] = [d₁′,e₁′] * G'
         #  [b ,d₂]   [0  ,d₂′]
@@ -248,7 +267,7 @@ function svd_gk!{T<:Real}(B::Bidiagonal{T},U,Vt,n₁,n₂,shift)
             e₂ = B.ev[i+1]
 
             G, r = givens(d₁, b, i, i+1)
-            A_mul_Bc!(U, G)
+            rmul!(U,adjoint(G))
 
             B.dv[i] =  r # G.c*d₁ + G.s*b
 
@@ -265,7 +284,7 @@ function svd_gk!{T<:Real}(B::Bidiagonal{T},U,Vt,n₁,n₂,shift)
             d₃′ = B.dv[i+2]
 
             G, r = givens(e₁′, b′, i+1, i+2)
-            A_mul_B!(G, Vt)
+            lmul!(G, Vt)
 
             B.ev[i] = r # e₁′*G.c + b′*G.s
 
@@ -280,7 +299,7 @@ function svd_gk!{T<:Real}(B::Bidiagonal{T},U,Vt,n₁,n₂,shift)
         #  [0 ,.]       [b ,d₂]
 
         G, r = givens(d₁,b,n₂-1,n₂)
-        A_mul_Bc!(U, G)
+        rmul!(U, adjoint(G))
 
         B.dv[n₂-1] =  r # G.c*d₁ + G.s*b
 

src/bidiagonalize.jl

@@ -5,7 +5,7 @@ Packed storage of bidiagonalizing QR reflectors `U` and `V'`.
 
 
 """
-immutable PackedUVt{T} <: Factorization{T}
+struct PackedUVt{T} <: Factorization{T}
     A::Matrix{T}
 end
 
@@ -15,60 +15,64 @@ end
 
 Bidiagonalize a tall matrix `A` into `B`. Both arguments are overwritten.
 """
-function bidiagonalize_tall!{T}(A::Matrix{T},B::Bidiagonal)
+function bidiagonalize_tall!(A::Matrix{T},B::Bidiagonal) where T
     m, n = size(A)
     # tall case: assumes m >= n
     # upper bidiagonal
+    istriu(B) || throw(ArgumentError("not implemented for lower BiDiag B"))
 
     for i = 1:n
         x = @view A[i:m, i]
-        τi = LinAlg.reflector!(x)
+        τi = LinearAlgebra.reflector!(x)
         B.dv[i] = real(A[i,i])
-        LinAlg.reflectorApply!(x, τi, @view(A[i:m, i+1:n]))
+        LinearAlgebra.reflectorApply!(x, τi, @view(A[i:m, i+1:n]))
         A[i,i] = τi # store reflector coefficient in diagonal
 
         # for Real, this only needs to be n-2
         # needed for Complex to ensure superdiagonal is Real
         if i <= n-1
             x = @view A[i, i+1:n]
             conj!(x)
-            τi = LinAlg.reflector!(x)
+            τi = LinearAlgebra.reflector!(x)
             B.ev[i] = real(A[i,i+1])
-            LinAlg.reflectorApply!(@view(A[i+1:m, i+1:n]), x, τi)
+            LinearAlgebra.reflectorApply!(@view(A[i+1:m, i+1:n]), x, τi)
             A[i,i+1] = τi
         end
     end
-    B.isupper = true
 
     B, PackedUVt(A)
 end
 
-function bidiagonalize_tall!{T}(A::Matrix{T})
+function bidiagonalize_tall!(A::Adjoint{T2,Matrix{T}}) where {T,T2}
+    bidiagonalize_tall!(Matrix(A))
+end
+
+function bidiagonalize_tall!(A::Matrix{T}) where T
     m,n = size(A)
     R = real(T)
-    B = Bidiagonal{R}(Vector{R}(n), Vector{R}(n - 1), true)
+    B = Bidiagonal(Vector{R}(undef, n), Vector{R}(undef, n - 1), :U)
     bidiagonalize_tall!(A, B)
 end
 
-function Base.full{T}(P::PackedUVt{T};thin=true)
+function unpack(P::PackedUVt{T};thin=true) where T
     A = P.A
     m,n = size(A)
 
     # U = Q_1 ... Q_n I_{m,n}
     w = thin ? n : m
-    U = eye(T,m,w)
+    U = Matrix(one(T)*I,m,w) # eye(T,m,w)
     for i = n:-1:1
         τi = A[i,i]
         x = @view A[i:m, i]
-        LinAlg.reflectorApply!(x, τi', @view(U[i:m, i:w]))
+        LinearAlgebra.reflectorApply!(x, τi', @view(U[i:m, i:w]))
     end
 
     # Vt = P_{n_2} ... P_1
-    Vt = eye(T,n,n)
+    Vt = Matrix(one(T)*I,n,n) # eye(T,n,n)
     for i = n-1:-1:1
         τi = A[i,i+1]
         x = @view A[i, i+1:n]
-        LinAlg.reflectorApply!(@view(Vt[i:n, i+1:n]), x, τi')
+        reflectorApply!(@view(Vt[i:n, i+1:n]), x, τi')
     end
     U,Vt
 end

src/utils.jl

@@ -1,4 +1,6 @@
-import Base.LinAlg: reflectorApply!
+# Avast, LinearAlgebra, prepare to be boarded!
+import LinearAlgebra: reflectorApply!
+
 @inline function reflectorApply!(A::StridedMatrix, x::AbstractVector, τ::Number) # apply conjugate transpose reflector from right.
     m, n = size(A)
     if length(x) != n
@@ -21,7 +23,7 @@ import Base.LinAlg: reflectorApply!
 end
 
 
-import Base: A_mul_B!, A_mul_Bc!, A_ldiv_B!
+import LinearAlgebra: lmul!, rmul!
 
-A_mul_B!(G::LinAlg.Givens, ::Void) = nothing
-A_mul_Bc!(::Void, G::LinAlg.Givens) = nothing
+lmul!(G::LinearAlgebra.Givens{T}, ::Nothing) where T = nothing
+rmul!(::Nothing, Ga::Adjoint{Any,LinearAlgebra.Givens{T}}) where T = nothing