Fix *drvls.f: duplicate loop to make work query for each of test cases

Workspace size is not monotonic function of input sizes so there should
be loop over all test cases with workspace queries and finding maximum
between them.

diff --git a/TESTING/LIN/cdrvls.f b/TESTING/LIN/cdrvls.f
index b9b8e0f..180e26d 100644 (file)
--- a/TESTING/LIN/cdrvls.f
+++ b/TESTING/LIN/cdrvls.f
@@ -237,9 +237,9 @@
       REAL               EPS, NORMA, NORMB, RCOND
 *     ..
 *     .. Local Arrays ..
-      INTEGER            ISEED( 4 ), ISEEDY( 4 ), IWORKQUERY
-      REAL               RESULT( NTESTS ), RWORKQUERY
-      COMPLEX            WORKQUERY
+      INTEGER            ISEED( 4 ), ISEEDY( 4 ), IWQ
+      REAL               RESULT( NTESTS ), RWQ
+      COMPLEX            WQ
 *     ..
 *     .. Allocatable Arrays ..
       COMPLEX, ALLOCATABLE :: WORK (:)
@@ -324,48 +324,85 @@
       M = MMAX
       N = NMAX
       NRHS = NSMAX
-      LDA = MAX( 1, M )
-      LDB = MAX( 1, M, N )
       MNMIN = MAX( MIN( M, N ), 1 )
 *
 *     Compute workspace needed for routines
 *     CQRT14, CQRT17 (two side cases), CQRT15 and CQRT12
 *
