LAPACK  3.6.1
LAPACK: Linear Algebra PACKage
subroutine cggsvd ( 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,
real, dimension( * )  RWORK,
integer, dimension( * )  IWORK,
integer  INFO 
)

CGGSVD computes the singular value decomposition (SVD) for OTHER matrices

Download CGGSVD + dependencies [TGZ] [ZIP] [TXT]

Purpose:
 This routine is deprecated and has been replaced by routine CGGSVD3.

 CGGSVD 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) "diagonal"
 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 orthnormal 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
[in]JOBU
          JOBU is CHARACTER*1
          = 'U':  Unitary matrix U is computed;
          = 'N':  U is not computed.
[in]JOBV
          JOBV is CHARACTER*1
          = 'V':  Unitary matrix V is computed;
          = 'N':  V is not computed.
[in]JOBQ
          JOBQ is CHARACTER*1
          = 'Q':  Unitary matrix Q is computed;
          = 'N':  Q is not computed.
[in]M
          M is INTEGER
          The number of rows of the matrix A.  M >= 0.
[in]N
          N is INTEGER
          The number of columns of the matrices A and B.  N >= 0.
[in]P
          P is INTEGER
          The number of rows of the matrix B.  P >= 0.
[out]K
          K is INTEGER
[out]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.
[in,out]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.
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A. LDA >= max(1,M).
[in,out]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.
[in]LDB
          LDB is INTEGER
          The leading dimension of the array B. LDB >= max(1,P).
[out]ALPHA
          ALPHA is REAL array, dimension (N)
[out]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
[out]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.
[in]LDU
          LDU is INTEGER
          The leading dimension of the array U. LDU >= max(1,M) if
          JOBU = 'U'; LDU >= 1 otherwise.
[out]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.
[in]LDV
          LDV is INTEGER
          The leading dimension of the array V. LDV >= max(1,P) if
          JOBV = 'V'; LDV >= 1 otherwise.
[out]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.
[in]LDQ
          LDQ is INTEGER
          The leading dimension of the array Q. LDQ >= max(1,N) if
          JOBQ = 'Q'; LDQ >= 1 otherwise.
[out]WORK
          WORK is COMPLEX array, dimension (max(3*N,M,P)+N)
[out]RWORK
          RWORK is REAL array, dimension (2*N)
[out]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).
[out]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.
Date
November 2011
Contributors:
Ming Gu and Huan Ren, Computer Science Division, University of California at Berkeley, USA

Definition at line 340 of file cggsvd.f.

