cunhr_col01.f

Go to the documentation of this file.

*> \brief \b CUNHR_COL01
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at
*            http://www.netlib.org/lapack/explore-html/
*
*  Definition:
*  ===========
*
*       SUBROUTINE CUNHR_COL01( M, N, MB1, NB1, NB2, RESULT )
*
*       .. Scalar Arguments ..
*       INTEGER           M, N, MB1, NB1, NB2
*       .. Return values ..
*       DOUBLE PRECISION  RESULT(6)
*
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> CUNHR_COL01 tests CUNGTSQR and CUNHR_COL using CLATSQR, CGEMQRT.
*> Therefore, CLATSQR (part of CGEQR), CGEMQRT (part of CGEMQR)
*> have to be tested before this test.
*>
*> \endverbatim
*
*  Arguments:
*  ==========
*
*> \param[in] M
*> \verbatim
*>          M is INTEGER
*>          Number of rows in test matrix.
*> \endverbatim
*> \param[in] N
*> \verbatim
*>          N is INTEGER
*>          Number of columns in test matrix.
*> \endverbatim
*> \param[in] MB1
*> \verbatim
*>          MB1 is INTEGER
*>          Number of row in row block in an input test matrix.
*> \endverbatim
*>
*> \param[in] NB1
*> \verbatim
*>          NB1 is INTEGER
*>          Number of columns in column block an input test matrix.
*> \endverbatim
*>
*> \param[in] NB2
*> \verbatim
*>          NB2 is INTEGER
*>          Number of columns in column block in an output test matrix.
*> \endverbatim
*>
*> \param[out] RESULT
*> \verbatim
*>          RESULT is REAL array, dimension (6)
*>          Results of each of the six tests below.
*>
*>            A is a m-by-n test input matrix to be factored.
*>            so that A = Q_gr * ( R )
*>                               ( 0 ),
*>
*>            Q_qr is an implicit m-by-m unitary Q matrix, the result
*>            of factorization in blocked WY-representation,
*>            stored in CGEQRT output format.
*>
*>            R is a n-by-n upper-triangular matrix,
*>
*>            0 is a (m-n)-by-n zero matrix,
*>
*>            Q is an explicit m-by-m unitary matrix Q = Q_gr * I
*>
*>            C is an m-by-n random matrix,
*>
*>            D is an n-by-m random matrix.
*>
*>          The six tests are:
*>
*>          RESULT(1) = |R - (Q**H) * A| / ( eps * m * |A| )
*>            is equivalent to test for | A - Q * R | / (eps * m * |A|),
*>
*>          RESULT(2) = |I - (Q**H) * Q| / ( eps * m ),
*>
*>          RESULT(3) = | Q_qr * C - Q * C | / (eps * m * |C|),
*>
*>          RESULT(4) = | (Q_gr**H) * C - (Q**H) * C | / (eps * m * |C|)
*>
*>          RESULT(5) = | D * Q_qr - D * Q | / (eps * m * |D|)
*>
*>          RESULT(6) = | D * (Q_qr**H) - D * (Q**H) | / (eps * m * |D|),
*>
*>          where:
*>            Q_qr * C, (Q_gr**H) * C, D * Q_qr, D * (Q_qr**H) are
*>            computed using CGEMQRT,
*>
*>            Q * C, (Q**H) * C, D * Q, D * (Q**H)  are
*>            computed using CGEMM.
*> \endverbatim
*
*  Authors:
*  ========
*
*> \author Univ. of Tennessee
*> \author Univ. of California Berkeley
*> \author Univ. of Colorado Denver
*> \author NAG Ltd.
*
*> \ingroup complex_lin
*
*  =====================================================================
      SUBROUTINE cunhr_col01( M, N, MB1, NB1, NB2, RESULT )
      IMPLICIT NONE
*
*  -- 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           M, N, MB1, NB1, NB2
*     .. Return values ..
      REAL              RESULT(6)
*
*  =====================================================================
*
*     ..
*     .. Local allocatable arrays
      COMPLEX         , ALLOCATABLE ::  A(:,:), AF(:,:), Q(:,:), R(:,:),
     $                   WORK( : ), T1(:,:), T2(:,:), DIAG(:),
     $                   C(:,:), CF(:,:), D(:,:), DF(:,:)
      REAL            , ALLOCATABLE :: RWORK(:)
*
*     .. Parameters ..
      REAL               ZERO
      parameter( zero = 0.0e+0 )
      COMPLEX            CONE, CZERO
      parameter( cone = ( 1.0e+0, 0.0e+0 ),
     $                     czero = ( 0.0e+0, 0.0e+0 ) )
*     ..
*     .. Local Scalars ..
      LOGICAL            TESTZEROS
      INTEGER            INFO, I, J, K, L, LWORK, NB1_UB, NB2_UB, NRB
      REAL               ANORM, EPS, RESID, CNORM, DNORM
*     ..
*     .. Local Arrays ..
      INTEGER            ISEED( 4 )
      COMPLEX            WORKQUERY( 1 )
