zckcsd.f

Go to the documentation of this file.

*> \brief \b ZCKCSD
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at
*            http://www.netlib.org/lapack/explore-html/
*
*  Definition:
*  ===========
*
*       SUBROUTINE ZCKCSD( NM, MVAL, PVAL, QVAL, NMATS, ISEED, THRESH,
*                          MMAX, X, XF, U1, U2, V1T, V2T, THETA, IWORK,
*                          WORK, RWORK, NIN, NOUT, INFO )
*
*       .. Scalar Arguments ..
*       INTEGER            INFO, NIN, NM, NMATS, MMAX, NOUT
*       DOUBLE PRECISION   THRESH
*       ..
*       .. Array Arguments ..
*       INTEGER            ISEED( 4 ), IWORK( * ), MVAL( * ), PVAL( * ),
*      $                   QVAL( * )
*       DOUBLE PRECISION   RWORK( * ), THETA( * )
*       COMPLEX*16         U1( * ), U2( * ), V1T( * ), V2T( * ),
*      $                   WORK( * ), X( * ), XF( * )
*       ..
*
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> ZCKCSD tests ZUNCSD:
*>        the CSD for an M-by-M unitary matrix X partitioned as
*>        [ X11 X12; X21 X22 ]. X11 is P-by-Q.
*> \endverbatim
*
*  Arguments:
*  ==========
*
*> \param[in] NM
*> \verbatim
*>          NM is INTEGER
*>          The number of values of M contained in the vector MVAL.
*> \endverbatim
*>
*> \param[in] MVAL
*> \verbatim
*>          MVAL is INTEGER array, dimension (NM)
*>          The values of the matrix row dimension M.
*> \endverbatim
*>
*> \param[in] PVAL
*> \verbatim
*>          PVAL is INTEGER array, dimension (NM)
*>          The values of the matrix row dimension P.
*> \endverbatim
*>
*> \param[in] QVAL
*> \verbatim
*>          QVAL is INTEGER array, dimension (NM)
*>          The values of the matrix column dimension Q.
*> \endverbatim
*>
*> \param[in] NMATS
*> \verbatim
*>          NMATS is INTEGER
*>          The number of matrix types to be tested for each combination
*>          of matrix dimensions.  If NMATS >= NTYPES (the maximum
*>          number of matrix types), then all the different types are
*>          generated for testing.  If NMATS < NTYPES, another input line
*>          is read to get the numbers of the matrix types to be used.
*> \endverbatim
*>
*> \param[in,out] ISEED
*> \verbatim
*>          ISEED is INTEGER array, dimension (4)
*>          On entry, the seed of the random number generator.  The array
*>          elements should be between 0 and 4095, otherwise they will be
*>          reduced mod 4096, and ISEED(4) must be odd.
*>          On exit, the next seed in the random number sequence after
*>          all the test matrices have been generated.
*> \endverbatim
*>
*> \param[in] THRESH
*> \verbatim
*>          THRESH is DOUBLE PRECISION
*>          The threshold value for the test ratios.  A result is
*>          included in the output file if RESULT >= THRESH.  To have
*>          every test ratio printed, use THRESH = 0.
*> \endverbatim
*>
*> \param[in] MMAX
*> \verbatim
*>          MMAX is INTEGER
*>          The maximum value permitted for M, used in dimensioning the
*>          work arrays.
*> \endverbatim
*>
*> \param[out] X
*> \verbatim
*>          X is COMPLEX*16 array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] XF
*> \verbatim
*>          XF is COMPLEX*16 array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] U1
*> \verbatim
*>          U1 is COMPLEX*16 array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] U2
*> \verbatim
*>          U2 is COMPLEX*16 array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] V1T
*> \verbatim
*>          V1T is COMPLEX*16 array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] V2T
*> \verbatim
*>          V2T is COMPLEX*16 array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] THETA
*> \verbatim
*>          THETA is DOUBLE PRECISION array, dimension (MMAX)
*> \endverbatim
*>
*> \param[out] IWORK
*> \verbatim
*>          IWORK is INTEGER array, dimension (MMAX)
*> \endverbatim
*>
*> \param[out] WORK
*> \verbatim
*>          WORK is COMPLEX*16 array
*> \endverbatim
*>
*> \param[out] RWORK
*> \verbatim
*>          RWORK is DOUBLE PRECISION array
*> \endverbatim
*>
*> \param[in] NIN
*> \verbatim
*>          NIN is INTEGER
*>          The unit number for input.
*> \endverbatim
*>
*> \param[in] NOUT
*> \verbatim
*>          NOUT is INTEGER
*>          The unit number for output.
*> \endverbatim
*>
*> \param[out] INFO
*> \verbatim
*>          INFO is INTEGER
*>          = 0 :  successful exit
*>          > 0 :  If ZLAROR returns an error code, the absolute value
*>                 of it is returned.
*> \endverbatim
*
*  Authors:
*  ========
*
*> \author Univ. of Tennessee
*> \author Univ. of California Berkeley
*> \author Univ. of Colorado Denver
*> \author NAG Ltd.
*
*> \ingroup complex16_eig
*
*  =====================================================================
      SUBROUTINE zckcsd( NM, MVAL, PVAL, QVAL, NMATS, ISEED, THRESH,
     $                   MMAX, X, XF, U1, U2, V1T, V2T, THETA, IWORK,
     $                   WORK, RWORK, NIN, NOUT, INFO )
*
*  -- 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            INFO, NIN, NM, NMATS, MMAX, NOUT
      DOUBLE PRECISION   THRESH
*     ..
*     .. Array Arguments ..
      INTEGER            ISEED( 4 ), IWORK( * ), MVAL( * ), PVAL( * ),
     $                   QVAL( * )
      DOUBLE PRECISION   RWORK( * ), THETA( * )
      COMPLEX*16         U1( * ), U2( * ), V1T( * ), V2T( * ),
     $                   work( * ), x( * ), xf( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      INTEGER            NTESTS
      PARAMETER          ( NTESTS = 15 )
      INTEGER            NTYPES
      parameter( ntypes = 4 )
      DOUBLE PRECISION   GAPDIGIT, ORTH, REALONE, REALZERO, TEN
      parameter( gapdigit = 18.0d0, orth = 1.0d-12,
     $                     realone = 1.0d0, realzero = 0.0d0,
     $                     ten = 10.0d0 )
      COMPLEX*16         ONE, ZERO
      PARAMETER          ( ONE = (1.0d0,0.0d0), zero = (0.0d0,0.0d0) )
      DOUBLE PRECISION   PIOVER2
      parameter( piover2 = 1.57079632679489661923132169163975144210d0 )
*     ..
*     .. Local Scalars ..
      LOGICAL            FIRSTT
      CHARACTER*3        PATH
      INTEGER            I, IINFO, IM, IMAT, J, LDU1, LDU2, LDV1T,
     $                   ldv2t, ldx, lwork, m, nfail, nrun, nt, p, q, r
*     ..
*     .. Local Arrays ..
      LOGICAL            DOTYPE( NTYPES )
      DOUBLE PRECISION   RESULT( NTESTS )
*     ..
*     .. External Subroutines ..
      EXTERNAL           alahdg, alareq, alasum, zcsdts, zlacsg, zlaror,
     $                   zlaset, zdrot
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, min
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DLARAN, DLARND
      EXTERNAL           DLARAN, DLARND
*     ..
*     .. Executable Statements ..
*
*     Initialize constants and the random number seed.
*
      path( 1: 3 ) = 'CSD'
      info = 0
      nrun = 0
      nfail = 0
      firstt = .true.
      CALL alareq( path, nmats, dotype, ntypes, nin, nout )
      ldx = mmax
      ldu1 = mmax
      ldu2 = mmax
      ldv1t = mmax
      ldv2t = mmax
      lwork = mmax*mmax
*
*     Do for each value of M in MVAL.
*
      DO 30 im = 1, nm
         m = mval( im )
         p = pval( im )
         q = qval( im )
*
         DO 20 imat = 1, ntypes
*
*           Do the tests only if DOTYPE( IMAT ) is true.
*
            IF( .NOT.dotype( imat ) )
     $         GO TO 20
*
*           Generate X
*
            IF( imat.EQ.1 ) THEN
               CALL zlaror( 'L', 'I', m, m, x, ldx, iseed, work, iinfo )
               IF( m .NE. 0 .AND. iinfo .NE. 0 ) THEN
                  WRITE( nout, fmt = 9999 ) m, iinfo
                  info = abs( iinfo )
                  GO TO 20
               END IF
            ELSE IF( imat.EQ.2 ) THEN
               r = min( p, m-p, q, m-q )
               DO i = 1, r
                  theta(i) = piover2 * dlarnd( 1, iseed )
               END DO
               CALL zlacsg( m, p, q, theta, iseed, x, ldx, work )
               DO i = 1, m
                  DO j = 1, m
                     x(i+(j-1)*ldx) = x(i+(j-1)*ldx) +
     $                                orth*dlarnd(2,iseed)
                  END DO
               END DO
            ELSE IF( imat.EQ.3 ) THEN
               r = min( p, m-p, q, m-q )
               DO i = 1, r+1
                  theta(i) = ten**(-dlarnd(1,iseed)*gapdigit)
               END DO
               DO i = 2, r+1
                  theta(i) = theta(i-1) + theta(i)
               END DO
               DO i = 1, r
                  theta(i) = piover2 * theta(i) / theta(r+1)
               END DO
               CALL zlacsg( m, p, q, theta, iseed, x, ldx, work )
            ELSE
               CALL zlaset( 'f', M, M, ZERO, ONE, X, LDX )
               DO I = 1, M
                  J = INT( DLARAN( ISEED ) * M ) + 1
.NE.                  IF( J  I ) THEN
                     CALL ZDROT( M, X(1+(I-1)*LDX), 1, X(1+(J-1)*LDX),
     $                 1, REALZERO, REALONE )
                  END IF
               END DO
            END IF
*
            NT = 15
*
            CALL ZCSDTS( M, P, Q, X, XF, LDX, U1, LDU1, U2, LDU2, V1T,
     $                   LDV1T, V2T, LDV2T, THETA, IWORK, WORK, LWORK,
     $                   RWORK, RESULT )
*
*           Print information about the tests that did not
*           pass the threshold.
*
            DO 10 I = 1, NT
.GE.               IF( RESULT( I )THRESH ) THEN
.EQ..AND.                  IF( NFAIL0  FIRSTT ) THEN
                     FIRSTT = .FALSE.
                     CALL ALAHDG( NOUT, PATH )
                  END IF
                  WRITE( NOUT, FMT = 9998 )M, P, Q, IMAT, I,
     $               RESULT( I )
                  NFAIL = NFAIL + 1
               END IF
   10       CONTINUE
            NRUN = NRUN + NT
   20    CONTINUE
   30 CONTINUE
*
*     Print a summary of the results.
*
      CALL ALASUM( PATH, NOUT, NFAIL, NRUN, 0 )
*
 9999 FORMAT( ' zlaror in zckcsd: m = ', I5, ', info = ', I15 )
 9998 FORMAT( ' m=', I4, ' p=', I4, ', q=', i4, ', type ', i2,
     $      ', test ', i2, ', ratio=', g13.6 )
      RETURN
*
*     End of ZCKCSD
*
      END
*
*
*
      SUBROUTINE zlacsg( M, P, Q, THETA, ISEED, X, LDX, WORK )
      IMPLICIT NONE
*
      INTEGER            LDX, M, P, Q
      INTEGER            ISEED( 4 )
      DOUBLE PRECISION   THETA( * )
      COMPLEX*16         WORK( * ), X( LDX, * )
*
      COMPLEX*16         ONE, ZERO
      PARAMETER          ( ONE = (1.0d0,0.0d0), zero = (0.0d0,0.0d0) )
*
      INTEGER            I, INFO, R
*
      r = min( p, m-p, q, m-q )
*
      CALL zlaset( 'Full', m, m, zero, zero, x, ldx )
*
      DO i = 1, min(p,q)-r
         x(i,i) = one
      END DO
      DO i = 1, r
         x(min(p,q)-r+i,min(p,q)-r+i) = dcmplx( cos(theta(i)), 0.0d0 )
      END DO
      DO i = 1, min(p,m-q)-r
         x(p-i+1,m-i+1) = -one
      END DO
      DO i = 1, r
         x(p-(min(p,m-q)-r)+1-i,m-(min(p,m-q)-r)+1-i) =
     $      dcmplx( -sin(theta(r-i+1)), 0.0d0 )
      END DO
      DO i = 1, min(m-p,q)-r
         x(m-i+1,q-i+1) = one
      END DO
      DO i = 1, r
         x(m-(min(m-p,q)-r)+1-i,q-(min(m-p,q)-r)+1-i) =
     $      dcmplx( sin(theta(r-i+1)), 0.0d0 )
      END DO
      DO i = 1, min(m-p,m-q)-r
         x(p+i,q+i) = one
      END DO
      DO i = 1, r
         x(p+(min(m-p,m-q)-r)+i,q+(min(m-p,m-q)-r)+i) =
     $      dcmplx( cos(theta(i)), 0.0d0 )
      END DO
      CALL zlaror( 'Left', 'No init', p, m, x, ldx, iseed, work, info )
      CALL zlaror( 'Left', 'No init', m-p, m, x(p+1,1), ldx,
     $             iseed, work, info )
      CALL zlaror( 'Right', 'No init', m, q, x, ldx, iseed,
     $             work, info )
      CALL zlaror( 'Right', 'No init', m, m-q,
     $             x(1,q+1), ldx, iseed, work, info )
*
      END