340 *
341 * -- LAPACK driver routine (version 3.4.0) --
342 * -- LAPACK is a software package provided by Univ. of Tennessee, --
343 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
344 * November 2011
345 *
346 * .. Scalar Arguments ..
347  CHARACTER jobq, jobu, jobv
348  INTEGER info, k, l, lda, ldb, ldq, ldu, ldv, m, n, p
349 * ..
350 * .. Array Arguments ..
351  INTEGER iwork( * )
352  REAL alpha( * ), beta( * ), rwork( * )
353  COMPLEX a( lda, * ), b( ldb, * ), q( ldq, * ),
354  $ u( ldu, * ), v( ldv, * ), work( * )
355 * ..
356 *
357 * =====================================================================
358 *
359 * .. Local Scalars ..
360  LOGICAL wantq, wantu, wantv
361  INTEGER i, ibnd, isub, j, ncycle
362  REAL anorm, bnorm, smax, temp, tola, tolb, ulp, unfl
363 * ..
364 * .. External Functions ..
365  LOGICAL lsame
366  REAL clange, slamch
367  EXTERNAL lsame, clange, slamch
368 * ..
369 * .. External Subroutines ..
370  EXTERNAL cggsvp, ctgsja, scopy, xerbla
371 * ..
372 * .. Intrinsic Functions ..
373  INTRINSIC max, min
374 * ..
375 * .. Executable Statements ..
376 *
377 * Decode and test the input parameters
378 *
379  wantu = lsame( jobu, 'U' )
380  wantv = lsame( jobv, 'V' )
381  wantq = lsame( jobq, 'Q' )
382 *
383  info = 0
384  IF( .NOT.( wantu .OR. lsame( jobu, 'N' ) ) ) THEN
385  info = -1
386  ELSE IF( .NOT.( wantv .OR. lsame( jobv, 'N' ) ) ) THEN
387  info = -2
388  ELSE IF( .NOT.( wantq .OR. lsame( jobq, 'N' ) ) ) THEN
389  info = -3
390  ELSE IF( m.LT.0 ) THEN
391  info = -4
392  ELSE IF( n.LT.0 ) THEN
393  info = -5
394  ELSE IF( p.LT.0 ) THEN
395  info = -6
396  ELSE IF( lda.LT.max( 1, m ) ) THEN
397  info = -10
398  ELSE IF( ldb.LT.max( 1, p ) ) THEN
399  info = -12
400  ELSE IF( ldu.LT.1 .OR. ( wantu .AND. ldu.LT.m ) ) THEN
401  info = -16
402  ELSE IF( ldv.LT.1 .OR. ( wantv .AND. ldv.LT.p ) ) THEN
403  info = -18
404  ELSE IF( ldq.LT.1 .OR. ( wantq .AND. ldq.LT.n ) ) THEN
405  info = -20
406  END IF
407  IF( info.NE.0 ) THEN
408  CALL xerbla( 'CGGSVD', -info )
409  RETURN
410  END IF
411 *
412 * Compute the Frobenius norm of matrices A and B
413 *
414  anorm = clange( '1', m, n, a, lda, rwork )
415  bnorm = clange( '1', p, n, b, ldb, rwork )
416 *
417 * Get machine precision and set up threshold for determining
418 * the effective numerical rank of the matrices A and B.
419 *
420  ulp = slamch( 'Precision' )
421  unfl = slamch( 'Safe Minimum' )
422  tola = max( m, n )*max( anorm, unfl )*ulp
423  tolb = max( p, n )*max( bnorm, unfl )*ulp
424 *
425  CALL cggsvp( jobu, jobv, jobq, m, p, n, a, lda, b, ldb, tola,
426  $ tolb, k, l, u, ldu, v, ldv, q, ldq, iwork, rwork,
427  $ work, work( n+1 ), info )
428 *
429 * Compute the GSVD of two upper "triangular" matrices
430 *
431  CALL ctgsja( jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb,
432  $ tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq,
433  $ work, ncycle, info )
434 *
435 * Sort the singular values and store the pivot indices in IWORK
436 * Copy ALPHA to RWORK, then sort ALPHA in RWORK
437 *
438  CALL scopy( n, alpha, 1, rwork, 1 )
439  ibnd = min( l, m-k )
440  DO 20 i = 1, ibnd
441 *
442 * Scan for largest ALPHA(K+I)
443 *
444  isub = i
445  smax = rwork( k+i )
446  DO 10 j = i + 1, ibnd
447  temp = rwork( k+j )
448  IF( temp.GT.smax ) THEN
449  isub = j
450  smax = temp
451  END IF
452  10 CONTINUE
453  IF( isub.NE.i ) THEN
454  rwork( k+isub ) = rwork( k+i )
455  rwork( k+i ) = smax
456  iwork( k+i ) = k + isub
457  ELSE
458  iwork( k+i ) = k + i
459  END IF
460  20 CONTINUE
461 *
462  RETURN
463 *
464 * End of CGGSVD
465 *
real function clange(NORM, M, N, A, LDA, WORK)
CLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition: clange.f:117
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
subroutine cggsvp(JOBU, JOBV, JOBQ, M, P, N, A, LDA, B, LDB, TOLA, TOLB, K, L, U, LDU, V, LDV, Q, LDQ, IWORK, RWORK, TAU, WORK, INFO)
CGGSVP
Definition: cggsvp.f:264
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:69
subroutine ctgsja(JOBU, JOBV, JOBQ, M, P, N, K, L, A, LDA, B, LDB, TOLA, TOLB, ALPHA, BETA, U, LDU, V, LDV, Q, LDQ, WORK, NCYCLE, INFO)
CTGSJA
Definition: ctgsja.f:381
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
subroutine scopy(N, SX, INCX, SY, INCY)
SCOPY
Definition: scopy.f:53

Here is the call graph for this function: