Reference

lansvd!: Compute leading singular triplets.

• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• aprod: function defining the linear operator A
• U: m x k array to store left singular vectors (k ≤ min(kmax,m,n))
• s: length k array to store desired singular values (k ≤ min(kmax,m,n))
• bnd: length k array to store error estimates on the singular values
• V: n x k array to store right singular vectors
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])
• work: work array of size
  • m + n + 9kmax + 2kmax^2 + 4 + max(m+n, 4*kmax+4) if jobu = jobv = 'N'
  • m + n + 9kmax + 5kmax^2 + 4 + max(3kmax^2 + 4kmax+4, nb*max(m,n)) otherwise where nb is a BLAS-3 block size
• iwork: integer work array of size
  • 2*kmax + 1 if jobu = jobv = 'N'
  • 8*kmax otherwise
• cwork: complex work array
• doption: [δ, η, ‖A‖], where
  • δ: the level of orthogonality desired,
  • η: vectors with components larger than η will be purged during reorthogonalization
  • ‖A‖: estimate of the norm of A
• ioption: [cgs, elr], where
  • cgs: 1 = classical Gram-Schmidt, 0 = modified Gram-Schmidt
  • elr: 1 = extended local orthogonality
• dparm: array for passing data to aprod; WARNING: we use dparm as passthrough pointer!!!
• iparm: array for passing integer data to aprod.

Returns: (U, s, V, bnd).

lansvd!: Compute leading singular triplets.

• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• aprod: function defining the linear operator A
• U: m x k array to store left singular vectors (k ≤ min(kmax,m,n))
• s: length k array to store desired singular values (k ≤ min(kmax,m,n))
• bnd: length k array to store error estimates on the singular values
• V: n x k array to store right singular vectors
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])
• work: work array of size
  • m + n + 9kmax + 2kmax^2 + 4 + max(m+n, 4*kmax+4) if jobu = jobv = 'N'
  • m + n + 9kmax + 5kmax^2 + 4 + max(3kmax^2 + 4kmax+4, nb*max(m,n)) otherwise where nb is a BLAS-3 block size
• iwork: integer work array of size
  • 2*kmax + 1 if jobu = jobv = 'N'
  • 8*kmax otherwise
• cwork: complex work array
• doption: [δ, η, ‖A‖], where
  • δ: the level of orthogonality desired,
  • η: vectors with components larger than η will be purged during reorthogonalization
  • ‖A‖: estimate of the norm of A
• ioption: [cgs, elr], where
  • cgs: 1 = classical Gram-Schmidt, 0 = modified Gram-Schmidt
  • elr: 1 = extended local orthogonality
• dparm: array for passing data to aprod; WARNING: we use dparm as passthrough pointer!!!
• iparm: array for passing integer data to aprod.

Returns: (U, s, V, bnd).

lansvd!: Compute leading singular triplets.

• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• aprod: function defining the linear operator A
• U: m x k array to store left singular vectors (k ≤ min(kmax,m,n))
• s: length k array to store desired singular values (k ≤ min(kmax,m,n))
• bnd: length k array to store error estimates on the singular values
• V: n x k array to store right singular vectors
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])
• work: work array of size
  • m + n + 9kmax + 2kmax^2 + 4 + max(m+n, 4*kmax+4) if jobu = jobv = 'N'
  • m + n + 9kmax + 5kmax^2 + 4 + max(3kmax^2 + 4kmax+4, nb*max(m,n)) otherwise where nb is a BLAS-3 block size
• iwork: integer work array of size
  • 2*kmax + 1 if jobu = jobv = 'N'
  • 8*kmax otherwise
• cwork: complex work array
• doption: [δ, η, ‖A‖], where
  • δ: the level of orthogonality desired,
  • η: vectors with components larger than η will be purged during reorthogonalization
  • ‖A‖: estimate of the norm of A
• ioption: [cgs, elr], where
  • cgs: 1 = classical Gram-Schmidt, 0 = modified Gram-Schmidt
  • elr: 1 = extended local orthogonality
• dparm: array for passing data to aprod; WARNING: we use dparm as passthrough pointer!!!
• iparm: array for passing integer data to aprod.

Returns: (U, s, V, bnd).

lansvd!: Compute leading singular triplets.

• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• aprod: function defining the linear operator A
• U: m x k array to store left singular vectors (k ≤ min(kmax,m,n))
• s: length k array to store desired singular values (k ≤ min(kmax,m,n))
• bnd: length k array to store error estimates on the singular values
• V: n x k array to store right singular vectors
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])
• work: work array of size
  • m + n + 9kmax + 2kmax^2 + 4 + max(m+n, 4*kmax+4) if jobu = jobv = 'N'
  • m + n + 9kmax + 5kmax^2 + 4 + max(3kmax^2 + 4kmax+4, nb*max(m,n)) otherwise where nb is a BLAS-3 block size
• iwork: integer work array of size
  • 2*kmax + 1 if jobu = jobv = 'N'
  • 8*kmax otherwise
• cwork: complex work array
• doption: [δ, η, ‖A‖], where
  • δ: the level of orthogonality desired,
  • η: vectors with components larger than η will be purged during reorthogonalization
  • ‖A‖: estimate of the norm of A
• ioption: [cgs, elr], where
  • cgs: 1 = classical Gram-Schmidt, 0 = modified Gram-Schmidt
  • elr: 1 = extended local orthogonality
• dparm: array for passing data to aprod; WARNING: we use dparm as passthrough pointer!!!
• iparm: array for passing integer data to aprod.

Returns: (U, s, V, bnd).

lansvd: Compute leading singular triplets: simplified interface.

• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• pff: pointer to function defining the linear operator A
• initvec: starting vector for bidiagonalization
• k: number of triplets desired
• kmax: maximum number of iterations (= max dimension of Krylov space)
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])

lansvd: Compute leading singular triplets: simplified interface.

• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• pff: pointer to function defining the linear operator A
• initvec: starting vector for bidiagonalization
• k: number of triplets desired
• kmax: maximum number of iterations (= max dimension of Krylov space)
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])

lansvd: Compute leading singular triplets: simplified interface.

• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• pff: pointer to function defining the linear operator A
• initvec: starting vector for bidiagonalization
• k: number of triplets desired
• kmax: maximum number of iterations (= max dimension of Krylov space)
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])

lansvd: Compute leading singular triplets: simplified interface.

• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• pff: pointer to function defining the linear operator A
• initvec: starting vector for bidiagonalization
• k: number of triplets desired
• kmax: maximum number of iterations (= max dimension of Krylov space)
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])

lansvd_irl!: Compute leading singular triplets.

• which: compute triplets for largest ('L') or smallest ('S') singular values
• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• p: number of shifts per restart
• maxiter: maximum number of restarts
• aprod: function defining the linear operator A
• U: m x k array to store left singular vectors (k ≤ min(kmax-p,m,n))
• s: length k array to store desired singular values (k ≤ min(kmax-p,m,n))
• bnd: length k array to store error estimates on the singular values
• V: n x k array to store right singular vectors
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])
• work: work array of size
  • m + n + 9kmax + 2kmax^2 + 4 + max(m+n, 4*kmax+4) if jobu = jobv = 'N'
  • m + n + 9kmax + 5kmax^2 + 4 + max(3kmax^2 + 4kmax+4, nb*max(m,n)) otherwise where nb is a BLAS-3 block size
• iwork: integer work array of size
  • 2*kmax + 1 if jobu = jobv = 'N'
  • 8*kmax otherwise
• cwork: complex work array
• doption: [δ, η, ‖A‖, gap], where
  • δ: the level of orthogonality desired,
  • η: vectors with components larger than η will be purged during reorthogonalization
  • ‖A‖: estimate of the norm of A
  • gap: smallest relative gap between the shifts and the lower bound on Ritz values
• ioption: [cgs, elr], where
  • cgs: 1 = classical Gram-Schmidt, 0 = modified Gram-Schmidt
  • elr: 1 = extended local orthogonality
• dparm: array for passing data to aprod; WARNING: we use dparm as passthrough pointer!!!
• iparm: array for passing integer data to aprod.

Returns: (U, s, V, bnd).

lansvd_irl!: Compute leading singular triplets.

• which: compute triplets for largest ('L') or smallest ('S') singular values
• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• p: number of shifts per restart
• maxiter: maximum number of restarts
• aprod: function defining the linear operator A
• U: m x k array to store left singular vectors (k ≤ min(kmax-p,m,n))
• s: length k array to store desired singular values (k ≤ min(kmax-p,m,n))
• bnd: length k array to store error estimates on the singular values
• V: n x k array to store right singular vectors
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])
• work: work array of size
  • m + n + 9kmax + 2kmax^2 + 4 + max(m+n, 4*kmax+4) if jobu = jobv = 'N'
  • m + n + 9kmax + 5kmax^2 + 4 + max(3kmax^2 + 4kmax+4, nb*max(m,n)) otherwise where nb is a BLAS-3 block size
