Cosine-sine decomposition: bidiagonal block form, simultaneous bidiagonalization, row and column permutations. More...
Functions/Subroutines | |
| pure subroutine, public | la_slapmr (forwrd, m, n, x, ldx, k) |
| SLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M. | |
| pure subroutine, public | la_dlapmr (forwrd, m, n, x, ldx, k) |
| DLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M. | |
| pure subroutine, public | la_qlapmr (forwrd, m, n, x, ldx, k) |
| QLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M. | |
| pure subroutine, public | la_slapmt (forwrd, m, n, x, ldx, k) |
| SLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N. | |
| pure subroutine, public | la_dlapmt (forwrd, m, n, x, ldx, k) |
| DLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N. | |
| pure subroutine, public | la_qlapmt (forwrd, m, n, x, ldx, k) |
| QLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N. | |
| pure subroutine, public | la_sorbdb6 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| SORBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned. | |
| pure subroutine, public | la_dorbdb6 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| DORBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned. | |
| pure subroutine, public | la_qorbdb6 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| QORBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned. | |
| pure subroutine, public | la_sbbcsd (jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, work, lwork, info) |
| SBBCSD: computes the CS decomposition of an orthogonal matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**T = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See SORCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The orthogonal matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices. | |
| pure subroutine, public | la_dbbcsd (jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, work, lwork, info) |
| DBBCSD: computes the CS decomposition of an orthogonal matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**T = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See DORCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The orthogonal matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices. | |
| pure subroutine, public | la_qbbcsd (jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, work, lwork, info) |
| QBBCSD: computes the CS decomposition of an orthogonal matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**T = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See QORCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The orthogonal matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices. | |
| subroutine, public | la_sorbdb (trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) |
| SORBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See SORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_dorbdb (trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) |
| DORBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See DORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_qorbdb (trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) |
| QORBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See QORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| pure subroutine, public | la_sorbdb5 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| SORBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way. | |
| pure subroutine, public | la_dorbdb5 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| DORBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way. | |
| pure subroutine, public | la_qorbdb5 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| QORBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way. | |
| recursive subroutine, public | la_sorcsd (jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, iwork, info) |
| SORCSD: computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). | |
| recursive subroutine, public | la_dorcsd (jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, iwork, info) |
| DORCSD: computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). | |
| recursive subroutine, public | la_qorcsd (jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, iwork, info) |
| QORCSD: computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). | |
| subroutine, public | la_sorbdb1 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| SORBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines SORBDB2, SORBDB3, and SORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_dorbdb1 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| DORBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines DORBDB2, DORBDB3, and DORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_qorbdb1 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| QORBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines QORBDB2, QORBDB3, and QORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_sorbdb2 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| SORBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines SORBDB1, SORBDB3, and SORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_dorbdb2 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| DORBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines DORBDB1, DORBDB3, and DORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_qorbdb2 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| QORBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines QORBDB1, QORBDB3, and QORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_sorbdb3 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| SORBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines SORBDB1, SORBDB2, and SORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_dorbdb3 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| DORBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines DORBDB1, DORBDB2, and DORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_qorbdb3 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| QORBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines QORBDB1, QORBDB2, and QORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_sorbdb4 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info) |
| SORBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines SORBDB1, SORBDB2, and SORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_dorbdb4 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info) |
| DORBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines DORBDB1, DORBDB2, and DORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_qorbdb4 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info) |
| QORBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines QORBDB1, QORBDB2, and QORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_sorcsd2by1 (jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, iwork, info) |
| SORCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0). | |
| subroutine, public | la_dorcsd2by1 (jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, iwork, info) |
| DORCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0). | |
| subroutine, public | la_qorcsd2by1 (jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, iwork, info) |
| QORCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0). | |
| pure subroutine, public | la_clapmr (forwrd, m, n, x, ldx, k) |
| CLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M. | |
| pure subroutine, public | la_zlapmr (forwrd, m, n, x, ldx, k) |
| ZLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M. | |
| pure subroutine, public | la_wlapmr (forwrd, m, n, x, ldx, k) |
| WLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M. | |
| pure subroutine, public | la_clapmt (forwrd, m, n, x, ldx, k) |
| CLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N. | |
| pure subroutine, public | la_zlapmt (forwrd, m, n, x, ldx, k) |
| ZLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N. | |
| pure subroutine, public | la_wlapmt (forwrd, m, n, x, ldx, k) |
| WLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N. | |
| subroutine, public | la_cunbdb (trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) |
| CUNBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_zunbdb (trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) |
| ZUNBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See ZUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_wunbdb (trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) |
| WUNBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See WUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| pure subroutine, public | la_cunbdb6 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| CUNBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned. | |
| pure subroutine, public | la_zunbdb6 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| ZUNBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned. | |
| pure subroutine, public | la_wunbdb6 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| WUNBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned. | |
| pure subroutine, public | la_cbbcsd (jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, rwork, lrwork, info) |
| CBBCSD: computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices. | |
| pure subroutine, public | la_zbbcsd (jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, rwork, lrwork, info) |
| ZBBCSD: computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See ZUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices. | |
| pure subroutine, public | la_wbbcsd (jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, rwork, lrwork, info) |
| WBBCSD: computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See WUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices. | |
| pure subroutine, public | la_cunbdb5 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| CUNBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way. | |
| pure subroutine, public | la_zunbdb5 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| ZUNBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way. | |
| pure subroutine, public | la_wunbdb5 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) |
| WUNBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way. | |
| recursive subroutine, public | la_cuncsd (jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, rwork, lrwork, iwork, info) |
| CUNCSD: computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). | |
| recursive subroutine, public | la_zuncsd (jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, rwork, lrwork, iwork, info) |
| ZUNCSD: computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). | |
| recursive subroutine, public | la_wuncsd (jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, rwork, lrwork, iwork, info) |
| WUNCSD: computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). | |
| subroutine, public | la_cunbdb1 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| CUNBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines CUNBDB2, CUNBDB3, and CUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_zunbdb1 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| ZUNBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines ZUNBDB2, ZUNBDB3, and ZUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_wunbdb1 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| WUNBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines WUNBDB2, WUNBDB3, and WUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_cunbdb2 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| CUNBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines CUNBDB1, CUNBDB3, and CUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_zunbdb2 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| ZUNBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines ZUNBDB1, ZUNBDB3, and ZUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_wunbdb2 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| WUNBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines WUNBDB1, WUNBDB3, and WUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_cunbdb3 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| CUNBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines CUNBDB1, CUNBDB2, and CUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_zunbdb3 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| ZUNBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines ZUNBDB1, ZUNBDB2, and ZUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_wunbdb3 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info) |
| WUNBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines WUNBDB1, WUNBDB2, and WUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_cunbdb4 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info) |
| CUNBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines CUNBDB1, CUNBDB2, and CUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_zunbdb4 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info) |
| ZUNBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines ZUNBDB1, ZUNBDB2, and ZUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_wunbdb4 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info) |
| WUNBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines WUNBDB1, WUNBDB2, and WUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI. | |
| subroutine, public | la_cuncsd2by1 (jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, rwork, lrwork, iwork, info) |
| CUNCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0). | |
| subroutine, public | la_zuncsd2by1 (jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, rwork, lrwork, iwork, info) |
| ZUNCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0). | |
| subroutine, public | la_wuncsd2by1 (jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, rwork, lrwork, iwork, info) |
| WUNCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0). | |
Detailed Description
Cosine-sine decomposition: bidiagonal block form, simultaneous bidiagonalization, row and column permutations.
Function/Subroutine Documentation
◆ la_cbbcsd()
| pure subroutine, public la_lapack_cosine_sine::la_cbbcsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(sp), dimension(*), intent(inout) | theta, | ||
| real(sp), dimension(*), intent(inout) | phi, | ||
| complex(sp), dimension(ldu1,*), intent(inout) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| complex(sp), dimension(ldu2,*), intent(inout) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| complex(sp), dimension(ldv1t,*), intent(inout) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| complex(sp), dimension(ldv2t,*), intent(inout) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| real(sp), dimension(*), intent(out) | b11d, | ||
| real(sp), dimension(*), intent(out) | b11e, | ||
| real(sp), dimension(*), intent(out) | b12d, | ||
| real(sp), dimension(*), intent(out) | b12e, | ||
| real(sp), dimension(*), intent(out) | b21d, | ||
| real(sp), dimension(*), intent(out) | b21e, | ||
| real(sp), dimension(*), intent(out) | b22d, | ||
| real(sp), dimension(*), intent(out) | b22e, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), intent(out) | info ) |
CBBCSD: computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.
◆ la_clapmr()
| pure subroutine, public la_lapack_cosine_sine::la_clapmr | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
CLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M.
◆ la_clapmt()
| pure subroutine, public la_lapack_cosine_sine::la_clapmt | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
CLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N.
◆ la_cunbdb()
| subroutine, public la_lapack_cosine_sine::la_cunbdb | ( | character, intent(in) | trans, |
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(sp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| complex(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| complex(sp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(*), intent(out) | phi, | ||
| complex(sp), dimension(*), intent(out) | taup1, | ||
| complex(sp), dimension(*), intent(out) | taup2, | ||
| complex(sp), dimension(*), intent(out) | tauq1, | ||
| complex(sp), dimension(*), intent(out) | tauq2, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CUNBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_cunbdb1()
| subroutine, public la_lapack_cosine_sine::la_cunbdb1 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(*), intent(out) | phi, | ||
| complex(sp), dimension(*), intent(out) | taup1, | ||
| complex(sp), dimension(*), intent(out) | taup2, | ||
| complex(sp), dimension(*), intent(out) | tauq1, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CUNBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines CUNBDB2, CUNBDB3, and CUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_cunbdb2()
| subroutine, public la_lapack_cosine_sine::la_cunbdb2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(*), intent(out) | phi, | ||
| complex(sp), dimension(*), intent(out) | taup1, | ||
| complex(sp), dimension(*), intent(out) | taup2, | ||
| complex(sp), dimension(*), intent(out) | tauq1, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CUNBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines CUNBDB1, CUNBDB3, and CUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_cunbdb3()
| subroutine, public la_lapack_cosine_sine::la_cunbdb3 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(*), intent(out) | phi, | ||
| complex(sp), dimension(*), intent(out) | taup1, | ||
| complex(sp), dimension(*), intent(out) | taup2, | ||
| complex(sp), dimension(*), intent(out) | tauq1, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CUNBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines CUNBDB1, CUNBDB2, and CUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_cunbdb4()
| subroutine, public la_lapack_cosine_sine::la_cunbdb4 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(*), intent(out) | phi, | ||
| complex(sp), dimension(*), intent(out) | taup1, | ||
| complex(sp), dimension(*), intent(out) | taup2, | ||
| complex(sp), dimension(*), intent(out) | tauq1, | ||
| complex(sp), dimension(*), intent(out) | phantom, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CUNBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines CUNBDB1, CUNBDB2, and CUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_cunbdb5()
| pure subroutine, public la_lapack_cosine_sine::la_cunbdb5 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| complex(sp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| complex(sp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| complex(sp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CUNBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
◆ la_cunbdb6()
| pure subroutine, public la_lapack_cosine_sine::la_cunbdb6 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| complex(sp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| complex(sp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| complex(sp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CUNBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
◆ la_cuncsd()
| recursive subroutine, public la_lapack_cosine_sine::la_cuncsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(sp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| complex(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| complex(sp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| complex(sp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| complex(sp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| complex(sp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| complex(sp), dimension(ldv2t,*), intent(out) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
CUNCSD: computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
◆ la_cuncsd2by1()
| subroutine, public la_lapack_cosine_sine::la_cuncsd2by1 | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| complex(sp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| complex(sp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| complex(sp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
CUNCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
◆ la_dbbcsd()
| pure subroutine, public la_lapack_cosine_sine::la_dbbcsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(dp), dimension(*), intent(inout) | theta, | ||
| real(dp), dimension(*), intent(inout) | phi, | ||
| real(dp), dimension(ldu1,*), intent(inout) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| real(dp), dimension(ldu2,*), intent(inout) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| real(dp), dimension(ldv1t,*), intent(inout) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| real(dp), dimension(ldv2t,*), intent(inout) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| real(dp), dimension(*), intent(out) | b11d, | ||
| real(dp), dimension(*), intent(out) | b11e, | ||
| real(dp), dimension(*), intent(out) | b12d, | ||
| real(dp), dimension(*), intent(out) | b12e, | ||
| real(dp), dimension(*), intent(out) | b21d, | ||
| real(dp), dimension(*), intent(out) | b21e, | ||
| real(dp), dimension(*), intent(out) | b22d, | ||
| real(dp), dimension(*), intent(out) | b22e, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DBBCSD: computes the CS decomposition of an orthogonal matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**T = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See DORCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The orthogonal matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.
◆ la_dlapmr()
| pure subroutine, public la_lapack_cosine_sine::la_dlapmr | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
DLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M.
◆ la_dlapmt()
| pure subroutine, public la_lapack_cosine_sine::la_dlapmt | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
DLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N.
◆ la_dorbdb()
| subroutine, public la_lapack_cosine_sine::la_dorbdb | ( | character, intent(in) | trans, |
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(dp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| real(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(*), intent(out) | phi, | ||
| real(dp), dimension(*), intent(out) | taup1, | ||
| real(dp), dimension(*), intent(out) | taup2, | ||
| real(dp), dimension(*), intent(out) | tauq1, | ||
| real(dp), dimension(*), intent(out) | tauq2, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DORBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See DORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_dorbdb1()
| subroutine, public la_lapack_cosine_sine::la_dorbdb1 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(*), intent(out) | phi, | ||
| real(dp), dimension(*), intent(out) | taup1, | ||
| real(dp), dimension(*), intent(out) | taup2, | ||
| real(dp), dimension(*), intent(out) | tauq1, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DORBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines DORBDB2, DORBDB3, and DORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_dorbdb2()
| subroutine, public la_lapack_cosine_sine::la_dorbdb2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(*), intent(out) | phi, | ||
| real(dp), dimension(*), intent(out) | taup1, | ||
| real(dp), dimension(*), intent(out) | taup2, | ||
| real(dp), dimension(*), intent(out) | tauq1, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DORBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines DORBDB1, DORBDB3, and DORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_dorbdb3()
| subroutine, public la_lapack_cosine_sine::la_dorbdb3 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(*), intent(out) | phi, | ||
| real(dp), dimension(*), intent(out) | taup1, | ||
| real(dp), dimension(*), intent(out) | taup2, | ||
| real(dp), dimension(*), intent(out) | tauq1, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DORBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines DORBDB1, DORBDB2, and DORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_dorbdb4()
| subroutine, public la_lapack_cosine_sine::la_dorbdb4 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(*), intent(out) | phi, | ||
| real(dp), dimension(*), intent(out) | taup1, | ||
| real(dp), dimension(*), intent(out) | taup2, | ||
| real(dp), dimension(*), intent(out) | tauq1, | ||
| real(dp), dimension(*), intent(out) | phantom, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DORBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines DORBDB1, DORBDB2, and DORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_dorbdb5()
| pure subroutine, public la_lapack_cosine_sine::la_dorbdb5 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| real(dp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| real(dp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| real(dp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DORBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
◆ la_dorbdb6()
| pure subroutine, public la_lapack_cosine_sine::la_dorbdb6 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| real(dp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| real(dp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| real(dp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DORBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
◆ la_dorcsd()
| recursive subroutine, public la_lapack_cosine_sine::la_dorcsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(dp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| real(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| real(dp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| real(dp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| real(dp), dimension(ldv2t,*), intent(out) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DORCSD: computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
◆ la_dorcsd2by1()
| subroutine, public la_lapack_cosine_sine::la_dorcsd2by1 | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| real(dp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| real(dp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DORCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
◆ la_qbbcsd()
| pure subroutine, public la_lapack_cosine_sine::la_qbbcsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(qp), dimension(*), intent(inout) | theta, | ||
| real(qp), dimension(*), intent(inout) | phi, | ||
| real(qp), dimension(ldu1,*), intent(inout) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| real(qp), dimension(ldu2,*), intent(inout) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| real(qp), dimension(ldv1t,*), intent(inout) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| real(qp), dimension(ldv2t,*), intent(inout) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| real(qp), dimension(*), intent(out) | b11d, | ||
| real(qp), dimension(*), intent(out) | b11e, | ||
| real(qp), dimension(*), intent(out) | b12d, | ||
| real(qp), dimension(*), intent(out) | b12e, | ||
| real(qp), dimension(*), intent(out) | b21d, | ||
| real(qp), dimension(*), intent(out) | b21e, | ||
| real(qp), dimension(*), intent(out) | b22d, | ||
| real(qp), dimension(*), intent(out) | b22e, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QBBCSD: computes the CS decomposition of an orthogonal matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**T = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See QORCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The orthogonal matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.
◆ la_qlapmr()
| pure subroutine, public la_lapack_cosine_sine::la_qlapmr | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
QLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M.
◆ la_qlapmt()
| pure subroutine, public la_lapack_cosine_sine::la_qlapmt | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
QLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N.
◆ la_qorbdb()
| subroutine, public la_lapack_cosine_sine::la_qorbdb | ( | character, intent(in) | trans, |
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(qp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| real(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(*), intent(out) | phi, | ||
| real(qp), dimension(*), intent(out) | taup1, | ||
| real(qp), dimension(*), intent(out) | taup2, | ||
| real(qp), dimension(*), intent(out) | tauq1, | ||
| real(qp), dimension(*), intent(out) | tauq2, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QORBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See QORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_qorbdb1()
| subroutine, public la_lapack_cosine_sine::la_qorbdb1 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(*), intent(out) | phi, | ||
| real(qp), dimension(*), intent(out) | taup1, | ||
| real(qp), dimension(*), intent(out) | taup2, | ||
| real(qp), dimension(*), intent(out) | tauq1, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QORBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines QORBDB2, QORBDB3, and QORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_qorbdb2()
| subroutine, public la_lapack_cosine_sine::la_qorbdb2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(*), intent(out) | phi, | ||
| real(qp), dimension(*), intent(out) | taup1, | ||
| real(qp), dimension(*), intent(out) | taup2, | ||
| real(qp), dimension(*), intent(out) | tauq1, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QORBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines QORBDB1, QORBDB3, and QORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_qorbdb3()
| subroutine, public la_lapack_cosine_sine::la_qorbdb3 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(*), intent(out) | phi, | ||
| real(qp), dimension(*), intent(out) | taup1, | ||
| real(qp), dimension(*), intent(out) | taup2, | ||
| real(qp), dimension(*), intent(out) | tauq1, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QORBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines QORBDB1, QORBDB2, and QORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_qorbdb4()
| subroutine, public la_lapack_cosine_sine::la_qorbdb4 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(*), intent(out) | phi, | ||
| real(qp), dimension(*), intent(out) | taup1, | ||
| real(qp), dimension(*), intent(out) | taup2, | ||
| real(qp), dimension(*), intent(out) | tauq1, | ||
| real(qp), dimension(*), intent(out) | phantom, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QORBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines QORBDB1, QORBDB2, and QORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_qorbdb5()
| pure subroutine, public la_lapack_cosine_sine::la_qorbdb5 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| real(qp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| real(qp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| real(qp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QORBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
◆ la_qorbdb6()
| pure subroutine, public la_lapack_cosine_sine::la_qorbdb6 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| real(qp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| real(qp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| real(qp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QORBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
◆ la_qorcsd()
| recursive subroutine, public la_lapack_cosine_sine::la_qorcsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(qp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| real(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| real(qp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| real(qp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| real(qp), dimension(ldv2t,*), intent(out) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QORCSD: computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
◆ la_qorcsd2by1()
| subroutine, public la_lapack_cosine_sine::la_qorcsd2by1 | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| real(qp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| real(qp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QORCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
◆ la_sbbcsd()
| pure subroutine, public la_lapack_cosine_sine::la_sbbcsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(sp), dimension(*), intent(inout) | theta, | ||
| real(sp), dimension(*), intent(inout) | phi, | ||
| real(sp), dimension(ldu1,*), intent(inout) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| real(sp), dimension(ldu2,*), intent(inout) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| real(sp), dimension(ldv1t,*), intent(inout) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| real(sp), dimension(ldv2t,*), intent(inout) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| real(sp), dimension(*), intent(out) | b11d, | ||
| real(sp), dimension(*), intent(out) | b11e, | ||
| real(sp), dimension(*), intent(out) | b12d, | ||
| real(sp), dimension(*), intent(out) | b12e, | ||
| real(sp), dimension(*), intent(out) | b21d, | ||
| real(sp), dimension(*), intent(out) | b21e, | ||
| real(sp), dimension(*), intent(out) | b22d, | ||
| real(sp), dimension(*), intent(out) | b22e, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SBBCSD: computes the CS decomposition of an orthogonal matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**T = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See SORCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The orthogonal matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.
◆ la_slapmr()
| pure subroutine, public la_lapack_cosine_sine::la_slapmr | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
SLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M.
◆ la_slapmt()
| pure subroutine, public la_lapack_cosine_sine::la_slapmt | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
SLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N.
◆ la_sorbdb()
| subroutine, public la_lapack_cosine_sine::la_sorbdb | ( | character, intent(in) | trans, |
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(sp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| real(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(*), intent(out) | phi, | ||
| real(sp), dimension(*), intent(out) | taup1, | ||
| real(sp), dimension(*), intent(out) | taup2, | ||
| real(sp), dimension(*), intent(out) | tauq1, | ||
| real(sp), dimension(*), intent(out) | tauq2, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SORBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See SORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_sorbdb1()
| subroutine, public la_lapack_cosine_sine::la_sorbdb1 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(*), intent(out) | phi, | ||
| real(sp), dimension(*), intent(out) | taup1, | ||
| real(sp), dimension(*), intent(out) | taup2, | ||
| real(sp), dimension(*), intent(out) | tauq1, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SORBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines SORBDB2, SORBDB3, and SORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_sorbdb2()
| subroutine, public la_lapack_cosine_sine::la_sorbdb2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(*), intent(out) | phi, | ||
| real(sp), dimension(*), intent(out) | taup1, | ||
| real(sp), dimension(*), intent(out) | taup2, | ||
| real(sp), dimension(*), intent(out) | tauq1, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SORBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines SORBDB1, SORBDB3, and SORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_sorbdb3()
| subroutine, public la_lapack_cosine_sine::la_sorbdb3 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(*), intent(out) | phi, | ||
| real(sp), dimension(*), intent(out) | taup1, | ||
| real(sp), dimension(*), intent(out) | taup2, | ||
| real(sp), dimension(*), intent(out) | tauq1, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SORBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines SORBDB1, SORBDB2, and SORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_sorbdb4()
| subroutine, public la_lapack_cosine_sine::la_sorbdb4 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(*), intent(out) | phi, | ||
| real(sp), dimension(*), intent(out) | taup1, | ||
| real(sp), dimension(*), intent(out) | taup2, | ||
| real(sp), dimension(*), intent(out) | tauq1, | ||
| real(sp), dimension(*), intent(out) | phantom, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SORBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines SORBDB1, SORBDB2, and SORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_sorbdb5()
| pure subroutine, public la_lapack_cosine_sine::la_sorbdb5 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| real(sp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| real(sp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| real(sp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SORBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
◆ la_sorbdb6()
| pure subroutine, public la_lapack_cosine_sine::la_sorbdb6 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| real(sp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| real(sp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| real(sp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SORBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
◆ la_sorcsd()
| recursive subroutine, public la_lapack_cosine_sine::la_sorcsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(sp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| real(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| real(sp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| real(sp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| real(sp), dimension(ldv2t,*), intent(out) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SORCSD: computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
◆ la_sorcsd2by1()
| subroutine, public la_lapack_cosine_sine::la_sorcsd2by1 | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(sp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| real(sp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(sp), dimension(*), intent(out) | theta, | ||
| real(sp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| real(sp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| real(sp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SORCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
◆ la_wbbcsd()
| pure subroutine, public la_lapack_cosine_sine::la_wbbcsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(qp), dimension(*), intent(inout) | theta, | ||
| real(qp), dimension(*), intent(inout) | phi, | ||
| complex(qp), dimension(ldu1,*), intent(inout) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| complex(qp), dimension(ldu2,*), intent(inout) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| complex(qp), dimension(ldv1t,*), intent(inout) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| complex(qp), dimension(ldv2t,*), intent(inout) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| real(qp), dimension(*), intent(out) | b11d, | ||
| real(qp), dimension(*), intent(out) | b11e, | ||
| real(qp), dimension(*), intent(out) | b12d, | ||
| real(qp), dimension(*), intent(out) | b12e, | ||
| real(qp), dimension(*), intent(out) | b21d, | ||
| real(qp), dimension(*), intent(out) | b21e, | ||
| real(qp), dimension(*), intent(out) | b22d, | ||
| real(qp), dimension(*), intent(out) | b22e, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), intent(out) | info ) |
WBBCSD: computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See WUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.
◆ la_wlapmr()
| pure subroutine, public la_lapack_cosine_sine::la_wlapmr | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
WLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M.
◆ la_wlapmt()
| pure subroutine, public la_lapack_cosine_sine::la_wlapmt | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
WLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N.
◆ la_wunbdb()
| subroutine, public la_lapack_cosine_sine::la_wunbdb | ( | character, intent(in) | trans, |
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(qp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| complex(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| complex(qp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(*), intent(out) | phi, | ||
| complex(qp), dimension(*), intent(out) | taup1, | ||
| complex(qp), dimension(*), intent(out) | taup2, | ||
| complex(qp), dimension(*), intent(out) | tauq1, | ||
| complex(qp), dimension(*), intent(out) | tauq2, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WUNBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See WUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_wunbdb1()
| subroutine, public la_lapack_cosine_sine::la_wunbdb1 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(*), intent(out) | phi, | ||
| complex(qp), dimension(*), intent(out) | taup1, | ||
| complex(qp), dimension(*), intent(out) | taup2, | ||
| complex(qp), dimension(*), intent(out) | tauq1, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WUNBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines WUNBDB2, WUNBDB3, and WUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_wunbdb2()
| subroutine, public la_lapack_cosine_sine::la_wunbdb2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(*), intent(out) | phi, | ||
| complex(qp), dimension(*), intent(out) | taup1, | ||
| complex(qp), dimension(*), intent(out) | taup2, | ||
| complex(qp), dimension(*), intent(out) | tauq1, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WUNBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines WUNBDB1, WUNBDB3, and WUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_wunbdb3()
| subroutine, public la_lapack_cosine_sine::la_wunbdb3 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(*), intent(out) | phi, | ||
| complex(qp), dimension(*), intent(out) | taup1, | ||
| complex(qp), dimension(*), intent(out) | taup2, | ||
| complex(qp), dimension(*), intent(out) | tauq1, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WUNBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines WUNBDB1, WUNBDB2, and WUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_wunbdb4()
| subroutine, public la_lapack_cosine_sine::la_wunbdb4 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| real(qp), dimension(*), intent(out) | phi, | ||
| complex(qp), dimension(*), intent(out) | taup1, | ||
| complex(qp), dimension(*), intent(out) | taup2, | ||
| complex(qp), dimension(*), intent(out) | tauq1, | ||
| complex(qp), dimension(*), intent(out) | phantom, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WUNBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines WUNBDB1, WUNBDB2, and WUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_wunbdb5()
| pure subroutine, public la_lapack_cosine_sine::la_wunbdb5 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| complex(qp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| complex(qp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| complex(qp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WUNBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
◆ la_wunbdb6()
| pure subroutine, public la_lapack_cosine_sine::la_wunbdb6 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| complex(qp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| complex(qp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| complex(qp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WUNBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
◆ la_wuncsd()
| recursive subroutine, public la_lapack_cosine_sine::la_wuncsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(qp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| complex(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| complex(qp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| complex(qp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| complex(qp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| complex(qp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| complex(qp), dimension(ldv2t,*), intent(out) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
WUNCSD: computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
◆ la_wuncsd2by1()
| subroutine, public la_lapack_cosine_sine::la_wuncsd2by1 | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(qp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(qp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(qp), dimension(*), intent(out) | theta, | ||
| complex(qp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| complex(qp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| complex(qp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
WUNCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
◆ la_zbbcsd()
| pure subroutine, public la_lapack_cosine_sine::la_zbbcsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| real(dp), dimension(*), intent(inout) | theta, | ||
| real(dp), dimension(*), intent(inout) | phi, | ||
| complex(dp), dimension(ldu1,*), intent(inout) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| complex(dp), dimension(ldu2,*), intent(inout) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| complex(dp), dimension(ldv1t,*), intent(inout) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| complex(dp), dimension(ldv2t,*), intent(inout) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| real(dp), dimension(*), intent(out) | b11d, | ||
| real(dp), dimension(*), intent(out) | b11e, | ||
| real(dp), dimension(*), intent(out) | b12d, | ||
| real(dp), dimension(*), intent(out) | b12e, | ||
| real(dp), dimension(*), intent(out) | b21d, | ||
| real(dp), dimension(*), intent(out) | b21e, | ||
| real(dp), dimension(*), intent(out) | b22d, | ||
| real(dp), dimension(*), intent(out) | b22e, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), intent(out) | info ) |
ZBBCSD: computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See ZUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.
◆ la_zlapmr()
| pure subroutine, public la_lapack_cosine_sine::la_zlapmr | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
ZLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M.
◆ la_zlapmt()
| pure subroutine, public la_lapack_cosine_sine::la_zlapmt | ( | logical(lk), intent(in) | forwrd, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| integer(ilp), dimension(*), intent(inout) | k ) |
ZLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N.
◆ la_zunbdb()
| subroutine, public la_lapack_cosine_sine::la_zunbdb | ( | character, intent(in) | trans, |
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(dp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| complex(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| complex(dp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(*), intent(out) | phi, | ||
| complex(dp), dimension(*), intent(out) | taup1, | ||
| complex(dp), dimension(*), intent(out) | taup2, | ||
| complex(dp), dimension(*), intent(out) | tauq1, | ||
| complex(dp), dimension(*), intent(out) | tauq2, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZUNBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See ZUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_zunbdb1()
| subroutine, public la_lapack_cosine_sine::la_zunbdb1 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(*), intent(out) | phi, | ||
| complex(dp), dimension(*), intent(out) | taup1, | ||
| complex(dp), dimension(*), intent(out) | taup2, | ||
| complex(dp), dimension(*), intent(out) | tauq1, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZUNBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines ZUNBDB2, ZUNBDB3, and ZUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_zunbdb2()
| subroutine, public la_lapack_cosine_sine::la_zunbdb2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(*), intent(out) | phi, | ||
| complex(dp), dimension(*), intent(out) | taup1, | ||
| complex(dp), dimension(*), intent(out) | taup2, | ||
| complex(dp), dimension(*), intent(out) | tauq1, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZUNBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines ZUNBDB1, ZUNBDB3, and ZUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_zunbdb3()
| subroutine, public la_lapack_cosine_sine::la_zunbdb3 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(*), intent(out) | phi, | ||
| complex(dp), dimension(*), intent(out) | taup1, | ||
| complex(dp), dimension(*), intent(out) | taup2, | ||
| complex(dp), dimension(*), intent(out) | tauq1, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZUNBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines ZUNBDB1, ZUNBDB2, and ZUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_zunbdb4()
| subroutine, public la_lapack_cosine_sine::la_zunbdb4 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| real(dp), dimension(*), intent(out) | phi, | ||
| complex(dp), dimension(*), intent(out) | taup1, | ||
| complex(dp), dimension(*), intent(out) | taup2, | ||
| complex(dp), dimension(*), intent(out) | tauq1, | ||
| complex(dp), dimension(*), intent(out) | phantom, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZUNBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines ZUNBDB1, ZUNBDB2, and ZUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
◆ la_zunbdb5()
| pure subroutine, public la_lapack_cosine_sine::la_zunbdb5 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| complex(dp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| complex(dp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| complex(dp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZUNBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
◆ la_zunbdb6()
| pure subroutine, public la_lapack_cosine_sine::la_zunbdb6 | ( | integer(ilp), intent(in) | m1, |
| integer(ilp), intent(in) | m2, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(inout) | x1, | ||
| integer(ilp), intent(in) | incx1, | ||
| complex(dp), dimension(*), intent(inout) | x2, | ||
| integer(ilp), intent(in) | incx2, | ||
| complex(dp), dimension(ldq1,*), intent(in) | q1, | ||
| integer(ilp), intent(in) | ldq1, | ||
| complex(dp), dimension(ldq2,*), intent(in) | q2, | ||
| integer(ilp), intent(in) | ldq2, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZUNBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
◆ la_zuncsd()
| recursive subroutine, public la_lapack_cosine_sine::la_zuncsd | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| character, intent(in) | jobv2t, | ||
| character, intent(in) | trans, | ||
| character, intent(in) | signs, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(dp), dimension(ldx12,*), intent(inout) | x12, | ||
| integer(ilp), intent(in) | ldx12, | ||
| complex(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| complex(dp), dimension(ldx22,*), intent(inout) | x22, | ||
| integer(ilp), intent(in) | ldx22, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| complex(dp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| complex(dp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| complex(dp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| complex(dp), dimension(ldv2t,*), intent(out) | v2t, | ||
| integer(ilp), intent(in) | ldv2t, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
ZUNCSD: computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
◆ la_zuncsd2by1()
| subroutine, public la_lapack_cosine_sine::la_zuncsd2by1 | ( | character, intent(in) | jobu1, |
| character, intent(in) | jobu2, | ||
| character, intent(in) | jobv1t, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | p, | ||
| integer(ilp), intent(in) | q, | ||
| complex(dp), dimension(ldx11,*), intent(inout) | x11, | ||
| integer(ilp), intent(in) | ldx11, | ||
| complex(dp), dimension(ldx21,*), intent(inout) | x21, | ||
| integer(ilp), intent(in) | ldx21, | ||
| real(dp), dimension(*), intent(out) | theta, | ||
| complex(dp), dimension(ldu1,*), intent(out) | u1, | ||
| integer(ilp), intent(in) | ldu1, | ||
| complex(dp), dimension(ldu2,*), intent(out) | u2, | ||
| integer(ilp), intent(in) | ldu2, | ||
| complex(dp), dimension(ldv1t,*), intent(out) | v1t, | ||
| integer(ilp), intent(in) | ldv1t, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | lrwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
ZUNCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
