--- name: "ggsvd3" section: "3" platform: "linux" package: "lapack-doc" version: "3.12.1-2" release: "Arch Linux 2026-11-01" platforms: ["linux"] url: "https://new.carta.tech/ggsvd3" --- # ggsvd3(3) ggsvd3: SVD, QR iteration ## NAME ggsvd3 - ggsvd3: SVD, QR iteration ## SYNOPSIS ### Functions subroutine **cggsvd3** (jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alpha, beta, u, ldu, v, ldv, q, ldq, work, lwork, rwork, iwork, info)\ **CGGSVD3 computes the singular value decomposition (SVD) for OTHER matrices** subroutine **dggsvd3** (jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alpha, beta, u, ldu, v, ldv, q, ldq, work, lwork, iwork, info)\ **DGGSVD3 computes the singular value decomposition (SVD) for OTHER matrices** subroutine **sggsvd3** (jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alpha, beta, u, ldu, v, ldv, q, ldq, work, lwork, iwork, info)\ **SGGSVD3 computes the singular value decomposition (SVD) for OTHER matrices** subroutine **zggsvd3** (jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alpha, beta, u, ldu, v, ldv, q, ldq, work, lwork, rwork, iwork, info)\ **ZGGSVD3 computes the singular value decomposition (SVD) for OTHER matrices** ## Detailed Description ## Function Documentation ### subroutine cggsvd3 (character jobu, character jobv, character jobq, integer m, integer n, integer p, integer k, integer l, complex, dimension( lda, \* ) a, integer lda, complex, dimension( ldb, \* ) b, integer ldb, real, dimension( \* ) alpha, real, dimension( \* ) beta, complex, dimension( ldu, \* ) u, integer ldu, complex, dimension( ldv, \* ) v, integer ldv, complex, dimension( ldq, \* ) q, integer ldq, complex, dimension( \* ) work, integer lwork, real, dimension( \* ) rwork, integer, dimension( \* ) iwork, integer info) **CGGSVD3 computes the singular value decomposition (SVD) for OTHER matrices** **Purpose:** ``` !> !> CGGSVD3 computes the generalized singular value decomposition (GSVD) !> of an M-by-N complex matrix A and P-by-N complex matrix B: !> !> U**H*A*Q = D1*( 0 R ), V**H*B*Q = D2*( 0 R ) !> !> where U, V and Q are unitary matrices. !> Let K+L = the effective numerical rank of the !> matrix (A**H,B**H)**H, then R is a (K+L)-by-(K+L) nonsingular upper !> triangular matrix, D1 and D2 are M-by-(K+L) and P-by-(K+L) !> matrices and of the following structures, respectively: !> !> If M-K-L >= 0, !> !> K L !> D1 = K ( I 0 ) !> L ( 0 C ) !> M-K-L ( 0 0 ) !> !> K L !> D2 = L ( 0 S ) !> P-L ( 0 0 ) !> !> N-K-L K L !> ( 0 R ) = K ( 0 R11 R12 ) !> L ( 0 0 R22 ) !> !> where !> !> C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), !> S = diag( BETA(K+1), ... , BETA(K+L) ), !> C**2 + S**2 = I. !> !> R is stored in A(1:K+L,N-K-L+1:N) on exit. !> !> If M-K-L < 0, !> !> K M-K K+L-M !> D1 = K ( I 0 0 ) !> M-K ( 0 C 0 ) !> !> K M-K K+L-M !> D2 = M-K ( 0 S 0 ) !> K+L-M ( 0 0 I ) !> P-L ( 0 0 0 ) !> !> N-K-L K M-K K+L-M !> ( 0 R ) = K ( 0 R11 R12 R13 ) !> M-K ( 0 0 R22 R23 ) !> K+L-M ( 0 0 0 R33 ) !> !> where !> !> C = diag( ALPHA(K+1), ... , ALPHA(M) ), !> S = diag( BETA(K+1), ... , BETA(M) ), !> C**2 + S**2 = I. !> !> (R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N), and R33 is stored !> ( 0 R22 R23 ) !> in B(M-K+1:L,N+M-K-L+1:N) on exit. !> !> The routine computes C, S, R, and optionally the unitary !> transformation matrices U, V and Q. !> !> In particular, if B is an N-by-N nonsingular matrix, then the GSVD of !> A and B implicitly gives the SVD of A*inv(B): !> A*inv(B) = U*(D1*inv(D2))*V**H. !> If ( A**H,B**H)**H has orthonormal columns, then the GSVD of A and B is also !> equal to the CS decomposition of A and B. Furthermore, the GSVD can !> be used to derive the solution of the eigenvalue problem: !> A**H*A x = lambda* B**H*B x. !> In some literature, the GSVD of A and B is presented in the form !> U**H*A*X = ( 0 D1 ), V**H*B*X = ( 0 D2 ) !> where U and V are orthogonal and X is nonsingular, and D1 and D2 are !> ``diagonal''. The former GSVD form can be converted to the latter !> form by taking the nonsingular matrix X as !> !> X = Q*( I 0 ) !> ( 0 inv(R) ) !> ``` **Parameters** *JOBU* ``` !> JOBU is CHARACTER*1 !> = 'U': Unitary matrix U is computed; !> = 'N': U is not computed. !> ``` *JOBV* ``` !> JOBV is CHARACTER*1 !> = 'V': Unitary matrix V is computed; !> = 'N': V is not computed. !> ``` *JOBQ* ``` !> JOBQ is CHARACTER*1 !> = 'Q': Unitary matrix Q is computed; !> = 'N': Q is not computed. !> ``` *M* ``` !> M is INTEGER !> The number of rows of the matrix A. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrices A and B. N >= 0. !> ``` *P* ``` !> P is INTEGER !> The number of rows of the matrix B. P >= 0. !> ``` *K* ``` !> K is INTEGER !> ``` *L* ``` !> L is INTEGER !> !> On exit, K and L specify the dimension of the subblocks !> described in Purpose. !> K + L = effective numerical rank of (A**H,B**H)**H. !> ``` *A* ``` !> A is COMPLEX array, dimension (LDA,N) !> On entry, the M-by-N matrix A. !> On exit, A contains the triangular matrix R, or part of R. !> See Purpose for details. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *B* ``` !> B is COMPLEX array, dimension (LDB,N) !> On entry, the P-by-N matrix B. !> On exit, B contains part of the triangular matrix R if !> M-K-L < 0. See Purpose for details. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,P). !> ``` *ALPHA* ``` !> ALPHA is REAL array, dimension (N) !> ``` *BETA* ``` !> BETA is REAL array, dimension (N) !> !> On exit, ALPHA and BETA contain the generalized singular !> value pairs of A and B; !> ALPHA(1:K) = 1, !> BETA(1:K) = 0, !> and if M-K-L >= 0, !> ALPHA(K+1:K+L) = C, !> BETA(K+1:K+L) = S, !> or if M-K-L < 0, !> ALPHA(K+1:M)=C, ALPHA(M+1:K+L)=0 !> BETA(K+1:M) =S, BETA(M+1:K+L) =1 !> and !> ALPHA(K+L+1:N) = 0 !> BETA(K+L+1:N) = 0 !> ``` *U* ``` !> U is COMPLEX array, dimension (LDU,M) !> If JOBU = 'U', U contains the M-by-M unitary matrix U. !> If JOBU = 'N', U is not referenced. !> ``` *LDU* ``` !> LDU is INTEGER !> The leading dimension of the array U. LDU >= max(1,M) if !> JOBU = 'U'; LDU >= 1 otherwise. !> ``` *V* ``` !> V is COMPLEX array, dimension (LDV,P) !> If JOBV = 'V', V contains the P-by-P unitary matrix V. !> If JOBV = 'N', V is not referenced. !> ``` *LDV* ``` !> LDV is INTEGER !> The leading dimension of the array V. LDV >= max(1,P) if !> JOBV = 'V'; LDV >= 1 otherwise. !> ``` *Q* ``` !> Q is COMPLEX array, dimension (LDQ,N) !> If JOBQ = 'Q', Q contains the N-by-N unitary matrix Q. !> If JOBQ = 'N', Q is not referenced. !> ``` *LDQ* ``` !> LDQ is INTEGER !> The leading dimension of the array Q. LDQ >= max(1,N) if !> JOBQ = 'Q'; LDQ >= 1 otherwise. !> ``` *WORK* ``` !> WORK is COMPLEX array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The dimension of the array WORK. LWORK >= 1. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *RWORK* ``` !> RWORK is REAL array, dimension (2*N) !> ``` *IWORK* ``` !> IWORK is INTEGER array, dimension (N) !> On exit, IWORK stores the sorting information. More !> precisely, the following loop will sort ALPHA !> for I = K+1, min(M,K+L) !> swap ALPHA(I) and ALPHA(IWORK(I)) !> endfor !> such that ALPHA(1) >= ALPHA(2) >= ... >= ALPHA(N). !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit. !> < 0: if INFO = -i, the i-th argument had an illegal value. !> > 0: if INFO = 1, the Jacobi-type procedure failed to !> converge. For further details, see subroutine CTGSJA. !> ``` **Internal Parameters:** ``` !> TOLA REAL !> TOLB REAL !> TOLA and TOLB are the thresholds to determine the effective !> rank of (A**H,B**H)**H. Generally, they are set to !> TOLA = MAX(M,N)*norm(A)*MACHEPS, !> TOLB = MAX(P,N)*norm(B)*MACHEPS. !> The size of TOLA and TOLB may affect the size of backward !> errors of the decomposition. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Contributors:** Ming Gu and Huan Ren, Computer Science Division, University of California at Berkeley, USA **Further Details:** CGGSVD3 replaces the deprecated subroutine CGGSVD. Definition at line **351** of file **cggsvd3.f**. ### subroutine dggsvd3 (character jobu, character jobv, character jobq, integer m, integer n, integer p, integer k, integer l, double precision, dimension( lda, \* ) a, integer lda, double precision, dimension( ldb, \* ) b, integer ldb, double precision, dimension( \* ) alpha, double precision, dimension( \* ) beta, double precision, dimension( ldu, \* ) u, integer ldu, double precision, dimension( ldv, \* ) v, integer ldv, double precision, dimension( ldq, \* ) q, integer ldq, double precision, dimension( \* ) work, integer lwork, integer, dimension( \* ) iwork, integer info) **DGGSVD3 computes the singular value decomposition (SVD) for OTHER matrices** **Purpose:** ``` !> !> DGGSVD3 computes the generalized singular value decomposition (GSVD) !> of an M-by-N real matrix A and P-by-N real matrix B: !> !> U**T*A*Q = D1*( 0 R ), V**T*B*Q = D2*( 0 R ) !> !> where U, V and Q are orthogonal matrices. !> Let K+L = the effective numerical rank of the matrix (A**T,B**T)**T, !> then R is a K+L-by-K+L nonsingular upper triangular matrix, D1 and !> D2 are M-by-(K+L) and P-by-(K+L) matrices and of the !> following structures, respectively: !> !> If M-K-L >= 0, !> !> K L !> D1 = K ( I 0 ) !> L ( 0 C ) !> M-K-L ( 0 0 ) !> !> K L !> D2 = L ( 0 S ) !> P-L ( 0 0 ) !> !> N-K-L K L !> ( 0 R ) = K ( 0 R11 R12 ) !> L ( 0 0 R22 ) !> !> where !> !> C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), !> S = diag( BETA(K+1), ... , BETA(K+L) ), !> C**2 + S**2 = I. !> !> R is stored in A(1:K+L,N-K-L+1:N) on exit. !> !> If M-K-L < 0, !> !> K M-K K+L-M !> D1 = K ( I 0 0 ) !> M-K ( 0 C 0 ) !> !> K M-K K+L-M !> D2 = M-K ( 0 S 0 ) !> K+L-M ( 0 0 I ) !> P-L ( 0 0 0 ) !> !> N-K-L K M-K K+L-M !> ( 0 R ) = K ( 0 R11 R12 R13 ) !> M-K ( 0 0 R22 R23 ) !> K+L-M ( 0 0 0 R33 ) !> !> where !> !> C = diag( ALPHA(K+1), ... , ALPHA(M) ), !> S = diag( BETA(K+1), ... , BETA(M) ), !> C**2 + S**2 = I. !> !> (R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N), and R33 is stored !> ( 0 R22 R23 ) !> in B(M-K+1:L,N+M-K-L+1:N) on exit. !> !> The routine computes C, S, R, and optionally the orthogonal !> transformation matrices U, V and Q. !> !> In particular, if B is an N-by-N nonsingular matrix, then the GSVD of !> A and B implicitly gives the SVD of A*inv(B): !> A*inv(B) = U*(D1*inv(D2))*V**T. !> If ( A**T,B**T)**T has orthonormal columns, then the GSVD of A and B is !> also equal to the CS decomposition of A and B. Furthermore, the GSVD !> can be used to derive the solution of the eigenvalue problem: !> A**T*A x = lambda* B**T*B x. !> In some literature, the GSVD of A and B is presented in the form !> U**T*A*X = ( 0 D1 ), V**T*B*X = ( 0 D2 ) !> where U and V are orthogonal and X is nonsingular, D1 and D2 are !> ``diagonal''. The former GSVD form can be converted to the latter !> form by taking the nonsingular matrix X as !> !> X = Q*( I 0 ) !> ( 0 inv(R) ). !> ``` **Parameters** *JOBU* ``` !> JOBU is CHARACTER*1 !> = 'U': Orthogonal matrix U is computed; !> = 'N': U is not computed. !> ``` *JOBV* ``` !> JOBV is CHARACTER*1 !> = 'V': Orthogonal matrix V is computed; !> = 'N': V is not computed. !> ``` *JOBQ* ``` !> JOBQ is CHARACTER*1 !> = 'Q': Orthogonal matrix Q is computed; !> = 'N': Q is not computed. !> ``` *M* ``` !> M is INTEGER !> The number of rows of the matrix A. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrices A and B. N >= 0. !> ``` *P* ``` !> P is INTEGER !> The number of rows of the matrix B. P >= 0. !> ``` *K* ``` !> K is INTEGER !> ``` *L* ``` !> L is INTEGER !> !> On exit, K and L specify the dimension of the subblocks !> described in Purpose. !> K + L = effective numerical rank of (A**T,B**T)**T. !> ``` *A* ``` !> A is DOUBLE PRECISION array, dimension (LDA,N) !> On entry, the M-by-N matrix A. !> On exit, A contains the triangular matrix R, or part of R. !> See Purpose for details. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *B* ``` !> B is DOUBLE PRECISION array, dimension (LDB,N) !> On entry, the P-by-N matrix B. !> On exit, B contains the triangular matrix R if M-K-L < 0. !> See Purpose for details. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,P). !> ``` *ALPHA* ``` !> ALPHA is DOUBLE PRECISION array, dimension (N) !> ``` *BETA* ``` !> BETA is DOUBLE PRECISION array, dimension (N) !> !> On exit, ALPHA and BETA contain the generalized singular !> value pairs of A and B; !> ALPHA(1:K) = 1, !> BETA(1:K) = 0, !> and if M-K-L >= 0, !> ALPHA(K+1:K+L) = C, !> BETA(K+1:K+L) = S, !> or if M-K-L < 0, !> ALPHA(K+1:M)=C, ALPHA(M+1:K+L)=0 !> BETA(K+1:M) =S, BETA(M+1:K+L) =1 !> and !> ALPHA(K+L+1:N) = 0 !> BETA(K+L+1:N) = 0 !> ``` *U* ``` !> U is DOUBLE PRECISION array, dimension (LDU,M) !> If JOBU = 'U', U contains the M-by-M orthogonal matrix U. !> If JOBU = 'N', U is not referenced. !> ``` *LDU* ``` !> LDU is INTEGER !> The leading dimension of the array U. LDU >= max(1,M) if !> JOBU = 'U'; LDU >= 1 otherwise. !> ``` *V* ``` !> V is DOUBLE PRECISION array, dimension (LDV,P) !> If JOBV = 'V', V contains the P-by-P orthogonal matrix V. !> If JOBV = 'N', V is not referenced. !> ``` *LDV* ``` !> LDV is INTEGER !> The leading dimension of the array V. LDV >= max(1,P) if !> JOBV = 'V'; LDV >= 1 otherwise. !> ``` *Q* ``` !> Q is DOUBLE PRECISION array, dimension (LDQ,N) !> If JOBQ = 'Q', Q contains the N-by-N orthogonal matrix Q. !> If JOBQ = 'N', Q is not referenced. !> ``` *LDQ* ``` !> LDQ is INTEGER !> The leading dimension of the array Q. LDQ >= max(1,N) if !> JOBQ = 'Q'; LDQ >= 1 otherwise. !> ``` *WORK* ``` !> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The dimension of the array WORK. LWORK >= 1. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *IWORK* ``` !> IWORK is INTEGER array, dimension (N) !> On exit, IWORK stores the sorting information. More !> precisely, the following loop will sort ALPHA !> for I = K+1, min(M,K+L) !> swap ALPHA(I) and ALPHA(IWORK(I)) !> endfor !> such that ALPHA(1) >= ALPHA(2) >= ... >= ALPHA(N). !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit. !> < 0: if INFO = -i, the i-th argument had an illegal value. !> > 0: if INFO = 1, the Jacobi-type procedure failed to !> converge. For further details, see subroutine DTGSJA. !> ``` **Internal Parameters:** ``` !> TOLA DOUBLE PRECISION !> TOLB DOUBLE PRECISION !> TOLA and TOLB are the thresholds to determine the effective !> rank of (A**T,B**T)**T. Generally, they are set to !> TOLA = MAX(M,N)*norm(A)*MACHEPS, !> TOLB = MAX(P,N)*norm(B)*MACHEPS. !> The size of TOLA and TOLB may affect the size of backward !> errors of the decomposition. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Contributors:** Ming Gu and Huan Ren, Computer Science Division, University of California at Berkeley, USA **Further Details:** DGGSVD3 replaces the deprecated subroutine DGGSVD. Definition at line **346** of file **dggsvd3.f**. ### subroutine sggsvd3 (character jobu, character jobv, character jobq, integer m, integer n, integer p, integer k, integer l, real, dimension( lda, \* ) a, integer lda, real, dimension( ldb, \* ) b, integer ldb, real, dimension( \* ) alpha, real, dimension( \* ) beta, real, dimension( ldu, \* ) u, integer ldu, real, dimension( ldv, \* ) v, integer ldv, real, dimension( ldq, \* ) q, integer ldq, real, dimension( \* ) work, integer lwork, integer, dimension( \* ) iwork, integer info) **SGGSVD3 computes the singular value decomposition (SVD) for OTHER matrices** **Purpose:** ``` !> !> SGGSVD3 computes the generalized singular value decomposition (GSVD) !> of an M-by-N real matrix A and P-by-N real matrix B: !> !> U**T*A*Q = D1*( 0 R ), V**T*B*Q = D2*( 0 R ) !> !> where U, V and Q are orthogonal matrices. !> Let K+L = the effective numerical rank of the matrix (A**T,B**T)**T, !> then R is a K+L-by-K+L nonsingular upper triangular matrix, D1 and !> D2 are M-by-(K+L) and P-by-(K+L) matrices and of the !> following structures, respectively: !> !> If M-K-L >= 0, !> !> K L !> D1 = K ( I 0 ) !> L ( 0 C ) !> M-K-L ( 0 0 ) !> !> K L !> D2 = L ( 0 S ) !> P-L ( 0 0 ) !> !> N-K-L K L !> ( 0 R ) = K ( 0 R11 R12 ) !> L ( 0 0 R22 ) !> !> where !> !> C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), !> S = diag( BETA(K+1), ... , BETA(K+L) ), !> C**2 + S**2 = I. !> !> R is stored in A(1:K+L,N-K-L+1:N) on exit. !> !> If M-K-L < 0, !> !> K M-K K+L-M !> D1 = K ( I 0 0 ) !> M-K ( 0 C 0 ) !> !> K M-K K+L-M !> D2 = M-K ( 0 S 0 ) !> K+L-M ( 0 0 I ) !> P-L ( 0 0 0 ) !> !> N-K-L K M-K K+L-M !> ( 0 R ) = K ( 0 R11 R12 R13 ) !> M-K ( 0 0 R22 R23 ) !> K+L-M ( 0 0 0 R33 ) !> !> where !> !> C = diag( ALPHA(K+1), ... , ALPHA(M) ), !> S = diag( BETA(K+1), ... , BETA(M) ), !> C**2 + S**2 = I. !> !> (R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N), and R33 is stored !> ( 0 R22 R23 ) !> in B(M-K+1:L,N+M-K-L+1:N) on exit. !> !> The routine computes C, S, R, and optionally the orthogonal !> transformation matrices U, V and Q. !> !> In particular, if B is an N-by-N nonsingular matrix, then the GSVD of !> A and B implicitly gives the SVD of A*inv(B): !> A*inv(B) = U*(D1*inv(D2))*V**T. !> If ( A**T,B**T)**T has orthonormal columns, then the GSVD of A and B is !> also equal to the CS decomposition of A and B. Furthermore, the GSVD !> can be used to derive the solution of the eigenvalue problem: !> A**T*A x = lambda* B**T*B x. !> In some literature, the GSVD of A and B is presented in the form !> U**T*A*X = ( 0 D1 ), V**T*B*X = ( 0 D2 ) !> where U and V are orthogonal and X is nonsingular, D1 and D2 are !> ``diagonal''. The former GSVD form can be converted to the latter !> form by taking the nonsingular matrix X as !> !> X = Q*( I 0 ) !> ( 0 inv(R) ). !> ``` **Parameters** *JOBU* ``` !> JOBU is CHARACTER*1 !> = 'U': Orthogonal matrix U is computed; !> = 'N': U is not computed. !> ``` *JOBV* ``` !> JOBV is CHARACTER*1 !> = 'V': Orthogonal matrix V is computed; !> = 'N': V is not computed. !> ``` *JOBQ* ``` !> JOBQ is CHARACTER*1 !> = 'Q': Orthogonal matrix Q is computed; !> = 'N': Q is not computed. !> ``` *M* ``` !> M is INTEGER !> The number of rows of the matrix A. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrices A and B. N >= 0. !> ``` *P* ``` !> P is INTEGER !> The number of rows of the matrix B. P >= 0. !> ``` *K* ``` !> K is INTEGER !> ``` *L* ``` !> L is INTEGER !> !> On exit, K and L specify the dimension of the subblocks !> described in Purpose. !> K + L = effective numerical rank of (A**T,B**T)**T. !> ``` *A* ``` !> A is REAL array, dimension (LDA,N) !> On entry, the M-by-N matrix A. !> On exit, A contains the triangular matrix R, or part of R. !> See Purpose for details. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *B* ``` !> B is REAL array, dimension (LDB,N) !> On entry, the P-by-N matrix B. !> On exit, B contains the triangular matrix R if M-K-L < 0. !> See Purpose for details. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,P). !> ``` *ALPHA* ``` !> ALPHA is REAL array, dimension (N) !> ``` *BETA* ``` !> BETA is REAL array, dimension (N) !> !> On exit, ALPHA and BETA contain the generalized singular !> value pairs of A and B; !> ALPHA(1:K) = 1, !> BETA(1:K) = 0, !> and if M-K-L >= 0, !> ALPHA(K+1:K+L) = C, !> BETA(K+1:K+L) = S, !> or if M-K-L < 0, !> ALPHA(K+1:M)=C, ALPHA(M+1:K+L)=0 !> BETA(K+1:M) =S, BETA(M+1:K+L) =1 !> and !> ALPHA(K+L+1:N) = 0 !> BETA(K+L+1:N) = 0 !> ``` *U* ``` !> U is REAL array, dimension (LDU,M) !> If JOBU = 'U', U contains the M-by-M orthogonal matrix U. !> If JOBU = 'N', U is not referenced. !> ``` *LDU* ``` !> LDU is INTEGER !> The leading dimension of the array U. LDU >= max(1,M) if !> JOBU = 'U'; LDU >= 1 otherwise. !> ``` *V* ``` !> V is REAL array, dimension (LDV,P) !> If JOBV = 'V', V contains the P-by-P orthogonal matrix V. !> If JOBV = 'N', V is not referenced. !> ``` *LDV* ``` !> LDV is INTEGER !> The leading dimension of the array V. LDV >= max(1,P) if !> JOBV = 'V'; LDV >= 1 otherwise. !> ``` *Q* ``` !> Q is REAL array, dimension (LDQ,N) !> If JOBQ = 'Q', Q contains the N-by-N orthogonal matrix Q. !> If JOBQ = 'N', Q is not referenced. !> ``` *LDQ* ``` !> LDQ is INTEGER !> The leading dimension of the array Q. LDQ >= max(1,N) if !> JOBQ = 'Q'; LDQ >= 1 otherwise. !> ``` *WORK* ``` !> WORK is REAL array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The dimension of the array WORK. LWORK >= 1. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *IWORK* ``` !> IWORK is INTEGER array, dimension (N) !> On exit, IWORK stores the sorting information. More !> precisely, the following loop will sort ALPHA !> for I = K+1, min(M,K+L) !> swap ALPHA(I) and ALPHA(IWORK(I)) !> endfor !> such that ALPHA(1) >= ALPHA(2) >= ... >= ALPHA(N). !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit. !> < 0: if INFO = -i, the i-th argument had an illegal value. !> > 0: if INFO = 1, the Jacobi-type procedure failed to !> converge. For further details, see subroutine STGSJA. !> ``` **Internal Parameters:** ``` !> TOLA REAL !> TOLB REAL !> TOLA and TOLB are the thresholds to determine the effective !> rank of (A**T,B**T)**T. Generally, they are set to !> TOLA = MAX(M,N)*norm(A)*MACHEPS, !> TOLB = MAX(P,N)*norm(B)*MACHEPS. !> The size of TOLA and TOLB may affect the size of backward !> errors of the decomposition. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Contributors:** Ming Gu and Huan Ren, Computer Science Division, University of California at Berkeley, USA **Further Details:** SGGSVD3 replaces the deprecated subroutine SGGSVD. Definition at line **346** of file **sggsvd3.f**. ### subroutine zggsvd3 (character jobu, character jobv, character jobq, integer m, integer n, integer p, integer k, integer l, complex\*16, dimension( lda, \* ) a, integer lda, complex\*16, dimension( ldb, \* ) b, integer ldb, double precision, dimension( \* ) alpha, double precision, dimension( \* ) beta, complex\*16, dimension( ldu, \* ) u, integer ldu, complex\*16, dimension( ldv, \* ) v, integer ldv, complex\*16, dimension( ldq, \* ) q, integer ldq, complex\*16, dimension( \* ) work, integer lwork, double precision, dimension( \* ) rwork, integer, dimension( \* ) iwork, integer info) **ZGGSVD3 computes the singular value decomposition (SVD) for OTHER matrices** **Purpose:** ``` !> !> ZGGSVD3 computes the generalized singular value decomposition (GSVD) !> of an M-by-N complex matrix A and P-by-N complex matrix B: !> !> U**H*A*Q = D1*( 0 R ), V**H*B*Q = D2*( 0 R ) !> !> where U, V and Q are unitary matrices. !> Let K+L = the effective numerical rank of the !> matrix (A**H,B**H)**H, then R is a (K+L)-by-(K+L) nonsingular upper !> triangular matrix, D1 and D2 are M-by-(K+L) and P-by-(K+L) !> matrices and of the following structures, respectively: !> !> If M-K-L >= 0, !> !> K L !> D1 = K ( I 0 ) !> L ( 0 C ) !> M-K-L ( 0 0 ) !> !> K L !> D2 = L ( 0 S ) !> P-L ( 0 0 ) !> !> N-K-L K L !> ( 0 R ) = K ( 0 R11 R12 ) !> L ( 0 0 R22 ) !> where !> !> C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), !> S = diag( BETA(K+1), ... , BETA(K+L) ), !> C**2 + S**2 = I. !> !> R is stored in A(1:K+L,N-K-L+1:N) on exit. !> !> If M-K-L < 0, !> !> K M-K K+L-M !> D1 = K ( I 0 0 ) !> M-K ( 0 C 0 ) !> !> K M-K K+L-M !> D2 = M-K ( 0 S 0 ) !> K+L-M ( 0 0 I ) !> P-L ( 0 0 0 ) !> !> N-K-L K M-K K+L-M !> ( 0 R ) = K ( 0 R11 R12 R13 ) !> M-K ( 0 0 R22 R23 ) !> K+L-M ( 0 0 0 R33 ) !> !> where !> !> C = diag( ALPHA(K+1), ... , ALPHA(M) ), !> S = diag( BETA(K+1), ... , BETA(M) ), !> C**2 + S**2 = I. !> !> (R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N), and R33 is stored !> ( 0 R22 R23 ) !> in B(M-K+1:L,N+M-K-L+1:N) on exit. !> !> The routine computes C, S, R, and optionally the unitary !> transformation matrices U, V and Q. !> !> In particular, if B is an N-by-N nonsingular matrix, then the GSVD of !> A and B implicitly gives the SVD of A*inv(B): !> A*inv(B) = U*(D1*inv(D2))*V**H. !> If ( A**H,B**H)**H has orthonormal columns, then the GSVD of A and B is also !> equal to the CS decomposition of A and B. Furthermore, the GSVD can !> be used to derive the solution of the eigenvalue problem: !> A**H*A x = lambda* B**H*B x. !> In some literature, the GSVD of A and B is presented in the form !> U**H*A*X = ( 0 D1 ), V**H*B*X = ( 0 D2 ) !> where U and V are orthogonal and X is nonsingular, and D1 and D2 are !> ``diagonal''. The former GSVD form can be converted to the latter !> form by taking the nonsingular matrix X as !> !> X = Q*( I 0 ) !> ( 0 inv(R) ) !> ``` **Parameters** *JOBU* ``` !> JOBU is CHARACTER*1 !> = 'U': Unitary matrix U is computed; !> = 'N': U is not computed. !> ``` *JOBV* ``` !> JOBV is CHARACTER*1 !> = 'V': Unitary matrix V is computed; !> = 'N': V is not computed. !> ``` *JOBQ* ``` !> JOBQ is CHARACTER*1 !> = 'Q': Unitary matrix Q is computed; !> = 'N': Q is not computed. !> ``` *M* ``` !> M is INTEGER !> The number of rows of the matrix A. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrices A and B. N >= 0. !> ``` *P* ``` !> P is INTEGER !> The number of rows of the matrix B. P >= 0. !> ``` *K* ``` !> K is INTEGER !> ``` *L* ``` !> L is INTEGER !> !> On exit, K and L specify the dimension of the subblocks !> described in Purpose. !> K + L = effective numerical rank of (A**H,B**H)**H. !> ``` *A* ``` !> A is COMPLEX*16 array, dimension (LDA,N) !> On entry, the M-by-N matrix A. !> On exit, A contains the triangular matrix R, or part of R. !> See Purpose for details. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *B* ``` !> B is COMPLEX*16 array, dimension (LDB,N) !> On entry, the P-by-N matrix B. !> On exit, B contains part of the triangular matrix R if !> M-K-L < 0. See Purpose for details. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,P). !> ``` *ALPHA* ``` !> ALPHA is DOUBLE PRECISION array, dimension (N) !> ``` *BETA* ``` !> BETA is DOUBLE PRECISION array, dimension (N) !> !> On exit, ALPHA and BETA contain the generalized singular !> value pairs of A and B; !> ALPHA(1:K) = 1, !> BETA(1:K) = 0, !> and if M-K-L >= 0, !> ALPHA(K+1:K+L) = C, !> BETA(K+1:K+L) = S, !> or if M-K-L < 0, !> ALPHA(K+1:M)=C, ALPHA(M+1:K+L)=0 !> BETA(K+1:M) =S, BETA(M+1:K+L) =1 !> and !> ALPHA(K+L+1:N) = 0 !> BETA(K+L+1:N) = 0 !> ``` *U* ``` !> U is COMPLEX*16 array, dimension (LDU,M) !> If JOBU = 'U', U contains the M-by-M unitary matrix U. !> If JOBU = 'N', U is not referenced. !> ``` *LDU* ``` !> LDU is INTEGER !> The leading dimension of the array U. LDU >= max(1,M) if !> JOBU = 'U'; LDU >= 1 otherwise. !> ``` *V* ``` !> V is COMPLEX*16 array, dimension (LDV,P) !> If JOBV = 'V', V contains the P-by-P unitary matrix V. !> If JOBV = 'N', V is not referenced. !> ``` *LDV* ``` !> LDV is INTEGER !> The leading dimension of the array V. LDV >= max(1,P) if !> JOBV = 'V'; LDV >= 1 otherwise. !> ``` *Q* ``` !> Q is COMPLEX*16 array, dimension (LDQ,N) !> If JOBQ = 'Q', Q contains the N-by-N unitary matrix Q. !> If JOBQ = 'N', Q is not referenced. !> ``` *LDQ* ``` !> LDQ is INTEGER !> The leading dimension of the array Q. LDQ >= max(1,N) if !> JOBQ = 'Q'; LDQ >= 1 otherwise. !> ``` *WORK* ``` !> WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The dimension of the array WORK. LWORK >= 1. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *RWORK* ``` !> RWORK is DOUBLE PRECISION array, dimension (2*N) !> ``` *IWORK* ``` !> IWORK is INTEGER array, dimension (N) !> On exit, IWORK stores the sorting information. More !> precisely, the following loop will sort ALPHA !> for I = K+1, min(M,K+L) !> swap ALPHA(I) and ALPHA(IWORK(I)) !> endfor !> such that ALPHA(1) >= ALPHA(2) >= ... >= ALPHA(N). !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit. !> < 0: if INFO = -i, the i-th argument had an illegal value. !> > 0: if INFO = 1, the Jacobi-type procedure failed to !> converge. For further details, see subroutine ZTGSJA. !> ``` **Internal Parameters:** ``` !> TOLA DOUBLE PRECISION !> TOLB DOUBLE PRECISION !> TOLA and TOLB are the thresholds to determine the effective !> rank of (A**H,B**H)**H. Generally, they are set to !> TOLA = MAX(M,N)*norm(A)*MACHEPS, !> TOLB = MAX(P,N)*norm(B)*MACHEPS. !> The size of TOLA and TOLB may affect the size of backward !> errors of the decomposition. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Contributors:** Ming Gu and Huan Ren, Computer Science Division, University of California at Berkeley, USA **Further Details:** ZGGSVD3 replaces the deprecated subroutine ZGGSVD. Definition at line **350** of file **zggsvd3.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.