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 (:)
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 ) )
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 (:)
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 ) )
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 (:)
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 ) )
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 (:)
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 ) )