LAPACK  3.5.0
LAPACK: Linear Algebra PACKage
cggsvd.f File Reference

Go to the source code of this file.

Functions/Subroutines

subroutine cggsvd (JOBU, JOBV, JOBQ, M, N, P, K, L, A, LDA, B, LDB, ALPHA, BETA, U, LDU, V, LDV, Q, LDQ, WORK, RWORK, IWORK, INFO)
  CGGSVD computes the singular value decomposition (SVD) for OTHER matrices More...
 

Function/Subroutine Documentation

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:
 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 338 of file cggsvd.f.

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

Here is the call graph for this function:

Here is the caller graph for this function: