cgsvts3.f

Go to the documentation of this file.

*> \brief \b CGSVTS3
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at
*            http://www.netlib.org/lapack/explore-html/
*
*  Definition:
*  ===========
*
*       SUBROUTINE CGSVTS3( M, P, N, A, AF, LDA, B, BF, LDB, U, LDU, V,
*                           LDV, Q, LDQ, ALPHA, BETA, R, LDR, IWORK, WORK,
*                           LWORK, RWORK, RESULT )
*
*       .. Scalar Arguments ..
*       INTEGER            LDA, LDB, LDQ, LDR, LDU, LDV, LWORK, M, N, P
*       ..
*       .. Array Arguments ..
*       INTEGER            IWORK( * )
*       REAL               ALPHA( * ), BETA( * ), RESULT( 6 ), RWORK( * )
*       COMPLEX            A( LDA, * ), AF( LDA, * ), B( LDB, * ),
*      $                   BF( LDB, * ), Q( LDQ, * ), R( LDR, * ),
*      $                   U( LDU, * ), V( LDV, * ), WORK( LWORK )
*       ..
*
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> CGSVTS3 tests CGGSVD3, which computes the GSVD of an M-by-N matrix A
*> and a P-by-N matrix B:
*>              U'*A*Q = D1*R and V'*B*Q = D2*R.
*> \endverbatim
*
*  Arguments:
*  ==========
*
*> \param[in] M
*> \verbatim
*>          M is INTEGER
*>          The number of rows of the matrix A.  M >= 0.
*> \endverbatim
*>
*> \param[in] P
*> \verbatim
*>          P is INTEGER
*>          The number of rows of the matrix B.  P >= 0.
*> \endverbatim
*>
*> \param[in] N
*> \verbatim
*>          N is INTEGER
*>          The number of columns of the matrices A and B.  N >= 0.
*> \endverbatim
*>
*> \param[in] A
*> \verbatim
*>          A is COMPLEX array, dimension (LDA,M)
*>          The M-by-N matrix A.
*> \endverbatim
*>
*> \param[out] AF
*> \verbatim
*>          AF is COMPLEX array, dimension (LDA,N)
*>          Details of the GSVD of A and B, as returned by CGGSVD3,
*>          see CGGSVD3 for further details.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*>          LDA is INTEGER
*>          The leading dimension of the arrays A and AF.
*>          LDA >= max( 1,M ).
*> \endverbatim
*>
*> \param[in] B
*> \verbatim
*>          B is COMPLEX array, dimension (LDB,P)
*>          On entry, the P-by-N matrix B.
*> \endverbatim
*>
*> \param[out] BF
*> \verbatim
*>          BF is COMPLEX array, dimension (LDB,N)
*>          Details of the GSVD of A and B, as returned by CGGSVD3,
*>          see CGGSVD3 for further details.
*> \endverbatim
*>
*> \param[in] LDB
*> \verbatim
*>          LDB is INTEGER
*>          The leading dimension of the arrays B and BF.
*>          LDB >= max(1,P).
*> \endverbatim
*>
*> \param[out] U
*> \verbatim
*>          U is COMPLEX array, dimension(LDU,M)
*>          The M by M unitary matrix U.
*> \endverbatim
*>
*> \param[in] LDU
*> \verbatim
*>          LDU is INTEGER
*>          The leading dimension of the array U. LDU >= max(1,M).
*> \endverbatim
*>
*> \param[out] V
*> \verbatim
*>          V is COMPLEX array, dimension(LDV,M)
*>          The P by P unitary matrix V.
*> \endverbatim
*>
*> \param[in] LDV
*> \verbatim
*>          LDV is INTEGER
*>          The leading dimension of the array V. LDV >= max(1,P).
*> \endverbatim
*>
*> \param[out] Q
*> \verbatim
*>          Q is COMPLEX array, dimension(LDQ,N)
*>          The N by N unitary matrix Q.
*> \endverbatim
*>
*> \param[in] LDQ
*> \verbatim
*>          LDQ is INTEGER
*>          The leading dimension of the array Q. LDQ >= max(1,N).
*> \endverbatim
*>
*> \param[out] ALPHA
*> \verbatim
*>          ALPHA is REAL array, dimension (N)
*> \endverbatim
*>
*> \param[out] BETA
*> \verbatim
*>          BETA is REAL array, dimension (N)
*>
*>          The generalized singular value pairs of A and B, the
*>          ``diagonal'' matrices D1 and D2 are constructed from
*>          ALPHA and BETA, see subroutine CGGSVD3 for details.
*> \endverbatim
*>
*> \param[out] R
*> \verbatim
*>          R is COMPLEX array, dimension(LDQ,N)
*>          The upper triangular matrix R.
*> \endverbatim
*>
*> \param[in] LDR
*> \verbatim
*>          LDR is INTEGER
*>          The leading dimension of the array R. LDR >= max(1,N).
*> \endverbatim
*>
*> \param[out] IWORK
*> \verbatim
*>          IWORK is INTEGER array, dimension (N)
*> \endverbatim
*>
*> \param[out] WORK
*> \verbatim
*>          WORK is COMPLEX array, dimension (LWORK)
*> \endverbatim
*>
*> \param[in] LWORK
*> \verbatim
*>          LWORK is INTEGER
*>          The dimension of the array WORK,
*>          LWORK >= max(M,P,N)*max(M,P,N).
*> \endverbatim
*>
*> \param[out] RWORK
*> \verbatim
*>          RWORK is REAL array, dimension (max(M,P,N))
*> \endverbatim
*>
*> \param[out] RESULT
*> \verbatim
*>          RESULT is REAL array, dimension (6)
*>          The test ratios:
*>          RESULT(1) = norm( U'*A*Q - D1*R ) / ( MAX(M,N)*norm(A)*ULP)
*>          RESULT(2) = norm( V'*B*Q - D2*R ) / ( MAX(P,N)*norm(B)*ULP)
*>          RESULT(3) = norm( I - U'*U ) / ( M*ULP )
*>          RESULT(4) = norm( I - V'*V ) / ( P*ULP )
*>          RESULT(5) = norm( I - Q'*Q ) / ( N*ULP )
*>          RESULT(6) = 0        if ALPHA is in decreasing order;
*>                    = ULPINV   otherwise.
*> \endverbatim
*
*  Authors:
*  ========
*
*> \author Univ. of Tennessee
*> \author Univ. of California Berkeley
*> \author Univ. of Colorado Denver
*> \author NAG Ltd.
*
*> \ingroup complex_eig
*
*  =====================================================================
      SUBROUTINE cgsvts3( M, P, N, A, AF, LDA, B, BF, LDB, U, LDU, V,
     $                    LDV, Q, LDQ, ALPHA, BETA, R, LDR, IWORK, WORK,
     $                    LWORK, RWORK, RESULT )
*
*  -- LAPACK test routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      INTEGER            LDA, LDB, LDQ, LDR, LDU, LDV, LWORK, M, N, P
*     ..
*     .. Array Arguments ..
      INTEGER            IWORK( * )
      REAL               ALPHA( * ), BETA( * ), RESULT( 6 ), RWORK( * )
      COMPLEX            A( LDA, * ), AF( LDA, * ), B( LDB, * ),
     $                   bf( ldb, * ), q( ldq, * ), r( ldr, * ),
     $                   u( ldu, * ), v( ldv, * ), work( lwork )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               ZERO, ONE
      PARAMETER          ( ZERO = 0.0e+0, one = 1.0e+0 )
      COMPLEX            CZERO, CONE
      parameter( czero = ( 0.0e+0, 0.0e+0 ),
     $                   cone = ( 1.0e+0, 0.0e+0 ) )
*     ..
*     .. Local Scalars ..
      INTEGER            I, INFO, J, K, L
      REAL               ANORM, BNORM, RESID, TEMP, ULP, ULPINV, UNFL
*     ..
*     .. External Functions ..
      REAL               CLANGE, CLANHE, SLAMCH
      EXTERNAL           CLANGE, CLANHE, SLAMCH
*     ..
*     .. External Subroutines ..
      EXTERNAL           cgemm, cggsvd3, cherk, clacpy, claset, scopy
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max, min, real
*     ..
*     .. Executable Statements ..
*
      ulp = slamch( 'Precision' )
      ulpinv = one / ulp
      unfl = slamch( 'Safe minimum' )
*
*     Copy the matrix A to the array AF.
*
      CALL clacpy( 'Full', m, n, a, lda, af, lda )
      CALL clacpy( 'Full', p, n, b, ldb, bf, ldb )
*
      anorm = max( clange( '1', m, n, a, lda, rwork ), unfl )
      bnorm = max( clange( '1', p, n, b, ldb, rwork ), unfl )
*
*     Factorize the matrices A and B in the arrays AF and BF.
*
      CALL cggsvd3( 'U', 'V', 'Q', m, n, p, k, l, af, lda, bf, ldb,
     $              alpha, beta, u, ldu, v, ldv, q, ldq, work, lwork,
     $              rwork, iwork, info )
*
*     Copy R
*
      DO 20 i = 1, min( k+l, m )
         DO 10 j = i, k + l
            r( i, j ) = af( i, n-k-l+j )
   10    CONTINUE
   20 CONTINUE
*
      IF( m-k-l.LT.0 ) THEN
         DO 40 i = m + 1, k + l
            DO 30 j = i, k + l
               r( i, j ) = bf( i-k, n-k-l+j )
   30       CONTINUE
   40    CONTINUE
      END IF
*
*     Compute A:= U'*A*Q - D1*R
*
      CALL cgemm( 'No transpose', 'No transpose', m, n, n, cone, a, lda,
     $            q, ldq, czero, work, lda )
*
      CALL cgemm( 'Conjugate transpose', 'No transpose', m, n, m, cone,
     $            u, ldu, work, lda, czero, a, lda )
*
      DO 60 i = 1, k
         DO 50 j = i, k + l
            a( i, n-k-l+j ) = a( i, n-k-l+j ) - r( i, j )
   50    CONTINUE
   60 CONTINUE
*
      DO 80 i = k + 1, min( k+l, m )
         DO 70 j = i, k + l
            a( i, n-k-l+j ) = a( i, n-k-l+j ) - alpha( i )*r( i, j )
   70    CONTINUE
   80 CONTINUE
*
*     Compute norm( U'*A*Q - D1*R ) / ( MAX(1,M,N)*norm(A)*ULP ) .
*
      resid = clange( '1', m, n, a, lda, rwork )
      IF( anorm.GT.zero ) THEN
         result( 1 ) = ( ( resid / real( max( 1, m, n ) ) ) / anorm ) /
     $                 ulp
      ELSE
         result( 1 ) = zero
      END IF
*
*     Compute B := V'*B*Q - D2*R
*
      CALL cgemm( 'No transpose', 'No transpose', p, n, n, cone, b, ldb,
     $            q, ldq, czero, work, ldb )
*
      CALL cgemm( 'Conjugate transpose', 'No transpose', p, n, p, cone,
     $            v, ldv, work, ldb, czero, b, ldb )
*
      DO 100 i = 1, l
         DO 90 j = i, l
            b( i, n-l+j ) = b( i, n-l+j ) - beta( k+i )*r( k+i, k+j )
   90    CONTINUE
  100 CONTINUE
*
*     Compute norm( V'*B*Q - D2*R ) / ( MAX(P,N)*norm(B)*ULP ) .
*
      resid = clange( '1', p, n, b, ldb, rwork )
      IF( bnorm.GT.zero ) THEN
         result( 2 ) = ( ( resid / real( max( 1, p, n ) ) ) / bnorm ) /
     $                 ulp
      ELSE
         result( 2 ) = zero
      END IF
*
*     Compute I - U'*U
*
      CALL claset( 'Full', m, m, czero, cone, work, ldq )
      CALL cherk( 'Upper', 'Conjugate transpose', m, m, -one, u, ldu,
     $            one, work, ldu )
*
*     Compute norm( I - U'*U ) / ( M * ULP ) .
*
      resid = clanhe( '1', 'Upper', m, work, ldu, rwork )
      result( 3 ) = ( resid / real( max( 1, m ) ) ) / ulp
*
*     Compute I - V'*V
*
      CALL claset( 'Full', p, p, czero, cone, work, ldv )
      CALL cherk( 'Upper', 'Conjugate transpose', p, p, -one, v, ldv,
     $            one, work, ldv )
*
*     Compute norm( I - V'*V ) / ( P * ULP ) .
*
      resid = clanhe( '1', 'Upper', p, work, ldv, rwork )
      result( 4 ) = ( resid / real( max( 1, p ) ) ) / ulp
*
*     Compute I - Q'*Q
*
      CALL claset( 'Full', n, n, czero, cone, work, ldq )
      CALL cherk( 'Upper', 'Conjugate transpose', n, n, -one, q, ldq,
     $            one, work, ldq )
*
*     Compute norm( I - Q'*Q ) / ( N * ULP ) .
*
      resid = clanhe( '1', 'Upper', n, work, ldq, rwork )
      result( 5 ) = ( resid / real( max( 1, n ) ) ) / ulp
*
*     Check sorting
*
      CALL scopy( n, alpha, 1, rwork, 1 )
      DO 110 i = k + 1, min( k+l, m )
         j = iwork( i )
         IF( i.NE.j ) THEN
            temp = rwork( i )
            rwork( i ) = rwork( j )
            rwork( j ) = temp
         END IF
  110 CONTINUE
*
      result( 6 ) = zero
      DO 120 i = k + 1, min( k+l, m ) - 1
         IF( rwork( i ).LT.rwork( i+1 ) )
     $      result( 6 ) = ulpinv
  120 CONTINUE
*
      RETURN
*
*     End of CGSVTS3
*
      SUBROUTINE cgsvts3( M, P, N, A, AF, LDA, B, BF, LDB, U, LDU, V, …
      END