*     ..
*     .. External Functions ..
      REAL               SLAMCH, CLANGE, CLANSY
      EXTERNAL           slamch, clange, clansy
*     ..
*     .. External Subroutines ..
      EXTERNAL           clacpy, clarnv, claset, clatsqr, cunhr_col,
     $                   cungtsqr, cscal, cgemm, cgemqrt, cherk
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          ceiling, real, max, min
*     ..
*     .. Scalars in Common ..
      CHARACTER(LEN=32)  SRNAMT
*     ..
*     .. Common blocks ..
      COMMON             / srmnamc / srnamt
*     ..
*     .. Data statements ..
      DATA iseed / 1988, 1989, 1990, 1991 /
*
*     TEST MATRICES WITH HALF OF MATRIX BEING ZEROS
*
      testzeros = .false.
*
      eps = slamch( 'Epsilon' )
      k = min( m, n )
      l = max( m, n, 1)
*
*     Dynamically allocate local arrays
*
      ALLOCATE ( a(m,n), af(m,n), q(l,l), r(m,l), rwork(l),
     $           c(m,n), cf(m,n),
     $           d(n,m), df(n,m) )
*
*     Put random numbers into A and copy to AF
*
      DO j = 1, n
         CALL clarnv( 2, iseed, m, a( 1, j ) )
      END DO
      IF( testzeros ) THEN
         IF( m.GE.4 ) THEN
            DO j = 1, n
               CALL clarnv( 2, iseed, m/2, a( m/4, j ) )
            END DO
         END IF
      END IF
      CALL clacpy( 'Full', m, n, a, m, af, m )
*
*     Number of row blocks in CLATSQR
*
      nrb = max( 1, ceiling( real( m - n ) / real( mb1 - n ) ) )
*
      ALLOCATE ( t1( nb1, n * nrb ) )
      ALLOCATE ( t2( nb2, n ) )
      ALLOCATE ( diag( n ) )
*
*     Begin determine LWORK for the array WORK and allocate memory.
*
*     CLATSQR requires NB1 to be bounded by N.
*
      nb1_ub = min( nb1, n)
*
*     CGEMQRT requires NB2 to be bounded by N.
*
      nb2_ub = min( nb2, n)
*
      CALL clatsqr( m, n, mb1, nb1_ub, af, m, t1, nb1,
     $              workquery, -1, info )
      lwork = int( workquery( 1 ) )
      CALL cungtsqr( m, n, mb1, nb1, af, m, t1, nb1, workquery, -1,
     $               info )
 
      lwork = max( lwork, int( workquery( 1 ) ) )
*
*     In CGEMQRT, WORK is N*NB2_UB if SIDE = 'L',
*                or  M*NB2_UB if SIDE = 'R'.
*
      lwork = max( lwork, nb2_ub * n, nb2_ub * m )
*
      ALLOCATE ( work( lwork ) )
*
*     End allocate memory for WORK.
*
*
*     Begin Householder reconstruction routines
*
*     Factor the matrix A in the array AF.
*
      srnamt = 'CLATSQR'
      CALL clatsqr( m, n, mb1, nb1_ub, af, m, t1, nb1, work, lwork,
     $              info )
*
*     Copy the factor R into the array R.
*
      srnamt = 'CLACPY'
      CALL clacpy( 'U', n, n, af, m, r, m )
*
*     Reconstruct the orthogonal matrix Q.
*
      srnamt = 'CUNGTSQR'
      CALL cungtsqr( m, n, mb1, nb1, af, m, t1, nb1, work, lwork,
     $               info )
*
*     Perform the Householder reconstruction, the result is stored
*     the arrays AF and T2.
*
      srnamt = 'cunhr_col'
      CALL CUNHR_COL( M, N, NB2, AF, M, T2, NB2, DIAG, INFO )
*
*     Compute the factor R_hr corresponding to the Householder
*     reconstructed Q_hr and place it in the upper triangle of AF to
*     match the Q storage format in CGEQRT. R_hr = R_tsqr * S,
*     this means changing the sign of I-th row of the matrix R_tsqr
*     according to sign of of I-th diagonal element DIAG(I) of the
*     matrix S.
*
      SRNAMT = 'clacpy'
      CALL CLACPY( 'u', N, N, R, M, AF, M )
*
      DO I = 1, N
.EQ.         IF( DIAG( I )-CONE ) THEN
            CALL CSCAL( N+1-I, -CONE, AF( I, I ), M )
         END IF
      END DO
*
*     End Householder reconstruction routines.
*
*
*     Generate the m-by-m matrix Q
*
      CALL CLASET( 'full', M, M, CZERO, CONE, Q, M )
*
      SRNAMT = 'cgemqrt'
      CALL CGEMQRT( 'l', 'n', M, M, K, NB2_UB, AF, M, T2, NB2, Q, M,
     $              WORK, INFO )
*
*     Copy R
*
      CALL CLASET( 'full', M, N, CZERO, CZERO, R, M )
*
      CALL CLACPY( 'upper', M, N, AF, M, R, M )
