1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
     100
     101
     102
     103
     104
     105
     106
     107
     108
     109
     110
     111
     112
     113
     114
     115
     116
     117
     118
     119
     120
     121
     122
     123
     124
     125
     126
     127
     128
     129
     130
     131
     132
     133
     134
     135
     136
     137
     138
     139
     140
     141
     142
     143
     144
     145
     146
     147
     148
     149
     150
     151
     152
     153
     154
     155
     156
     157
     158
     159
     160
     161
     162
     163
     164
      DOUBLE PRECISION FUNCTION DQRT12MNALDASWORKLWORK )
*
*  -- LAPACK test routine (version 3.1.1) --
*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
*     January 2007
*
*     .. Scalar Arguments ..
      INTEGER            LDALWORKMN
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   ALDA* ), S* ), WORKLWORK )
*     ..
*
*  Purpose
*  =======
*
*  DQRT12 computes the singular values `svlues' of the upper trapezoid
*  of A(1:M,1:N) and returns the ratio
*
*       || s - svlues||/(||svlues||*eps*max(M,N))
*
*  Arguments
*  =========
*
*  M       (input) INTEGER
*          The number of rows of the matrix A.
*
*  N       (input) INTEGER
*          The number of columns of the matrix A.
*
*  A       (input) DOUBLE PRECISION array, dimension (LDA,N)
*          The M-by-N matrix A. Only the upper trapezoid is referenced.
*
*  LDA     (input) INTEGER
*          The leading dimension of the array A.
*
*  S       (input) DOUBLE PRECISION array, dimension (min(M,N))
*          The singular values of the matrix A.
*
*  WORK    (workspace) DOUBLE PRECISION array, dimension (LWORK)
*
*  LWORK   (input) INTEGER
*          The length of the array WORK. LWORK >= max(M*N + 4*min(M,N) +
*          max(M,N), M*N+2*MIN( M, N )+4*N).
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   ZEROONE
      PARAMETER          ( ZERO = 0.0D0ONE = 1.0D0 )
*     ..
*     .. Local Scalars ..
      INTEGER            IINFOISCLJMN
      DOUBLE PRECISION   ANRMBIGNUMNRMSVLSMLNUM
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DASUMDLAMCHDLANGEDNRM2
      EXTERNAL           DASUMDLAMCHDLANGEDNRM2
*     ..
*     .. External Subroutines ..
      EXTERNAL           DAXPYDBDSQRDGEBD2DLABADDLASCLDLASET,
     $                   XERBLA
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          DBLEMAXMIN
*     ..
*     .. Local Arrays ..
      DOUBLE PRECISION   DUMMY1 )
*     ..
*     .. Executable Statements ..
*
      DQRT12 = ZERO
*
*     Test that enough workspace is supplied
*
      IFLWORK.LT.MAXM*N+4*MINMN )+MAXMN ),
     $                  M*N+2*MINMN )+4*N) ) THEN
         CALL XERBLA'DQRT12'7 )
         RETURN
      END IF
*
*     Quick return if possible
*
      MN = MINMN )
      IFMN.LE.ZERO )
     $   RETURN
*
      NRMSVL = DNRM2MNS1 )
*
*     Copy upper triangle of A into work
*
      CALL DLASET'Full'MNZEROZEROWORKM )
      DO 20 J = 1N
         DO 10 I = 1MINJM )
            WORK( ( J-1 )*M+I ) = AIJ )
   10    CONTINUE
   20 CONTINUE
*
*     Get machine parameters
*
      SMLNUM = DLAMCH'S' ) / DLAMCH'P' )
      BIGNUM = ONE / SMLNUM
      CALL DLABADSMLNUMBIGNUM )
*
*     Scale work if max entry outside range [SMLNUM,BIGNUM]
*
      ANRM = DLANGE'M'MNWORKMDUMMY )
      ISCL = 0
      IFANRM.GT.ZERO .AND. ANRM.LT.SMLNUM ) THEN
*
*        Scale matrix norm up to SMLNUM
*
         CALL DLASCL'G'00ANRMSMLNUMMNWORKMINFO )
         ISCL = 1
      ELSE IFANRM.GT.BIGNUM ) THEN
*
*        Scale matrix norm down to BIGNUM
*
         CALL DLASCL'G'00ANRMBIGNUMMNWORKMINFO )
         ISCL = 1
      END IF
*
      IFANRM.NE.ZERO ) THEN
*
*        Compute SVD of work
*
         CALL DGEBD2MNWORKMWORKM*N+1 ), WORKM*N+MN+1 ),
     $                WORKM*N+2*MN+1 ), WORKM*N+3*MN+1 ),
     $                WORKM*N+4*MN+1 ), INFO )
         CALL DBDSQR'Upper'MN000WORKM*N+1 ),
     $                WORKM*N+MN+1 ), DUMMYMNDUMMY1DUMMYMN,
     $                WORKM*N+2*MN+1 ), INFO )
*
         IFISCL.EQ.1 ) THEN
            IFANRM.GT.BIGNUM ) THEN
               CALL DLASCL'G'00BIGNUMANRMMN1,
     $                      WORKM*N+1 ), MNINFO )
            END IF
            IFANRM.LT.SMLNUM ) THEN
               CALL DLASCL'G'00SMLNUMANRMMN1,
     $                      WORKM*N+1 ), MNINFO )
            END IF
         END IF
*
      ELSE
*
         DO 30 I = 1MN
            WORKM*N+I ) = ZERO
   30    CONTINUE
      END IF
*
*     Compare s and singular values of work
*
      CALL DAXPYMN-ONES1WORKM*N+1 ), 1 )
      DQRT12 = DASUMMNWORKM*N+1 ), 1 ) /
     $         ( DLAMCH'Epsilon' )*DBLEMAXMN ) ) )
      IFNRMSVL.NE.ZERO )
     $   DQRT12 = DQRT12 / NRMSVL
*
      RETURN
*
*     End of DQRT12
*
      END