-      LWORK = MAX( ( M+N )*NRHS,
+      LWORK = MAX( 1, ( M+N )*NRHS,
      $      ( N+NRHS )*( M+2 ), ( M+NRHS )*( N+2 ),
      $      MAX( M+MNMIN, NRHS*MNMIN,2*N+M ),
      $      MAX( M*N+4*MNMIN+MAX(M,N), M*N+2*MNMIN+4*N ) )
+      LRWORK = 1
+      LIWORK = 1
+*
+*     Iterate through all test cases and compute necessary workspace
+*     sizes for ?GELS, ?GETSLS, ?GELSY, ?GELSS and ?GELSD routines.
+*
+      DO IM = 1, NM
+         M = MVAL( IM )
+         LDA = MAX( 1, M )
+         DO IN = 1, NN
+            N = NVAL( IN )
+            MNMIN = MAX(MIN( M, N ),1)
+            LDB = MAX( 1, M, N )
+            DO INS = 1, NNS
+               NRHS = NSVAL( INS )
+               DO IRANK = 1, 2
+                  DO ISCALE = 1, 3
+                     ITYPE = ( IRANK-1 )*3 + ISCALE
+                     IF( DOTYPE( ITYPE ) ) THEN
+                        IF( IRANK.EQ.1 ) THEN
+                           DO ITRAN = 1, 2
+                              IF( ITRAN.EQ.1 ) THEN
+                                 TRANS = 'N'
+                              ELSE
+                                 TRANS = 'C'
+                              END IF
+*
+*                             Compute workspace needed for CGELS
+                              CALL CGELS( TRANS, M, N, NRHS, A, LDA,
+     $                                    B, LDB, WQ, -1, INFO )
+                              LWORK_CGELS = INT( WQ )
+*                             Compute workspace needed for CGETSLS
+                              CALL CGETSLS( TRANS, M, N, NRHS, A, LDA,
+     $                                      B, LDB, WQ, -1, INFO )
+                              LWORK_CGETSLS = INT( WQ )
+                           ENDDO
+                        END IF
+*                       Compute workspace needed for CGELSY
+                        CALL CGELSY( M, N, NRHS, A, LDA, B, LDB,
+     $                               IWQ, RCOND, CRANK, WQ, -1, RWORK,
+     $                               INFO )
+                        LWORK_CGELSY = INT( WQ )
+                        LRWORK_CGELSY = 2*N
+*                       Compute workspace needed for CGELSS
+                        CALL CGELSS( M, N, NRHS, A, LDA, B, LDB, S,
+     $                               RCOND, CRANK, WQ, -1, RWORK, INFO )
+                        LWORK_CGELSS = INT( WQ )
+                        LRWORK_CGELSS = 5*MNMIN
+*                       Compute workspace needed for CGELSD
+                        CALL CGELSD( M, N, NRHS, A, LDA, B, LDB, S,
+     $                               RCOND, CRANK, WQ, -1, RWQ, IWQ,
+     $                               INFO )
+                        LWORK_CGELSD = INT( WQ )
+                        LRWORK_CGELSD = INT( RWQ )
+*                       Compute LIWORK workspace needed for CGELSY and CGELSD
+                        LIWORK = MAX( LIWORK, N, IWQ )
+*                       Compute LRWORK workspace needed for CGELSY, CGELSS and CGELSD
+                        LRWORK = MAX( LRWORK, LRWORK_CGELSY,
+     $                                LRWORK_CGELSS, LRWORK_CGELSD )
+*                       Compute LWORK workspace needed for all functions
+                        LWORK = MAX( LWORK, LWORK_CGELS, LWORK_CGETSLS,
+     $                               LWORK_CGELSY, LWORK_CGELSS,
+     $                               LWORK_CGELSD )
+                     END IF
+                  ENDDO
+               ENDDO
+            ENDDO
+         ENDDO
+      ENDDO
 *
-*     Compute workspace needed for CGELS
-      CALL CGELS( 'N', M, N, NRHS, A, LDA, B, LDB,
-     $            WORKQUERY, -1, INFO )
-      LWORK_CGELS = INT( WORKQUERY )
-*     Compute workspace needed for CGETSLS
-      CALL CGETSLS( 'N', M, N, NRHS, A, LDA, B, LDB,
-     $              WORKQUERY, -1, INFO )
-      LWORK_CGETSLS = INT( WORKQUERY )
-*     Compute workspace needed for CGELSY
-      CALL CGELSY( M, N, NRHS, A, LDA, B, LDB, IWORKQUERY,
-     $             RCOND, CRANK, WORKQUERY, -1, RWORK, INFO )
-      LWORK_CGELSY = INT( WORKQUERY )
-      LRWORK_CGELSY = 2*N
-*     Compute workspace needed for CGELSS
-      CALL CGELSS( M, N, NRHS, A, LDA, B, LDB, S,
-     $             RCOND, CRANK, WORKQUERY, -1, RWORK, INFO )
-      LWORK_CGELSS = INT( WORKQUERY )
-      LRWORK_CGELSS = 5*MNMIN
-*     Compute workspace needed for CGELSD
-      CALL CGELSD( M, N, NRHS, A, LDA, B, LDB, S, RCOND, CRANK,
-     $             WORKQUERY, -1, RWORKQUERY, IWORKQUERY, INFO )
-      LWORK_CGELSD = INT( WORKQUERY )
-      LRWORK_CGELSD = INT( RWORKQUERY )
-*     Compute LIWORK workspace needed for CGELSY and CGELSD
-      LIWORK = MAX( 1, N, IWORKQUERY )
-*     Compute LRWORK workspace needed for CGELSY, CGELSS and CGELSD
-      LRWORK = MAX( 1, LRWORK_CGELSY, LRWORK_CGELSS, LRWORK_CGELSD )
-*     Compute LWORK workspace needed for all functions
-      LWORK = MAX( 1, LWORK, LWORK_CGELS, LWORK_CGETSLS, LWORK_CGELSY,
-     $             LWORK_CGELSS, LWORK_CGELSD )
       LWLSY = LWORK
 *
       ALLOCATE( WORK( LWORK ) )

diff --git a/TESTING/LIN/ddrvls.f b/TESTING/LIN/ddrvls.f
index 5d190e1..a06701b 100644 (file)
--- a/TESTING/LIN/ddrvls.f
+++ b/TESTING/LIN/ddrvls.f
@@ -233,8 +233,8 @@
       DOUBLE PRECISION   EPS, NORMA, NORMB, RCOND
 *     ..
 *     .. Local Arrays ..
-      INTEGER            ISEED( 4 ), ISEEDY( 4 ), IWORKQUERY
-      DOUBLE PRECISION   RESULT( NTESTS ), WORKQUERY
+      INTEGER            ISEED( 4 ), ISEEDY( 4 ), IWQ
+      DOUBLE PRECISION   RESULT( NTESTS ), WQ
 *     ..
 *     .. Allocatable Arrays ..
       DOUBLE PRECISION, ALLOCATABLE :: WORK (:)
@@ -321,43 +321,76 @@
       M = MMAX
       N = NMAX
       NRHS = NSMAX
-      LDA = MAX( 1, M )
-      LDB = MAX( 1, M, N )
       MNMIN = MAX( MIN( M, N ), 1 )
 *
 *     Compute workspace needed for routines
 *     DQRT14, DQRT17 (two side cases), DQRT15 and DQRT12
 *
-      LWORK = MAX( ( M+N )*NRHS,
+      LWORK = MAX( 1, ( M+N )*NRHS,
      $      ( N+NRHS )*( M+2 ), ( M+NRHS )*( N+2 ),
      $      MAX( M+MNMIN, NRHS*MNMIN,2*N+M ),
      $      MAX( M*N+4*MNMIN+MAX(M,N), M*N+2*MNMIN+4*N ) )
+      LIWORK = 1
+*
+*     Iterate through all test cases and compute necessary workspace
+*     sizes for ?GELS, ?GETSLS, ?GELSY, ?GELSS and ?GELSD routines.
+*
+      DO IM = 1, NM
+         M = MVAL( IM )
+         LDA = MAX( 1, M )
+         DO IN = 1, NN
+            N = NVAL( IN )
+            MNMIN = MAX(MIN( M, N ),1)
+            LDB = MAX( 1, M, N )
+            DO INS = 1, NNS
+               NRHS = NSVAL( INS )
+               DO IRANK = 1, 2
+                  DO ISCALE = 1, 3
+                     ITYPE = ( IRANK-1 )*3 + ISCALE
+                     IF( DOTYPE( ITYPE ) ) THEN
+                        IF( IRANK.EQ.1 ) THEN
+                           DO ITRAN = 1, 2
+                              IF( ITRAN.EQ.1 ) THEN
+                                 TRANS = 'N'
+                              ELSE
+                                 TRANS = 'T'
+                              END IF
+*
+*                             Compute workspace needed for DGELS
+                              CALL DGELS( TRANS, M, N, NRHS, A, LDA,
+     $                                    B, LDB, WQ, -1, INFO )
+                              LWORK_DGELS = INT ( WQ )
+*                             Compute workspace needed for DGETSLS
+                              CALL DGETSLS( TRANS, M, N, NRHS, A, LDA,
+     $                                      B, LDB, WQ, -1, INFO )
+                              LWORK_DGETSLS = INT( WQ )
+                           ENDDO
+                        END IF
+*                       Compute workspace needed for DGELSY
+                        CALL DGELSY( M, N, NRHS, A, LDA, B, LDB, IWQ,
+     $                               RCOND, CRANK, WQ, -1, INFO )
+                        LWORK_DGELSY = INT( WQ )
+*                       Compute workspace needed for DGELSS
+                        CALL DGELSS( M, N, NRHS, A, LDA, B, LDB, S,
+     $                               RCOND, CRANK, WQ, -1 , INFO )
+                        LWORK_DGELSS = INT( WQ )
+*                       Compute workspace needed for DGELSD
+                        CALL DGELSD( M, N, NRHS, A, LDA, B, LDB, S,
+     $                               RCOND, CRANK, WQ, -1, IWQ, INFO )
+                        LWORK_DGELSD = INT( WQ )
+*                       Compute LIWORK workspace needed for DGELSY and DGELSD
+                        LIWORK = MAX( LIWORK, N, IWQ )
+*                       Compute LWORK workspace needed for all functions
+                        LWORK = MAX( LWORK, LWORK_DGELS, LWORK_DGETSLS,
+     $                               LWORK_DGELSY, LWORK_DGELSS,
+     $                               LWORK_DGELSD )
+                     END IF
+                  ENDDO
+               ENDDO
+            ENDDO
+         ENDDO
+      ENDDO
 *
-*     Compute workspace needed for DGELS
-      CALL DGELS( 'N', M, N, NRHS, A, LDA, B, LDB,
-     $            WORKQUERY, -1, INFO )
-      LWORK_DGELS = INT ( WORKQUERY )
-*     Compute workspace needed for DGETSLS
-      CALL DGETSLS( 'N', M, N, NRHS, A, LDA, B, LDB,
-     $              WORKQUERY, -1, INFO )
-      LWORK_DGETSLS = INT( WORKQUERY )
-*     Compute workspace needed for DGELSY
-      CALL DGELSY( M, N, NRHS, A, LDA, B, LDB, IWORKQUERY,
-     $             RCOND, CRANK, WORKQUERY, -1, INFO )
-      LWORK_DGELSY = INT( WORKQUERY )
-*     Compute workspace needed for DGELSS
-      CALL DGELSS( M, N, NRHS, A, LDA, B, LDB, S,
-     $             RCOND, CRANK, WORKQUERY, -1 , INFO )
-      LWORK_DGELSS = INT( WORKQUERY )
-*     Compute workspace needed for DGELSD
-      CALL DGELSD( M, N, NRHS, A, LDA, B, LDB, S,
-     $             RCOND, CRANK, WORKQUERY, -1, IWORKQUERY, INFO )
-      LWORK_DGELSD = INT( WORKQUERY )
-*     Compute LIWORK workspace needed for DGELSY and DGELSD
-      LIWORK = MAX( 1, N, IWORKQUERY )
-*     Compute LWORK workspace needed for all functions
-      LWORK = MAX( 1, LWORK, LWORK_DGELS, LWORK_DGETSLS, LWORK_DGELSY,
-     $             LWORK_DGELSS, LWORK_DGELSD )
       LWLSY = LWORK
 *
       ALLOCATE( WORK( LWORK ) )

diff --git a/TESTING/LIN/sdrvls.f b/TESTING/LIN/sdrvls.f
index c408a9b..a7ecdbc 100644 (file)
--- a/TESTING/LIN/sdrvls.f
+++ b/TESTING/LIN/sdrvls.f
@@ -233,8 +233,8 @@
       REAL               EPS, NORMA, NORMB, RCOND
 *     ..
 *     .. Local Arrays ..
-      INTEGER            ISEED( 4 ), ISEEDY( 4 ), IWORKQUERY
-      REAL               RESULT( NTESTS ), WORKQUERY
+      INTEGER            ISEED( 4 ), ISEEDY( 4 ), IWQ
+      REAL               RESULT( NTESTS ), WQ
 *     ..
 *     .. Allocatable Arrays ..
       REAL, ALLOCATABLE :: WORK (:)
@@ -321,43 +321,76 @@
       M = MMAX
       N = NMAX
       NRHS = NSMAX
-      LDA = MAX( 1, M )
-      LDB = MAX( 1, M, N )
       MNMIN = MAX( MIN( M, N ), 1 )
 *
 *     Compute workspace needed for routines
 *     SQRT14, SQRT17 (two side cases), SQRT15 and SQRT12
 *
-      LWORK = MAX( ( M+N )*NRHS,
+      LWORK = MAX( 1, ( M+N )*NRHS,
      $      ( N+NRHS )*( M+2 ), ( M+NRHS )*( N+2 ),
      $      MAX( M+MNMIN, NRHS*MNMIN,2*N+M ),
      $      MAX( M*N+4*MNMIN+MAX(M,N), M*N+2*MNMIN+4*N ) )
+      LIWORK = 1
+*
+*     Iterate through all test cases and compute necessary workspace
+*     sizes for ?GELS, ?GETSLS, ?GELSY, ?GELSS and ?GELSD routines.
+*
+      DO IM = 1, NM
+         M = MVAL( IM )
+         LDA = MAX( 1, M )
+         DO IN = 1, NN
+            N = NVAL( IN )
+            MNMIN = MAX(MIN( M, N ),1)
+            LDB = MAX( 1, M, N )
+            DO INS = 1, NNS
+               NRHS = NSVAL( INS )
+               DO IRANK = 1, 2
+                  DO ISCALE = 1, 3
+                     ITYPE = ( IRANK-1 )*3 + ISCALE
+                     IF( DOTYPE( ITYPE ) ) THEN
+                        IF( IRANK.EQ.1 ) THEN
+                           DO ITRAN = 1, 2
+                              IF( ITRAN.EQ.1 ) THEN
+                                 TRANS = 'N'
+                              ELSE
+                                 TRANS = 'T'
+                              END IF
+*
+*                             Compute workspace needed for SGELS
+                              CALL SGELS( TRANS, M, N, NRHS, A, LDA,
+     $                                    B, LDB, WQ, -1, INFO )
+                              LWORK_SGELS = INT ( WQ )
+*                             Compute workspace needed for SGETSLS
+                              CALL SGETSLS( TRANS, M, N, NRHS, A, LDA,
+     $                                      B, LDB, WQ, -1, INFO )
+                              LWORK_SGETSLS = INT( WQ )
+                           ENDDO
+                        END IF
+*                       Compute workspace needed for SGELSY
+                        CALL SGELSY( M, N, NRHS, A, LDA, B, LDB, IWQ,
+     $                               RCOND, CRANK, WQ, -1, INFO )
+                        LWORK_SGELSY = INT( WQ )
+*                       Compute workspace needed for SGELSS
+                        CALL SGELSS( M, N, NRHS, A, LDA, B, LDB, S,
+     $                               RCOND, CRANK, WQ, -1 , INFO )
+                        LWORK_SGELSS = INT( WQ )
+*                       Compute workspace needed for SGELSD
+                        CALL SGELSD( M, N, NRHS, A, LDA, B, LDB, S,
+     $                               RCOND, CRANK, WQ, -1, IWQ, INFO )
+                        LWORK_SGELSD = INT( WQ )
+*                       Compute LIWORK workspace needed for SGELSY and SGELSD
+                        LIWORK = MAX( LIWORK, N, IWQ )
+*                       Compute LWORK workspace needed for all functions
+                        LWORK = MAX( LWORK, LWORK_SGELS, LWORK_SGETSLS,
+     $                               LWORK_SGELSY, LWORK_SGELSS,
+     $                               LWORK_SGELSD )
+                     END IF
+                  ENDDO
+               ENDDO
+            ENDDO
+         ENDDO
+      ENDDO
 *
-*     Compute workspace needed for SGELS
-      CALL SGELS( 'N', M, N, NRHS, A, LDA, B, LDB,
-     $            WORKQUERY, -1, INFO )
-      LWORK_SGELS = INT ( WORKQUERY )
-*     Compute workspace needed for SGETSLS
-      CALL SGETSLS( 'N', M, N, NRHS, A, LDA, B, LDB,
-     $              WORKQUERY, -1, INFO )
-      LWORK_SGETSLS = INT( WORKQUERY )
-*     Compute workspace needed for SGELSY
-      CALL SGELSY( M, N, NRHS, A, LDA, B, LDB, IWORKQUERY,
-     $             RCOND, CRANK, WORKQUERY, -1, INFO )
-      LWORK_SGELSY = INT( WORKQUERY )
-*     Compute workspace needed for SGELSS
-      CALL SGELSS( M, N, NRHS, A, LDA, B, LDB, S,
-     $             RCOND, CRANK, WORKQUERY, -1 , INFO )
-      LWORK_SGELSS = INT( WORKQUERY )
-*     Compute workspace needed for SGELSD
-      CALL SGELSD( M, N, NRHS, A, LDA, B, LDB, S,
-     $             RCOND, CRANK, WORKQUERY, -1, IWORKQUERY, INFO )
-      LWORK_SGELSD = INT( WORKQUERY )
-*     Compute LIWORK workspace needed for SGELSY and SGELSD
-      LIWORK = MAX( 1, N, IWORKQUERY )
-*     Compute LWORK workspace needed for all functions
-      LWORK = MAX( 1, LWORK, LWORK_SGELS, LWORK_SGETSLS, LWORK_SGELSY,
-     $             LWORK_SGELSS, LWORK_SGELSD )
       LWLSY = LWORK
 *
       ALLOCATE( WORK( LWORK ) )

diff --git a/TESTING/LIN/zdrvls.f b/TESTING/LIN/zdrvls.f
index c9485e4..b4c376d 100644 (file)
--- a/TESTING/LIN/zdrvls.f
+++ b/TESTING/LIN/zdrvls.f
@@ -237,9 +237,9 @@
       DOUBLE PRECISION   EPS, NORMA, NORMB, RCOND
 *     ..
 *     .. Local Arrays ..
-      INTEGER            ISEED( 4 ), ISEEDY( 4 ), IWORKQUERY
-      DOUBLE PRECISION   RESULT( NTESTS ), RWORKQUERY
-      COMPLEX*16         WORKQUERY
+      INTEGER            ISEED( 4 ), ISEEDY( 4 ), IWQ
+      DOUBLE PRECISION   RESULT( NTESTS ), RWQ
+      COMPLEX*16         WQ
 *     ..
 *     .. Allocatable Arrays ..
       COMPLEX*16, ALLOCATABLE :: WORK (:)
@@ -324,48 +324,85 @@
       M = MMAX
       N = NMAX
       NRHS = NSMAX
-      LDA = MAX( 1, M )
-      LDB = MAX( 1, M, N )
       MNMIN = MAX( MIN( M, N ), 1 )
 *
 *     Compute workspace needed for routines
 *     ZQRT14, ZQRT17 (two side cases), ZQRT15 and ZQRT12
 *
-      LWORK = MAX( ( M+N )*NRHS,
+      LWORK = MAX( 1, ( M+N )*NRHS,
      $      ( N+NRHS )*( M+2 ), ( M+NRHS )*( N+2 ),
      $      MAX( M+MNMIN, NRHS*MNMIN,2*N+M ),
      $      MAX( M*N+4*MNMIN+MAX(M,N), M*N+2*MNMIN+4*N ) )
+      LRWORK = 1
+      LIWORK = 1
+*
+*     Iterate through all test cases and compute necessary workspace
+*     sizes for ?GELS, ?GETSLS, ?GELSY, ?GELSS and ?GELSD routines.
+*
+      DO IM = 1, NM
+         M = MVAL( IM )
+         LDA = MAX( 1, M )
+         DO IN = 1, NN
+            N = NVAL( IN )
+            MNMIN = MAX(MIN( M, N ),1)
+            LDB = MAX( 1, M, N )
+            DO INS = 1, NNS
+               NRHS = NSVAL( INS )
+               DO IRANK = 1, 2
+                  DO ISCALE = 1, 3
+                     ITYPE = ( IRANK-1 )*3 + ISCALE
+                     IF( DOTYPE( ITYPE ) ) THEN
+                        IF( IRANK.EQ.1 ) THEN
+                           DO ITRAN = 1, 2
+                              IF( ITRAN.EQ.1 ) THEN
+                                 TRANS = 'N'
+                              ELSE
+                                 TRANS = 'C'
+                              END IF
+*
+*                             Compute workspace needed for ZGELS
+                              CALL ZGELS( TRANS, M, N, NRHS, A, LDA,
+     $                                    B, LDB, WQ, -1, INFO )
+                              LWORK_ZGELS = INT ( WQ )
+*                             Compute workspace needed for ZGETSLS
+                              CALL ZGETSLS( TRANS, M, N, NRHS, A, LDA,
+     $                                      B, LDB, WQ, -1, INFO )
+                              LWORK_ZGETSLS = INT( WQ )
+                           ENDDO
+                        END IF
+*                       Compute workspace needed for ZGELSY
+                        CALL ZGELSY( M, N, NRHS, A, LDA, B, LDB, IWQ,
+     $                               RCOND, CRANK, WQ, -1, RWORK, INFO )
+                        LWORK_ZGELSY = INT( WQ )
+                        LRWORK_ZGELSY = 2*N
+*                       Compute workspace needed for ZGELSS
+                        CALL ZGELSS( M, N, NRHS, A, LDA, B, LDB, S,
+     $                               RCOND, CRANK, WQ, -1 , RWORK,
+     $                               INFO )
+                        LWORK_ZGELSS = INT( WQ )
+                        LRWORK_ZGELSS = 5*MNMIN
+*                       Compute workspace needed for ZGELSD
+                        CALL ZGELSD( M, N, NRHS, A, LDA, B, LDB, S,
+     $                               RCOND, CRANK, WQ, -1, RWQ, IWQ,
+     $                               INFO )
+                        LWORK_ZGELSD = INT( WQ )
+                        LRWORK_ZGELSD = INT( RWQ )
+*                       Compute LIWORK workspace needed for ZGELSY and ZGELSD
+                        LIWORK = MAX( LIWORK, N, IWQ )
+*                       Compute LRWORK workspace needed for ZGELSY, ZGELSS and ZGELSD
+                        LRWORK = MAX( LRWORK, LRWORK_ZGELSY,
+     $                                LRWORK_ZGELSS, LRWORK_ZGELSD )
+*                       Compute LWORK workspace needed for all functions
+                        LWORK = MAX( LWORK, LWORK_ZGELS, LWORK_ZGETSLS,
+     $                               LWORK_ZGELSY, LWORK_ZGELSS,
+     $                               LWORK_ZGELSD )
+                     END IF
+                  ENDDO
+               ENDDO
+            ENDDO
+         ENDDO
+      ENDDO
 *
-*     Compute workspace needed for ZGELS
-      CALL ZGELS( 'N', M, N, NRHS, A, LDA, B, LDB,
-     $            WORKQUERY, -1, INFO )
-      LWORK_ZGELS = INT ( WORKQUERY )
-*     Compute workspace needed for ZGETSLS
-      CALL ZGETSLS( 'N', M, N, NRHS, A, LDA, B, LDB,
-     $              WORKQUERY, -1, INFO )
-      LWORK_ZGETSLS = INT( WORKQUERY )
-*     Compute workspace needed for ZGELSY
-      CALL ZGELSY( M, N, NRHS, A, LDA, B, LDB, IWORKQUERY,
-     $             RCOND, CRANK, WORKQUERY, -1, RWORK, INFO )
-      LWORK_ZGELSY = INT( WORKQUERY )
-      LRWORK_ZGELSY = 2*N
-*     Compute workspace needed for ZGELSS
-      CALL ZGELSS( M, N, NRHS, A, LDA, B, LDB, S,
-     $             RCOND, CRANK, WORKQUERY, -1 , RWORK, INFO )
-      LWORK_ZGELSS = INT( WORKQUERY )
-      LRWORK_ZGELSS = 5*MNMIN
-*     Compute workspace needed for ZGELSD
-      CALL ZGELSD( M, N, NRHS, A, LDA, B, LDB, S, RCOND, CRANK,
-     $             WORKQUERY, -1, RWORKQUERY, IWORKQUERY, INFO )
-      LWORK_ZGELSD = INT( WORKQUERY )
-      LRWORK_ZGELSD = INT( RWORKQUERY )
-*     Compute LIWORK workspace needed for ZGELSY and ZGELSD
-      LIWORK = MAX( 1, N, IWORKQUERY )
-*     Compute LRWORK workspace needed for ZGELSY, ZGELSS and ZGELSD
-      LRWORK = MAX( 1, LRWORK_ZGELSY, LRWORK_ZGELSS, LRWORK_ZGELSD )
-*     Compute LWORK workspace needed for all functions
-      LWORK = MAX( 1, LWORK, LWORK_ZGELS, LWORK_ZGETSLS, LWORK_ZGELSY,
-     $             LWORK_ZGELSS, LWORK_ZGELSD )
       LWLSY = LWORK
 *
       ALLOCATE( WORK( LWORK ) )