• iwork: integer work array of size
  • 2*kmax + 1 if jobu = jobv = 'N'
  • 8*kmax otherwise
• cwork: complex work array
• doption: [δ, η, ‖A‖, gap], where
  • δ: the level of orthogonality desired,
  • η: vectors with components larger than η will be purged during reorthogonalization
  • ‖A‖: estimate of the norm of A
  • gap: smallest relative gap between the shifts and the lower bound on Ritz values
• ioption: [cgs, elr], where
  • cgs: 1 = classical Gram-Schmidt, 0 = modified Gram-Schmidt
  • elr: 1 = extended local orthogonality
• dparm: array for passing data to aprod; WARNING: we use dparm as passthrough pointer!!!
• iparm: array for passing integer data to aprod.

Returns: (U, s, V, bnd).

lansvd_irl!: Compute leading singular triplets.

• which: compute triplets for largest ('L') or smallest ('S') singular values
• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• p: number of shifts per restart
• maxiter: maximum number of restarts
• aprod: function defining the linear operator A
• U: m x k array to store left singular vectors (k ≤ min(kmax-p,m,n))
• s: length k array to store desired singular values (k ≤ min(kmax-p,m,n))
• bnd: length k array to store error estimates on the singular values
• V: n x k array to store right singular vectors
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])
• work: work array of size
  • m + n + 9kmax + 2kmax^2 + 4 + max(m+n, 4*kmax+4) if jobu = jobv = 'N'
  • m + n + 9kmax + 5kmax^2 + 4 + max(3kmax^2 + 4kmax+4, nb*max(m,n)) otherwise where nb is a BLAS-3 block size
• iwork: integer work array of size
  • 2*kmax + 1 if jobu = jobv = 'N'
  • 8*kmax otherwise
• cwork: complex work array
• doption: [δ, η, ‖A‖, gap], where
  • δ: the level of orthogonality desired,
  • η: vectors with components larger than η will be purged during reorthogonalization
  • ‖A‖: estimate of the norm of A
  • gap: smallest relative gap between the shifts and the lower bound on Ritz values
• ioption: [cgs, elr], where
  • cgs: 1 = classical Gram-Schmidt, 0 = modified Gram-Schmidt
  • elr: 1 = extended local orthogonality
• dparm: array for passing data to aprod; WARNING: we use dparm as passthrough pointer!!!
• iparm: array for passing integer data to aprod.

Returns: (U, s, V, bnd).

lansvd_irl!: Compute leading singular triplets.

• which: compute triplets for largest ('L') or smallest ('S') singular values
• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• p: number of shifts per restart
• maxiter: maximum number of restarts
• aprod: function defining the linear operator A
• U: m x k array to store left singular vectors (k ≤ min(kmax-p,m,n))
• s: length k array to store desired singular values (k ≤ min(kmax-p,m,n))
• bnd: length k array to store error estimates on the singular values
• V: n x k array to store right singular vectors
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i])
• work: work array of size
  • m + n + 9kmax + 2kmax^2 + 4 + max(m+n, 4*kmax+4) if jobu = jobv = 'N'
  • m + n + 9kmax + 5kmax^2 + 4 + max(3kmax^2 + 4kmax+4, nb*max(m,n)) otherwise where nb is a BLAS-3 block size
• iwork: integer work array of size
  • 2*kmax + 1 if jobu = jobv = 'N'
  • 8*kmax otherwise
• cwork: complex work array
• doption: [δ, η, ‖A‖, gap], where
  • δ: the level of orthogonality desired,
  • η: vectors with components larger than η will be purged during reorthogonalization
  • ‖A‖: estimate of the norm of A
  • gap: smallest relative gap between the shifts and the lower bound on Ritz values
• ioption: [cgs, elr], where
  • cgs: 1 = classical Gram-Schmidt, 0 = modified Gram-Schmidt
  • elr: 1 = extended local orthogonality
• dparm: array for passing data to aprod; WARNING: we use dparm as passthrough pointer!!!
• iparm: array for passing integer data to aprod.

Returns: (U, s, V, bnd).

lansvd_irl: Compute leading singular triplets, simplified interface.

• which: compute triplets for largest ('L') or smallest ('S') singular values
• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• p: number of shifts per restart
• k: number of triplets desired
• maxiter: maximum number of restarts
• pff: pointer to function defining the linear operator A
• initvec: starting vector for bidiagonalization
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i]).

Returns: (U, s, V, bnd).

lansvd_irl: Compute leading singular triplets, simplified interface.

• which: compute triplets for largest ('L') or smallest ('S') singular values
• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• p: number of shifts per restart
• k: number of triplets desired
• maxiter: maximum number of restarts
• pff: pointer to function defining the linear operator A
• initvec: starting vector for bidiagonalization
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i]).

Returns: (U, s, V, bnd).

lansvd_irl: Compute leading singular triplets, simplified interface.

• which: compute triplets for largest ('L') or smallest ('S') singular values
• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• p: number of shifts per restart
• k: number of triplets desired
• maxiter: maximum number of restarts
• pff: pointer to function defining the linear operator A
• initvec: starting vector for bidiagonalization
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i]).

Returns: (U, s, V, bnd).

lansvd_irl: Compute leading singular triplets, simplified interface.

• which: compute triplets for largest ('L') or smallest ('S') singular values
• jobu: compute left singular vectors ('Y'/'N')
• jobv: compute right singular vectors ('Y'/'N')
• m: number of rows of A
• n: number of cols of A
• kmax: maximum number of iterations (= max dimension of Krylov space)
• p: number of shifts per restart
• k: number of triplets desired
• maxiter: maximum number of restarts
• pff: pointer to function defining the linear operator A
• initvec: starting vector for bidiagonalization
• tolin: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i]).

Returns: (U, s, V, bnd).

tsvd(A::AbstractLinearOperator; kwargs...)

Compute a few leading singular triplets of A using only products with A and A'.

Keyword arguments

• initvec::Vector: initial vector for the iterations (default: zeros)
• k::Integer: number of leading singular values to approximate (default: 1)
• kmax::Integer: maximum dimensionality of search space (default: min(size(A))+10)
• tolin::Real: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i]) (default: √ϵ).

Return values

• U::Matrix: orthogonal matrix of left singular vectors
• s::Vector: approximate leading singular values
• V::Matrix: orthogonal matrix of right singular vectors
• bnd::Vector: bound on the accuracy of each singular value
• nprod::Int: number of products with A required
• ntprod::Int: number of products with A' required.

The arrays U, s and V are such that A - U * diagm(s) * V' should be of the order of the next largest singular value.

tsvd_irl(A::AbstractLinearOperator; kwargs...)

Compute a few extreme singular triplets of A using only products with A and A' and the implicitly restarted Lanczos bidiagonalization method.

Keyword arguments

• smallest::Bool: whether the smallest or leading triplets should be approximated (default: True)
• initvec::Vector: initial vector for the iterations (default: zeros)
• kmax::Integer: maximum dimensionality of search space (default: min(size(A))+10)
• p::Integer: number of shifts per restart (default: 1)
• k::Integer: number of extreme singular values to approximate (default: 1)
• maxiter::Integer: maximum number of restarts (default: min(size(A)))
• tolin::Real: desired accuracy; the error on s[i] is approximately max(16ϵ s[1], tolin * s[i]) (default: √ϵ).

Return values

• U::Matrix: orthogonal matrix of left singular vectors
• s::Vector: approximate leading singular values
• V::Matrix: orthogonal matrix of right singular vectors
• bnd::Vector: bound on the accuracy of each singular value
• nprod::Int: number of products with A required
• ntprod::Int: number of products with A' required.

If smallest == False, the arrays U, s and V are such that A - U * diagm(s) * V' should be of the order of the next largest singular value.

If smallest == True, U * diagm(s) * V' is (an approximation of) the best rank-k approximation of A.

tsvdvals(A::AbstractLinearOperator; kwargs...)

Compute a few leading singular values of A using only products with A and A'.

Keyword arguments

See the documentation of tsvd().

Return values

• s::Vector: approximate leading singular values
• bnd::Vector: bound on the accuracy of each singular value
• nprod::Int: number of products with A required
• ntprod::Int: number of products with A' required.

tsvdvals_irl(A::AbstractLinearOperator; kwargs...)

Compute a few extreme singular values of A using only products with A and A' and the implicitly restarted Lanczos bidiagonalization method.

Keyword arguments

See the documentation of tsdv_irl().

Return values

• s::Vector: approximate leading singular values
• bnd::Vector: bound on the accuracy of each singular value
• nprod::Int: number of products with A required
• ntprod::Int: number of products with A' required.