pdsvdcmp()

subroutine pdsvdcmp	(	integer	m,
		integer	n,
		integer	jobtype,
		double precision, dimension( * )	s,
		double precision, dimension( * )	sc,
		double precision, dimension( * )	u,
		double precision, dimension( * )	uc,
		integer	iu,
		integer	ju,
		integer, dimension( * )	descu,
		double precision, dimension( * )	vt,
		double precision, dimension( * )	vtc,
		integer	ivt,
		integer	jvt,
		integer, dimension( * )	descvt,
		double precision	thresh,
		integer, dimension( * )	result,
		double precision	delta,
		double precision, dimension( * )	work,
		integer	lwork
	)

Definition at line 1 of file pdsvdcmp.f.

*
*  -- ScaLAPACK routine (version 1.7) --
*     University of Tennessee, Knoxville, Oak Ridge National Laboratory,
*     and University of California, Berkeley.
*     May 1, 1997
*
*     .. Scalar Arguments ..
      INTEGER            IU, IVT, JOBTYPE, JU, JVT, LWORK, M, N
      DOUBLE PRECISION   DELTA, THRESH
*     ..
*     .. Array Arguments ..
      INTEGER            DESCU( * ), DESCVT( * ), RESULT( * )
      DOUBLE PRECISION   S( * ), SC( * ), U( * ), UC( * ), VT( * ),
     $                   VTC( * ), WORK( * )