*
*     TEST 1
*     Compute |R - (Q**H)*A| / ( eps * m * |A| ) and store in RESULT(1)
*
      CALL CGEMM( 'c', 'n', M, N, M, -CONE, Q, M, A, M, CONE, R, M )
*
      ANORM = CLANGE( '1', M, N, A, M, RWORK )
      RESID = CLANGE( '1', M, N, R, M, RWORK )
.GT.      IF( ANORMZERO ) THEN
         RESULT( 1 ) = RESID / ( EPS * MAX( 1, M ) * ANORM )
      ELSE
         RESULT( 1 ) = ZERO
      END IF
*
*     TEST 2
*     Compute |I - (Q**H)*Q| / ( eps * m ) and store in RESULT(2)
*
      CALL CLASET( 'full', M, M, CZERO, CONE, R, M )
      CALL CHERK( 'u', 'c', M, M, -CONE, Q, M, CONE, R, M )
      RESID = CLANSY( '1', 'upper', M, R, M, RWORK )
      RESULT( 2 ) = RESID / ( EPS * MAX( 1, M ) )
*
*     Generate random m-by-n matrix C
*
      DO J = 1, N
         CALL CLARNV( 2, ISEED, M, C( 1, J ) )
      END DO
      CNORM = CLANGE( '1', M, N, C, M, RWORK )
      CALL CLACPY( 'full', M, N, C, M, CF, M )
*
*     Apply Q to C as Q*C = CF
*
      SRNAMT = 'cgemqrt'
      CALL CGEMQRT( 'l', 'n', M, N, K, NB2_UB, AF, M, T2, NB2, CF, M,
     $               WORK, INFO )
*
*     TEST 3
*     Compute |CF - Q*C| / ( eps *  m * |C| )
*
      CALL CGEMM( 'n', 'n', M, N, M, -CONE, Q, M, C, M, CONE, CF, M )
      RESID = CLANGE( '1', M, N, CF, M, RWORK )
.GT.      IF( CNORMZERO ) THEN
         RESULT( 3 ) = RESID / ( EPS * MAX( 1, M ) * CNORM )
      ELSE
         RESULT( 3 ) = ZERO
      END IF
*
*     Copy C into CF again
*
      CALL CLACPY( 'full', M, N, C, M, CF, M )
*
*     Apply Q to C as (Q**H)*C = CF
*
      SRNAMT = 'cgemqrt'
      CALL CGEMQRT( 'l', 'c', M, N, K, NB2_UB, AF, M, T2, NB2, CF, M,
     $               WORK, INFO )
*
*     TEST 4
*     Compute |CF - (Q**H)*C| / ( eps * m * |C|)
*
      CALL CGEMM( 'c', 'n', M, N, M, -CONE, Q, M, C, M, CONE, CF, M )
      RESID = CLANGE( '1', M, N, CF, M, RWORK )
.GT.      IF( CNORMZERO ) THEN
         RESULT( 4 ) = RESID / ( EPS * MAX( 1, M ) * CNORM )
      ELSE
         RESULT( 4 ) = ZERO
      END IF
*
*     Generate random n-by-m matrix D and a copy DF
*
      DO J = 1, M
         CALL CLARNV( 2, ISEED, N, D( 1, J ) )
      END DO
      DNORM = CLANGE( '1', N, M, D, N, RWORK )
      CALL CLACPY( 'full', N, M, D, N, DF, N )
*
*     Apply Q to D as D*Q = DF
*
      SRNAMT = 'cgemqrt'
      CALL CGEMQRT( 'r', 'n', N, M, K, NB2_UB, AF, M, T2, NB2, DF, N,
     $               WORK, INFO )
*
*     TEST 5
*     Compute |DF - D*Q| / ( eps * m * |D| )
*
      CALL CGEMM( 'n', 'n', N, M, M, -CONE, D, N, Q, M, CONE, DF, N )
      RESID = CLANGE( '1', N, M, DF, N, RWORK )
.GT.      IF( DNORMZERO ) THEN
         RESULT( 5 ) = RESID / ( EPS * MAX( 1, M ) * DNORM )
      ELSE
         RESULT( 5 ) = ZERO
      END IF
*
*     Copy D into DF again
*
      CALL CLACPY( 'full', N, M, D, N, DF, N )
*
*     Apply Q to D as D*QT = DF
*
      SRNAMT = 'cgemqrt'
      CALL CGEMQRT( 'r', 'C', n, m, k, nb2_ub, af, m, t2, nb2, df, n,
     $               work, info )
*
*     TEST 6
*     Compute |DF - D*(Q**H)| / ( eps * m * |D| )
*
      CALL cgemm( 'N', 'C', n, m, m, -cone, d, n, q, m, cone, df, n )
      resid = clange( '1', n, m, df, n, rwork )
      IF( dnorm.GT.zero ) THEN
         result( 6 ) = resid / ( eps * max( 1, m ) * dnorm )
      ELSE
         result( 6 ) = zero
      END IF
*
*     Deallocate all arrays
*
      DEALLOCATE ( a, af, q, r, rwork, work, t1, t2, diag,
     $             c, d, cf, df )
*
      RETURN
*
*     End of CUNHR_COL01
*
      END