SVD drivers: divide and conquer, Jacobi and preconditioned Jacobi. More...
Functions/Subroutines | |
| pure subroutine, public | la_sgesvj (joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, work, lwork, info) |
| SGESVJ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^t, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. SGESVJ can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details. | |
| pure subroutine, public | la_dgesvj (joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, work, lwork, info) |
| DGESVJ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^t, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. DGESVJ can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details. | |
| pure subroutine, public | la_qgesvj (joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, work, lwork, info) |
| QGESVJ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^t, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. QGESVJ can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details. | |
| pure subroutine, public | la_sgejsv (joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, work, lwork, iwork, info) |
| SGEJSV: computes the singular value decomposition (SVD) of a real M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^t, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and [V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. SGEJSV can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details. | |
| pure subroutine, public | la_dgejsv (joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, work, lwork, iwork, info) |
| DGEJSV: computes the singular value decomposition (SVD) of a real M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^t, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and [V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. DGEJSV can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details. | |
| pure subroutine, public | la_qgejsv (joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, work, lwork, iwork, info) |
| QGEJSV: computes the singular value decomposition (SVD) of a real M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^t, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and [V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. QGEJSV can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details. | |
| subroutine, public | la_sgesdd (jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info) |
| SGESDD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**T, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. | |
| subroutine, public | la_dgesdd (jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info) |
| DGESDD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**T, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. | |
| subroutine, public | la_qgesdd (jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info) |
| QGESDD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**T, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. | |
| subroutine, public | la_cgesdd (jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info) |
| CGESDD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. | |
| subroutine, public | la_zgesdd (jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info) |
| ZGESDD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. | |
| subroutine, public | la_wgesdd (jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info) |
| WGESDD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. | |
| pure subroutine, public | la_cgejsv (joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, cwork, lwork, rwork, lrwork, iwork, info) |
| CGEJSV: computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. | |
| pure subroutine, public | la_zgejsv (joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, cwork, lwork, rwork, lrwork, iwork, info) |
| ZGEJSV: computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. | |
| pure subroutine, public | la_wgejsv (joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, cwork, lwork, rwork, lrwork, iwork, info) |
| WGEJSV: computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. | |
| pure subroutine, public | la_cgesvj (joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, cwork, lwork, rwork, lrwork, info) |
| CGESVJ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. | |
| pure subroutine, public | la_zgesvj (joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, cwork, lwork, rwork, lrwork, info) |
| ZGESVJ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. | |
| pure subroutine, public | la_wgesvj (joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, cwork, lwork, rwork, lrwork, info) |
| WGESVJ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. | |
Detailed Description
SVD drivers: divide and conquer, Jacobi and preconditioned Jacobi.
Function/Subroutine Documentation
◆ la_cgejsv()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_cgejsv | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| character, intent(in) | jobr, | ||
| character, intent(in) | jobt, | ||
| character, intent(in) | jobp, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(n), intent(out) | sva, | ||
| complex(sp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| complex(sp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(sp), dimension(lwork), intent(out) | cwork, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(sp), dimension(lrwork), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
CGEJSV: computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA.
◆ la_cgesdd()
| subroutine, public la_lapack_eigv_svd_drivers2::la_cgesdd | ( | character, intent(in) | jobz, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| complex(sp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| complex(sp), dimension(ldvt,*), intent(out) | vt, | ||
| integer(ilp), intent(in) | ldvt, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
CGESDD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
◆ la_cgesvj()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_cgesvj | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(n), intent(out) | sva, | ||
| integer(ilp), intent(in) | mv, | ||
| complex(sp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(sp), dimension(lwork), intent(inout) | cwork, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(sp), dimension(lrwork), intent(inout) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), intent(out) | info ) |
CGESVJ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
◆ la_dgejsv()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_dgejsv | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| character, intent(in) | jobr, | ||
| character, intent(in) | jobt, | ||
| character, intent(in) | jobp, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(n), intent(out) | sva, | ||
| real(dp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(dp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(dp), dimension(lwork), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DGEJSV: computes the singular value decomposition (SVD) of a real M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^t, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and [V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. DGEJSV can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.
◆ la_dgesdd()
| subroutine, public la_lapack_eigv_svd_drivers2::la_dgesdd | ( | character, intent(in) | jobz, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| real(dp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(dp), dimension(ldvt,*), intent(out) | vt, | ||
| integer(ilp), intent(in) | ldvt, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DGESDD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**T, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
◆ la_dgesvj()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_dgesvj | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(n), intent(out) | sva, | ||
| integer(ilp), intent(in) | mv, | ||
| real(dp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(dp), dimension(lwork), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DGESVJ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^t, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. DGESVJ can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.
◆ la_qgejsv()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_qgejsv | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| character, intent(in) | jobr, | ||
| character, intent(in) | jobt, | ||
| character, intent(in) | jobp, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(n), intent(out) | sva, | ||
| real(qp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(qp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(qp), dimension(lwork), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QGEJSV: computes the singular value decomposition (SVD) of a real M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^t, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and [V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. QGEJSV can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.
◆ la_qgesdd()
| subroutine, public la_lapack_eigv_svd_drivers2::la_qgesdd | ( | character, intent(in) | jobz, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | s, | ||
| real(qp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(qp), dimension(ldvt,*), intent(out) | vt, | ||
| integer(ilp), intent(in) | ldvt, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QGESDD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**T, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
◆ la_qgesvj()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_qgesvj | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(n), intent(out) | sva, | ||
| integer(ilp), intent(in) | mv, | ||
| real(qp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(qp), dimension(lwork), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QGESVJ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^t, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. QGESVJ can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.
◆ la_sgejsv()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_sgejsv | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| character, intent(in) | jobr, | ||
| character, intent(in) | jobt, | ||
| character, intent(in) | jobp, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(n), intent(out) | sva, | ||
| real(sp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(sp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(sp), dimension(lwork), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SGEJSV: computes the singular value decomposition (SVD) of a real M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^t, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and [V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. SGEJSV can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.
◆ la_sgesdd()
| subroutine, public la_lapack_eigv_svd_drivers2::la_sgesdd | ( | character, intent(in) | jobz, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| real(sp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(sp), dimension(ldvt,*), intent(out) | vt, | ||
| integer(ilp), intent(in) | ldvt, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SGESDD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**T, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
◆ la_sgesvj()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_sgesvj | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(n), intent(out) | sva, | ||
| integer(ilp), intent(in) | mv, | ||
| real(sp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(sp), dimension(lwork), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SGESVJ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^t, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. SGESVJ can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.
◆ la_wgejsv()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_wgejsv | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| character, intent(in) | jobr, | ||
| character, intent(in) | jobt, | ||
| character, intent(in) | jobp, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(n), intent(out) | sva, | ||
| complex(qp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| complex(qp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(qp), dimension(lwork), intent(out) | cwork, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), dimension(lrwork), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
WGEJSV: computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA.
◆ la_wgesdd()
| subroutine, public la_lapack_eigv_svd_drivers2::la_wgesdd | ( | character, intent(in) | jobz, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | s, | ||
| complex(qp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| complex(qp), dimension(ldvt,*), intent(out) | vt, | ||
| integer(ilp), intent(in) | ldvt, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
WGESDD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
◆ la_wgesvj()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_wgesvj | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(n), intent(out) | sva, | ||
| integer(ilp), intent(in) | mv, | ||
| complex(qp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(qp), dimension(lwork), intent(inout) | cwork, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), dimension(lrwork), intent(inout) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), intent(out) | info ) |
WGESVJ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
◆ la_zgejsv()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_zgejsv | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| character, intent(in) | jobr, | ||
| character, intent(in) | jobt, | ||
| character, intent(in) | jobp, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(n), intent(out) | sva, | ||
| complex(dp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| complex(dp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(dp), dimension(lwork), intent(out) | cwork, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(dp), dimension(lrwork), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
ZGEJSV: computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA.
◆ la_zgesdd()
| subroutine, public la_lapack_eigv_svd_drivers2::la_zgesdd | ( | character, intent(in) | jobz, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| complex(dp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| complex(dp), dimension(ldvt,*), intent(out) | vt, | ||
| integer(ilp), intent(in) | ldvt, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
ZGESDD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
◆ la_zgesvj()
| pure subroutine, public la_lapack_eigv_svd_drivers2::la_zgesvj | ( | character, intent(in) | joba, |
| character, intent(in) | jobu, | ||
| character, intent(in) | jobv, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(n), intent(out) | sva, | ||
| integer(ilp), intent(in) | mv, | ||
| complex(dp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(dp), dimension(lwork), intent(inout) | cwork, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(dp), dimension(lrwork), intent(inout) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), intent(out) | info ) |
ZGESVJ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