*     ..
*
*  Purpose
*  ========
*  Testing how accurately "full" and "partial" decomposition options
*  provided by PDGESVD correspond to each other.
*
*  Notes
*  =====
*
*  Each global data object is described by an associated description
*  vector.  This vector stores the information required to establish
*  the mapping between an object element and its corresponding process
*  and memory location.
*
*  Let A be a generic term for any 2D block cyclicly distributed array.
*  Such a global array has an associated description vector DESCA.
*  In the following comments, the character _ should be read as
*  "of the global array".
*
*  NOTATION        STORED IN      EXPLANATION
*  --------------- -------------- --------------------------------------
*  DTYPE_A(global) DESCA( DTYPE_ )The descriptor type.  In this case,
*                                 DTYPE_A = 1.
*  CTXT_A (global) DESCA( CTXT_ ) The BLACS context handle, indicating
*                                 the BLACS process grid A is distribu-
*                                 ted over. The context itself is glo-
*                                 bal, but the handle (the integer
*                                 value) may vary.
*  M_A    (global) DESCA( M_ )    The number of rows in the global
*                                 array A.
*  N_A    (global) DESCA( N_ )    The number of columns in the global
*                                 array A.
*  MB_A   (global) DESCA( MB_ )   The blocking factor used to distribute
*                                 the rows of the array.
*  NB_A   (global) DESCA( NB_ )   The blocking factor used to distribute
*                                 the columns of the array.
*  RSRC_A (global) DESCA( RSRC_ ) The process row over which the first
*                                 row of the array A is distributed.
*  CSRC_A (global) DESCA( CSRC_ ) The process column over which the
*                                 first column of the array A is
*                                 distributed.
*  LLD_A  (local)  DESCA( LLD_ )  The leading dimension of the local
*                                 array.  LLD_A >= MAX(1,LOCr(M_A)).
*
*  Let K be the number of rows or columns of a distributed matrix,
*  and assume that its process grid has dimension p x q.
*  LOCr( K ) denotes the number of elements of K that a process
*  would receive if K were distributed over the p processes of its
*  process column.
*  Similarly, LOCc( K ) denotes the number of elements of K that a
*  process would receive if K were distributed over the q processes of
*  its process row.
*  The values of LOCr() and LOCc() may be determined via a call to the
*  ScaLAPACK tool function, NUMROC:
*          LOCr( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
*          LOCc( N ) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).
*  An upper bound for these quantities may be computed by:
*          LOCr( M ) <= ceil( ceil(M/MB_A)/NPROW )*MB_A
*          LOCc( N ) <= ceil( ceil(N/NB_A)/NPCOL )*NB_A
*
*   Arguments
*   ==========
*
*   M        (global input) INTEGER
*            Number of rows of the distributed matrix, for which
*            SVD was calculated
*
*   N        (global input) INTEGER
*            Number of columns of the distributed matrix, for which
*            SVD was calculated
*
*   JOBTYPE  (global input) INTEGER
*            Depending on the value of this parameter,
*            the following comparisons are performed:
*
*            JOBTYPE  |   COMPARISON
*            -------------------------------------------
*               2     |  | U - UC | / ( M ulp ) > THRESH,
*               3     |  | VT - VTC | / ( N ulp ) > THRESH
*
*            In addition, for JOBTYPE = 2:4 comparison
*            | S1 - S2 | / ( SIZE ulp |S| ) > THRESH
*            is performed. Positive result of any of the comparisons
*            typically indicates erroneous computations and sets
*            to one corresponding element of array RESULT
*
*    S       (global input) DOUBLE PRECISION  array of singular values
*            calculated for JOBTYPE equal to  1
*
*    SC      (global input) DOUBLE PRECISION  array of singular values
*            calculated for JOBTYPE nonequal to 1
*
*    U       (local input) DOUBLE PRECISION array of left singular
*            vectors calculated for JOBTYPE equal to 1, local
*            dimension (MP, SIZEQ), global dimension (M, SIZE)
*
*    UC      (local input) DOUBLE PRECISION  array of left singular
*            vectors calculated for JOBTYPE non equal to 1, local
*            dimension (MP, SIZEQ), global dimension (M, SIZE)
*
*    IU      (global input) INTEGER
*            The row index in the global array U indicating the first
*            row of sub( U ).
*
*    JU      (global input) INTEGER
*            The column index in the global array U indicating the
*            first column of sub( U ).
*
*    DESCU   (global input) INTEGER array of dimension DLEN_
*            The array descriptor for the distributed matrix U and UC
*
*    V       (local input) DOUBLE PRECISION array of right singular
*            vectors calculated for JOBTYPE equal to 1, local
*            dimension (SIZEP, NQ), global dimension (SIZE, N)
*
*    VC      (local input) DOUBLE PRECISION array of right singular
*            vectors calculated for JOBTYPE non equal to 1, local
*            dimension (SIZEP, NQ), global dimension (SIZE, N)
*
*    IVT     (global input) INTEGER
*            The row index in the global array VT indicating the first
*            row of sub( VT ).
*
*    JVT     (global input) INTEGER
*            The column index in the global array VT indicating the
*            first column of sub( VT ).
*
*    DESCVT  (global input) INTEGER array of dimension DLEN_
*            The array descriptor for the distributed matrix VT and
*            VTC
*
*    THRESH  (global input) DOUBLE PRECISION
*            The threshold value for the test ratios.  A result is
*            included in the output file if RESULT >= THRESH.  The test
*            ratios are scaled to be O(1), so THRESH should be a small
*            multiple of 1, e.g., 10 or 100. To have every test ratio
*            printed, use THRESH = 0.
*
*    RESULT  (global input/output) INTEGER array.
*            Every nonzero entry corresponds to erroneous computation.
*
*    DELTA   (global output) DOUBLE PRECISION
*            maximum of the available of the following three values
*            | U - UC | / ( M ulp THRESH ),
*            | VT - VT | / ( N ulp THRESH ),
*            | S1 - S2 | / ( SIZE ulp |S| THRESH )
*
*    WORK    (local workspace/output) DOUBLE PRECISION array,
*            dimension (LWORK)
*            On exit, WORK(1) returns the optimal LWORK.
*
*    LWORK   (local input) INTEGER
*            The dimension of the array WORK.
*
* ======================================================================
*
*     .. Parameters ..
      INTEGER            BLOCK_CYCLIC_2D, DLEN_, DTYPE_, CTXT_, M_, N_,
     $                   MB_, NB_, RSRC_, CSRC_, LLD_
      parameter( block_cyclic_2d = 1, dlen_ = 9, dtype_ = 1,
     $                   ctxt_ = 2, m_ = 3, n_ = 4, mb_ = 5, nb_ = 6,
     $                   rsrc_ = 7, csrc_ = 8, lld_ = 9 )
*     ..
*     .. Local Scalars ..
      INTEGER            COLPTR, I, INFO, J, LWMIN, MYCOL, MYROW, NPCOL,
     $                   NPROW, NQ, RESULTS, SIZE, SIZEPOS, SIZEQ
      DOUBLE PRECISION   ACCUR, CMP, NORMDIFS, NORMDIFU, NORMDIFV,
     $                   NORMS, ULP
*     ..
*     .. External Functions ..
      INTEGER            NUMROC
      DOUBLE PRECISION   DLANGE, PDLAMCH, PDLANGE
      EXTERNAL           numroc, dlange, pdlamch, pdlange
