zunhr_col02()

subroutine zunhr_col02	(	integer	m,
		integer	n,
		integer	mb1,
		integer	nb1,
		integer	nb2,
		double precision, dimension(6)	result
	)

ZUNHR_COL02

Purpose:

 ZUNHR_COL02 tests ZUNGTSQR_ROW and ZUNHR_COL inside ZGETSQRHRT
 (which calls ZLATSQR, ZUNGTSQR_ROW and ZUNHR_COL) using ZGEMQRT.
 Therefore, ZLATSQR (part of ZGEQR), ZGEMQRT (part of ZGEMQR)
 have to be tested before this test.

Parameters

[in]	M	M is INTEGER Number of rows in test matrix.
[in]	N	N is INTEGER Number of columns in test matrix.
[in]	MB1	MB1 is INTEGER Number of row in row block in an input test matrix.
[in]	NB1	NB1 is INTEGER Number of columns in column block an input test matrix.
[in]	NB2	NB2 is INTEGER Number of columns in column block in an output test matrix.
[out]	RESULT	RESULT is DOUBLE PRECISION 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 ZGEQRT 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 ZGEMQRT, Q * C, (Q**H) * C, D * Q, D * (Q**H) are computed using ZGEMM.

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 119 of file zunhr_col02.f.

      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 ..
      DOUBLE PRECISION  RESULT(6)
*
*  =====================================================================
*
*     ..
*     .. Local allocatable arrays
      COMPLEX*16      , ALLOCATABLE ::  A(:,:), AF(:,:), Q(:,:), R(:,:),
     $                   WORK( : ), T1(:,:), T2(:,:), DIAG(:),
     $                   C(:,:), CF(:,:), D(:,:), DF(:,:)
      DOUBLE PRECISION, ALLOCATABLE :: RWORK(:)
*
*     .. Parameters ..
      DOUBLE PRECISION   ZERO
      parameter( zero = 0.0d+0 )
      COMPLEX*16         CONE, CZERO
      parameter( cone = ( 1.0d+0, 0.0d+0 ),
     $                     czero = ( 0.0d+0, 0.0d+0 ) )
*     ..
*     .. Local Scalars ..
      LOGICAL            TESTZEROS
      INTEGER            INFO, J, K, L, LWORK, NB2_UB, NRB
      DOUBLE PRECISION   ANORM, EPS, RESID, CNORM, DNORM
*     ..
*     .. Local Arrays ..
      INTEGER            ISEED( 4 )
      COMPLEX*16         WORKQUERY( 1 )
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DLAMCH, ZLANGE, ZLANSY
      EXTERNAL           dlamch, zlange, zlansy
*     ..
*     .. External Subroutines ..
      EXTERNAL           zlacpy, zlarnv, zlaset, zgetsqrhrt,
     $                   zscal, zgemm, zgemqrt, zherk
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          ceiling, dble, 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 = dlamch( '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 zlarnv( 2, iseed, m, a( 1, j ) )
      END DO
      IF( testzeros ) THEN
         IF( m.GE.4 ) THEN
            DO j = 1, n
               CALL zlarnv( 2, iseed, m/2, a( m/4, j ) )
            END DO
         END IF
      END IF
      CALL zlacpy( 'Full', m, n, a, m, af, m )
*
*     Number of row blocks in ZLATSQR
*
      nrb = max( 1, ceiling( dble( m - n ) / dble( mb1 - n ) ) )
*
      ALLOCATE ( t1( nb1, n * nrb ) )
      ALLOCATE ( t2( nb2, n ) )
      ALLOCATE ( diag( n ) )
*
*     Begin determine LWORK for the array WORK and allocate memory.
*
*     ZGEMQRT requires NB2 to be bounded by N.
*
      nb2_ub = min( nb2, n)
*
*
      CALL zgetsqrhrt( m, n, mb1, nb1, nb2, af, m, t2, nb2,
     $                 workquery, -1, info )
*
      lwork = int( workquery( 1 ) )
*
*     In ZGEMQRT, 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 = 'ZGETSQRHRT'
      CALL zgetsqrhrt( m, n, mb1, nb1, nb2, af, m, t2, nb2,
     $                 work, lwork, info )
*
*     End Householder reconstruction routines.
*
*
*     Generate the m-by-m matrix Q
*
      CALL zlaset( 'Full', m, m, czero, cone, q, m )
*
      srnamt = 'ZGEMQRT'
      CALL zgemqrt( 'L', 'N', m, m, k, nb2_ub, af, m, t2, nb2, q, m,
     $              work, info )
*
*     Copy R
*
      CALL zlaset( 'Full', m, n, czero, czero, r, m )
*
      CALL zlacpy( 'Upper', m, n, af, m, r, m )
*
*     TEST 1
*     Compute |R - (Q**T)*A| / ( eps * m * |A| ) and store in RESULT(1)
*
      CALL zgemm( 'C', 'N', m, n, m, -cone, q, m, a, m, cone, r, m )
*
      anorm = zlange( '1', m, n, a, m, rwork )
      resid = zlange( '1', m, n, r, m, rwork )
      IF( anorm.GT.zero ) THEN
         result( 1 ) = resid / ( eps * max( 1, m ) * anorm )
      ELSE
         result( 1 ) = zero
      END IF
*
*     TEST 2
*     Compute |I - (Q**T)*Q| / ( eps * m ) and store in RESULT(2)
*
      CALL zlaset( 'Full', m, m, czero, cone, r, m )
      CALL zherk( 'U', 'C', m, m, real(-cone), q, m, real(cone), r, m )
      resid = zlansy( '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 zlarnv( 2, iseed, m, c( 1, j ) )
      END DO
      cnorm = zlange( '1', m, n, c, m, rwork )
      CALL zlacpy( 'Full', m, n, c, m, cf, m )
*
*     Apply Q to C as Q*C = CF
*
      srnamt = 'ZGEMQRT'
      CALL zgemqrt( '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 zgemm( 'N', 'N', m, n, m, -cone, q, m, c, m, cone, cf, m )
      resid = zlange( '1', m, n, cf, m, rwork )
      IF( cnorm.GT.zero ) THEN
         result( 3 ) = resid / ( eps * max( 1, m ) * cnorm )
      ELSE
         result( 3 ) = zero
      END IF
*
*     Copy C into CF again
*
      CALL zlacpy( 'Full', m, n, c, m, cf, m )
*
*     Apply Q to C as (Q**T)*C = CF
*
      srnamt = 'ZGEMQRT'
      CALL zgemqrt( 'L', 'C', m, n, k, nb2_ub, af, m, t2, nb2, cf, m,
     $               work, info )
*
*     TEST 4
*     Compute |CF - (Q**T)*C| / ( eps * m * |C|)
*
      CALL zgemm( 'C', 'N', m, n, m, -cone, q, m, c, m, cone, cf, m )
      resid = zlange( '1', m, n, cf, m, rwork )
      IF( cnorm.GT.zero ) 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 zlarnv( 2, iseed, n, d( 1, j ) )
      END DO
      dnorm = zlange( '1', n, m, d, n, rwork )
      CALL zlacpy( 'Full', n, m, d, n, df, n )
*
*     Apply Q to D as D*Q = DF
*
      srnamt = 'ZGEMQRT'
      CALL zgemqrt( '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 zgemm( 'N', 'N', n, m, m, -cone, d, n, q, m, cone, df, n )
      resid = zlange( '1', n, m, df, n, rwork )
      IF( dnorm.GT.zero ) THEN
         result( 5 ) = resid / ( eps * max( 1, m ) * dnorm )
      ELSE
         result( 5 ) = zero
      END IF
*
*     Copy D into DF again
*
      CALL zlacpy( 'Full', n, m, d, n, df, n )
*
*     Apply Q to D as D*QT = DF
*
      srnamt = 'ZGEMQRT'
      CALL zgemqrt( 'R', 'C', n, m, k, nb2_ub, af, m, t2, nb2, df, n,
     $               work, info )
*
*     TEST 6
*     Compute |DF - D*(Q**T)| / ( eps * m * |D| )
*
      CALL zgemm( 'N', 'C', n, m, m, -cone, d, n, q, m, cone, df, n )
      resid = zlange( '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 ZUNHR_COL02
*

Here is the call graph for this function:

Here is the caller graph for this function: