SVD components: bidiagonal reduction, 2-by-2 singular values, Jacobi generators. More...
Functions/Subroutines | |
| pure subroutine, public | la_slartgs (x, y, sigma, cs, sn) |
| SLARTGS: generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2. | |
| pure subroutine, public | la_dlartgs (x, y, sigma, cs, sn) |
| DLARTGS: generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2. | |
| pure subroutine, public | la_qlartgs (x, y, sigma, cs, sn) |
| QLARTGS: generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2. | |
| pure subroutine, public | la_slas2 (f, g, h, ssmin, ssmax) |
| SLAS2: computes the singular values of the 2-by-2 matrix [ F G ] [ 0 H ]. On return, SSMIN is the smaller singular value and SSMAX is the larger singular value. | |
| pure subroutine, public | la_dlas2 (f, g, h, ssmin, ssmax) |
| DLAS2: computes the singular values of the 2-by-2 matrix [ F G ] [ 0 H ]. On return, SSMIN is the smaller singular value and SSMAX is the larger singular value. | |
| pure subroutine, public | la_qlas2 (f, g, h, ssmin, ssmax) |
| QLAS2: computes the singular values of the 2-by-2 matrix [ F G ] [ 0 H ]. On return, SSMIN is the smaller singular value and SSMAX is the larger singular value. | |
| pure subroutine, public | la_slasv2 (f, g, h, ssmin, ssmax, snr, csr, snl, csl) |
| SLASV2: computes the singular value decomposition of a 2-by-2 triangular matrix [ F G ] [ 0 H ]. On return, abs(SSMAX) is the larger singular value, abs(SSMIN) is the smaller singular value, and (CSL,SNL) and (CSR,SNR) are the left and right singular vectors for abs(SSMAX), giving the decomposition [ CSL SNL ] [ F G ] [ CSR -SNR ] = [ SSMAX 0 ] [-SNL CSL ] [ 0 H ] [ SNR CSR ] [ 0 SSMIN ]. | |
| pure subroutine, public | la_dlasv2 (f, g, h, ssmin, ssmax, snr, csr, snl, csl) |
| DLASV2: computes the singular value decomposition of a 2-by-2 triangular matrix [ F G ] [ 0 H ]. On return, abs(SSMAX) is the larger singular value, abs(SSMIN) is the smaller singular value, and (CSL,SNL) and (CSR,SNR) are the left and right singular vectors for abs(SSMAX), giving the decomposition [ CSL SNL ] [ F G ] [ CSR -SNR ] = [ SSMAX 0 ] [-SNL CSL ] [ 0 H ] [ SNR CSR ] [ 0 SSMIN ]. | |
| pure subroutine, public | la_qlasv2 (f, g, h, ssmin, ssmax, snr, csr, snl, csl) |
| QLASV2: computes the singular value decomposition of a 2-by-2 triangular matrix [ F G ] [ 0 H ]. On return, abs(SSMAX) is the larger singular value, abs(SSMIN) is the smaller singular value, and (CSL,SNL) and (CSR,SNR) are the left and right singular vectors for abs(SSMAX), giving the decomposition [ CSL SNL ] [ F G ] [ CSR -SNR ] = [ SSMAX 0 ] [-SNL CSL ] [ 0 H ] [ SNR CSR ] [ 0 SSMIN ]. | |
| pure subroutine, public | la_slags2 (upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) |
| SLAGS2: computes 2-by-2 orthogonal matrices U, V and Q, such that if ( UPPER ) then U**T A*Q = U**T *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**T*B*Q = V**T *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**T *A*Q = U**T *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**T*B*Q = V**T( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) The rows of the transformed A and B are parallel, where U = ( CSU SNU ), V = ( CSV SNV ), Q = ( CSQ SNQ ) ( -SNU CSU ) ( -SNV CSV ) ( -SNQ CSQ ) Z**T denotes the transpose of Z. | |
| pure subroutine, public | la_dlags2 (upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) |
| DLAGS2: computes 2-by-2 orthogonal matrices U, V and Q, such that if ( UPPER ) then U**T A*Q = U**T *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**T*B*Q = V**T *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**T *A*Q = U**T *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**T*B*Q = V**T( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) The rows of the transformed A and B are parallel, where U = ( CSU SNU ), V = ( CSV SNV ), Q = ( CSQ SNQ ) ( -SNU CSU ) ( -SNV CSV ) ( -SNQ CSQ ) Z**T denotes the transpose of Z. | |
| pure subroutine, public | la_qlags2 (upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) |
| QLAGS2: computes 2-by-2 orthogonal matrices U, V and Q, such that if ( UPPER ) then U**T A*Q = U**T *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**T*B*Q = V**T *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**T *A*Q = U**T *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**T*B*Q = V**T( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) The rows of the transformed A and B are parallel, where U = ( CSU SNU ), V = ( CSV SNV ), Q = ( CSQ SNQ ) ( -SNU CSU ) ( -SNV CSV ) ( -SNQ CSQ ) Z**T denotes the transpose of Z. | |
| pure subroutine, public | la_slabrd (m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) |
| SLABRD: reduces the first NB rows and columns of a real general m by n matrix A to upper or lower bidiagonal form by an orthogonal transformation Q**T * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by SGEBRD. | |
| pure subroutine, public | la_dlabrd (m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) |
| DLABRD: reduces the first NB rows and columns of a real general m by n matrix A to upper or lower bidiagonal form by an orthogonal transformation Q**T * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by DGEBRD. | |
| pure subroutine, public | la_qlabrd (m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) |
| QLABRD: reduces the first NB rows and columns of a real general m by n matrix A to upper or lower bidiagonal form by an orthogonal transformation Q**T * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by QGEBRD. | |
| pure subroutine, public | la_slapll (n, x, incx, y, incy, ssmin) |
| Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y. | |
| pure subroutine, public | la_dlapll (n, x, incx, y, incy, ssmin) |
| Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y. | |
| pure subroutine, public | la_qlapll (n, x, incx, y, incy, ssmin) |
| Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y. | |
| pure subroutine, public | la_clabrd (m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) |
| CLABRD: reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by CGEBRD. | |
| pure subroutine, public | la_zlabrd (m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) |
| ZLABRD: reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by ZGEBRD. | |
| pure subroutine, public | la_wlabrd (m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) |
| WLABRD: reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by WGEBRD. | |
| pure subroutine, public | la_clags2 (upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) |
| CLAGS2: computes 2-by-2 unitary matrices U, V and Q, such that if ( UPPER ) then U**H *A*Q = U**H *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**H*B*Q = V**H *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**H *A*Q = U**H *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**H *B*Q = V**H *( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) where U = ( CSU SNU ), V = ( CSV SNV ), ( -SNU**H CSU ) ( -SNV**H CSV ) Q = ( CSQ SNQ ) ( -SNQ**H CSQ ) The rows of the transformed A and B are parallel. Moreover, if the input 2-by-2 matrix A is not zero, then the transformed (1,1) entry of A is not zero. If the input matrices A and B are both not zero, then the transformed (2,2) element of B is not zero, except when the first rows of input A and B are parallel and the second rows are zero. | |
| pure subroutine, public | la_zlags2 (upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) |
| ZLAGS2: computes 2-by-2 unitary matrices U, V and Q, such that if ( UPPER ) then U**H *A*Q = U**H *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**H*B*Q = V**H *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**H *A*Q = U**H *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**H *B*Q = V**H *( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) where U = ( CSU SNU ), V = ( CSV SNV ), ( -SNU**H CSU ) ( -SNV**H CSV ) Q = ( CSQ SNQ ) ( -SNQ**H CSQ ) The rows of the transformed A and B are parallel. Moreover, if the input 2-by-2 matrix A is not zero, then the transformed (1,1) entry of A is not zero. If the input matrices A and B are both not zero, then the transformed (2,2) element of B is not zero, except when the first rows of input A and B are parallel and the second rows are zero. | |
| pure subroutine, public | la_wlags2 (upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) |
| WLAGS2: computes 2-by-2 unitary matrices U, V and Q, such that if ( UPPER ) then U**H *A*Q = U**H *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**H*B*Q = V**H *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**H *A*Q = U**H *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**H *B*Q = V**H *( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) where U = ( CSU SNU ), V = ( CSV SNV ), ( -SNU**H CSU ) ( -SNV**H CSV ) Q = ( CSQ SNQ ) ( -SNQ**H CSQ ) The rows of the transformed A and B are parallel. Moreover, if the input 2-by-2 matrix A is not zero, then the transformed (1,1) entry of A is not zero. If the input matrices A and B are both not zero, then the transformed (2,2) element of B is not zero, except when the first rows of input A and B are parallel and the second rows are zero. | |
| pure subroutine, public | la_clapll (n, x, incx, y, incy, ssmin) |
| Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y. | |
| pure subroutine, public | la_zlapll (n, x, incx, y, incy, ssmin) |
| Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y. | |
| pure subroutine, public | la_wlapll (n, x, incx, y, incy, ssmin) |
| Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y. | |
Detailed Description
SVD components: bidiagonal reduction, 2-by-2 singular values, Jacobi generators.
Function/Subroutine Documentation
◆ la_clabrd()
| pure subroutine, public la_lapack_svd_comp2::la_clabrd | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nb, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | d, | ||
| real(sp), dimension(*), intent(out) | e, | ||
| complex(sp), dimension(*), intent(out) | tauq, | ||
| complex(sp), dimension(*), intent(out) | taup, | ||
| complex(sp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| complex(sp), dimension(ldy,*), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
CLABRD: reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by CGEBRD.
◆ la_clags2()
| pure subroutine, public la_lapack_svd_comp2::la_clags2 | ( | logical(lk), intent(in) | upper, |
| real(sp), intent(in) | a1, | ||
| complex(sp), intent(in) | a2, | ||
| real(sp), intent(in) | a3, | ||
| real(sp), intent(in) | b1, | ||
| complex(sp), intent(in) | b2, | ||
| real(sp), intent(in) | b3, | ||
| real(sp), intent(out) | csu, | ||
| complex(sp), intent(out) | snu, | ||
| real(sp), intent(out) | csv, | ||
| complex(sp), intent(out) | snv, | ||
| real(sp), intent(out) | csq, | ||
| complex(sp), intent(out) | snq ) |
CLAGS2: computes 2-by-2 unitary matrices U, V and Q, such that if ( UPPER ) then U**H *A*Q = U**H *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**H*B*Q = V**H *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**H *A*Q = U**H *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**H *B*Q = V**H *( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) where U = ( CSU SNU ), V = ( CSV SNV ), ( -SNU**H CSU ) ( -SNV**H CSV ) Q = ( CSQ SNQ ) ( -SNQ**H CSQ ) The rows of the transformed A and B are parallel. Moreover, if the input 2-by-2 matrix A is not zero, then the transformed (1,1) entry of A is not zero. If the input matrices A and B are both not zero, then the transformed (2,2) element of B is not zero, except when the first rows of input A and B are parallel and the second rows are zero.
◆ la_clapll()
| pure subroutine, public la_lapack_svd_comp2::la_clapll | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(sp), intent(out) | ssmin ) |
Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.
◆ la_dlabrd()
| pure subroutine, public la_lapack_svd_comp2::la_dlabrd | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nb, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | d, | ||
| real(dp), dimension(*), intent(out) | e, | ||
| real(dp), dimension(*), intent(out) | tauq, | ||
| real(dp), dimension(*), intent(out) | taup, | ||
| real(dp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(dp), dimension(ldy,*), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
DLABRD: reduces the first NB rows and columns of a real general m by n matrix A to upper or lower bidiagonal form by an orthogonal transformation Q**T * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by DGEBRD.
◆ la_dlags2()
| pure subroutine, public la_lapack_svd_comp2::la_dlags2 | ( | logical(lk), intent(in) | upper, |
| real(dp), intent(in) | a1, | ||
| real(dp), intent(in) | a2, | ||
| real(dp), intent(in) | a3, | ||
| real(dp), intent(in) | b1, | ||
| real(dp), intent(in) | b2, | ||
| real(dp), intent(in) | b3, | ||
| real(dp), intent(out) | csu, | ||
| real(dp), intent(out) | snu, | ||
| real(dp), intent(out) | csv, | ||
| real(dp), intent(out) | snv, | ||
| real(dp), intent(out) | csq, | ||
| real(dp), intent(out) | snq ) |
DLAGS2: computes 2-by-2 orthogonal matrices U, V and Q, such that if ( UPPER ) then U**T A*Q = U**T *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**T*B*Q = V**T *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**T *A*Q = U**T *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**T*B*Q = V**T( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) The rows of the transformed A and B are parallel, where U = ( CSU SNU ), V = ( CSV SNV ), Q = ( CSQ SNQ ) ( -SNU CSU ) ( -SNV CSV ) ( -SNQ CSQ ) Z**T denotes the transpose of Z.
◆ la_dlapll()
| pure subroutine, public la_lapack_svd_comp2::la_dlapll | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(dp), intent(out) | ssmin ) |
Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.
◆ la_dlartgs()
| pure subroutine, public la_lapack_svd_comp2::la_dlartgs | ( | real(dp), intent(in) | x, |
| real(dp), intent(in) | y, | ||
| real(dp), intent(in) | sigma, | ||
| real(dp), intent(out) | cs, | ||
| real(dp), intent(out) | sn ) |
DLARTGS: generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2.
◆ la_dlas2()
| pure subroutine, public la_lapack_svd_comp2::la_dlas2 | ( | real(dp), intent(in) | f, |
| real(dp), intent(in) | g, | ||
| real(dp), intent(in) | h, | ||
| real(dp), intent(out) | ssmin, | ||
| real(dp), intent(out) | ssmax ) |
DLAS2: computes the singular values of the 2-by-2 matrix [ F G ] [ 0 H ]. On return, SSMIN is the smaller singular value and SSMAX is the larger singular value.
◆ la_dlasv2()
| pure subroutine, public la_lapack_svd_comp2::la_dlasv2 | ( | real(dp), intent(in) | f, |
| real(dp), intent(in) | g, | ||
| real(dp), intent(in) | h, | ||
| real(dp), intent(out) | ssmin, | ||
| real(dp), intent(out) | ssmax, | ||
| real(dp), intent(out) | snr, | ||
| real(dp), intent(out) | csr, | ||
| real(dp), intent(out) | snl, | ||
| real(dp), intent(out) | csl ) |
DLASV2: computes the singular value decomposition of a 2-by-2 triangular matrix [ F G ] [ 0 H ]. On return, abs(SSMAX) is the larger singular value, abs(SSMIN) is the smaller singular value, and (CSL,SNL) and (CSR,SNR) are the left and right singular vectors for abs(SSMAX), giving the decomposition [ CSL SNL ] [ F G ] [ CSR -SNR ] = [ SSMAX 0 ] [-SNL CSL ] [ 0 H ] [ SNR CSR ] [ 0 SSMIN ].
◆ la_qlabrd()
| pure subroutine, public la_lapack_svd_comp2::la_qlabrd | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nb, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | d, | ||
| real(qp), dimension(*), intent(out) | e, | ||
| real(qp), dimension(*), intent(out) | tauq, | ||
| real(qp), dimension(*), intent(out) | taup, | ||
| real(qp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(ldy,*), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
QLABRD: reduces the first NB rows and columns of a real general m by n matrix A to upper or lower bidiagonal form by an orthogonal transformation Q**T * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by QGEBRD.
◆ la_qlags2()
| pure subroutine, public la_lapack_svd_comp2::la_qlags2 | ( | logical(lk), intent(in) | upper, |
| real(qp), intent(in) | a1, | ||
| real(qp), intent(in) | a2, | ||
| real(qp), intent(in) | a3, | ||
| real(qp), intent(in) | b1, | ||
| real(qp), intent(in) | b2, | ||
| real(qp), intent(in) | b3, | ||
| real(qp), intent(out) | csu, | ||
| real(qp), intent(out) | snu, | ||
| real(qp), intent(out) | csv, | ||
| real(qp), intent(out) | snv, | ||
| real(qp), intent(out) | csq, | ||
| real(qp), intent(out) | snq ) |
QLAGS2: computes 2-by-2 orthogonal matrices U, V and Q, such that if ( UPPER ) then U**T A*Q = U**T *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**T*B*Q = V**T *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**T *A*Q = U**T *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**T*B*Q = V**T( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) The rows of the transformed A and B are parallel, where U = ( CSU SNU ), V = ( CSV SNV ), Q = ( CSQ SNQ ) ( -SNU CSU ) ( -SNV CSV ) ( -SNQ CSQ ) Z**T denotes the transpose of Z.
◆ la_qlapll()
| pure subroutine, public la_lapack_svd_comp2::la_qlapll | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(qp), intent(out) | ssmin ) |
Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.
◆ la_qlartgs()
| pure subroutine, public la_lapack_svd_comp2::la_qlartgs | ( | real(qp), intent(in) | x, |
| real(qp), intent(in) | y, | ||
| real(qp), intent(in) | sigma, | ||
| real(qp), intent(out) | cs, | ||
| real(qp), intent(out) | sn ) |
QLARTGS: generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2.
◆ la_qlas2()
| pure subroutine, public la_lapack_svd_comp2::la_qlas2 | ( | real(qp), intent(in) | f, |
| real(qp), intent(in) | g, | ||
| real(qp), intent(in) | h, | ||
| real(qp), intent(out) | ssmin, | ||
| real(qp), intent(out) | ssmax ) |
QLAS2: computes the singular values of the 2-by-2 matrix [ F G ] [ 0 H ]. On return, SSMIN is the smaller singular value and SSMAX is the larger singular value.
◆ la_qlasv2()
| pure subroutine, public la_lapack_svd_comp2::la_qlasv2 | ( | real(qp), intent(in) | f, |
| real(qp), intent(in) | g, | ||
| real(qp), intent(in) | h, | ||
| real(qp), intent(out) | ssmin, | ||
| real(qp), intent(out) | ssmax, | ||
| real(qp), intent(out) | snr, | ||
| real(qp), intent(out) | csr, | ||
| real(qp), intent(out) | snl, | ||
| real(qp), intent(out) | csl ) |
QLASV2: computes the singular value decomposition of a 2-by-2 triangular matrix [ F G ] [ 0 H ]. On return, abs(SSMAX) is the larger singular value, abs(SSMIN) is the smaller singular value, and (CSL,SNL) and (CSR,SNR) are the left and right singular vectors for abs(SSMAX), giving the decomposition [ CSL SNL ] [ F G ] [ CSR -SNR ] = [ SSMAX 0 ] [-SNL CSL ] [ 0 H ] [ SNR CSR ] [ 0 SSMIN ].
◆ la_slabrd()
| pure subroutine, public la_lapack_svd_comp2::la_slabrd | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nb, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | d, | ||
| real(sp), dimension(*), intent(out) | e, | ||
| real(sp), dimension(*), intent(out) | tauq, | ||
| real(sp), dimension(*), intent(out) | taup, | ||
| real(sp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(sp), dimension(ldy,*), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
SLABRD: reduces the first NB rows and columns of a real general m by n matrix A to upper or lower bidiagonal form by an orthogonal transformation Q**T * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by SGEBRD.
◆ la_slags2()
| pure subroutine, public la_lapack_svd_comp2::la_slags2 | ( | logical(lk), intent(in) | upper, |
| real(sp), intent(in) | a1, | ||
| real(sp), intent(in) | a2, | ||
| real(sp), intent(in) | a3, | ||
| real(sp), intent(in) | b1, | ||
| real(sp), intent(in) | b2, | ||
| real(sp), intent(in) | b3, | ||
| real(sp), intent(out) | csu, | ||
| real(sp), intent(out) | snu, | ||
| real(sp), intent(out) | csv, | ||
| real(sp), intent(out) | snv, | ||
| real(sp), intent(out) | csq, | ||
| real(sp), intent(out) | snq ) |
SLAGS2: computes 2-by-2 orthogonal matrices U, V and Q, such that if ( UPPER ) then U**T A*Q = U**T *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**T*B*Q = V**T *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**T *A*Q = U**T *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**T*B*Q = V**T( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) The rows of the transformed A and B are parallel, where U = ( CSU SNU ), V = ( CSV SNV ), Q = ( CSQ SNQ ) ( -SNU CSU ) ( -SNV CSV ) ( -SNQ CSQ ) Z**T denotes the transpose of Z.
◆ la_slapll()
| pure subroutine, public la_lapack_svd_comp2::la_slapll | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(sp), intent(out) | ssmin ) |
Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.
◆ la_slartgs()
| pure subroutine, public la_lapack_svd_comp2::la_slartgs | ( | real(sp), intent(in) | x, |
| real(sp), intent(in) | y, | ||
| real(sp), intent(in) | sigma, | ||
| real(sp), intent(out) | cs, | ||
| real(sp), intent(out) | sn ) |
SLARTGS: generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2.
◆ la_slas2()
| pure subroutine, public la_lapack_svd_comp2::la_slas2 | ( | real(sp), intent(in) | f, |
| real(sp), intent(in) | g, | ||
| real(sp), intent(in) | h, | ||
| real(sp), intent(out) | ssmin, | ||
| real(sp), intent(out) | ssmax ) |
SLAS2: computes the singular values of the 2-by-2 matrix [ F G ] [ 0 H ]. On return, SSMIN is the smaller singular value and SSMAX is the larger singular value.
◆ la_slasv2()
| pure subroutine, public la_lapack_svd_comp2::la_slasv2 | ( | real(sp), intent(in) | f, |
| real(sp), intent(in) | g, | ||
| real(sp), intent(in) | h, | ||
| real(sp), intent(out) | ssmin, | ||
| real(sp), intent(out) | ssmax, | ||
| real(sp), intent(out) | snr, | ||
| real(sp), intent(out) | csr, | ||
| real(sp), intent(out) | snl, | ||
| real(sp), intent(out) | csl ) |
SLASV2: computes the singular value decomposition of a 2-by-2 triangular matrix [ F G ] [ 0 H ]. On return, abs(SSMAX) is the larger singular value, abs(SSMIN) is the smaller singular value, and (CSL,SNL) and (CSR,SNR) are the left and right singular vectors for abs(SSMAX), giving the decomposition [ CSL SNL ] [ F G ] [ CSR -SNR ] = [ SSMAX 0 ] [-SNL CSL ] [ 0 H ] [ SNR CSR ] [ 0 SSMIN ].
◆ la_wlabrd()
| pure subroutine, public la_lapack_svd_comp2::la_wlabrd | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nb, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | d, | ||
| real(qp), dimension(*), intent(out) | e, | ||
| complex(qp), dimension(*), intent(out) | tauq, | ||
| complex(qp), dimension(*), intent(out) | taup, | ||
| complex(qp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| complex(qp), dimension(ldy,*), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
WLABRD: reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by WGEBRD.
◆ la_wlags2()
| pure subroutine, public la_lapack_svd_comp2::la_wlags2 | ( | logical(lk), intent(in) | upper, |
| real(qp), intent(in) | a1, | ||
| complex(qp), intent(in) | a2, | ||
| real(qp), intent(in) | a3, | ||
| real(qp), intent(in) | b1, | ||
| complex(qp), intent(in) | b2, | ||
| real(qp), intent(in) | b3, | ||
| real(qp), intent(out) | csu, | ||
| complex(qp), intent(out) | snu, | ||
| real(qp), intent(out) | csv, | ||
| complex(qp), intent(out) | snv, | ||
| real(qp), intent(out) | csq, | ||
| complex(qp), intent(out) | snq ) |
WLAGS2: computes 2-by-2 unitary matrices U, V and Q, such that if ( UPPER ) then U**H *A*Q = U**H *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**H*B*Q = V**H *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**H *A*Q = U**H *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**H *B*Q = V**H *( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) where U = ( CSU SNU ), V = ( CSV SNV ), ( -SNU**H CSU ) ( -SNV**H CSV ) Q = ( CSQ SNQ ) ( -SNQ**H CSQ ) The rows of the transformed A and B are parallel. Moreover, if the input 2-by-2 matrix A is not zero, then the transformed (1,1) entry of A is not zero. If the input matrices A and B are both not zero, then the transformed (2,2) element of B is not zero, except when the first rows of input A and B are parallel and the second rows are zero.
◆ la_wlapll()
| pure subroutine, public la_lapack_svd_comp2::la_wlapll | ( | integer(ilp), intent(in) | n, |
| complex(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(qp), intent(out) | ssmin ) |
Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.
◆ la_zlabrd()
| pure subroutine, public la_lapack_svd_comp2::la_zlabrd | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nb, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | d, | ||
| real(dp), dimension(*), intent(out) | e, | ||
| complex(dp), dimension(*), intent(out) | tauq, | ||
| complex(dp), dimension(*), intent(out) | taup, | ||
| complex(dp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| complex(dp), dimension(ldy,*), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
ZLABRD: reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by ZGEBRD.
◆ la_zlags2()
| pure subroutine, public la_lapack_svd_comp2::la_zlags2 | ( | logical(lk), intent(in) | upper, |
| real(dp), intent(in) | a1, | ||
| complex(dp), intent(in) | a2, | ||
| real(dp), intent(in) | a3, | ||
| real(dp), intent(in) | b1, | ||
| complex(dp), intent(in) | b2, | ||
| real(dp), intent(in) | b3, | ||
| real(dp), intent(out) | csu, | ||
| complex(dp), intent(out) | snu, | ||
| real(dp), intent(out) | csv, | ||
| complex(dp), intent(out) | snv, | ||
| real(dp), intent(out) | csq, | ||
| complex(dp), intent(out) | snq ) |
ZLAGS2: computes 2-by-2 unitary matrices U, V and Q, such that if ( UPPER ) then U**H *A*Q = U**H *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**H*B*Q = V**H *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**H *A*Q = U**H *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**H *B*Q = V**H *( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) where U = ( CSU SNU ), V = ( CSV SNV ), ( -SNU**H CSU ) ( -SNV**H CSV ) Q = ( CSQ SNQ ) ( -SNQ**H CSQ ) The rows of the transformed A and B are parallel. Moreover, if the input 2-by-2 matrix A is not zero, then the transformed (1,1) entry of A is not zero. If the input matrices A and B are both not zero, then the transformed (2,2) element of B is not zero, except when the first rows of input A and B are parallel and the second rows are zero.
◆ la_zlapll()
| pure subroutine, public la_lapack_svd_comp2::la_zlapll | ( | integer(ilp), intent(in) | n, |
| complex(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(dp), intent(out) | ssmin ) |
Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.