*     ..
*     .. External Subroutines ..
      EXTERNAL           blacs_gridinfo, chk1mat, pxerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max, min
*     ..
*     .. Executable Statements ..
*     This is just to keep ftnchek happy
      IF( block_cyclic_2d*csrc_*dlen_*dtype_*mb_*m_*n_*rsrc_.LT.0 ) 
     $   RETURN
*
      results = 0
      normdifs = 0
      normdifu = 0
      normdifv = 0
      SIZE = min( m, n )
*
*     Sizepos is a number of parameters to pdsvdcmp plus one. It's used
*     for the error reporting.
*
      sizepos = 17
      info = 0
      CALL blacs_gridinfo( descu( ctxt_ ), nprow, npcol, myrow, mycol )
      IF( nprow.EQ.-1 ) THEN
         info = -607
      ELSE
         CALL chk1mat( m, 1, SIZE, sizepos, 1, 1, descu, 8, info )
         CALL chk1mat( SIZE, sizepos, n, 2, 1, 1, descvt, 11, info )
      END IF
*
      IF( info.EQ.0 ) THEN
*
*        Calculate workspace.
*
         sizeq = numroc( SIZE, descu( nb_ ), mycol, 0, npcol )
         nq = numroc( n, descvt( nb_ ), mycol, 0, npcol )
         lwmin = max( sizeq, nq ) + 4
         work( 1 ) = lwmin
         IF( lwork.EQ.-1 )
     $      GO TO 60
         IF( lwork.LT.lwmin ) THEN
            info = -16
         ELSE IF( thresh.LE.0 ) THEN
            info = -12
         END IF
      END IF
*
      IF( info.NE.0 ) THEN
         CALL pxerbla( descu( ctxt_ ), 'PDSVDCMP', -info )
         RETURN
      END IF
*
      ulp = pdlamch( descu( ctxt_ ), 'P' )
*
*     Make comparison of singular values.
*
      norms = dlange( '1', SIZE, 1, s, SIZE, work )
      DO 10 i = 1, SIZE
         sc( i ) = s( i ) - sc( i )
   10 CONTINUE
*
      normdifs = dlange( '1', SIZE, 1, sc, SIZE, work )
      accur = ulp*size*norms*thresh
*
      IF( normdifs.GT.accur )
     $   results = 1
      IF( normdifs.EQ.0 .AND. accur.EQ.0 ) THEN
         normdifs = 0
      ELSE
         normdifs = normdifs / accur
      END IF
*
      IF( jobtype.EQ.2 ) THEN
*
         result( 5 ) = results
         accur = ulp*m*thresh
         DO 30 j = 1, sizeq
            colptr = descu( lld_ )*( j-1 )
            DO 20 i = 1, descu( lld_ )
               uc( i+colptr ) = u( i+colptr ) - uc( i+colptr )
   20       CONTINUE
   30    CONTINUE
*
         normdifu = pdlange( '1', m, SIZE, uc, iu, ju, descu, work )
*
         IF( normdifu.GE.accur )
     $      result( 6 ) = 1
         IF( normdifu.EQ.0 .AND. accur.EQ.0 ) THEN
            normdifu = 0
         ELSE
            normdifu = normdifu / accur
         END IF
*
      ELSE IF( jobtype.EQ.3 ) THEN
*
         result( 7 ) = results
         accur = ulp*n*thresh
         DO 50 j = 1, nq
            colptr = descvt( lld_ )*( j-1 )
            DO 40 i = 1, descvt( lld_ )
               vtc( i+colptr ) = vt( i+colptr ) - vtc( i+colptr )
   40       CONTINUE
   50    CONTINUE
*
         normdifv = pdlange( '1', SIZE, n, vtc, ivt, jvt, descvt, work )
*
         IF( normdifv.GE.accur )
     $      result( 8 ) = 1
*
         IF( normdifv.EQ.0 .AND. accur.EQ.0 ) THEN
            normdifv = 0
         ELSE
            normdifv = normdifv / accur
         END IF
*
      ELSE IF( jobtype.EQ.4 ) THEN
*
         result( 9 ) = results
*
      END IF
*
      cmp = max( normdifv, normdifu )
      delta = max( cmp, normdifs )
*
   60 CONTINUE
*
*     End of PDSVDCMP
*
      RETURN

Here is the call graph for this function:

Here is the caller graph for this function: