sckcsd.f

Go to the documentation of this file.

*> \brief \b SCKCSD
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at
*            http://www.netlib.org/lapack/explore-html/
*
*  Definition:
*  ===========
*
*       SUBROUTINE SCKCSD( 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
*       REAL               THRESH
*       ..
*       .. Array Arguments ..
*       INTEGER            ISEED( 4 ), IWORK( * ), MVAL( * ), PVAL( * ),
*      $                   QVAL( * )
*       REAL               RWORK( * ), THETA( * )
*       REAL               U1( * ), U2( * ), V1T( * ), V2T( * ),
*      $                   WORK( * ), X( * ), XF( * )
*       ..
*
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> SCKCSD tests SORCSD:
*>        the CSD for an M-by-M orthogonal 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 REAL
*>          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 REAL array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] XF
*> \verbatim
*>          XF is REAL array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] U1
*> \verbatim
*>          U1 is REAL array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] U2
*> \verbatim
*>          U2 is REAL array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] V1T
*> \verbatim
*>          V1T is REAL array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] V2T
*> \verbatim
*>          V2T is REAL array, dimension (MMAX*MMAX)
*> \endverbatim
*>
*> \param[out] THETA
*> \verbatim
*>          THETA is REAL array, dimension (MMAX)
*> \endverbatim
*>
*> \param[out] IWORK
*> \verbatim
*>          IWORK is INTEGER array, dimension (MMAX)
*> \endverbatim
*>
*> \param[out] WORK
*> \verbatim
*>          WORK is REAL array
*> \endverbatim
*>
*> \param[out] RWORK
*> \verbatim
*>          RWORK is REAL 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 SLAROR 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 single_eig
*
*  =====================================================================
      SUBROUTINE sckcsd( 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
      REAL               THRESH
*     ..
*     .. Array Arguments ..
      INTEGER            ISEED( 4 ), IWORK( * ), MVAL( * ), PVAL( * ),
     $                   QVAL( * )
      REAL               RWORK( * ), THETA( * )
      REAL               U1( * ), U2( * ), V1T( * ), V2T( * ),
     $                   work( * ), x( * ), xf( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      INTEGER            NTESTS
      PARAMETER          ( NTESTS = 15 )
      INTEGER            NTYPES
      parameter( ntypes = 4 )
      REAL               GAPDIGIT, ONE, ORTH, TEN, ZERO
      parameter( gapdigit = 10.0e0, one = 1.0e0,
     $                     orth = 1.0e-4, ten = 10.0e0, zero = 0.0e0 )
      REAL               PIOVER2
      PARAMETER ( PIOVER2 = 1.57079632679489661923132169163975144210e0 )
*     ..
*     .. 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 )
      REAL               RESULT( NTESTS )
*     ..
*     .. External Subroutines ..
      EXTERNAL           alahdg, alareq, alasum, scsdts, slacsg, slaror,
     $                   slaset, srot
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, min
*     ..
*     .. External Functions ..
      REAL               SLARAN, SLARND
      EXTERNAL           SLARAN, SLARND
*     ..
*     .. 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 slaror( '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 * slarnd( 1, iseed )
               END DO
               CALL slacsg( 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*slarnd(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**(-slarnd(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 slacsg( m, p, q, theta, iseed, x, ldx, work )
            ELSE
               CALL slaset( 'F', m, m, zero, one, x, ldx )
               DO i = 1, m
                  j = int( slaran( iseed ) * m ) + 1
                  IF( j .NE. i ) THEN
                     CALL srot( m, x(1+(i-1)*ldx), 1, x(1+(j-1)*ldx), 1,
     $                 zero, one )
                  END IF
               END DO
            END IF
*
            nt = 15
*
            CALL scsdts( 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
               IF( result( i ).GE.thresh ) THEN
                  IF( nfail.EQ.0 .AND. 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( ' SLAROR in SCKCSD: M = ', i5, ', INFO = ', i15 )
 9998 FORMAT( ' M=', i4, ' P=', i4, ', Q=', i4, ', type ', i2,
     $      ', test ', i2, ', ratio=', g13.6 )
      RETURN
*
*     End of SCKCSD
*
      END
*
*
*
      SUBROUTINE slacsg( M, P, Q, THETA, ISEED, X, LDX, WORK )
      IMPLICIT NONE
*
      INTEGER            LDX, M, P, Q
      INTEGER            ISEED( 4 )
      REAL               THETA( * )
      REAL               WORK( * ), X( LDX, * )
*
      REAL               ONE, ZERO
      PARAMETER          ( ONE = 1.0e0, zero = 0.0e0 )
*
      INTEGER            I, INFO, R
*
      r = min( p, m-p, q, m-q )
*
      CALL slaset( '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) = cos(theta(i))
      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) =
     $      -sin(theta(r-i+1))
      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) =
     $      sin(theta(r-i+1))
      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) =
     $      cos(theta(i))
      END DO
      CALL slaror( 'Left', 'No init', p, m, x, ldx, iseed, work, info )
      CALL slaror( 'Left', 'No init', m-p, m, x(p+1,1), ldx,
     $             iseed, work, info )
      CALL slaror( 'Right', 'No init', m, q, x, ldx, iseed,
     $             work, info )
      CALL slaror( 'Right', 'No init', m, m-q,
     $             x(1,q+1), ldx, iseed, work, info )
*
      END