Least-squares helpers: incremental condition estimation and divide-and-conquer back-substitution. More...
Functions/Subroutines | |
| pure subroutine, public | la_slaic1 (job, j, x, sest, w, gamma, sestpr, s, c) |
| SLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then SLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**T gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**T and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ alpha ] [ gamma ] where alpha = x**T*w. | |
| pure subroutine, public | la_dlaic1 (job, j, x, sest, w, gamma, sestpr, s, c) |
| DLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then DLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**T gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**T and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ alpha ] [ gamma ] where alpha = x**T*w. | |
| pure subroutine, public | la_qlaic1 (job, j, x, sest, w, gamma, sestpr, s, c) |
| QLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then QLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**T gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**T and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ alpha ] [ gamma ] where alpha = x**T*w. | |
| pure subroutine, public | la_slals0 (icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info) |
| SLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L). | |
| pure subroutine, public | la_dlals0 (icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info) |
| DLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L). | |
| pure subroutine, public | la_qlals0 (icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info) |
| QLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L). | |
| pure subroutine, public | la_slalsa (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info) |
| SLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, SLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, SLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by SLALSA. | |
| pure subroutine, public | la_dlalsa (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info) |
| DLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, DLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, DLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by DLALSA. | |
| pure subroutine, public | la_qlalsa (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info) |
| QLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, QLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, QLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by QLALSA. | |
| pure subroutine, public | la_slalsd (uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, iwork, info) |
| SLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, 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_dlalsd (uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, iwork, info) |
| DLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, 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_qlalsd (uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, iwork, info) |
| QLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, 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_claic1 (job, j, x, sest, w, gamma, sestpr, s, c) |
| CLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then CLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**H gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**H and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = x**H*w. | |
| pure subroutine, public | la_zlaic1 (job, j, x, sest, w, gamma, sestpr, s, c) |
| ZLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then ZLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**H gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**H and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = x**H * w. | |
| pure subroutine, public | la_wlaic1 (job, j, x, sest, w, gamma, sestpr, s, c) |
| WLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then WLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**H gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**H and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = x**H * w. | |
| pure subroutine, public | la_clals0 (icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info) |
| CLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L). | |
| pure subroutine, public | la_zlals0 (icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info) |
| ZLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L). | |
| pure subroutine, public | la_wlals0 (icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info) |
| WLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L). | |
| pure subroutine, public | la_clalsa (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info) |
| CLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, CLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, CLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by CLALSA. | |
| pure subroutine, public | la_zlalsa (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info) |
| ZLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, ZLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, ZLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by ZLALSA. | |
| pure subroutine, public | la_wlalsa (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info) |
| WLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, WLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, WLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by WLALSA. | |
| pure subroutine, public | la_clalsd (uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info) |
| CLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, 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_zlalsd (uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info) |
| ZLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, 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_wlalsd (uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info) |
| WLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. | |
Detailed Description
Least-squares helpers: incremental condition estimation and divide-and-conquer back-substitution.
Function/Subroutine Documentation
◆ la_claic1()
| pure subroutine, public la_lapack_lsq_aux::la_claic1 | ( | integer(ilp), intent(in) | job, |
| integer(ilp), intent(in) | j, | ||
| complex(sp), dimension(j), intent(in) | x, | ||
| real(sp), intent(in) | sest, | ||
| complex(sp), dimension(j), intent(in) | w, | ||
| complex(sp), intent(in) | gamma, | ||
| real(sp), intent(out) | sestpr, | ||
| complex(sp), intent(out) | s, | ||
| complex(sp), intent(out) | c ) |
CLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then CLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**H gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**H and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = x**H*w.
◆ la_clals0()
| pure subroutine, public la_lapack_lsq_aux::la_clals0 | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | nl, | ||
| integer(ilp), intent(in) | nr, | ||
| integer(ilp), intent(in) | sqre, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| integer(ilp), dimension(*), intent(in) | perm, | ||
| integer(ilp), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| real(sp), dimension(ldgnum,*), intent(in) | givnum, | ||
| integer(ilp), intent(in) | ldgnum, | ||
| real(sp), dimension(ldgnum,*), intent(in) | poles, | ||
| real(sp), dimension(*), intent(in) | difl, | ||
| real(sp), dimension(ldgnum,*), intent(in) | difr, | ||
| real(sp), dimension( *), intent(in) | z, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), intent(in) | c, | ||
| real(sp), intent(in) | s, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
CLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).
◆ la_clalsa()
| pure subroutine, public la_lapack_lsq_aux::la_clalsa | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| real(sp), dimension(ldu,*), intent(in) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(sp), dimension(ldu,*), intent(in) | vt, | ||
| integer(ilp), dimension(*), intent(in) | k, | ||
| real(sp), dimension(ldu,*), intent(in) | difl, | ||
| real(sp), dimension(ldu,*), intent(in) | difr, | ||
| real(sp), dimension(ldu,*), intent(in) | z, | ||
| real(sp), dimension(ldu,*), intent(in) | poles, | ||
| integer(ilp), dimension(*), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | perm, | ||
| real(sp), dimension(ldu,*), intent(in) | givnum, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| real(sp), dimension( *), intent(in) | s, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
CLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, CLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, CLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by CLALSA.
◆ la_clalsd()
| pure subroutine, public la_lapack_lsq_aux::la_clalsd | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(*), intent(inout) | d, | ||
| real(sp), dimension(*), intent(inout) | e, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), intent(in) | rcond, | ||
| integer(ilp), intent(out) | rank, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
CLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
◆ la_dlaic1()
| pure subroutine, public la_lapack_lsq_aux::la_dlaic1 | ( | integer(ilp), intent(in) | job, |
| integer(ilp), intent(in) | j, | ||
| real(dp), dimension(j), intent(in) | x, | ||
| real(dp), intent(in) | sest, | ||
| real(dp), dimension(j), intent(in) | w, | ||
| real(dp), intent(in) | gamma, | ||
| real(dp), intent(out) | sestpr, | ||
| real(dp), intent(out) | s, | ||
| real(dp), intent(out) | c ) |
DLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then DLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**T gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**T and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ alpha ] [ gamma ] where alpha = x**T*w.
◆ la_dlals0()
| pure subroutine, public la_lapack_lsq_aux::la_dlals0 | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | nl, | ||
| integer(ilp), intent(in) | nr, | ||
| integer(ilp), intent(in) | sqre, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| integer(ilp), dimension(*), intent(in) | perm, | ||
| integer(ilp), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| real(dp), dimension(ldgnum,*), intent(in) | givnum, | ||
| integer(ilp), intent(in) | ldgnum, | ||
| real(dp), dimension(ldgnum,*), intent(in) | poles, | ||
| real(dp), dimension(*), intent(in) | difl, | ||
| real(dp), dimension(ldgnum,*), intent(in) | difr, | ||
| real(dp), dimension( *), intent(in) | z, | ||
| integer(ilp), intent(in) | k, | ||
| real(dp), intent(in) | c, | ||
| real(dp), intent(in) | s, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
DLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).
◆ la_dlalsa()
| pure subroutine, public la_lapack_lsq_aux::la_dlalsa | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| real(dp), dimension(ldu,*), intent(in) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(dp), dimension(ldu,*), intent(in) | vt, | ||
| integer(ilp), dimension(*), intent(in) | k, | ||
| real(dp), dimension(ldu,*), intent(in) | difl, | ||
| real(dp), dimension(ldu,*), intent(in) | difr, | ||
| real(dp), dimension(ldu,*), intent(in) | z, | ||
| real(dp), dimension(ldu,*), intent(in) | poles, | ||
| integer(ilp), dimension(*), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | perm, | ||
| real(dp), dimension(ldu,*), intent(in) | givnum, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| real(dp), dimension( *), intent(in) | s, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, DLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, DLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by DLALSA.
◆ la_dlalsd()
| pure subroutine, public la_lapack_lsq_aux::la_dlalsd | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(*), intent(inout) | d, | ||
| real(dp), dimension(*), intent(inout) | e, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), intent(in) | rcond, | ||
| integer(ilp), intent(out) | rank, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
◆ la_qlaic1()
| pure subroutine, public la_lapack_lsq_aux::la_qlaic1 | ( | integer(ilp), intent(in) | job, |
| integer(ilp), intent(in) | j, | ||
| real(qp), dimension(j), intent(in) | x, | ||
| real(qp), intent(in) | sest, | ||
| real(qp), dimension(j), intent(in) | w, | ||
| real(qp), intent(in) | gamma, | ||
| real(qp), intent(out) | sestpr, | ||
| real(qp), intent(out) | s, | ||
| real(qp), intent(out) | c ) |
QLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then QLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**T gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**T and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ alpha ] [ gamma ] where alpha = x**T*w.
◆ la_qlals0()
| pure subroutine, public la_lapack_lsq_aux::la_qlals0 | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | nl, | ||
| integer(ilp), intent(in) | nr, | ||
| integer(ilp), intent(in) | sqre, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| integer(ilp), dimension(*), intent(in) | perm, | ||
| integer(ilp), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| real(qp), dimension(ldgnum,*), intent(in) | givnum, | ||
| integer(ilp), intent(in) | ldgnum, | ||
| real(qp), dimension(ldgnum,*), intent(in) | poles, | ||
| real(qp), dimension(*), intent(in) | difl, | ||
| real(qp), dimension(ldgnum,*), intent(in) | difr, | ||
| real(qp), dimension( *), intent(in) | z, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), intent(in) | c, | ||
| real(qp), intent(in) | s, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).
◆ la_qlalsa()
| pure subroutine, public la_lapack_lsq_aux::la_qlalsa | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| real(qp), dimension(ldu,*), intent(in) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(qp), dimension(ldu,*), intent(in) | vt, | ||
| integer(ilp), dimension(*), intent(in) | k, | ||
| real(qp), dimension(ldu,*), intent(in) | difl, | ||
| real(qp), dimension(ldu,*), intent(in) | difr, | ||
| real(qp), dimension(ldu,*), intent(in) | z, | ||
| real(qp), dimension(ldu,*), intent(in) | poles, | ||
| integer(ilp), dimension(*), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | perm, | ||
| real(qp), dimension(ldu,*), intent(in) | givnum, | ||
| real(qp), dimension(*), intent(in) | c, | ||
| real(qp), dimension( *), intent(in) | s, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, QLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, QLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by QLALSA.
◆ la_qlalsd()
| pure subroutine, public la_lapack_lsq_aux::la_qlalsd | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(inout) | d, | ||
| real(qp), dimension(*), intent(inout) | e, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(in) | rcond, | ||
| integer(ilp), intent(out) | rank, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
◆ la_slaic1()
| pure subroutine, public la_lapack_lsq_aux::la_slaic1 | ( | integer(ilp), intent(in) | job, |
| integer(ilp), intent(in) | j, | ||
| real(sp), dimension(j), intent(in) | x, | ||
| real(sp), intent(in) | sest, | ||
| real(sp), dimension(j), intent(in) | w, | ||
| real(sp), intent(in) | gamma, | ||
| real(sp), intent(out) | sestpr, | ||
| real(sp), intent(out) | s, | ||
| real(sp), intent(out) | c ) |
SLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then SLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**T gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**T and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ alpha ] [ gamma ] where alpha = x**T*w.
◆ la_slals0()
| pure subroutine, public la_lapack_lsq_aux::la_slals0 | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | nl, | ||
| integer(ilp), intent(in) | nr, | ||
| integer(ilp), intent(in) | sqre, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| integer(ilp), dimension(*), intent(in) | perm, | ||
| integer(ilp), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| real(sp), dimension(ldgnum,*), intent(in) | givnum, | ||
| integer(ilp), intent(in) | ldgnum, | ||
| real(sp), dimension(ldgnum,*), intent(in) | poles, | ||
| real(sp), dimension(*), intent(in) | difl, | ||
| real(sp), dimension(ldgnum,*), intent(in) | difr, | ||
| real(sp), dimension( *), intent(in) | z, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), intent(in) | c, | ||
| real(sp), intent(in) | s, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
SLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).
◆ la_slalsa()
| pure subroutine, public la_lapack_lsq_aux::la_slalsa | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| real(sp), dimension(ldu,*), intent(in) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(sp), dimension(ldu,*), intent(in) | vt, | ||
| integer(ilp), dimension(*), intent(in) | k, | ||
| real(sp), dimension(ldu,*), intent(in) | difl, | ||
| real(sp), dimension(ldu,*), intent(in) | difr, | ||
| real(sp), dimension(ldu,*), intent(in) | z, | ||
| real(sp), dimension(ldu,*), intent(in) | poles, | ||
| integer(ilp), dimension(*), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | perm, | ||
| real(sp), dimension(ldu,*), intent(in) | givnum, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| real(sp), dimension( *), intent(in) | s, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, SLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, SLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by SLALSA.
◆ la_slalsd()
| pure subroutine, public la_lapack_lsq_aux::la_slalsd | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(*), intent(inout) | d, | ||
| real(sp), dimension(*), intent(inout) | e, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), intent(in) | rcond, | ||
| integer(ilp), intent(out) | rank, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
◆ la_wlaic1()
| pure subroutine, public la_lapack_lsq_aux::la_wlaic1 | ( | integer(ilp), intent(in) | job, |
| integer(ilp), intent(in) | j, | ||
| complex(qp), dimension(j), intent(in) | x, | ||
| real(qp), intent(in) | sest, | ||
| complex(qp), dimension(j), intent(in) | w, | ||
| complex(qp), intent(in) | gamma, | ||
| real(qp), intent(out) | sestpr, | ||
| complex(qp), intent(out) | s, | ||
| complex(qp), intent(out) | c ) |
WLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then WLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**H gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**H and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = x**H * w.
◆ la_wlals0()
| pure subroutine, public la_lapack_lsq_aux::la_wlals0 | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | nl, | ||
| integer(ilp), intent(in) | nr, | ||
| integer(ilp), intent(in) | sqre, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| integer(ilp), dimension(*), intent(in) | perm, | ||
| integer(ilp), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| real(qp), dimension(ldgnum,*), intent(in) | givnum, | ||
| integer(ilp), intent(in) | ldgnum, | ||
| real(qp), dimension(ldgnum,*), intent(in) | poles, | ||
| real(qp), dimension(*), intent(in) | difl, | ||
| real(qp), dimension(ldgnum,*), intent(in) | difr, | ||
| real(qp), dimension( *), intent(in) | z, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), intent(in) | c, | ||
| real(qp), intent(in) | s, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).
◆ la_wlalsa()
| pure subroutine, public la_lapack_lsq_aux::la_wlalsa | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| real(qp), dimension(ldu,*), intent(in) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(qp), dimension(ldu,*), intent(in) | vt, | ||
| integer(ilp), dimension(*), intent(in) | k, | ||
| real(qp), dimension(ldu,*), intent(in) | difl, | ||
| real(qp), dimension(ldu,*), intent(in) | difr, | ||
| real(qp), dimension(ldu,*), intent(in) | z, | ||
| real(qp), dimension(ldu,*), intent(in) | poles, | ||
| integer(ilp), dimension(*), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | perm, | ||
| real(qp), dimension(ldu,*), intent(in) | givnum, | ||
| real(qp), dimension(*), intent(in) | c, | ||
| real(qp), dimension( *), intent(in) | s, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
WLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, WLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, WLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by WLALSA.
◆ la_wlalsd()
| pure subroutine, public la_lapack_lsq_aux::la_wlalsd | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(inout) | d, | ||
| real(qp), dimension(*), intent(inout) | e, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(in) | rcond, | ||
| integer(ilp), intent(out) | rank, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
WLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
◆ la_zlaic1()
| pure subroutine, public la_lapack_lsq_aux::la_zlaic1 | ( | integer(ilp), intent(in) | job, |
| integer(ilp), intent(in) | j, | ||
| complex(dp), dimension(j), intent(in) | x, | ||
| real(dp), intent(in) | sest, | ||
| complex(dp), dimension(j), intent(in) | w, | ||
| complex(dp), intent(in) | gamma, | ||
| real(dp), intent(out) | sestpr, | ||
| complex(dp), intent(out) | s, | ||
| complex(dp), intent(out) | c ) |
ZLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then ZLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**H gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**H and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = x**H * w.
◆ la_zlals0()
| pure subroutine, public la_lapack_lsq_aux::la_zlals0 | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | nl, | ||
| integer(ilp), intent(in) | nr, | ||
| integer(ilp), intent(in) | sqre, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| integer(ilp), dimension(*), intent(in) | perm, | ||
| integer(ilp), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| real(dp), dimension(ldgnum,*), intent(in) | givnum, | ||
| integer(ilp), intent(in) | ldgnum, | ||
| real(dp), dimension(ldgnum,*), intent(in) | poles, | ||
| real(dp), dimension(*), intent(in) | difl, | ||
| real(dp), dimension(ldgnum,*), intent(in) | difr, | ||
| real(dp), dimension( *), intent(in) | z, | ||
| integer(ilp), intent(in) | k, | ||
| real(dp), intent(in) | c, | ||
| real(dp), intent(in) | s, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
ZLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).
◆ la_zlalsa()
| pure subroutine, public la_lapack_lsq_aux::la_zlalsa | ( | integer(ilp), intent(in) | icompq, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldbx,*), intent(out) | bx, | ||
| integer(ilp), intent(in) | ldbx, | ||
| real(dp), dimension(ldu,*), intent(in) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| real(dp), dimension(ldu,*), intent(in) | vt, | ||
| integer(ilp), dimension(*), intent(in) | k, | ||
| real(dp), dimension(ldu,*), intent(in) | difl, | ||
| real(dp), dimension(ldu,*), intent(in) | difr, | ||
| real(dp), dimension(ldu,*), intent(in) | z, | ||
| real(dp), dimension(ldu,*), intent(in) | poles, | ||
| integer(ilp), dimension(*), intent(in) | givptr, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | givcol, | ||
| integer(ilp), intent(in) | ldgcol, | ||
| integer(ilp), dimension(ldgcol,*), intent(in) | perm, | ||
| real(dp), dimension(ldu,*), intent(in) | givnum, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| real(dp), dimension( *), intent(in) | s, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
ZLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, ZLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, ZLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by ZLALSA.
◆ la_zlalsd()
| pure subroutine, public la_lapack_lsq_aux::la_zlalsd | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | smlsiz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(*), intent(inout) | d, | ||
| real(dp), dimension(*), intent(inout) | e, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), intent(in) | rcond, | ||
| integer(ilp), intent(out) | rank, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
ZLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code 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 XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
