Merge pull request #4391 from martin-frbg/lapack942
Handle corner cases of LWORK (Reference-LAPACK PR 942)
This commit is contained in:
		
						commit
						05dde8ef04
					
				| 
						 | 
				
			
			@ -123,7 +123,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of the array WORK.  LWORK >= max(1,M,N).
 | 
			
		||||
*>          The length of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= MAX(M,N), otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= (M+N)*NB, where NB
 | 
			
		||||
*>          is the optimal blocksize.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -148,7 +149,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexGEcomputational
 | 
			
		||||
*> \ingroup gebrd
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -225,8 +226,8 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY
 | 
			
		||||
      INTEGER            I, IINFO, J, LDWRKX, LDWRKY, LWKOPT, MINMN, NB,
 | 
			
		||||
     $                   NBMIN, NX, WS
 | 
			
		||||
      INTEGER            I, IINFO, J, LDWRKX, LDWRKY, LWKMIN, LWKOPT,
 | 
			
		||||
     $                   MINMN, NB, NBMIN, NX, WS
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CGEBD2, CGEMM, CLABRD, XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -236,16 +237,24 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      INTEGER            ILAENV
 | 
			
		||||
      EXTERNAL           ILAENV
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           ILAENV, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Executable Statements ..
 | 
			
		||||
*
 | 
			
		||||
*     Test the input parameters
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
         LWKMIN = 1
 | 
			
		||||
         LWKOPT = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKMIN = MAX( M, N )
 | 
			
		||||
         NB = MAX( 1, ILAENV( 1, 'CGEBRD', ' ', M, N, -1, -1 ) )
 | 
			
		||||
         LWKOPT = ( M+N )*NB
 | 
			
		||||
      WORK( 1 ) = REAL( LWKOPT )
 | 
			
		||||
      END IF
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -253,7 +262,7 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, M, N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -265,7 +274,6 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -284,7 +292,7 @@
 | 
			
		|||
*        Determine when to switch from blocked to unblocked code.
 | 
			
		||||
*
 | 
			
		||||
         IF( NX.LT.MINMN ) THEN
 | 
			
		||||
            WS = ( M+N )*NB
 | 
			
		||||
            WS = LWKOPT
 | 
			
		||||
            IF( LWORK.LT.WS ) THEN
 | 
			
		||||
*
 | 
			
		||||
*              Not enough work space for the optimal NB, consider using
 | 
			
		||||
| 
						 | 
				
			
			@ -343,7 +351,7 @@
 | 
			
		|||
*
 | 
			
		||||
      CALL CGEBD2( M-I+1, N-I+1, A( I, I ), LDA, D( I ), E( I ),
 | 
			
		||||
     $             TAUQ( I ), TAUP( I ), WORK, IINFO )
 | 
			
		||||
      WORK( 1 ) = WS
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( WS )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CGEBRD
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -89,7 +89,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (LWORK)
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -222,13 +222,19 @@
 | 
			
		|||
         INFO = -8
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      NH = IHI - ILO + 1
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
*
 | 
			
		||||
*        Compute the workspace requirements
 | 
			
		||||
*
 | 
			
		||||
         NB = MIN( NBMAX, ILAENV( 1, 'CGEHRD', ' ', N, ILO, IHI, -1 ) )
 | 
			
		||||
         IF( NH.LE.1 ) THEN
 | 
			
		||||
            LWKOPT = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            NB = MIN( NBMAX, ILAENV( 1, 'DGEHRD', ' ', N, ILO, IHI,
 | 
			
		||||
     $                              -1 ) )
 | 
			
		||||
            LWKOPT = N*NB + TSIZE
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -249,7 +255,6 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      NH = IHI - ILO + 1
 | 
			
		||||
      IF( NH.LE.1 ) THEN
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -269,7 +274,7 @@
 | 
			
		|||
*
 | 
			
		||||
*           Determine if workspace is large enough for blocked code
 | 
			
		||||
*
 | 
			
		||||
            IF( LWORK.LT.N*NB+TSIZE ) THEN
 | 
			
		||||
            IF( LWORK.LT.LWKOPT ) THEN
 | 
			
		||||
*
 | 
			
		||||
*              Not enough workspace to use optimal NB:  determine the
 | 
			
		||||
*              minimum value of NB, and reduce NB or force use of
 | 
			
		||||
| 
						 | 
				
			
			@ -345,7 +350,8 @@
 | 
			
		|||
*     Use unblocked code to reduce the rest of the matrix
 | 
			
		||||
*
 | 
			
		||||
      CALL CGEHD2( N, I, IHI, A, LDA, TAU, WORK, IINFO )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -98,7 +98,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1 or -2, then a workspace query is assumed. The routine
 | 
			
		||||
*>          only calculates the sizes of the T and WORK arrays, returns these
 | 
			
		||||
*>          values as the first entries of the T and WORK arrays, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -295,9 +295,9 @@
 | 
			
		|||
        T( 2 ) = MB
 | 
			
		||||
        T( 3 ) = NB
 | 
			
		||||
        IF( MINW ) THEN
 | 
			
		||||
          WORK( 1 ) = SROUNDUP_LWORK(LWMIN)
 | 
			
		||||
          WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
        ELSE
 | 
			
		||||
          WORK( 1 ) = SROUNDUP_LWORK(LWREQ)
 | 
			
		||||
          WORK( 1 ) = SROUNDUP_LWORK( LWREQ )
 | 
			
		||||
        END IF
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -322,7 +322,7 @@
 | 
			
		|||
     $                LWORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWREQ)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWREQ )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -93,7 +93,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= max(1,M).
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= M, otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= M*NB, where NB is the
 | 
			
		||||
*>          optimal blocksize.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -175,9 +176,8 @@
 | 
			
		|||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      K = MIN( M, N )
 | 
			
		||||
      NB = ILAENV( 1, 'CGELQF', ' ', M, N, -1, -1 )
 | 
			
		||||
      LWKOPT = M*NB
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -185,19 +185,25 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, M ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -7
 | 
			
		||||
      ELSE IF( .NOT.LQUERY ) THEN
 | 
			
		||||
         IF( LWORK.LE.0 .OR. ( N.GT.0 .AND. LWORK.LT.MAX( 1, M ) ) )
 | 
			
		||||
     $      INFO = -7
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
         CALL XERBLA( 'CGELQF', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         IF( K.EQ.0 ) THEN
 | 
			
		||||
            LWKOPT = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            LWKOPT = M*NB
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      K = MIN( M, N )
 | 
			
		||||
      IF( K.EQ.0 ) THEN
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -267,7 +273,7 @@
 | 
			
		|||
     $   CALL CGELQ2( M-I+1, N-I+1, A( I, I ), LDA, TAU( I ), WORK,
 | 
			
		||||
     $                IINFO )
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(IWS)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( IWS )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CGELQF
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -111,12 +111,13 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed. The routine
 | 
			
		||||
*>          only calculates the size of the WORK array, returns this
 | 
			
		||||
*>          value as WORK(1), and no error message related to WORK
 | 
			
		||||
| 
						 | 
				
			
			@ -164,6 +165,8 @@
 | 
			
		|||
*>  Further Details in CLAMSWLQ or CGEMLQT.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \ingroup gemlq
 | 
			
		||||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE CGEMLQ( SIDE, TRANS, M, N, K, A, LDA, T, TSIZE,
 | 
			
		||||
     $                   C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -185,11 +188,12 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LEFT, RIGHT, TRAN, NOTRAN, LQUERY
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN, MINMNK, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      EXTERNAL           LSAME
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CLAMSWLQ, CGEMLQT, XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -201,7 +205,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      LQUERY  = LWORK.EQ.-1
 | 
			
		||||
      LQUERY  = ( LWORK.EQ.-1 )
 | 
			
		||||
      NOTRAN  = LSAME( TRANS, 'N' )
 | 
			
		||||
      TRAN    = LSAME( TRANS, 'C' )
 | 
			
		||||
      LEFT    = LSAME( SIDE, 'L' )
 | 
			
		||||
| 
						 | 
				
			
			@ -216,6 +220,13 @@
 | 
			
		|||
        LW = M * MB
 | 
			
		||||
        MN = N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      MINMNK = MIN( M, N, K )
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = MAX( 1, LW )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( ( NB.GT.K ) .AND. ( MN.GT.K ) ) THEN
 | 
			
		||||
        IF( MOD( MN - K, NB - K ) .EQ. 0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -244,12 +255,12 @@
 | 
			
		|||
        INFO = -9
 | 
			
		||||
      ELSE IF( LDC.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
        INFO = -11
 | 
			
		||||
      ELSE IF( ( LWORK.LT.MAX( 1, LW ) ) .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
      ELSE IF( ( LWORK.LT.LWMIN ) .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
        INFO = -13
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = REAL( LW )
 | 
			
		||||
        WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -261,7 +272,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN( M, N, K ).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -274,7 +285,7 @@
 | 
			
		|||
     $                 MB, C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = REAL( LW )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -112,12 +112,13 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed. The routine
 | 
			
		||||
*>          only calculates the size of the WORK array, returns this
 | 
			
		||||
*>          value as WORK(1), and no error message related to WORK
 | 
			
		||||
| 
						 | 
				
			
			@ -166,6 +167,8 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \ingroup gemqr
 | 
			
		||||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE CGEMQR( SIDE, TRANS, M, N, K, A, LDA, T, TSIZE,
 | 
			
		||||
     $                   C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -187,11 +190,12 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LEFT, RIGHT, TRAN, NOTRAN, LQUERY
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN, MINMNK, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      EXTERNAL           LSAME
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CGEMQRT, CLAMTSQR, XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -203,7 +207,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      LQUERY  = LWORK.EQ.-1
 | 
			
		||||
      LQUERY  = ( LWORK.EQ.-1 )
 | 
			
		||||
      NOTRAN  = LSAME( TRANS, 'N' )
 | 
			
		||||
      TRAN    = LSAME( TRANS, 'C' )
 | 
			
		||||
      LEFT    = LSAME( SIDE, 'L' )
 | 
			
		||||
| 
						 | 
				
			
			@ -218,6 +222,13 @@
 | 
			
		|||
        LW = MB * NB
 | 
			
		||||
        MN = N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      MINMNK = MIN( M, N, K )
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = MAX( 1, LW )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( ( MB.GT.K ) .AND. ( MN.GT.K ) ) THEN
 | 
			
		||||
        IF( MOD( MN - K, MB - K ).EQ.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -251,7 +262,7 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = LW
 | 
			
		||||
        WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -263,7 +274,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN( M, N, K ).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -276,7 +287,7 @@
 | 
			
		|||
     $                 NB, C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = LW
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -88,7 +88,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= max(1,N).
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= N, otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= N*NB, where NB is
 | 
			
		||||
*>          the optimal blocksize.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -187,10 +188,11 @@
 | 
			
		|||
            NB = ILAENV( 1, 'CGEQLF', ' ', M, N, -1, -1 )
 | 
			
		||||
            LWKOPT = N*NB
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
         IF( LWORK.LT.MAX( 1, N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
            INFO = -7
 | 
			
		||||
         IF( .NOT.LQUERY ) THEN
 | 
			
		||||
            IF( LWORK.LE.0 .OR. ( M.GT.0 .AND. LWORK.LT.MAX( 1, N ) ) )
 | 
			
		||||
     $         INFO = -7
 | 
			
		||||
         END IF
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -277,7 +279,7 @@
 | 
			
		|||
      IF( MU.GT.0 .AND. NU.GT.0 )
 | 
			
		||||
     $   CALL CGEQL2( MU, NU, A, LDA, TAU, WORK, IINFO )
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(IWS)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( IWS )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CGEQLF
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -428,7 +428,8 @@
 | 
			
		|||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*.          LWORK >= N+NRHS-1
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and
 | 
			
		||||
*>          LWORK >= N+NRHS-1, otherwise.
 | 
			
		||||
*>          For optimal performance LWORK >= NB*( N+NRHS+1 ),
 | 
			
		||||
*>          where NB is the optimal block size for CGEQP3RK returned
 | 
			
		||||
*>          by ILAENV. Minimal block size MINNB=2.
 | 
			
		||||
| 
						 | 
				
			
			@ -627,8 +628,9 @@
 | 
			
		|||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            SISNAN
 | 
			
		||||
      INTEGER            ISAMAX, ILAENV
 | 
			
		||||
      REAL               SLAMCH, SCNRM2
 | 
			
		||||
      EXTERNAL           SISNAN, SLAMCH, SCNRM2, ISAMAX, ILAENV
 | 
			
		||||
      REAL               SLAMCH, SCNRM2, SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           SISNAN, SLAMCH, SCNRM2, ISAMAX, ILAENV,
 | 
			
		||||
     $                   SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Intrinsic Functions ..
 | 
			
		||||
      INTRINSIC          CMPLX, MAX, MIN
 | 
			
		||||
| 
						 | 
				
			
			@ -703,7 +705,7 @@
 | 
			
		|||
*
 | 
			
		||||
            LWKOPT = 2*N + NB*( N+NRHS+1 )
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
         IF( ( LWORK.LT.IWS ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
            INFO = -15
 | 
			
		||||
| 
						 | 
				
			
			@ -726,7 +728,7 @@
 | 
			
		|||
         K = 0
 | 
			
		||||
         MAXC2NRMK = ZERO
 | 
			
		||||
         RELMAXC2NRMK = ZERO
 | 
			
		||||
         WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -778,7 +780,7 @@
 | 
			
		|||
*
 | 
			
		||||
*        Array TAU is not set and contains undefined elements.
 | 
			
		||||
*
 | 
			
		||||
         WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -797,7 +799,7 @@
 | 
			
		|||
            TAU( J ) = CZERO
 | 
			
		||||
         END DO
 | 
			
		||||
*
 | 
			
		||||
         WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
         RETURN
 | 
			
		||||
*
 | 
			
		||||
      END IF
 | 
			
		||||
| 
						 | 
				
			
			@ -828,7 +830,7 @@
 | 
			
		|||
         DO J = 1, MINMN
 | 
			
		||||
            TAU( J ) = CZERO
 | 
			
		||||
         END DO
 | 
			
		||||
         WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -873,7 +875,7 @@
 | 
			
		|||
            TAU( J ) = CZERO
 | 
			
		||||
         END DO
 | 
			
		||||
*
 | 
			
		||||
         WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -991,7 +993,7 @@
 | 
			
		|||
*
 | 
			
		||||
*              Return from the routine.
 | 
			
		||||
*
 | 
			
		||||
               WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
               WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
               RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -1082,7 +1084,7 @@
 | 
			
		|||
*
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -99,7 +99,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1 or -2, then a workspace query is assumed. The routine
 | 
			
		||||
*>          only calculates the sizes of the T and WORK arrays, returns these
 | 
			
		||||
*>          values as the first entries of the T and WORK arrays, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -168,6 +168,8 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \ingroup geqr
 | 
			
		||||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE CGEQR( M, N, A, LDA, T, TSIZE, WORK, LWORK,
 | 
			
		||||
     $                  INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -188,11 +190,12 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY, LMINWS, MINT, MINW
 | 
			
		||||
      INTEGER            MB, NB, MINTSZ, NBLCKS
 | 
			
		||||
      INTEGER            MB, NB, MINTSZ, NBLCKS, LWMIN, LWREQ
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      EXTERNAL           LSAME
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CLATSQR, CGEQRT, XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -244,8 +247,10 @@
 | 
			
		|||
*
 | 
			
		||||
*     Determine if the workspace size satisfies minimal size
 | 
			
		||||
*
 | 
			
		||||
      LWMIN = MAX( 1, N )
 | 
			
		||||
      LWREQ = MAX( 1, N*NB )
 | 
			
		||||
      LMINWS = .FALSE.
 | 
			
		||||
      IF( ( TSIZE.LT.MAX( 1, NB*N*NBLCKS + 5 ) .OR. LWORK.LT.NB*N )
 | 
			
		||||
      IF( ( TSIZE.LT.MAX( 1, NB*N*NBLCKS + 5 ) .OR. LWORK.LT.LWREQ )
 | 
			
		||||
     $    .AND. ( LWORK.GE.N ) .AND. ( TSIZE.GE.MINTSZ )
 | 
			
		||||
     $    .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
        IF( TSIZE.LT.MAX( 1, NB*N*NBLCKS + 5 ) ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -253,7 +258,7 @@
 | 
			
		|||
          NB = 1
 | 
			
		||||
          MB = M
 | 
			
		||||
        END IF
 | 
			
		||||
        IF( LWORK.LT.NB*N ) THEN
 | 
			
		||||
        IF( LWORK.LT.LWREQ ) THEN
 | 
			
		||||
          LMINWS = .TRUE.
 | 
			
		||||
          NB = 1
 | 
			
		||||
        END IF
 | 
			
		||||
| 
						 | 
				
			
			@ -268,7 +273,7 @@
 | 
			
		|||
      ELSE IF( TSIZE.LT.MAX( 1, NB*N*NBLCKS + 5 )
 | 
			
		||||
     $   .AND. ( .NOT.LQUERY ) .AND. ( .NOT.LMINWS ) ) THEN
 | 
			
		||||
        INFO = -6
 | 
			
		||||
      ELSE IF( ( LWORK.LT.MAX( 1, N*NB ) ) .AND. ( .NOT.LQUERY )
 | 
			
		||||
      ELSE IF( ( LWORK.LT.LWREQ ) .AND. ( .NOT.LQUERY )
 | 
			
		||||
     $   .AND. ( .NOT.LMINWS ) ) THEN
 | 
			
		||||
        INFO = -8
 | 
			
		||||
      END IF
 | 
			
		||||
| 
						 | 
				
			
			@ -282,9 +287,9 @@
 | 
			
		|||
        T( 2 ) = MB
 | 
			
		||||
        T( 3 ) = NB
 | 
			
		||||
        IF( MINW ) THEN
 | 
			
		||||
          WORK( 1 ) = MAX( 1, N )
 | 
			
		||||
          WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
        ELSE
 | 
			
		||||
          WORK( 1 ) = MAX( 1, NB*N )
 | 
			
		||||
          WORK( 1 ) = SROUNDUP_LWORK( LWREQ )
 | 
			
		||||
        END IF
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -309,7 +314,7 @@
 | 
			
		|||
     $                LWORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = MAX( 1, NB*N )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWREQ )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -97,7 +97,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= max(1,N).
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= N, otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= N*NB, where NB is
 | 
			
		||||
*>          the optimal blocksize.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -162,8 +163,8 @@
 | 
			
		|||
*
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY
 | 
			
		||||
      INTEGER            I, IB, IINFO, IWS, K, LDWORK, LWKOPT, NB,
 | 
			
		||||
     $                   NBMIN, NX
 | 
			
		||||
      INTEGER            I, IB, IINFO, IWS, K, LDWORK, LWKMIN, LWKOPT,
 | 
			
		||||
     $                   NB, NBMIN, NX
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CGEQR2P, CLARFB, CLARFT, XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -182,8 +183,16 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      NB = ILAENV( 1, 'CGEQRF', ' ', M, N, -1, -1 )
 | 
			
		||||
      K = MIN( M, N )
 | 
			
		||||
      IF( K.EQ.0 ) THEN
 | 
			
		||||
         LWKMIN = 1
 | 
			
		||||
         LWKOPT = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKMIN = N
 | 
			
		||||
         LWKOPT = N*NB
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      END IF
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -191,7 +200,7 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -7
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -203,7 +212,6 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      K = MIN( M, N )
 | 
			
		||||
      IF( K.EQ.0 ) THEN
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -211,7 +219,7 @@
 | 
			
		|||
*
 | 
			
		||||
      NBMIN = 2
 | 
			
		||||
      NX = 0
 | 
			
		||||
      IWS = N
 | 
			
		||||
      IWS = LWKMIN
 | 
			
		||||
      IF( NB.GT.1 .AND. NB.LT.K ) THEN
 | 
			
		||||
*
 | 
			
		||||
*        Determine when to cross over from blocked to unblocked code.
 | 
			
		||||
| 
						 | 
				
			
			@ -273,7 +281,7 @@
 | 
			
		|||
     $   CALL CGEQR2P( M-I+1, N-I+1, A( I, I ), LDA, TAU( I ), WORK,
 | 
			
		||||
     $                IINFO )
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(IWS)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( IWS )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CGEQRFP
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -208,7 +208,7 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK;
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
| 
						 | 
				
			
			@ -261,7 +261,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexGEsing
 | 
			
		||||
*> \ingroup gesvdx
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE CGESVDX( JOBU, JOBVT, RANGE, M, N, A, LDA, VL, VU,
 | 
			
		||||
| 
						 | 
				
			
			@ -312,8 +312,8 @@
 | 
			
		|||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      INTEGER            ILAENV
 | 
			
		||||
      REAL               SLAMCH, CLANGE
 | 
			
		||||
      EXTERNAL           LSAME, ILAENV, SLAMCH, CLANGE
 | 
			
		||||
      REAL               SLAMCH, CLANGE, SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, ILAENV, SLAMCH, CLANGE, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Intrinsic Functions ..
 | 
			
		||||
      INTRINSIC          MAX, MIN, SQRT
 | 
			
		||||
| 
						 | 
				
			
			@ -448,7 +448,7 @@
 | 
			
		|||
            END IF
 | 
			
		||||
         END IF
 | 
			
		||||
         MAXWRK = MAX( MAXWRK, MINWRK )
 | 
			
		||||
         WORK( 1 ) = CMPLX( REAL( MAXWRK ), ZERO )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( MAXWRK )
 | 
			
		||||
*
 | 
			
		||||
         IF( LWORK.LT.MINWRK .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
            INFO = -19
 | 
			
		||||
| 
						 | 
				
			
			@ -464,7 +464,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( M.EQ.0 .OR. N.EQ.0 ) THEN
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -846,7 +846,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Return optimal workspace in WORK(1)
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = CMPLX( REAL( MAXWRK ), ZERO )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( MAXWRK )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -208,15 +208,17 @@
 | 
			
		|||
*> \verbatim
 | 
			
		||||
*>          CWORK is COMPLEX array, dimension (max(1,LWORK))
 | 
			
		||||
*>          Used as workspace.
 | 
			
		||||
*>          If on entry LWORK = -1, then a workspace query is assumed and
 | 
			
		||||
*>          no computation is done; CWORK(1) is set to the minial (and optimal)
 | 
			
		||||
*>          length of CWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER.
 | 
			
		||||
*>          Length of CWORK, LWORK >= M+N.
 | 
			
		||||
*>          Length of CWORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= M+N, otherwise.
 | 
			
		||||
*>
 | 
			
		||||
*>          If on entry LWORK = -1, then a workspace query is assumed and
 | 
			
		||||
*>          no computation is done; CWORK(1) is set to the minial (and optimal)
 | 
			
		||||
*>          length of CWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in,out] RWORK
 | 
			
		||||
| 
						 | 
				
			
			@ -247,15 +249,17 @@
 | 
			
		|||
*>          RWORK(6) = the largest absolute value over all sines of the
 | 
			
		||||
*>                    Jacobi rotation angles in the last sweep. It can be
 | 
			
		||||
*>                    useful for a post festum analysis.
 | 
			
		||||
*>         If on entry LRWORK = -1, then a workspace query is assumed and
 | 
			
		||||
*>         no computation is done; RWORK(1) is set to the minial (and optimal)
 | 
			
		||||
*>         length of RWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LRWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>         LRWORK is INTEGER
 | 
			
		||||
*>         Length of RWORK, LRWORK >= MAX(6,N).
 | 
			
		||||
*>         Length of RWORK.
 | 
			
		||||
*>         LRWORK >= 1, if MIN(M,N) = 0, and LRWORK >= MAX(6,N), otherwise
 | 
			
		||||
*>
 | 
			
		||||
*>         If on entry LRWORK = -1, then a workspace query is assumed and
 | 
			
		||||
*>         no computation is done; RWORK(1) is set to the minial (and optimal)
 | 
			
		||||
*>         length of RWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[out] INFO
 | 
			
		||||
| 
						 | 
				
			
			@ -276,7 +280,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexGEcomputational
 | 
			
		||||
*> \ingroup gesvj
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -381,7 +385,8 @@
 | 
			
		|||
     $           SKL, SFMIN, SMALL, SN, T, TEMP1, THETA, THSIGN, TOL
 | 
			
		||||
      INTEGER    BLSKIP, EMPTSW, i, ibr, IERR, igl, IJBLSK, ir1,
 | 
			
		||||
     $           ISWROT, jbc, jgl, KBL, LKAHEAD, MVL, N2, N34,
 | 
			
		||||
     $        N4, NBL, NOTROT, p, PSKIPPED, q, ROWSKIP, SWBAND
 | 
			
		||||
     $           N4, NBL, NOTROT, p, PSKIPPED, q, ROWSKIP, SWBAND,
 | 
			
		||||
     $           MINMN, LWMIN, LRWMIN
 | 
			
		||||
      LOGICAL    APPLV, GOSCALE, LOWER, LQUERY, LSVEC, NOSCALE, ROTOK,
 | 
			
		||||
     $           RSVEC, UCTOL, UPPER
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -398,8 +403,8 @@
 | 
			
		|||
      INTEGER            ISAMAX
 | 
			
		||||
      EXTERNAL           ISAMAX
 | 
			
		||||
*     from LAPACK
 | 
			
		||||
      REAL               SLAMCH
 | 
			
		||||
      EXTERNAL           SLAMCH
 | 
			
		||||
      REAL               SLAMCH, SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           SLAMCH, SROUNDUP_LWORK
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      EXTERNAL           LSAME
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -422,7 +427,16 @@
 | 
			
		|||
      UPPER = LSAME( JOBA, 'U' )
 | 
			
		||||
      LOWER = LSAME( JOBA, 'L' )
 | 
			
		||||
*
 | 
			
		||||
      LQUERY = ( LWORK .EQ. -1 ) .OR. ( LRWORK .EQ. -1 )
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
         LWMIN  = 1
 | 
			
		||||
         LRWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN  = M + N
 | 
			
		||||
         LRWMIN = MAX( 6, N )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 ) .OR. ( LRWORK.EQ.-1 )
 | 
			
		||||
      IF( .NOT.( UPPER .OR. LOWER .OR. LSAME( JOBA, 'G' ) ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( .NOT.( LSVEC .OR. UCTOL .OR. LSAME( JOBU, 'N' ) ) ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -442,9 +456,9 @@
 | 
			
		|||
         INFO = -11
 | 
			
		||||
      ELSE IF( UCTOL .AND. ( RWORK( 1 ).LE.ONE ) ) THEN
 | 
			
		||||
         INFO = -12
 | 
			
		||||
      ELSE IF( LWORK.LT.( M+N ) .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
         INFO = -13
 | 
			
		||||
      ELSE IF( LRWORK.LT.MAX( N, 6 ) .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
      ELSE IF( LRWORK.LT.LRWMIN .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
         INFO = -15
 | 
			
		||||
      ELSE
 | 
			
		||||
         INFO = 0
 | 
			
		||||
| 
						 | 
				
			
			@ -454,15 +468,15 @@
 | 
			
		|||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
         CALL XERBLA( 'CGESVJ', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF ( LQUERY ) THEN
 | 
			
		||||
         CWORK(1) = M + N
 | 
			
		||||
         RWORK(1) = MAX( N, 6 )
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         CWORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
         RWORK( 1 ) = SROUNDUP_LWORK( LRWMIN )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
* #:) Quick return for void matrix
 | 
			
		||||
*
 | 
			
		||||
      IF( ( M.EQ.0 ) .OR. ( N.EQ.0 ) )RETURN
 | 
			
		||||
      IF( MINMN.EQ.0 ) RETURN
 | 
			
		||||
*
 | 
			
		||||
*     Set numerical parameters
 | 
			
		||||
*     The stopping criterion for Jacobi rotations is
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -153,8 +153,8 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      NB = ILAENV( 1, 'CGETRI', ' ', N, -1, -1, -1 )
 | 
			
		||||
      LWKOPT = N*NB
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      LWKOPT = MAX( 1, N*NB )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( N.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -252,7 +252,7 @@
 | 
			
		|||
     $      CALL CSWAP( N, A( 1, J ), 1, A( 1, JP ), 1 )
 | 
			
		||||
   60 CONTINUE
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(IWS)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( IWS )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CGETRI
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -127,7 +127,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1 or -2, then a workspace query is assumed.
 | 
			
		||||
*>          If LWORK = -1, the routine calculates optimal size of WORK for the
 | 
			
		||||
*>          optimal performance and returns this value in WORK(1).
 | 
			
		||||
| 
						 | 
				
			
			@ -229,7 +229,10 @@
 | 
			
		|||
*
 | 
			
		||||
*     Determine the optimum and minimum LWORK
 | 
			
		||||
*
 | 
			
		||||
       IF( M.GE.N ) THEN
 | 
			
		||||
       IF( MIN( M, N, NRHS ).EQ.0 ) THEN
 | 
			
		||||
         WSIZEO = 1
 | 
			
		||||
         WSIZEM = 1
 | 
			
		||||
       ELSE IF ( M.GE.N ) THEN
 | 
			
		||||
         CALL CGEQR( M, N, A, LDA, TQ, -1, WORKQ, -1, INFO2 )
 | 
			
		||||
         TSZO = INT( TQ( 1 ) )
 | 
			
		||||
         LWO  = INT( WORKQ( 1 ) )
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -131,13 +131,15 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= MAX( LWT + LW1, MAX( LWT+N*N+LW2, LWT+N*N+N ) ),
 | 
			
		||||
*>          If MIN(M,N) = 0, LWORK >= 1, else
 | 
			
		||||
*>          LWORK >= MAX( 1, LWT + LW1, MAX( LWT+N*N+LW2, LWT+N*N+N ) ),
 | 
			
		||||
*>          where
 | 
			
		||||
*>             NUM_ALL_ROW_BLOCKS = CEIL((M-N)/(MB1-N)),
 | 
			
		||||
*>             NB1LOCAL = MIN(NB1,N).
 | 
			
		||||
*>             LWT = NUM_ALL_ROW_BLOCKS * N * NB1LOCAL,
 | 
			
		||||
*>             LW1 = NB1LOCAL * N,
 | 
			
		||||
*>             LW2 = NB1LOCAL * MAX( NB1LOCAL, ( N - NB1LOCAL ) ),
 | 
			
		||||
*>             LW2 = NB1LOCAL * MAX( NB1LOCAL, ( N - NB1LOCAL ) ).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed.
 | 
			
		||||
*>          The routine only calculates the optimal size of the WORK
 | 
			
		||||
*>          array, returns this value as the first entry of the WORK
 | 
			
		||||
| 
						 | 
				
			
			@ -160,7 +162,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup comlpexOTHERcomputational
 | 
			
		||||
*> \ingroup getsqrhrt
 | 
			
		||||
*
 | 
			
		||||
*> \par Contributors:
 | 
			
		||||
*  ==================
 | 
			
		||||
| 
						 | 
				
			
			@ -200,6 +202,10 @@
 | 
			
		|||
      INTEGER            I, IINFO, J, LW1, LW2, LWT, LDWT, LWORKOPT,
 | 
			
		||||
     $                   NB1LOCAL, NB2LOCAL, NUM_ALL_ROW_BLOCKS
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CCOPY, CLATSQR, CUNGTSQR_ROW, CUNHR_COL,
 | 
			
		||||
     $                   XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -212,7 +218,7 @@
 | 
			
		|||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      LQUERY  = LWORK.EQ.-1
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 .OR. M.LT.N ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -263,8 +269,9 @@
 | 
			
		|||
            LW2 = NB1LOCAL * MAX( NB1LOCAL, ( N - NB1LOCAL ) )
 | 
			
		||||
*
 | 
			
		||||
            LWORKOPT = MAX( LWT + LW1, MAX( LWT+N*N+LW2, LWT+N*N+N ) )
 | 
			
		||||
            LWORKOPT = MAX( 1, LWORKOPT )
 | 
			
		||||
*
 | 
			
		||||
            IF( ( LWORK.LT.MAX( 1, LWORKOPT ) ).AND.(.NOT.LQUERY) ) THEN
 | 
			
		||||
            IF( LWORK.LT.LWORKOPT .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
               INFO = -11
 | 
			
		||||
            END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -277,14 +284,14 @@
 | 
			
		|||
         CALL XERBLA( 'CGETSQRHRT', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF ( LQUERY ) THEN
 | 
			
		||||
         WORK( 1 ) = CMPLX( LWORKOPT )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWORKOPT )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN( M, N ).EQ.0 ) THEN
 | 
			
		||||
         WORK( 1 ) = CMPLX( LWORKOPT )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWORKOPT )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -341,7 +348,7 @@
 | 
			
		|||
         END IF
 | 
			
		||||
      END DO
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = CMPLX( LWORKOPT )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWORKOPT )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CGETSQRHRT
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -215,7 +215,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= MAX(1,2*N).
 | 
			
		||||
*>          For good performance, LWORK must generally be larger.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -260,7 +261,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexGEeigen
 | 
			
		||||
*> \ingroup gges3
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE CGGES3( JOBVSL, JOBVSR, SORT, SELCTG, N, A, LDA, B,
 | 
			
		||||
| 
						 | 
				
			
			@ -300,7 +301,8 @@
 | 
			
		|||
      LOGICAL            CURSL, ILASCL, ILBSCL, ILVSL, ILVSR, LASTSL,
 | 
			
		||||
     $                   LQUERY, WANTST
 | 
			
		||||
      INTEGER            I, ICOLS, IERR, IHI, IJOBVL, IJOBVR, ILEFT,
 | 
			
		||||
     $                   ILO, IRIGHT, IROWS, IRWRK, ITAU, IWRK, LWKOPT
 | 
			
		||||
     $                   ILO, IRIGHT, IROWS, IRWRK, ITAU, IWRK, LWKOPT,
 | 
			
		||||
     $                   LWKMIN
 | 
			
		||||
      REAL               ANRM, ANRMTO, BIGNUM, BNRM, BNRMTO, EPS, PVSL,
 | 
			
		||||
     $                   PVSR, SMLNUM
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -310,13 +312,12 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CGEQRF, CGGBAK, CGGBAL, CGGHD3, CLAQZ0, CLACPY,
 | 
			
		||||
     $                   CLASCL, CLASET, CTGSEN, CUNGQR, CUNMQR, SLABAD,
 | 
			
		||||
     $                   XERBLA
 | 
			
		||||
     $                   CLASCL, CLASET, CTGSEN, CUNGQR, CUNMQR, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      REAL               CLANGE, SLAMCH
 | 
			
		||||
      EXTERNAL           LSAME, CLANGE, SLAMCH
 | 
			
		||||
      REAL               CLANGE, SLAMCH, SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, CLANGE, SLAMCH, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Intrinsic Functions ..
 | 
			
		||||
      INTRINSIC          MAX, SQRT
 | 
			
		||||
| 
						 | 
				
			
			@ -353,6 +354,8 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      LWKMIN = MAX( 1, 2*N )
 | 
			
		||||
*
 | 
			
		||||
      IF( IJOBVL.LE.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( IJOBVR.LE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -369,7 +372,7 @@
 | 
			
		|||
         INFO = -14
 | 
			
		||||
      ELSE IF( LDVSR.LT.1 .OR. ( ILVSR .AND. LDVSR.LT.N ) ) THEN
 | 
			
		||||
         INFO = -16
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, 2*N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -18
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -377,29 +380,33 @@
 | 
			
		|||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         CALL CGEQRF( N, N, B, LDB, WORK, WORK, -1, IERR )
 | 
			
		||||
         LWKOPT = MAX( 1,  N + INT ( WORK( 1 ) ) )
 | 
			
		||||
         LWKOPT = MAX( LWKMIN, N + INT( WORK( 1 ) ) )
 | 
			
		||||
         CALL CUNMQR( 'L', 'C', N, N, N, B, LDB, WORK, A, LDA, WORK,
 | 
			
		||||
     $                -1, IERR )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, N + INT ( WORK( 1 ) ) )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, N + INT( WORK( 1 ) ) )
 | 
			
		||||
         IF( ILVSL ) THEN
 | 
			
		||||
            CALL CUNGQR( N, N, N, VSL, LDVSL, WORK, WORK, -1,
 | 
			
		||||
     $                   IERR )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, N + INT ( WORK( 1 ) ) )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, N + INT( WORK( 1 ) ) )
 | 
			
		||||
         END IF
 | 
			
		||||
         CALL CGGHD3( JOBVSL, JOBVSR, N, 1, N, A, LDA, B, LDB, VSL,
 | 
			
		||||
     $                LDVSL, VSR, LDVSR, WORK, -1, IERR )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, N + INT ( WORK( 1 ) ) )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, N + INT( WORK( 1 ) ) )
 | 
			
		||||
         CALL CLAQZ0( 'S', JOBVSL, JOBVSR, N, 1, N, A, LDA, B, LDB,
 | 
			
		||||
     $                ALPHA, BETA, VSL, LDVSL, VSR, LDVSR, WORK, -1,
 | 
			
		||||
     $                RWORK, 0, IERR )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, INT ( WORK( 1 ) ) )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, INT( WORK( 1 ) ) )
 | 
			
		||||
         IF( WANTST ) THEN
 | 
			
		||||
            CALL CTGSEN( 0, ILVSL, ILVSR, BWORK, N, A, LDA, B, LDB,
 | 
			
		||||
     $                   ALPHA, BETA, VSL, LDVSL, VSR, LDVSR, SDIM,
 | 
			
		||||
     $                   PVSL, PVSR, DIF, WORK, -1, IDUM, 1, IERR )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, INT ( WORK( 1 ) ) )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, INT( WORK( 1 ) ) )
 | 
			
		||||
         END IF
 | 
			
		||||
         IF( N.EQ.0 ) THEN
 | 
			
		||||
            WORK( 1 ) = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
      END IF
 | 
			
		||||
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -422,7 +429,6 @@
 | 
			
		|||
      EPS = SLAMCH( 'P' )
 | 
			
		||||
      SMLNUM = SLAMCH( 'S' )
 | 
			
		||||
      BIGNUM = ONE / SMLNUM
 | 
			
		||||
      CALL SLABAD( SMLNUM, BIGNUM )
 | 
			
		||||
      SMLNUM = SQRT( SMLNUM ) / EPS
 | 
			
		||||
      BIGNUM = ONE / SMLNUM
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -585,7 +591,7 @@
 | 
			
		|||
*
 | 
			
		||||
   30 CONTINUE
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -174,7 +174,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= MAX(1,2*N).
 | 
			
		||||
*>          For good performance, LWORK must generally be larger.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -208,7 +209,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexGEeigen
 | 
			
		||||
*> \ingroup ggev3
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE CGGEV3( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHA, BETA,
 | 
			
		||||
| 
						 | 
				
			
			@ -243,7 +244,7 @@
 | 
			
		|||
      CHARACTER          CHTEMP
 | 
			
		||||
      INTEGER            ICOLS, IERR, IHI, IJOBVL, IJOBVR, ILEFT, ILO,
 | 
			
		||||
     $                   IN, IRIGHT, IROWS, IRWRK, ITAU, IWRK, JC, JR,
 | 
			
		||||
     $                   LWKOPT
 | 
			
		||||
     $                   LWKOPT, LWKMIN
 | 
			
		||||
      REAL               ANRM, ANRMTO, BIGNUM, BNRM, BNRMTO, EPS,
 | 
			
		||||
     $                   SMLNUM, TEMP
 | 
			
		||||
      COMPLEX            X
 | 
			
		||||
| 
						 | 
				
			
			@ -253,13 +254,12 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CGEQRF, CGGBAK, CGGBAL, CGGHD3, CLAQZ0, CLACPY,
 | 
			
		||||
     $                   CLASCL, CLASET, CTGEVC, CUNGQR, CUNMQR, SLABAD,
 | 
			
		||||
     $                   XERBLA
 | 
			
		||||
     $                   CLASCL, CLASET, CTGEVC, CUNGQR, CUNMQR, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      REAL               CLANGE, SLAMCH
 | 
			
		||||
      EXTERNAL           LSAME, CLANGE, SLAMCH
 | 
			
		||||
      REAL               CLANGE, SLAMCH, SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, CLANGE, SLAMCH, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Intrinsic Functions ..
 | 
			
		||||
      INTRINSIC          ABS, AIMAG, MAX, REAL, SQRT
 | 
			
		||||
| 
						 | 
				
			
			@ -301,6 +301,7 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      LWKMIN = MAX( 1, 2*N )
 | 
			
		||||
      IF( IJOBVL.LE.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( IJOBVR.LE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -315,7 +316,7 @@
 | 
			
		|||
         INFO = -11
 | 
			
		||||
      ELSE IF( LDVR.LT.1 .OR. ( ILVR .AND. LDVR.LT.N ) ) THEN
 | 
			
		||||
         INFO = -13
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, 2*N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -15
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -323,7 +324,7 @@
 | 
			
		|||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         CALL CGEQRF( N, N, B, LDB, WORK, WORK, -1, IERR )
 | 
			
		||||
         LWKOPT = MAX( N,  N+INT( WORK( 1 ) ) )
 | 
			
		||||
         LWKOPT = MAX( LWKMIN, N+INT( WORK( 1 ) ) )
 | 
			
		||||
         CALL CUNMQR( 'L', 'C', N, N, N, B, LDB, WORK, A, LDA, WORK,
 | 
			
		||||
     $                -1, IERR )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, N+INT( WORK( 1 ) ) )
 | 
			
		||||
| 
						 | 
				
			
			@ -348,7 +349,11 @@
 | 
			
		|||
     $                   RWORK, 0, IERR )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, N+INT( WORK( 1 ) ) )
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
         IF( N.EQ.0 ) THEN
 | 
			
		||||
            WORK( 1 ) = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
         END IF
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -368,7 +373,6 @@
 | 
			
		|||
      EPS = SLAMCH( 'E' )*SLAMCH( 'B' )
 | 
			
		||||
      SMLNUM = SLAMCH( 'S' )
 | 
			
		||||
      BIGNUM = ONE / SMLNUM
 | 
			
		||||
      CALL SLABAD( SMLNUM, BIGNUM )
 | 
			
		||||
      SMLNUM = SQRT( SMLNUM ) / EPS
 | 
			
		||||
      BIGNUM = ONE / SMLNUM
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -549,7 +553,7 @@
 | 
			
		|||
      IF( ILBSCL )
 | 
			
		||||
     $   CALL CLASCL( 'G', 0, 0, BNRMTO, BNRM, N, 1, BETA, N, IERR )
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CGGEV3
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -180,7 +180,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (LWORK)
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -212,7 +212,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexOTHERcomputational
 | 
			
		||||
*> \ingroup gghd3
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -265,7 +265,8 @@
 | 
			
		|||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      INTEGER            ILAENV
 | 
			
		||||
      EXTERNAL           ILAENV, LSAME
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           ILAENV, LSAME, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CGGHRD, CLARTG, CLASET, CUNM22, CROT, CGEMM,
 | 
			
		||||
| 
						 | 
				
			
			@ -280,8 +281,13 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      NB = ILAENV( 1, 'CGGHD3', ' ', N, ILO, IHI, -1 )
 | 
			
		||||
      LWKOPT = MAX( 6*N*NB, 1 )
 | 
			
		||||
      WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
      NH = IHI - ILO + 1
 | 
			
		||||
      IF( NH.LE.1 ) THEN
 | 
			
		||||
         LWKOPT = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKOPT = 6*N*NB
 | 
			
		||||
      END IF
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      INITQ = LSAME( COMPQ, 'I' )
 | 
			
		||||
      WANTQ = INITQ .OR. LSAME( COMPQ, 'V' )
 | 
			
		||||
      INITZ = LSAME( COMPZ, 'I' )
 | 
			
		||||
| 
						 | 
				
			
			@ -330,7 +336,6 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      NH = IHI - ILO + 1
 | 
			
		||||
      IF( NH.LE.1 ) THEN
 | 
			
		||||
         WORK( 1 ) = CONE
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -888,7 +893,8 @@
 | 
			
		|||
      IF ( JCOL.LT.IHI )
 | 
			
		||||
     $   CALL CGGHRD( COMPQ2, COMPZ2, N, JCOL, IHI, A, LDA, B, LDB, Q,
 | 
			
		||||
     $                LDQ, Z, LDZ, IERR )
 | 
			
		||||
      WORK( 1 ) = CMPLX( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -251,8 +251,8 @@
 | 
			
		|||
      NB2 = ILAENV( 1, 'CGERQF', ' ', N, P, -1, -1 )
 | 
			
		||||
      NB3 = ILAENV( 1, 'CUNMQR', ' ', N, M, P, -1 )
 | 
			
		||||
      NB = MAX( NB1, NB2, NB3 )
 | 
			
		||||
      LWKOPT = MAX( N, M, P)*NB
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      LWKOPT = MAX( 1, MAX( N, M, P )*NB )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( N.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -288,7 +288,7 @@
 | 
			
		|||
*     RQ factorization of N-by-P matrix B: B = T*Z.
 | 
			
		||||
*
 | 
			
		||||
      CALL CGERQF( N, P, B, LDB, TAUB, WORK, LWORK, INFO )
 | 
			
		||||
      WORK( 1 ) = MAX( LOPT, INT( WORK( 1 ) ) )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( MAX( LOPT, INT( WORK( 1 ) ) ) )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -250,8 +250,8 @@
 | 
			
		|||
      NB2 = ILAENV( 1, 'CGEQRF', ' ', P, N, -1, -1 )
 | 
			
		||||
      NB3 = ILAENV( 1, 'CUNMRQ', ' ', M, N, P, -1 )
 | 
			
		||||
      NB = MAX( NB1, NB2, NB3 )
 | 
			
		||||
      LWKOPT = MAX( N, M, P)*NB
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      LWKOPT = MAX( 1, MAX( N, M, P )*NB )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -288,7 +288,7 @@
 | 
			
		|||
*     QR factorization of P-by-N matrix B: B = Z*T
 | 
			
		||||
*
 | 
			
		||||
      CALL CGEQRF( P, N, B, LDB, TAUB, WORK, LWORK, INFO )
 | 
			
		||||
      WORK( 1 ) = MAX( LOPT, INT( WORK( 1 ) ) )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( MAX( LOPT, INT( WORK( 1 ) ) ) )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -278,7 +278,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -333,7 +333,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexGEsing
 | 
			
		||||
*> \ingroup ggsvd3
 | 
			
		||||
*
 | 
			
		||||
*> \par Contributors:
 | 
			
		||||
*  ==================
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -233,7 +233,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -256,7 +256,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexOTHERcomputational
 | 
			
		||||
*> \ingroup ggsvp3
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -116,8 +116,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] RWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          RWORK is REAL array,
 | 
			
		||||
*>                                         dimension (LRWORK)
 | 
			
		||||
*>          RWORK is REAL array, dimension (MAX(1,LRWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -282,8 +281,8 @@
 | 
			
		|||
            LROPT = LRWMIN
 | 
			
		||||
            LIOPT = LIWMIN
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LOPT)
 | 
			
		||||
         RWORK( 1 ) = LROPT
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LOPT )
 | 
			
		||||
         RWORK( 1 ) = SROUNDUP_LWORK( LROPT )
 | 
			
		||||
         IWORK( 1 ) = LIOPT
 | 
			
		||||
*
 | 
			
		||||
         IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -378,8 +377,8 @@
 | 
			
		|||
         CALL SSCAL( IMAX, ONE / SIGMA, W, 1 )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LOPT)
 | 
			
		||||
      RWORK( 1 ) = LROPT
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LOPT )
 | 
			
		||||
      RWORK( 1 ) = SROUNDUP_LWORK( LROPT )
 | 
			
		||||
      IWORK( 1 ) = LIOPT
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -272,7 +272,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of the array WORK.  LWORK >= max(1,2*N).
 | 
			
		||||
*>          The length of the array WORK.
 | 
			
		||||
*>          If N <= 1, LWORK >= 1, else LWORK >= 2*N.
 | 
			
		||||
*>          For optimal efficiency, LWORK >= (NB+1)*N,
 | 
			
		||||
*>          where NB is the max of the blocksize for CHETRD and for
 | 
			
		||||
*>          CUNMTR as returned by ILAENV.
 | 
			
		||||
| 
						 | 
				
			
			@ -294,7 +295,8 @@
 | 
			
		|||
*> \param[in] LRWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LRWORK is INTEGER
 | 
			
		||||
*>          The length of the array RWORK.  LRWORK >= max(1,24*N).
 | 
			
		||||
*>          The length of the array RWORK.
 | 
			
		||||
*>          If N <= 1, LRWORK >= 1, else LRWORK >= 24*N.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LRWORK = -1, then a workspace query is assumed; the
 | 
			
		||||
*>          routine only calculates the optimal sizes of the WORK, RWORK
 | 
			
		||||
| 
						 | 
				
			
			@ -313,7 +315,8 @@
 | 
			
		|||
*> \param[in] LIWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LIWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array IWORK.  LIWORK >= max(1,10*N).
 | 
			
		||||
*>          The dimension of the array IWORK.
 | 
			
		||||
*>          If N <= 1, LIWORK >= 1, else LIWORK >= 10*N.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LIWORK = -1, then a workspace query is assumed; the
 | 
			
		||||
*>          routine only calculates the optimal sizes of the WORK, RWORK
 | 
			
		||||
| 
						 | 
				
			
			@ -417,9 +420,15 @@
 | 
			
		|||
      LQUERY = ( ( LWORK.EQ.-1 ) .OR. ( LRWORK.EQ.-1 ) .OR.
 | 
			
		||||
     $         ( LIWORK.EQ.-1 ) )
 | 
			
		||||
*
 | 
			
		||||
      LRWMIN = MAX( 1, 24*N )
 | 
			
		||||
      LIWMIN = MAX( 1, 10*N )
 | 
			
		||||
      LWMIN = MAX( 1, 2*N )
 | 
			
		||||
      IF( N.LE.1 ) THEN
 | 
			
		||||
         LWMIN  = 1
 | 
			
		||||
         LRWMIN = 1
 | 
			
		||||
         LIWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN  = 2*N
 | 
			
		||||
         LRWMIN = 24*N
 | 
			
		||||
         LIWMIN = 10*N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      IF( .NOT.( WANTZ .OR. LSAME( JOBZ, 'N' ) ) ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -454,8 +463,8 @@
 | 
			
		|||
         NB = ILAENV( 1, 'CHETRD', UPLO, N, -1, -1, -1 )
 | 
			
		||||
         NB = MAX( NB, ILAENV( 1, 'CUNMTR', UPLO, N, -1, -1, -1 ) )
 | 
			
		||||
         LWKOPT = MAX( ( NB+1 )*N, LWMIN )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         RWORK( 1 ) = LRWMIN
 | 
			
		||||
         WORK( 1 )  = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
         RWORK( 1 ) = SROUNDUP_LWORK( LRWMIN )
 | 
			
		||||
         IWORK( 1 ) = LIWMIN
 | 
			
		||||
*
 | 
			
		||||
         IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -483,7 +492,7 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( N.EQ.1 ) THEN
 | 
			
		||||
         WORK( 1 ) = 2
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         IF( ALLEIG .OR. INDEIG ) THEN
 | 
			
		||||
            M = 1
 | 
			
		||||
            W( 1 ) = REAL( A( 1, 1 ) )
 | 
			
		||||
| 
						 | 
				
			
			@ -710,8 +719,8 @@
 | 
			
		|||
*
 | 
			
		||||
*     Set WORK(1) to optimal workspace size.
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      RWORK( 1 ) = LRWMIN
 | 
			
		||||
      WORK( 1 )  = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      RWORK( 1 ) = SROUNDUP_LWORK( LRWMIN )
 | 
			
		||||
      IWORK( 1 ) = LIWMIN
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -280,6 +280,7 @@
 | 
			
		|||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If N <= 1,               LWORK must be at least 1.
 | 
			
		||||
*>          If JOBZ = 'N' and N > 1, LWORK must be queried.
 | 
			
		||||
*>                                   LWORK = MAX(1, 26*N, dimension) where
 | 
			
		||||
*>                                   dimension = max(stage1,stage2) + (KD+1)*N + N
 | 
			
		||||
| 
						 | 
				
			
			@ -310,7 +311,8 @@
 | 
			
		|||
*> \param[in] LRWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LRWORK is INTEGER
 | 
			
		||||
*>          The length of the array RWORK.  LRWORK >= max(1,24*N).
 | 
			
		||||
*>          The length of the array RWORK.
 | 
			
		||||
*>          If N <= 1, LRWORK >= 1, else LRWORK >= 24*N.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LRWORK = -1, then a workspace query is assumed; the
 | 
			
		||||
*>          routine only calculates the optimal sizes of the WORK, RWORK
 | 
			
		||||
| 
						 | 
				
			
			@ -329,7 +331,8 @@
 | 
			
		|||
*> \param[in] LIWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LIWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array IWORK.  LIWORK >= max(1,10*N).
 | 
			
		||||
*>          The dimension of the array IWORK.
 | 
			
		||||
*>          If N <= 1, LIWORK >= 1, else LIWORK >= 10*N.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LIWORK = -1, then a workspace query is assumed; the
 | 
			
		||||
*>          routine only calculates the optimal sizes of the WORK, RWORK
 | 
			
		||||
| 
						 | 
				
			
			@ -354,7 +357,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexHEeigen
 | 
			
		||||
*> \ingroup heevr_2stage
 | 
			
		||||
*
 | 
			
		||||
*> \par Contributors:
 | 
			
		||||
*  ==================
 | 
			
		||||
| 
						 | 
				
			
			@ -443,8 +446,9 @@
 | 
			
		|||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      INTEGER            ILAENV, ILAENV2STAGE
 | 
			
		||||
      REAL               SLAMCH, CLANSY
 | 
			
		||||
      EXTERNAL           LSAME, SLAMCH, CLANSY, ILAENV, ILAENV2STAGE
 | 
			
		||||
      REAL               SLAMCH, CLANSY, SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, SLAMCH, CLANSY, ILAENV, ILAENV2STAGE,
 | 
			
		||||
     $                   SROUNDUP_LWORK 
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           SCOPY, SSCAL, SSTEBZ, SSTERF, XERBLA, CSSCAL,
 | 
			
		||||
| 
						 | 
				
			
			@ -472,9 +476,16 @@
 | 
			
		|||
      IB     = ILAENV2STAGE( 2, 'CHETRD_2STAGE', JOBZ, N, KD, -1, -1 )
 | 
			
		||||
      LHTRD  = ILAENV2STAGE( 3, 'CHETRD_2STAGE', JOBZ, N, KD, IB, -1 )
 | 
			
		||||
      LWTRD  = ILAENV2STAGE( 4, 'CHETRD_2STAGE', JOBZ, N, KD, IB, -1 )
 | 
			
		||||
*
 | 
			
		||||
      IF( N.LE.1 ) THEN
 | 
			
		||||
         LWMIN  = 1
 | 
			
		||||
         LRWMIN = 1
 | 
			
		||||
         LIWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN  = N + LHTRD + LWTRD
 | 
			
		||||
      LRWMIN = MAX( 1, 24*N )
 | 
			
		||||
      LIWMIN = MAX( 1, 10*N )
 | 
			
		||||
         LRWMIN = 24*N
 | 
			
		||||
         LIWMIN = 10*N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      IF( .NOT.( LSAME( JOBZ, 'N' ) ) ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -506,8 +517,8 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         WORK( 1 )  = LWMIN
 | 
			
		||||
         RWORK( 1 ) = LRWMIN
 | 
			
		||||
         WORK( 1 )  = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
         RWORK( 1 ) = SROUNDUP_LWORK( LRWMIN )
 | 
			
		||||
         IWORK( 1 ) = LIWMIN
 | 
			
		||||
*
 | 
			
		||||
         IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -535,7 +546,7 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( N.EQ.1 ) THEN
 | 
			
		||||
         WORK( 1 ) = 2
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         IF( ALLEIG .OR. INDEIG ) THEN
 | 
			
		||||
            M = 1
 | 
			
		||||
            W( 1 ) = REAL( A( 1, 1 ) )
 | 
			
		||||
| 
						 | 
				
			
			@ -666,7 +677,7 @@
 | 
			
		|||
            CALL SCOPY( N-1, RWORK( INDRE ), 1, RWORK( INDREE ), 1 )
 | 
			
		||||
            CALL SCOPY( N, RWORK( INDRD ), 1, RWORK( INDRDD ), 1 )
 | 
			
		||||
*
 | 
			
		||||
            IF (ABSTOL .LE. TWO*N*EPS) THEN
 | 
			
		||||
            IF ( ABSTOL .LE. TWO*N*EPS ) THEN
 | 
			
		||||
               TRYRAC = .TRUE.
 | 
			
		||||
            ELSE
 | 
			
		||||
               TRYRAC = .FALSE.
 | 
			
		||||
| 
						 | 
				
			
			@ -765,8 +776,8 @@
 | 
			
		|||
*
 | 
			
		||||
*     Set WORK(1) to optimal workspace size.
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 )  = LWMIN
 | 
			
		||||
      RWORK( 1 ) = LRWMIN
 | 
			
		||||
      WORK( 1 )  = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      RWORK( 1 ) = SROUNDUP_LWORK( LRWMIN )
 | 
			
		||||
      IWORK( 1 ) = LIWMIN
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -348,14 +348,14 @@
 | 
			
		|||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         IF( N.LE.1 ) THEN
 | 
			
		||||
            LWKMIN = 1
 | 
			
		||||
            WORK( 1 ) = LWKMIN
 | 
			
		||||
            LWKOPT = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            LWKMIN = 2*N
 | 
			
		||||
            NB = ILAENV( 1, 'CHETRD', UPLO, N, -1, -1, -1 )
 | 
			
		||||
            NB = MAX( NB, ILAENV( 1, 'CUNMTR', UPLO, N, -1, -1, -1 ) )
 | 
			
		||||
            LWKOPT = MAX( 1, ( NB + 1 )*N )
 | 
			
		||||
            WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
            LWKOPT = ( NB + 1 )*N
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
         IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY )
 | 
			
		||||
     $      INFO = -17
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -177,7 +177,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY
 | 
			
		||||
      INTEGER            LWKOPT, LWKOPT_HETRF, LWKOPT_HETRS
 | 
			
		||||
      INTEGER            LWKMIN, LWKOPT, LWKOPT_HETRF, LWKOPT_HETRS
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -197,6 +197,7 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      LWKMIN = MAX( 1, 2*N, 3*N-2 )
 | 
			
		||||
      IF( .NOT.LSAME( UPLO, 'U' ) .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -207,18 +208,18 @@
 | 
			
		|||
         INFO = -5
 | 
			
		||||
      ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -8
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 2*N, 3*N-2 ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         CALL CHETRF_AA( UPLO, N, A, LDA, IPIV, WORK, -1, INFO )
 | 
			
		||||
         LWKOPT_HETRF = INT( WORK(1) )
 | 
			
		||||
         LWKOPT_HETRF = INT( WORK( 1 ) )
 | 
			
		||||
         CALL CHETRS_AA( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
 | 
			
		||||
     $                   -1, INFO )
 | 
			
		||||
         LWKOPT_HETRS = INT( WORK(1) )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT_HETRF, LWKOPT_HETRS )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         LWKOPT_HETRS = INT( WORK( 1 ) )
 | 
			
		||||
         LWKOPT = MAX( LWKMIN, LWKOPT_HETRF, LWKOPT_HETRS )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -240,7 +241,7 @@
 | 
			
		|||
*
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -99,14 +99,14 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] TB
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          TB is COMPLEX array, dimension (LTB)
 | 
			
		||||
*>          TB is COMPLEX array, dimension (MAX(1,LTB)).
 | 
			
		||||
*>          On exit, details of the LU factorization of the band matrix.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LTB
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LTB is INTEGER
 | 
			
		||||
*>          The size of the array TB. LTB >= 4*N, internally
 | 
			
		||||
*>          The size of the array TB. LTB >= MAX(1,4*N), internally
 | 
			
		||||
*>          used to select NB such that LTB >= (3*NB+1)*N.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LTB = -1, then a workspace query is assumed; the
 | 
			
		||||
| 
						 | 
				
			
			@ -146,14 +146,15 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is COMPLEX workspace of size LWORK
 | 
			
		||||
*>          WORK is COMPLEX workspace of size (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The size of WORK. LWORK >= N, internally used to select NB
 | 
			
		||||
*>          such that LWORK >= N*NB.
 | 
			
		||||
*>          The size of WORK. LWORK >= MAX(1,N), internally used to
 | 
			
		||||
*>          select NB such that LWORK >= N*NB.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the
 | 
			
		||||
*>          routine only calculates the optimal size of the WORK array,
 | 
			
		||||
| 
						 | 
				
			
			@ -203,7 +204,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            UPPER, TQUERY, WQUERY
 | 
			
		||||
      INTEGER            LWKOPT
 | 
			
		||||
      INTEGER            LWKMIN, LWKOPT
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -225,6 +226,7 @@
 | 
			
		|||
      UPPER = LSAME( UPLO, 'U' )
 | 
			
		||||
      WQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      TQUERY = ( LTB.EQ.-1 )
 | 
			
		||||
      LWKMIN = MAX( 1, N )
 | 
			
		||||
      IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -233,18 +235,19 @@
 | 
			
		|||
         INFO = -3
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -5
 | 
			
		||||
      ELSE IF( LTB.LT.( 4*N ) .AND. .NOT.TQUERY ) THEN
 | 
			
		||||
      ELSE IF( LTB.LT.MAX( 1, 4*N ) .AND. .NOT.TQUERY ) THEN
 | 
			
		||||
         INFO = -7
 | 
			
		||||
      ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -11
 | 
			
		||||
      ELSE IF( LWORK.LT.N .AND. .NOT.WQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.WQUERY ) THEN
 | 
			
		||||
         INFO = -13
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         CALL CHETRF_AA_2STAGE( UPLO, N, A, LDA, TB, -1, IPIV,
 | 
			
		||||
     $                          IPIV2, WORK, -1, INFO )
 | 
			
		||||
         LWKOPT = INT( WORK(1) )
 | 
			
		||||
         LWKOPT = MAX( LWKMIN, INT( WORK( 1 ) ) )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -254,7 +257,6 @@
 | 
			
		|||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*
 | 
			
		||||
*     Compute the factorization A = U**H*T*U or A = L*T*L**H.
 | 
			
		||||
*
 | 
			
		||||
      CALL CHETRF_AA_2STAGE( UPLO, N, A, LDA, TB, LTB, IPIV, IPIV2,
 | 
			
		||||
| 
						 | 
				
			
			@ -268,7 +270,7 @@
 | 
			
		|||
*
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -307,7 +307,7 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY, NOFACT
 | 
			
		||||
      INTEGER            LWKOPT, NB
 | 
			
		||||
      INTEGER            LWKMIN, LWKOPT, NB
 | 
			
		||||
      REAL               ANORM
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
| 
						 | 
				
			
			@ -329,6 +329,7 @@
 | 
			
		|||
      INFO = 0
 | 
			
		||||
      NOFACT = LSAME( FACT, 'N' )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      LWKMIN = MAX( 1, 2*N )
 | 
			
		||||
      IF( .NOT.NOFACT .AND. .NOT.LSAME( FACT, 'F' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( .NOT.LSAME( UPLO, 'U' ) .AND. .NOT.LSAME( UPLO, 'L' ) )
 | 
			
		||||
| 
						 | 
				
			
			@ -346,17 +347,17 @@
 | 
			
		|||
         INFO = -11
 | 
			
		||||
      ELSE IF( LDX.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -13
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, 2*N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -18
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         LWKOPT = MAX( 1, 2*N )
 | 
			
		||||
         LWKOPT = LWKMIN
 | 
			
		||||
         IF( NOFACT ) THEN
 | 
			
		||||
            NB = ILAENV( 1, 'CHETRF', UPLO, N, -1, -1, -1 )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, N*NB )
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -405,7 +406,7 @@
 | 
			
		|||
      IF( RCOND.LT.SLAMCH( 'Epsilon' ) )
 | 
			
		||||
     $   INFO = N + 1
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -123,7 +123,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] HOUS2
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          HOUS2 is COMPLEX array, dimension (LHOUS2)
 | 
			
		||||
*>          HOUS2 is COMPLEX array, dimension (MAX(1,LHOUS2))
 | 
			
		||||
*>          Stores the Householder representation of the stage2
 | 
			
		||||
*>          band to tridiagonal.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
| 
						 | 
				
			
			@ -132,6 +132,8 @@
 | 
			
		|||
*> \verbatim
 | 
			
		||||
*>          LHOUS2 is INTEGER
 | 
			
		||||
*>          The dimension of the array HOUS2.
 | 
			
		||||
*>          LHOUS2 >= 1.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, or LHOUS2=-1,
 | 
			
		||||
*>          then a query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the HOUS2 array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -143,13 +145,16 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (LWORK)
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK. LWORK = MAX(1, dimension)
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If N = 0, LWORK >= 1, else LWORK = MAX(1, dimension).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, or LHOUS2 = -1,
 | 
			
		||||
*>          then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -182,7 +187,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexHEcomputational
 | 
			
		||||
*> \ingroup hetrd_2stage
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -250,7 +255,8 @@
 | 
			
		|||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      INTEGER            ILAENV2STAGE
 | 
			
		||||
      EXTERNAL           LSAME, ILAENV2STAGE
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, ILAENV2STAGE, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Executable Statements ..
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -265,10 +271,13 @@
 | 
			
		|||
*
 | 
			
		||||
      KD     = ILAENV2STAGE( 1, 'CHETRD_2STAGE', VECT, N, -1, -1, -1 )
 | 
			
		||||
      IB     = ILAENV2STAGE( 2, 'CHETRD_2STAGE', VECT, N, KD, -1, -1 )
 | 
			
		||||
      IF( N.EQ.0 ) THEN
 | 
			
		||||
         LHMIN = 1
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LHMIN = ILAENV2STAGE( 3, 'CHETRD_2STAGE', VECT, N, KD, IB, -1 )
 | 
			
		||||
         LWMIN = ILAENV2STAGE( 4, 'CHETRD_2STAGE', VECT, N, KD, IB, -1 )
 | 
			
		||||
*      WRITE(*,*),'CHETRD_2STAGE N KD UPLO LHMIN LWMIN ',N, KD, UPLO,
 | 
			
		||||
*     $            LHMIN, LWMIN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.LSAME( VECT, 'N' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -285,8 +294,8 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         HOUS2( 1 ) = LHMIN
 | 
			
		||||
         WORK( 1 )  = LWMIN
 | 
			
		||||
         HOUS2( 1 ) = SROUNDUP_LWORK( LHMIN )
 | 
			
		||||
         WORK( 1 )  = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -324,8 +333,7 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*
 | 
			
		||||
      HOUS2( 1 ) = LHMIN
 | 
			
		||||
      WORK( 1 )  = LWMIN
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CHETRD_2STAGE
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -132,15 +132,17 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] HOUS
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          HOUS is COMPLEX array, dimension LHOUS, that
 | 
			
		||||
*>          store the Householder representation.
 | 
			
		||||
*>          HOUS is COMPLEX array, dimension (MAX(1,LHOUS))
 | 
			
		||||
*>          Stores the Householder representation.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LHOUS
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LHOUS is INTEGER
 | 
			
		||||
*>          The dimension of the array HOUS. LHOUS = MAX(1, dimension)
 | 
			
		||||
*>          If LWORK = -1, or LHOUS=-1,
 | 
			
		||||
*>          The dimension of the array HOUS.
 | 
			
		||||
*>          If N = 0 or KD <= 1, LHOUS >= 1, else LHOUS = MAX(1, dimension).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, or LHOUS = -1,
 | 
			
		||||
*>          then a query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the HOUS array, returns
 | 
			
		||||
*>          this value as the first entry of the HOUS array, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -152,14 +154,17 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is COMPLEX array, dimension LWORK.
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (MAX(1,LWORK)).
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK. LWORK = MAX(1, dimension)
 | 
			
		||||
*>          If LWORK = -1, or LHOUS=-1,
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If N = 0 or KD <= 1, LWORK >= 1, else LWORK = MAX(1, dimension).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, or LHOUS = -1,
 | 
			
		||||
*>          then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -262,7 +267,7 @@
 | 
			
		|||
      INTEGER            I, M, K, IB, SWEEPID, MYID, SHIFT, STT, ST,
 | 
			
		||||
     $                   ED, STIND, EDIND, BLKLASTIND, COLPT, THED,
 | 
			
		||||
     $                   STEPERCOL, GRSIZ, THGRSIZ, THGRNB, THGRID,
 | 
			
		||||
     $                   NBTILES, TTYPE, TID, NTHREADS, DEBUG,
 | 
			
		||||
     $                   NBTILES, TTYPE, TID, NTHREADS,
 | 
			
		||||
     $                   ABDPOS, ABOFDPOS, DPOS, OFDPOS, AWPOS,
 | 
			
		||||
     $                   INDA, INDW, APOS, SIZEA, LDA, INDV, INDTAU,
 | 
			
		||||
     $                   SICEV, SIZETAU, LDV, LHMIN, LWMIN
 | 
			
		||||
| 
						 | 
				
			
			@ -286,7 +291,6 @@
 | 
			
		|||
*     Determine the minimal workspace size required.
 | 
			
		||||
*     Test the input parameters
 | 
			
		||||
*
 | 
			
		||||
      DEBUG   = 0
 | 
			
		||||
      INFO    = 0
 | 
			
		||||
      AFTERS1 = LSAME( STAGE1, 'Y' )
 | 
			
		||||
      WANTQ   = LSAME( VECT, 'V' )
 | 
			
		||||
| 
						 | 
				
			
			@ -296,8 +300,13 @@
 | 
			
		|||
*     Determine the block size, the workspace size and the hous size.
 | 
			
		||||
*
 | 
			
		||||
      IB       = ILAENV2STAGE( 2, 'CHETRD_HB2ST', VECT, N, KD, -1, -1 )
 | 
			
		||||
      IF( N.EQ.0 .OR. KD.LE.1 ) THEN
 | 
			
		||||
         LHMIN = 1
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LHMIN = ILAENV2STAGE( 3, 'CHETRD_HB2ST', VECT, N, KD, IB, -1 )
 | 
			
		||||
         LWMIN = ILAENV2STAGE( 4, 'CHETRD_HB2ST', VECT, N, KD, IB, -1 )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.AFTERS1 .AND. .NOT.LSAME( STAGE1, 'N' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -318,8 +327,8 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         HOUS( 1 ) = LHMIN
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWMIN)
 | 
			
		||||
         HOUS( 1 ) = SROUNDUP_LWORK( LHMIN )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -575,8 +584,7 @@ C                 END IF
 | 
			
		|||
  170     CONTINUE
 | 
			
		||||
      ENDIF
 | 
			
		||||
*
 | 
			
		||||
      HOUS( 1 ) = LHMIN
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWMIN)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CHETRD_HB2ST
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -123,8 +123,8 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (LWORK)
 | 
			
		||||
*>          On exit, if INFO = 0, or if LWORK=-1, 
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, or if LWORK = -1,
 | 
			
		||||
*>          WORK(1) returns the size of LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -132,7 +132,9 @@
 | 
			
		|||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK which should be calculated
 | 
			
		||||
*>          by a workspace query. LWORK = MAX(1, LWORK_QUERY)
 | 
			
		||||
*>          by a workspace query.
 | 
			
		||||
*>          If N <= KD+1, LWORK >= 1, else LWORK = MAX(1, LWORK_QUERY).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -294,8 +296,12 @@
 | 
			
		|||
      INFO   = 0
 | 
			
		||||
      UPPER  = LSAME( UPLO, 'U' )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( N.LE.KD+1 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = ILAENV2STAGE( 4, 'CHETRD_HE2HB', '', N, KD, -1, -1 )
 | 
			
		||||
      
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -314,7 +320,7 @@
 | 
			
		|||
         CALL XERBLA( 'CHETRD_HE2HB', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWMIN)
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -507,7 +513,7 @@
 | 
			
		|||
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWMIN)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CHETRD_HE2HB
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -107,7 +107,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of WORK.  LWORK >=1.  For best performance
 | 
			
		||||
*>          The length of WORK. LWORK >= 1. For best performance
 | 
			
		||||
*>          LWORK >= N*NB, where NB is the block size returned by ILAENV.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -228,8 +228,8 @@
 | 
			
		|||
*        Determine the block size
 | 
			
		||||
*
 | 
			
		||||
         NB = ILAENV( 1, 'CHETRF', UPLO, N, -1, -1, -1 )
 | 
			
		||||
         LWKOPT = N*NB
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         LWKOPT = MAX( 1, N*NB )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -347,7 +347,7 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
   40 CONTINUE
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CHETRF
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -101,8 +101,10 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of WORK.  LWORK >= 2*N. For optimum performance
 | 
			
		||||
*>          LWORK >= N*(1+NB), where NB is the optimal blocksize.
 | 
			
		||||
*>          The length of WORK.
 | 
			
		||||
*>          LWORK >= 1, if N <= 1, and LWORK >= 2*N, otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= N*(1+NB), where NB is
 | 
			
		||||
*>          the optimal blocksize, returned by ILAENV.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -128,7 +130,7 @@
 | 
			
		|||
*> \ingroup hetrf_aa
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE CHETRF_AA( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
 | 
			
		||||
      SUBROUTINE CHETRF_AA( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
 | 
			
		||||
*
 | 
			
		||||
*  -- LAPACK computational routine --
 | 
			
		||||
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 | 
			
		||||
| 
						 | 
				
			
			@ -152,7 +154,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL      LQUERY, UPPER
 | 
			
		||||
      INTEGER      J, LWKOPT
 | 
			
		||||
      INTEGER      J, LWKMIN, LWKOPT
 | 
			
		||||
      INTEGER      NB, MJ, NJ, K1, K2, J1, J2, J3, JB
 | 
			
		||||
      COMPLEX      ALPHA
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -179,19 +181,26 @@
 | 
			
		|||
      INFO = 0
 | 
			
		||||
      UPPER = LSAME( UPLO, 'U' )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( N.LE.1 ) THEN
 | 
			
		||||
         LWKMIN = 1
 | 
			
		||||
         LWKOPT = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKMIN = 2*N
 | 
			
		||||
         LWKOPT = (NB+1)*N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF( LWORK.LT.( 2*N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -7
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         LWKOPT = (NB+1)*N
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -203,11 +212,11 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return
 | 
			
		||||
*
 | 
			
		||||
      IF ( N.EQ.0 ) THEN
 | 
			
		||||
      IF( N.EQ.0 ) THEN
 | 
			
		||||
          RETURN
 | 
			
		||||
      ENDIF
 | 
			
		||||
      IPIV( 1 ) = 1
 | 
			
		||||
      IF ( N.EQ.1 ) THEN
 | 
			
		||||
      IF( N.EQ.1 ) THEN
 | 
			
		||||
         A( 1, 1 ) = REAL( A( 1, 1 ) )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
| 
						 | 
				
			
			@ -460,7 +469,7 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
   20 CONTINUE
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CHETRF_AA
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -87,14 +87,14 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] TB
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          TB is COMPLEX array, dimension (LTB)
 | 
			
		||||
*>          TB is COMPLEX array, dimension (MAX(1,LTB))
 | 
			
		||||
*>          On exit, details of the LU factorization of the band matrix.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LTB
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LTB is INTEGER
 | 
			
		||||
*>          The size of the array TB. LTB >= 4*N, internally
 | 
			
		||||
*>          The size of the array TB. LTB >= MAX(1,4*N), internally
 | 
			
		||||
*>          used to select NB such that LTB >= (3*NB+1)*N.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LTB = -1, then a workspace query is assumed; the
 | 
			
		||||
| 
						 | 
				
			
			@ -121,14 +121,14 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is COMPLEX workspace of size LWORK
 | 
			
		||||
*>          WORK is COMPLEX workspace of size (MAX(1,LWORK))
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The size of WORK. LWORK >= N, internally used to select NB
 | 
			
		||||
*>          such that LWORK >= N*NB.
 | 
			
		||||
*>          The size of WORK. LWORK >= MAX(1,N), internally used
 | 
			
		||||
*>          to select NB such that LWORK >= N*NB.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the
 | 
			
		||||
*>          routine only calculates the optimal size of the WORK array,
 | 
			
		||||
| 
						 | 
				
			
			@ -152,7 +152,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexSYcomputational
 | 
			
		||||
*> \ingroup hetrf_aa_2stage
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE CHETRF_AA_2STAGE( UPLO, N, A, LDA, TB, LTB, IPIV,
 | 
			
		||||
| 
						 | 
				
			
			@ -188,7 +188,8 @@
 | 
			
		|||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      INTEGER            ILAENV
 | 
			
		||||
      EXTERNAL           LSAME, ILAENV
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, ILAENV, SROUNDUP_LWORK
 | 
			
		||||
      
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
| 
						 | 
				
			
			@ -213,9 +214,9 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF ( LTB .LT. 4*N .AND. .NOT.TQUERY ) THEN
 | 
			
		||||
      ELSE IF( LTB.LT.MAX( 1, 4*N ) .AND. .NOT.TQUERY ) THEN
 | 
			
		||||
         INFO = -6
 | 
			
		||||
      ELSE IF ( LWORK .LT. N .AND. .NOT.WQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, N ) .AND. .NOT.WQUERY ) THEN
 | 
			
		||||
         INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -229,10 +230,10 @@
 | 
			
		|||
      NB = ILAENV( 1, 'CHETRF_AA_2STAGE', UPLO, N, -1, -1, -1 )
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         IF( TQUERY ) THEN
 | 
			
		||||
            TB( 1 ) = (3*NB+1)*N
 | 
			
		||||
            TB( 1 ) = SROUNDUP_LWORK( MAX( 1, (3*NB+1)*N ) )
 | 
			
		||||
         END IF
 | 
			
		||||
         IF( WQUERY ) THEN
 | 
			
		||||
            WORK( 1 ) = N*NB
 | 
			
		||||
            WORK( 1 ) = SROUNDUP_LWORK( MAX( 1, N*NB ) )
 | 
			
		||||
         END IF
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( TQUERY .OR. WQUERY ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -241,7 +242,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return
 | 
			
		||||
*
 | 
			
		||||
      IF ( N.EQ.0 ) THEN
 | 
			
		||||
      IF( N.EQ.0 ) THEN
 | 
			
		||||
         RETURN
 | 
			
		||||
      ENDIF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -177,14 +177,14 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is COMPLEX array, dimension ( MAX(1,LWORK) ).
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (MAX(1,LWORK)).
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of WORK.  LWORK >=1.  For best performance
 | 
			
		||||
*>          The length of WORK.  LWORK >= 1.  For best performance
 | 
			
		||||
*>          LWORK >= N*NB, where NB is the block size returned
 | 
			
		||||
*>          by ILAENV.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -311,8 +311,8 @@
 | 
			
		|||
*        Determine the block size
 | 
			
		||||
*
 | 
			
		||||
         NB = ILAENV( 1, 'CHETRF_RK', UPLO, N, -1, -1, -1 )
 | 
			
		||||
         LWKOPT = N*NB
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         LWKOPT = MAX( 1, N*NB )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -488,7 +488,7 @@
 | 
			
		|||
*
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CHETRF_RK
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -122,7 +122,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of WORK.  LWORK >=1.  For best performance
 | 
			
		||||
*>          The length of WORK.  LWORK >= 1.  For best performance
 | 
			
		||||
*>          LWORK >= N*NB, where NB is the block size returned by ILAENV.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
| 
						 | 
				
			
			@ -264,7 +264,7 @@
 | 
			
		|||
*
 | 
			
		||||
         NB = ILAENV( 1, 'CHETRF_ROOK', UPLO, N, -1, -1, -1 )
 | 
			
		||||
         LWKOPT = MAX( 1, N*NB )
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -387,7 +387,7 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
   40 CONTINUE
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CHETRF_ROOK
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -88,14 +88,14 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (N+NB+1)*(NB+3)
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          WORK is size >= (N+NB+1)*(NB+3)
 | 
			
		||||
*>          If N = 0, LWORK >= 1, else LWORK >= (N+NB+1)*(NB+3).
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          calculates:
 | 
			
		||||
*>              - the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -120,7 +120,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup complexHEcomputational
 | 
			
		||||
*> \ingroup hetri2
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE CHETRI2( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -147,7 +147,8 @@
 | 
			
		|||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      INTEGER            ILAENV
 | 
			
		||||
      EXTERNAL           LSAME, ILAENV
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, ILAENV, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CHETRI2X, CHETRI, XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -159,9 +160,13 @@
 | 
			
		|||
      INFO = 0
 | 
			
		||||
      UPPER = LSAME( UPLO, 'U' )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
*
 | 
			
		||||
*     Get blocksize
 | 
			
		||||
*
 | 
			
		||||
      NBMAX = ILAENV( 1, 'CHETRF', UPLO, N, -1, -1, -1 )
 | 
			
		||||
      IF ( NBMAX .GE. N ) THEN
 | 
			
		||||
      IF( N.EQ.0 ) THEN
 | 
			
		||||
         MINSIZE = 1
 | 
			
		||||
      ELSE IF( NBMAX.GE.N ) THEN
 | 
			
		||||
         MINSIZE = N
 | 
			
		||||
      ELSE
 | 
			
		||||
         MINSIZE = (N+NBMAX+1)*(NBMAX+3)
 | 
			
		||||
| 
						 | 
				
			
			@ -173,28 +178,29 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF (LWORK .LT. MINSIZE .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.MINSIZE .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -7
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
         CALL XERBLA( 'CHETRI2', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         WORK(1)=MINSIZE
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( MINSIZE )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( N.EQ.0 )
 | 
			
		||||
     $   RETURN
 | 
			
		||||
 | 
			
		||||
      IF( NBMAX .GE. N ) THEN
 | 
			
		||||
      IF( NBMAX.GE.N ) THEN
 | 
			
		||||
         CALL CHETRI( UPLO, N, A, LDA, IPIV, WORK, INFO )
 | 
			
		||||
      ELSE
 | 
			
		||||
         CALL CHETRI2X( UPLO, N, A, LDA, IPIV, WORK, NBMAX, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CHETRI2
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -119,16 +119,17 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (N+NB+1)*(NB+3).
 | 
			
		||||
*>          WORK is COMPLEX array, dimension (MAX(1,LWORK)).
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of WORK. LWORK >= (N+NB+1)*(NB+3).
 | 
			
		||||
*>          The length of WORK.
 | 
			
		||||
*>          If N = 0, LWORK >= 1, else LWORK >= (N+NB+1)*(NB+3).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LDWORK = -1, then a workspace query is assumed;
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed;
 | 
			
		||||
*>          the routine only calculates the optimal size of the optimal
 | 
			
		||||
*>          size of the WORK array, returns this value as the first
 | 
			
		||||
*>          entry of the WORK array, and no error message related to
 | 
			
		||||
| 
						 | 
				
			
			@ -209,8 +210,13 @@
 | 
			
		|||
*
 | 
			
		||||
*     Determine the block size
 | 
			
		||||
*
 | 
			
		||||
      IF( N.EQ.0 ) THEN
 | 
			
		||||
         LWKOPT = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         NB = MAX( 1, ILAENV( 1, 'CHETRI_3', UPLO, N, -1, -1, -1 ) )
 | 
			
		||||
         LWKOPT = ( N+NB+1 ) * ( NB+3 )
 | 
			
		||||
      END IF
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -218,7 +224,7 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF ( LWORK .LT. LWKOPT .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKOPT .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -8
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -226,7 +232,6 @@
 | 
			
		|||
         CALL XERBLA( 'CHETRI_3', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -237,7 +242,7 @@
 | 
			
		|||
*
 | 
			
		||||
      CALL CHETRI_3X( UPLO, N, A, LDA, E, IPIV, WORK, NB, INFO )
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -105,7 +105,13 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= max(1,3*N-2).
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If MIN(N,NRHS) = 0, LWORK >= 1, else LWORK >= 3*N-2.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the minimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[out] INFO
 | 
			
		||||
| 
						 | 
				
			
			@ -151,24 +157,30 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY, UPPER
 | 
			
		||||
      INTEGER            K, KP, LWKOPT
 | 
			
		||||
      INTEGER            K, KP, LWKMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME,SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CLACPY, CLACGV, CGTSV, CSWAP, CTRSM, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Intrinsic Functions ..
 | 
			
		||||
      INTRINSIC          MAX
 | 
			
		||||
      INTRINSIC          MIN, MAX
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Executable Statements ..
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      UPPER = LSAME( UPLO, 'U' )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( MIN( N, NRHS ).EQ.0 ) THEN
 | 
			
		||||
         LWKMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKMIN = 3*N-2
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -179,21 +191,20 @@
 | 
			
		|||
         INFO = -5
 | 
			
		||||
      ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -8
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, 3*N-2 ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
         CALL XERBLA( 'CHETRS_AA', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         LWKOPT = (3*N-2)
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKMIN )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( N.EQ.0 .OR. NRHS.EQ.0 )
 | 
			
		||||
      IF( MIN( N, NRHS ).EQ.0 )
 | 
			
		||||
     $   RETURN
 | 
			
		||||
*
 | 
			
		||||
      IF( UPPER ) THEN
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -128,16 +128,19 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If SIDE = 'L', LWORK >= max(1,NB) * MB;
 | 
			
		||||
*>          if SIDE = 'R', LWORK >= max(1,M) * MB.
 | 
			
		||||
*>          If MIN(M,N,K) = 0, LWORK >= 1.
 | 
			
		||||
*>          If SIDE = 'L', LWORK >= max(1,NB*MB).
 | 
			
		||||
*>          If SIDE = 'R', LWORK >= max(1,M*MB).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          only calculates the minimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
| 
						 | 
				
			
			@ -204,7 +207,7 @@
 | 
			
		|||
      INTEGER            INFO, LDA, M, N, K, MB, NB, LDT, LWORK, LDC
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Array Arguments ..
 | 
			
		||||
      COMPLEX           A( LDA, * ), WORK( * ), C(LDC, * ),
 | 
			
		||||
      COMPLEX            A( LDA, * ), WORK( * ), C( LDC, * ),
 | 
			
		||||
     $                   T( LDT, * )
 | 
			
		||||
*     ..
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -213,12 +216,13 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LEFT, RIGHT, TRAN, NOTRAN, LQUERY
 | 
			
		||||
      INTEGER    I, II, KK, LW, CTR
 | 
			
		||||
      INTEGER            I, II, KK, LW, CTR, MINMNK, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CTPMLQT, CGEMLQT, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -226,18 +230,25 @@
 | 
			
		|||
*
 | 
			
		||||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      LQUERY  = LWORK.LT.0
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      LQUERY  = ( LWORK.EQ.-1 )
 | 
			
		||||
      NOTRAN  = LSAME( TRANS, 'N' )
 | 
			
		||||
      TRAN    = LSAME( TRANS, 'C' )
 | 
			
		||||
      LEFT    = LSAME( SIDE, 'L' )
 | 
			
		||||
      RIGHT   = LSAME( SIDE, 'R' )
 | 
			
		||||
      IF (LEFT) THEN
 | 
			
		||||
      IF( LEFT ) THEN
 | 
			
		||||
        LW = N * MB
 | 
			
		||||
      ELSE
 | 
			
		||||
        LW = M * MB
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      MINMNK = MIN( M, N, K )
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
        LWMIN = MAX( 1, LW )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.LEFT .AND. .NOT.RIGHT ) THEN
 | 
			
		||||
        INFO = -1
 | 
			
		||||
      ELSE IF( .NOT.TRAN .AND. .NOT.NOTRAN ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -248,36 +259,37 @@
 | 
			
		|||
        INFO = -3
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
        INFO = -4
 | 
			
		||||
      ELSE IF( K.LT.MB .OR. MB.LT.1) THEN
 | 
			
		||||
      ELSE IF( K.LT.MB .OR. MB.LT.1 ) THEN
 | 
			
		||||
        INFO = -6
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, K ) ) THEN
 | 
			
		||||
        INFO = -9
 | 
			
		||||
      ELSE IF( LDT.LT.MAX( 1, MB) ) THEN
 | 
			
		||||
      ELSE IF( LDT.LT.MAX( 1, MB ) ) THEN
 | 
			
		||||
        INFO = -11
 | 
			
		||||
      ELSE IF( LDC.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
        INFO = -13
 | 
			
		||||
      ELSE IF(( LWORK.LT.MAX(1,LW)).AND.(.NOT.LQUERY)) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
        INFO = -15
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
        CALL XERBLA( 'CLAMSWLQ', -INFO )
 | 
			
		||||
        WORK(1) = SROUNDUP_LWORK(LW)
 | 
			
		||||
        RETURN
 | 
			
		||||
      ELSE IF (LQUERY) THEN
 | 
			
		||||
        WORK(1) = SROUNDUP_LWORK(LW)
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN(M,N,K).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF((NB.LE.K).OR.(NB.GE.MAX(M,N,K))) THEN
 | 
			
		||||
        CALL CGEMLQT( SIDE, TRANS, M, N, K, MB, A, LDA,
 | 
			
		||||
     $        T, LDT, C, LDC, WORK, INFO)
 | 
			
		||||
     $        T, LDT, C, LDC, WORK, INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -404,7 +416,7 @@
 | 
			
		|||
*
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK(1) = SROUNDUP_LWORK(LW)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CLAMSWLQ
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -129,21 +129,23 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If MIN(M,N,K) = 0, LWORK >= 1.
 | 
			
		||||
*>          If SIDE = 'L', LWORK >= max(1,N*NB).
 | 
			
		||||
*>          If SIDE = 'R', LWORK >= max(1,MB*NB).
 | 
			
		||||
*>
 | 
			
		||||
*>          If SIDE = 'L', LWORK >= max(1,N)*NB;
 | 
			
		||||
*>          if SIDE = 'R', LWORK >= max(1,MB)*NB.
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          only calculates the minimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*>
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[out] INFO
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          INFO is INTEGER
 | 
			
		||||
| 
						 | 
				
			
			@ -206,7 +208,7 @@
 | 
			
		|||
      INTEGER            INFO, LDA, M, N, K, MB, NB, LDT, LWORK, LDC
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Array Arguments ..
 | 
			
		||||
      COMPLEX        A( LDA, * ), WORK( * ), C(LDC, * ),
 | 
			
		||||
      COMPLEX            A( LDA, * ), WORK( * ), C( LDC, * ),
 | 
			
		||||
     $                   T( LDT, * )
 | 
			
		||||
*     ..
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -215,12 +217,13 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LEFT, RIGHT, TRAN, NOTRAN, LQUERY
 | 
			
		||||
      INTEGER    I, II, KK, LW, CTR, Q
 | 
			
		||||
      INTEGER            I, II, KK, LW, CTR, Q, MINMNK, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CGEMQRT, CTPMQRT, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -228,12 +231,13 @@
 | 
			
		|||
*
 | 
			
		||||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      LQUERY  = LWORK.LT.0
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      LQUERY  = ( LWORK.EQ.-1 )
 | 
			
		||||
      NOTRAN  = LSAME( TRANS, 'N' )
 | 
			
		||||
      TRAN    = LSAME( TRANS, 'C' )
 | 
			
		||||
      LEFT    = LSAME( SIDE, 'L' )
 | 
			
		||||
      RIGHT   = LSAME( SIDE, 'R' )
 | 
			
		||||
      IF (LEFT) THEN
 | 
			
		||||
      IF( LEFT ) THEN
 | 
			
		||||
        LW = N * NB
 | 
			
		||||
        Q = M
 | 
			
		||||
      ELSE
 | 
			
		||||
| 
						 | 
				
			
			@ -241,7 +245,13 @@
 | 
			
		|||
        Q = N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      MINMNK = MIN( M, N, K )
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
        LWMIN = MAX( 1, LW )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.LEFT .AND. .NOT.RIGHT ) THEN
 | 
			
		||||
        INFO = -1
 | 
			
		||||
      ELSE IF( .NOT.TRAN .AND. .NOT.NOTRAN ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -256,36 +266,36 @@
 | 
			
		|||
        INFO = -7
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, Q ) ) THEN
 | 
			
		||||
        INFO = -9
 | 
			
		||||
      ELSE IF( LDT.LT.MAX( 1, NB) ) THEN
 | 
			
		||||
      ELSE IF( LDT.LT.MAX( 1, NB ) ) THEN
 | 
			
		||||
        INFO = -11
 | 
			
		||||
      ELSE IF( LDC.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
        INFO = -13
 | 
			
		||||
      ELSE IF(( LWORK.LT.MAX(1,LW)).AND.(.NOT.LQUERY)) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
        INFO = -15
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Determine the block size if it is tall skinny or short and wide
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0)  THEN
 | 
			
		||||
          WORK(1) = SROUNDUP_LWORK(LW)
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
        CALL XERBLA( 'CLAMTSQR', -INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      ELSE IF (LQUERY) THEN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN(M,N,K).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Determine the block size if it is tall skinny or short and wide
 | 
			
		||||
*
 | 
			
		||||
      IF((MB.LE.K).OR.(MB.GE.MAX(M,N,K))) THEN
 | 
			
		||||
        CALL CGEMQRT( SIDE, TRANS, M, N, K, NB, A, LDA,
 | 
			
		||||
     $        T, LDT, C, LDC, WORK, INFO)
 | 
			
		||||
     $        T, LDT, C, LDC, WORK, INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -412,7 +422,7 @@
 | 
			
		|||
*
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK(1) = SROUNDUP_LWORK(LW)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CLAMTSQR
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -96,22 +96,24 @@
 | 
			
		|||
*>          The leading dimension of the array T.  LDT >= MB.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= MB*M.
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= MB*M, otherwise.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          only calculates the minimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*>
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[out] INFO
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          INFO is INTEGER
 | 
			
		||||
| 
						 | 
				
			
			@ -163,7 +165,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE CLASWLQ( M, N, MB, NB, A, LDA, T, LDT, WORK, LWORK,
 | 
			
		||||
     $                  INFO)
 | 
			
		||||
     $                    INFO )
 | 
			
		||||
*
 | 
			
		||||
*  -- LAPACK computational routine --
 | 
			
		||||
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 | 
			
		||||
| 
						 | 
				
			
			@ -173,7 +175,7 @@
 | 
			
		|||
      INTEGER            INFO, LDA, M, N, MB, NB, LWORK, LDT
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Array Arguments ..
 | 
			
		||||
      COMPLEX           A( LDA, * ), WORK( * ), T( LDT, *)
 | 
			
		||||
      COMPLEX            A( LDA, * ), WORK( * ), T( LDT, * )
 | 
			
		||||
*     ..
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
| 
						 | 
				
			
			@ -181,15 +183,17 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY
 | 
			
		||||
      INTEGER    I, II, KK, CTR
 | 
			
		||||
      INTEGER            I, II, KK, CTR, MINMN, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. EXTERNAL FUNCTIONS ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      INTEGER            ILAENV
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, ILAENV, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. EXTERNAL SUBROUTINES ..
 | 
			
		||||
      EXTERNAL           CGELQT, CTPLQT, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. INTRINSIC FUNCTIONS ..
 | 
			
		||||
      INTRINSIC          MAX, MIN, MOD
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -200,12 +204,19 @@
 | 
			
		|||
      INFO = 0
 | 
			
		||||
*
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
*
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
        LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
        LWMIN = M*MB
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
        INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 .OR. N.LT.M ) THEN
 | 
			
		||||
        INFO = -2
 | 
			
		||||
      ELSE IF( MB.LT.1 .OR. ( MB.GT.M .AND. M.GT.0 )) THEN
 | 
			
		||||
      ELSE IF( MB.LT.1 .OR. ( MB.GT.M .AND. M.GT.0 ) ) THEN
 | 
			
		||||
        INFO = -3
 | 
			
		||||
      ELSE IF( NB.LE.0 ) THEN
 | 
			
		||||
        INFO = -4
 | 
			
		||||
| 
						 | 
				
			
			@ -213,35 +224,36 @@
 | 
			
		|||
        INFO = -6
 | 
			
		||||
      ELSE IF( LDT.LT.MB ) THEN
 | 
			
		||||
        INFO = -8
 | 
			
		||||
      ELSE IF( ( LWORK.LT.M*MB) .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
        INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.EQ.0)  THEN
 | 
			
		||||
      WORK(1) = SROUNDUP_LWORK(MB*M)
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
        CALL XERBLA( 'CLASWLQ', -INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      ELSE IF (LQUERY) THEN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN(M,N).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     The LQ Decomposition
 | 
			
		||||
*
 | 
			
		||||
       IF((M.GE.N).OR.(NB.LE.M).OR.(NB.GE.N)) THEN
 | 
			
		||||
      IF( (M.GE.N) .OR. (NB.LE.M) .OR. (NB.GE.N) ) THEN
 | 
			
		||||
        CALL CGELQT( M, N, MB, A, LDA, T, LDT, WORK, INFO)
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      KK = MOD((N-M),(NB-M))
 | 
			
		||||
       II=N-KK+1
 | 
			
		||||
      II = N-KK+1
 | 
			
		||||
*
 | 
			
		||||
*     Compute the LQ factorization of the first block A(1:M,1:NB)
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -260,13 +272,13 @@
 | 
			
		|||
*
 | 
			
		||||
*     Compute the QR factorization of the last block A(1:M,II:N)
 | 
			
		||||
*
 | 
			
		||||
       IF (II.LE.N) THEN
 | 
			
		||||
      IF( II.LE.N ) THEN
 | 
			
		||||
        CALL CTPLQT( M, KK, 0, MB, A(1,1), LDA, A( 1, II ),
 | 
			
		||||
     $                  LDA, T(1,CTR*M+1), LDT,
 | 
			
		||||
     $                  WORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(M * MB)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CLASWLQ
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -152,13 +152,17 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is REAL array, dimension (LWORK).
 | 
			
		||||
*>          WORK is REAL array, dimension (MAX(1,LWORK)).
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal size of
 | 
			
		||||
*>          WORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>
 | 
			
		||||
*>          If MIN(N,NRHS) = 0, LWORK >= 1, else
 | 
			
		||||
*>          LWORK >= MAX(1, 2*NBA * MAX(NBA, MIN(NRHS, 32)), where
 | 
			
		||||
*>          NBA = (N + NB - 1)/NB and NB is the optimal block size.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -166,6 +170,7 @@
 | 
			
		|||
*>          only calculates the optimal dimensions of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[out] INFO
 | 
			
		||||
*> \verbatim
 | 
			
		||||
| 
						 | 
				
			
			@ -182,7 +187,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleOTHERauxiliary
 | 
			
		||||
*> \ingroup latrs3
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
*  \verbatim
 | 
			
		||||
| 
						 | 
				
			
			@ -257,15 +262,16 @@
 | 
			
		|||
      LOGICAL            LQUERY, NOTRAN, NOUNIT, UPPER
 | 
			
		||||
      INTEGER            AWRK, I, IFIRST, IINC, ILAST, II, I1, I2, J,
 | 
			
		||||
     $                   JFIRST, JINC, JLAST, J1, J2, K, KK, K1, K2,
 | 
			
		||||
     $                   LANRM, LDS, LSCALE, NB, NBA, NBX, RHS
 | 
			
		||||
     $                   LANRM, LDS, LSCALE, NB, NBA, NBX, RHS, LWMIN
 | 
			
		||||
      REAL               ANRM, BIGNUM, BNRM, RSCAL, SCAL, SCALOC,
 | 
			
		||||
     $                   SCAMIN, SMLNUM, TMAX
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      INTEGER            ILAENV
 | 
			
		||||
      REAL               SLAMCH, CLANGE, SLARMM
 | 
			
		||||
      EXTERNAL           ILAENV, LSAME, SLAMCH, CLANGE, SLARMM
 | 
			
		||||
      REAL               SLAMCH, CLANGE, SLARMM, SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           ILAENV, LSAME, SLAMCH, CLANGE, SLARMM,
 | 
			
		||||
     $                   SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           CLATRS, CSSCAL, XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -296,15 +302,24 @@
 | 
			
		|||
*     row. WORK( I + KK * LDS ) is the scale factor of the vector
 | 
			
		||||
*     segment associated with the I-th block row and the KK-th vector
 | 
			
		||||
*     in the block column.
 | 
			
		||||
*
 | 
			
		||||
      LSCALE = NBA * MAX( NBA, MIN( NRHS, NBRHS ) )
 | 
			
		||||
      LDS = NBA
 | 
			
		||||
*
 | 
			
		||||
*     The second part stores upper bounds of the triangular A. There are
 | 
			
		||||
*     a total of NBA x NBA blocks, of which only the upper triangular
 | 
			
		||||
*     part or the lower triangular part is referenced. The upper bound of
 | 
			
		||||
*     the block A( I, J ) is stored as WORK( AWRK + I + J * NBA ).
 | 
			
		||||
*
 | 
			
		||||
      LANRM = NBA * NBA
 | 
			
		||||
      AWRK = LSCALE
 | 
			
		||||
      WORK( 1 ) = LSCALE + LANRM
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN( N, NRHS ).EQ.0 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = LSCALE + LANRM
 | 
			
		||||
      END IF
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
*
 | 
			
		||||
*     Test the input parameters.
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -326,7 +341,7 @@
 | 
			
		|||
         INFO = -8
 | 
			
		||||
      ELSE IF( LDX.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -10
 | 
			
		||||
      ELSE IF( .NOT.LQUERY .AND. LWORK.LT.WORK( 1 ) ) THEN
 | 
			
		||||
      ELSE IF( .NOT.LQUERY .AND. LWORK.LT.LWMIN ) THEN
 | 
			
		||||
         INFO = -14
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -659,6 +674,9 @@
 | 
			
		|||
            END IF
 | 
			
		||||
         END DO
 | 
			
		||||
      END DO
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CLATRS3
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -102,14 +102,17 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) COMPLEX array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= NB*N.
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= NB*N, otherwise.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          only calculates the minimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
| 
						 | 
				
			
			@ -165,7 +168,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE CLATSQR( M, N, MB, NB, A, LDA, T, LDT, WORK,
 | 
			
		||||
     $                    LWORK, INFO)
 | 
			
		||||
     $                    LWORK, INFO )
 | 
			
		||||
*
 | 
			
		||||
*  -- LAPACK computational routine --
 | 
			
		||||
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 | 
			
		||||
| 
						 | 
				
			
			@ -175,7 +178,7 @@
 | 
			
		|||
      INTEGER            INFO, LDA, M, N, MB, NB, LDT, LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Array Arguments ..
 | 
			
		||||
      COMPLEX           A( LDA, * ), WORK( * ), T(LDT, *)
 | 
			
		||||
      COMPLEX            A( LDA, * ), WORK( * ), T( LDT, * )
 | 
			
		||||
*     ..
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
| 
						 | 
				
			
			@ -183,14 +186,16 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY
 | 
			
		||||
      INTEGER    I, II, KK, CTR
 | 
			
		||||
      INTEGER            I, II, KK, CTR, LWMIN, MINMN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. EXTERNAL FUNCTIONS ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. EXTERNAL SUBROUTINES ..
 | 
			
		||||
      EXTERNAL           CGEQRT, CTPQRT, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. INTRINSIC FUNCTIONS ..
 | 
			
		||||
      INTRINSIC          MAX, MIN, MOD
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -201,6 +206,13 @@
 | 
			
		|||
      INFO = 0
 | 
			
		||||
*
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
*
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
        LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
        LWMIN = N*NB
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
        INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -208,46 +220,47 @@
 | 
			
		|||
        INFO = -2
 | 
			
		||||
      ELSE IF( MB.LT.1 ) THEN
 | 
			
		||||
        INFO = -3
 | 
			
		||||
      ELSE IF( NB.LT.1 .OR. ( NB.GT.N .AND. N.GT.0 )) THEN
 | 
			
		||||
      ELSE IF( NB.LT.1 .OR. ( NB.GT.N .AND. N.GT.0 ) ) THEN
 | 
			
		||||
        INFO = -4
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
        INFO = -6
 | 
			
		||||
      ELSE IF( LDT.LT.NB ) THEN
 | 
			
		||||
        INFO = -8
 | 
			
		||||
      ELSE IF( LWORK.LT.(N*NB) .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
        INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.EQ.0)  THEN
 | 
			
		||||
        WORK(1) = SROUNDUP_LWORK(NB*N)
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
        CALL XERBLA( 'CLATSQR', -INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      ELSE IF (LQUERY) THEN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN(M,N).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     The QR Decomposition
 | 
			
		||||
*
 | 
			
		||||
       IF ((MB.LE.N).OR.(MB.GE.M)) THEN
 | 
			
		||||
         CALL CGEQRT( M, N, NB, A, LDA, T, LDT, WORK, INFO)
 | 
			
		||||
      IF ( (MB.LE.N) .OR. (MB.GE.M) ) THEN
 | 
			
		||||
        CALL CGEQRT( M, N, NB, A, LDA, T, LDT, WORK, INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
      KK = MOD((M-N),(MB-N))
 | 
			
		||||
       II=M-KK+1
 | 
			
		||||
      II = M-KK+1
 | 
			
		||||
*
 | 
			
		||||
*     Compute the QR factorization of the first block A(1:MB,1:N)
 | 
			
		||||
*
 | 
			
		||||
      CALL CGEQRT( MB, N, NB, A(1,1), LDA, T, LDT, WORK, INFO )
 | 
			
		||||
      CTR = 1
 | 
			
		||||
*
 | 
			
		||||
       DO I = MB+1, II-MB+N ,  (MB-N)
 | 
			
		||||
      DO I = MB+1, II-MB+N, (MB-N)
 | 
			
		||||
*
 | 
			
		||||
*       Compute the QR factorization of the current block A(I:I+MB-N,1:N)
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -259,13 +272,13 @@
 | 
			
		|||
*
 | 
			
		||||
*     Compute the QR factorization of the last block A(II:M,1:N)
 | 
			
		||||
*
 | 
			
		||||
       IF (II.LE.M) THEN
 | 
			
		||||
      IF( II.LE.M ) THEN
 | 
			
		||||
        CALL CTPQRT( KK, N, 0, NB, A(1,1), LDA, A( II, 1 ), LDA,
 | 
			
		||||
     $                 T(1, CTR * N + 1), LDT,
 | 
			
		||||
     $                 WORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(N*NB)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of CLATSQR
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -122,7 +122,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of the array WORK.  LWORK >= max(1,M,N).
 | 
			
		||||
*>          The length of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= MAX(M,N), otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= (M+N)*NB, where NB
 | 
			
		||||
*>          is the optimal blocksize.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -147,7 +148,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEcomputational
 | 
			
		||||
*> \ingroup gebrd
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -223,8 +224,8 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY
 | 
			
		||||
      INTEGER            I, IINFO, J, LDWRKX, LDWRKY, LWKOPT, MINMN, NB,
 | 
			
		||||
     $                   NBMIN, NX, WS
 | 
			
		||||
      INTEGER            I, IINFO, J, LDWRKX, LDWRKY, LWKMIN, LWKOPT,
 | 
			
		||||
     $                   MINMN, NB, NBMIN, NX, WS
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           DGEBD2, DGEMM, DLABRD, XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -241,9 +242,17 @@
 | 
			
		|||
*     Test the input parameters
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
         LWKMIN = 1
 | 
			
		||||
         LWKOPT = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKMIN = MAX( M, N )
 | 
			
		||||
         NB = MAX( 1, ILAENV( 1, 'DGEBRD', ' ', M, N, -1, -1 ) )
 | 
			
		||||
         LWKOPT = ( M+N )*NB
 | 
			
		||||
      ENDIF
 | 
			
		||||
      WORK( 1 ) = DBLE( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -251,7 +260,7 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, M, N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -263,7 +272,6 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -282,7 +290,7 @@
 | 
			
		|||
*        Determine when to switch from blocked to unblocked code.
 | 
			
		||||
*
 | 
			
		||||
         IF( NX.LT.MINMN ) THEN
 | 
			
		||||
            WS = ( M+N )*NB
 | 
			
		||||
            WS = LWKOPT
 | 
			
		||||
            IF( LWORK.LT.WS ) THEN
 | 
			
		||||
*
 | 
			
		||||
*              Not enough work space for the optimal NB, consider using
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -89,7 +89,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (LWORK)
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -120,7 +120,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEcomputational
 | 
			
		||||
*> \ingroup gehrd
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -221,12 +221,18 @@
 | 
			
		|||
         INFO = -8
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      NH = IHI - ILO + 1
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
*
 | 
			
		||||
*        Compute the workspace requirements
 | 
			
		||||
*
 | 
			
		||||
         NB = MIN( NBMAX, ILAENV( 1, 'DGEHRD', ' ', N, ILO, IHI, -1 ) )
 | 
			
		||||
         IF( NH.LE.1 ) THEN
 | 
			
		||||
            LWKOPT = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            NB = MIN( NBMAX, ILAENV( 1, 'DGEHRD', ' ', N, ILO, IHI,
 | 
			
		||||
     $                              -1 ) )
 | 
			
		||||
            LWKOPT = N*NB + TSIZE
 | 
			
		||||
         ENDIF
 | 
			
		||||
         WORK( 1 ) = LWKOPT
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -248,7 +254,6 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      NH = IHI - ILO + 1
 | 
			
		||||
      IF( NH.LE.1 ) THEN
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -268,7 +273,7 @@
 | 
			
		|||
*
 | 
			
		||||
*           Determine if workspace is large enough for blocked code
 | 
			
		||||
*
 | 
			
		||||
            IF( LWORK.LT.N*NB+TSIZE ) THEN
 | 
			
		||||
            IF( LWORK.LT.LWKOPT ) THEN
 | 
			
		||||
*
 | 
			
		||||
*              Not enough workspace to use optimal NB:  determine the
 | 
			
		||||
*              minimum value of NB, and reduce NB or force use of
 | 
			
		||||
| 
						 | 
				
			
			@ -344,6 +349,7 @@
 | 
			
		|||
*     Use unblocked code to reduce the rest of the matrix
 | 
			
		||||
*
 | 
			
		||||
      CALL DGEHD2( N, I, IHI, A, LDA, TAU, WORK, IINFO )
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = LWKOPT
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -98,7 +98,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1 or -2, then a workspace query is assumed. The routine
 | 
			
		||||
*>          only calculates the sizes of the T and WORK arrays, returns these
 | 
			
		||||
*>          values as the first entries of the T and WORK arrays, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -166,6 +166,8 @@
 | 
			
		|||
*>  the LQ factorization.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \ingroup gelq
 | 
			
		||||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DGELQ( M, N, A, LDA, T, TSIZE, WORK, LWORK,
 | 
			
		||||
     $                  INFO )
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -93,7 +93,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= max(1,M).
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= M, otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= M*NB, where NB is the
 | 
			
		||||
*>          optimal blocksize.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -118,7 +119,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEcomputational
 | 
			
		||||
*> \ingroup gelqf
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -174,9 +175,8 @@
 | 
			
		|||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      K = MIN( M, N )
 | 
			
		||||
      NB = ILAENV( 1, 'DGELQF', ' ', M, N, -1, -1 )
 | 
			
		||||
      LWKOPT = M*NB
 | 
			
		||||
      WORK( 1 ) = LWKOPT
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -184,19 +184,25 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, M ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -7
 | 
			
		||||
      ELSE IF( .NOT.LQUERY ) THEN
 | 
			
		||||
         IF( LWORK.LE.0 .OR. ( N.GT.0 .AND. LWORK.LT.MAX( 1, M ) ) )
 | 
			
		||||
     $      INFO = -7
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
         CALL XERBLA( 'DGELQF', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         IF( K.EQ.0 ) THEN
 | 
			
		||||
            LWKOPT = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            LWKOPT = M*NB
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = LWKOPT
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      K = MIN( M, N )
 | 
			
		||||
      IF( K.EQ.0 ) THEN
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -188,7 +188,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEsolve
 | 
			
		||||
*> \ingroup gelsd
 | 
			
		||||
*
 | 
			
		||||
*> \par Contributors:
 | 
			
		||||
*  ==================
 | 
			
		||||
| 
						 | 
				
			
			@ -228,7 +228,7 @@
 | 
			
		|||
      DOUBLE PRECISION   ANRM, BIGNUM, BNRM, EPS, SFMIN, SMLNUM
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           DGEBRD, DGELQF, DGEQRF, DLABAD, DLACPY, DLALSD,
 | 
			
		||||
      EXTERNAL           DGEBRD, DGELQF, DGEQRF, DLACPY, DLALSD,
 | 
			
		||||
     $                   DLASCL, DLASET, DORMBR, DORMLQ, DORMQR, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
| 
						 | 
				
			
			@ -276,7 +276,7 @@
 | 
			
		|||
     $       LOG( TWO ) ) + 1, 0 )
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         MAXWRK = 0
 | 
			
		||||
         MAXWRK = 1
 | 
			
		||||
         LIWORK = 3*MINMN*NLVL + 11*MINMN
 | 
			
		||||
         MM = M
 | 
			
		||||
         IF( M.GE.N .AND. M.GE.MNTHR ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -372,7 +372,6 @@
 | 
			
		|||
      SFMIN = DLAMCH( 'S' )
 | 
			
		||||
      SMLNUM = SFMIN / EPS
 | 
			
		||||
      BIGNUM = ONE / SMLNUM
 | 
			
		||||
      CALL DLABAD( SMLNUM, BIGNUM )
 | 
			
		||||
*
 | 
			
		||||
*     Scale A if max entry outside range [SMLNUM,BIGNUM].
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -112,12 +112,13 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed. The routine
 | 
			
		||||
*>          only calculates the size of the WORK array, returns this
 | 
			
		||||
*>          value as WORK(1), and no error message related to WORK
 | 
			
		||||
| 
						 | 
				
			
			@ -165,6 +166,8 @@
 | 
			
		|||
*>  Further Details in DLAMSWLQ or DGEMLQT.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \ingroup gemlq
 | 
			
		||||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DGEMLQ( SIDE, TRANS, M, N, K, A, LDA, T, TSIZE,
 | 
			
		||||
     $                   C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -186,7 +189,7 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LEFT, RIGHT, TRAN, NOTRAN, LQUERY
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN, MINMNK, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -202,7 +205,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      LQUERY  = LWORK.EQ.-1
 | 
			
		||||
      LQUERY  = ( LWORK.EQ.-1 )
 | 
			
		||||
      NOTRAN  = LSAME( TRANS, 'N' )
 | 
			
		||||
      TRAN    = LSAME( TRANS, 'T' )
 | 
			
		||||
      LEFT    = LSAME( SIDE, 'L' )
 | 
			
		||||
| 
						 | 
				
			
			@ -217,6 +220,13 @@
 | 
			
		|||
        LW = M * MB
 | 
			
		||||
        MN = N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      MINMNK = MIN( M, N, K )
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = MAX( 1, LW )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( ( NB.GT.K ) .AND. ( MN.GT.K ) ) THEN
 | 
			
		||||
        IF( MOD( MN - K, NB - K ) .EQ. 0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -245,12 +255,12 @@
 | 
			
		|||
        INFO = -9
 | 
			
		||||
      ELSE IF( LDC.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
        INFO = -11
 | 
			
		||||
      ELSE IF( ( LWORK.LT.MAX( 1, LW ) ) .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
        INFO = -13
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = LW
 | 
			
		||||
        WORK( 1 ) = LWMIN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -262,7 +272,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN( M, N, K ).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -275,7 +285,7 @@
 | 
			
		|||
     $                 MB, C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = LW
 | 
			
		||||
      WORK( 1 ) = LWMIN
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -112,12 +112,13 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed. The routine
 | 
			
		||||
*>          only calculates the size of the WORK array, returns this
 | 
			
		||||
*>          value as WORK(1), and no error message related to WORK
 | 
			
		||||
| 
						 | 
				
			
			@ -166,6 +167,8 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \ingroup gemqr
 | 
			
		||||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DGEMQR( SIDE, TRANS, M, N, K, A, LDA, T, TSIZE,
 | 
			
		||||
     $                   C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -187,7 +190,7 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LEFT, RIGHT, TRAN, NOTRAN, LQUERY
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN, MINMNK, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -203,7 +206,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      LQUERY  = LWORK.EQ.-1
 | 
			
		||||
      LQUERY  = ( LWORK.EQ.-1 )
 | 
			
		||||
      NOTRAN  = LSAME( TRANS, 'N' )
 | 
			
		||||
      TRAN    = LSAME( TRANS, 'T' )
 | 
			
		||||
      LEFT    = LSAME( SIDE, 'L' )
 | 
			
		||||
| 
						 | 
				
			
			@ -218,6 +221,13 @@
 | 
			
		|||
        LW = MB * NB
 | 
			
		||||
        MN = N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      MINMNK = MIN( M, N, K )
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = MAX( 1, LW )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( ( MB.GT.K ) .AND. ( MN.GT.K ) ) THEN
 | 
			
		||||
        IF( MOD( MN - K, MB - K ).EQ.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -246,12 +256,12 @@
 | 
			
		|||
        INFO = -9
 | 
			
		||||
      ELSE IF( LDC.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
        INFO = -11
 | 
			
		||||
      ELSE IF( ( LWORK.LT.MAX( 1, LW ) ) .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
        INFO = -13
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = LW
 | 
			
		||||
        WORK( 1 ) = LWMIN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -263,7 +273,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN( M, N, K ).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -276,7 +286,7 @@
 | 
			
		|||
     $                 NB, C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = LW
 | 
			
		||||
      WORK( 1 ) = LWMIN
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -88,7 +88,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= max(1,N).
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= N, otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= N*NB, where NB is the
 | 
			
		||||
*>          optimal blocksize.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -113,7 +114,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEcomputational
 | 
			
		||||
*> \ingroup geqlf
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -188,8 +189,9 @@
 | 
			
		|||
         END IF
 | 
			
		||||
         WORK( 1 ) = LWKOPT
 | 
			
		||||
*
 | 
			
		||||
         IF( LWORK.LT.MAX( 1, N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
            INFO = -7
 | 
			
		||||
         IF( .NOT.LQUERY ) THEN
 | 
			
		||||
            IF( LWORK.LE.0 .OR. ( M.GT.0 .AND. LWORK.LT.MAX( 1, N ) ) )
 | 
			
		||||
     $         INFO = -7
 | 
			
		||||
         END IF
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -427,7 +427,8 @@
 | 
			
		|||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*.          LWORK >= (3*N + NRHS - 1)
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and
 | 
			
		||||
*>          LWORK >= (3*N+NRHS-1), otherwise.
 | 
			
		||||
*>          For optimal performance LWORK >= (2*N + NB*( N+NRHS+1 )),
 | 
			
		||||
*>          where NB is the optimal block size for DGEQP3RK returned
 | 
			
		||||
*>          by ILAENV. Minimal block size MINNB=2.
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -99,7 +99,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1 or -2, then a workspace query is assumed. The routine
 | 
			
		||||
*>          only calculates the sizes of the T and WORK arrays, returns these
 | 
			
		||||
*>          values as the first entries of the T and WORK arrays, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -168,6 +168,8 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \ingroup geqr
 | 
			
		||||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DGEQR( M, N, A, LDA, T, TSIZE, WORK, LWORK,
 | 
			
		||||
     $                  INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -188,7 +190,7 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY, LMINWS, MINT, MINW
 | 
			
		||||
      INTEGER            MB, NB, MINTSZ, NBLCKS
 | 
			
		||||
      INTEGER            MB, NB, MINTSZ, NBLCKS, LWMIN, LWREQ
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -244,8 +246,10 @@
 | 
			
		|||
*
 | 
			
		||||
*     Determine if the workspace size satisfies minimal size
 | 
			
		||||
*
 | 
			
		||||
      LWMIN = MAX( 1, N )
 | 
			
		||||
      LWREQ = MAX( 1, N*NB )
 | 
			
		||||
      LMINWS = .FALSE.
 | 
			
		||||
      IF( ( TSIZE.LT.MAX( 1, NB*N*NBLCKS + 5 ) .OR. LWORK.LT.NB*N )
 | 
			
		||||
      IF( ( TSIZE.LT.MAX( 1, NB*N*NBLCKS + 5 ) .OR. LWORK.LT.LWREQ )
 | 
			
		||||
     $    .AND. ( LWORK.GE.N ) .AND. ( TSIZE.GE.MINTSZ )
 | 
			
		||||
     $    .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
        IF( TSIZE.LT.MAX( 1, NB*N*NBLCKS + 5 ) ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -253,7 +257,7 @@
 | 
			
		|||
          NB = 1
 | 
			
		||||
          MB = M
 | 
			
		||||
        END IF
 | 
			
		||||
        IF( LWORK.LT.NB*N ) THEN
 | 
			
		||||
        IF( LWORK.LT.LWREQ ) THEN
 | 
			
		||||
          LMINWS = .TRUE.
 | 
			
		||||
          NB = 1
 | 
			
		||||
        END IF
 | 
			
		||||
| 
						 | 
				
			
			@ -268,7 +272,7 @@
 | 
			
		|||
      ELSE IF( TSIZE.LT.MAX( 1, NB*N*NBLCKS + 5 )
 | 
			
		||||
     $   .AND. ( .NOT.LQUERY ) .AND. ( .NOT.LMINWS ) ) THEN
 | 
			
		||||
        INFO = -6
 | 
			
		||||
      ELSE IF( ( LWORK.LT.MAX( 1, N*NB ) ) .AND. ( .NOT.LQUERY )
 | 
			
		||||
      ELSE IF( ( LWORK.LT.LWREQ ) .AND. ( .NOT.LQUERY )
 | 
			
		||||
     $   .AND. ( .NOT.LMINWS ) ) THEN
 | 
			
		||||
        INFO = -8
 | 
			
		||||
      END IF
 | 
			
		||||
| 
						 | 
				
			
			@ -282,9 +286,9 @@
 | 
			
		|||
        T( 2 ) = MB
 | 
			
		||||
        T( 3 ) = NB
 | 
			
		||||
        IF( MINW ) THEN
 | 
			
		||||
          WORK( 1 ) = MAX( 1, N )
 | 
			
		||||
          WORK( 1 ) = LWMIN
 | 
			
		||||
        ELSE
 | 
			
		||||
          WORK( 1 ) = MAX( 1, NB*N )
 | 
			
		||||
          WORK( 1 ) = LWREQ
 | 
			
		||||
        END IF
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -309,7 +313,7 @@
 | 
			
		|||
     $                LWORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = MAX( 1, NB*N )
 | 
			
		||||
      WORK( 1 ) = LWREQ
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -97,7 +97,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= max(1,N).
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= N, otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= N*NB, where NB is
 | 
			
		||||
*>          the optimal blocksize.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -122,7 +123,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEcomputational
 | 
			
		||||
*> \ingroup geqrfp
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -162,8 +163,8 @@
 | 
			
		|||
*
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY
 | 
			
		||||
      INTEGER            I, IB, IINFO, IWS, K, LDWORK, LWKOPT, NB,
 | 
			
		||||
     $                   NBMIN, NX
 | 
			
		||||
      INTEGER            I, IB, IINFO, IWS, K, LDWORK, LWKMIN, LWKOPT,
 | 
			
		||||
     $                   NB, NBMIN, NX
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           DGEQR2P, DLARFB, DLARFT, XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -181,8 +182,16 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      NB = ILAENV( 1, 'DGEQRF', ' ', M, N, -1, -1 )
 | 
			
		||||
      K = MIN( M, N )
 | 
			
		||||
      IF( K.EQ.0 ) THEN
 | 
			
		||||
         LWKMIN = 1
 | 
			
		||||
         LWKOPT = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKMIN = N
 | 
			
		||||
         LWKOPT = N*NB
 | 
			
		||||
      END IF
 | 
			
		||||
      WORK( 1 ) = LWKOPT
 | 
			
		||||
*
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -190,7 +199,7 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -7
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -202,7 +211,6 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      K = MIN( M, N )
 | 
			
		||||
      IF( K.EQ.0 ) THEN
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -210,7 +218,7 @@
 | 
			
		|||
*
 | 
			
		||||
      NBMIN = 2
 | 
			
		||||
      NX = 0
 | 
			
		||||
      IWS = N
 | 
			
		||||
      IWS = LWKMIN
 | 
			
		||||
      IF( NB.GT.1 .AND. NB.LT.K ) THEN
 | 
			
		||||
*
 | 
			
		||||
*        Determine when to cross over from blocked to unblocked code.
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -114,7 +114,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEcomputational
 | 
			
		||||
*> \ingroup gerqf
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -189,7 +189,7 @@
 | 
			
		|||
         END IF
 | 
			
		||||
         WORK( 1 ) = LWKOPT
 | 
			
		||||
*
 | 
			
		||||
         IF ( .NOT.LQUERY ) THEN
 | 
			
		||||
         IF( .NOT.LQUERY ) THEN
 | 
			
		||||
            IF( LWORK.LE.0 .OR. ( N.GT.0 .AND. LWORK.LT.MAX( 1, M ) ) )
 | 
			
		||||
     $         INFO = -7
 | 
			
		||||
         END IF
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -208,7 +208,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[in,out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (LWORK)
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On entry :
 | 
			
		||||
*>          If JOBU = 'C' :
 | 
			
		||||
*>          WORK(1) = CTOL, where CTOL defines the threshold for convergence.
 | 
			
		||||
| 
						 | 
				
			
			@ -239,7 +239,12 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          length of WORK, WORK >= MAX(6,M+N)
 | 
			
		||||
*>          The length of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= MAX(6,M+N), otherwise.
 | 
			
		||||
*>
 | 
			
		||||
*>          If on entry LWORK = -1, then a workspace query is assumed and
 | 
			
		||||
*>          no computation is done; WORK(1) is set to the minial (and optimal)
 | 
			
		||||
*>          length of WORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[out] INFO
 | 
			
		||||
| 
						 | 
				
			
			@ -260,7 +265,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEcomputational
 | 
			
		||||
*> \ingroup gesvj
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -365,9 +370,9 @@
 | 
			
		|||
      INTEGER            BLSKIP, EMPTSW, i, ibr, IERR, igl, IJBLSK, ir1,
 | 
			
		||||
     $                   ISWROT, jbc, jgl, KBL, LKAHEAD, MVL, N2, N34,
 | 
			
		||||
     $                   N4, NBL, NOTROT, p, PSKIPPED, q, ROWSKIP,
 | 
			
		||||
     $                   SWBAND
 | 
			
		||||
      LOGICAL            APPLV, GOSCALE, LOWER, LSVEC, NOSCALE, ROTOK,
 | 
			
		||||
     $                   RSVEC, UCTOL, UPPER
 | 
			
		||||
     $                   SWBAND, MINMN, LWMIN
 | 
			
		||||
      LOGICAL            APPLV, GOSCALE, LOWER, LQUERY, LSVEC, NOSCALE,
 | 
			
		||||
     $                   ROTOK, RSVEC, UCTOL, UPPER
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Local Arrays ..
 | 
			
		||||
      DOUBLE PRECISION   FASTR( 5 )
 | 
			
		||||
| 
						 | 
				
			
			@ -408,6 +413,14 @@
 | 
			
		|||
      UPPER = LSAME( JOBA, 'U' )
 | 
			
		||||
      LOWER = LSAME( JOBA, 'L' )
 | 
			
		||||
*
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = MAX( 6, M+N )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( .NOT.( UPPER .OR. LOWER .OR. LSAME( JOBA, 'G' ) ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( .NOT.( LSVEC .OR. UCTOL .OR. LSAME( JOBU, 'N' ) ) ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -427,7 +440,7 @@
 | 
			
		|||
         INFO = -11
 | 
			
		||||
      ELSE IF( UCTOL .AND. ( WORK( 1 ).LE.ONE ) ) THEN
 | 
			
		||||
         INFO = -12
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( M+N, 6 ) ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
         INFO = -13
 | 
			
		||||
      ELSE
 | 
			
		||||
         INFO = 0
 | 
			
		||||
| 
						 | 
				
			
			@ -437,11 +450,14 @@
 | 
			
		|||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
         CALL XERBLA( 'DGESVJ', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         WORK( 1 ) = LWMIN
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
* #:) Quick return for void matrix
 | 
			
		||||
*
 | 
			
		||||
      IF( ( M.EQ.0 ) .OR. ( N.EQ.0 ) )RETURN
 | 
			
		||||
      IF( MINMN.EQ.0 ) RETURN
 | 
			
		||||
*
 | 
			
		||||
*     Set numerical parameters
 | 
			
		||||
*     The stopping criterion for Jacobi rotations is
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -107,7 +107,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEcomputational
 | 
			
		||||
*> \ingroup getri
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DGETRI( N, A, LDA, IPIV, WORK, LWORK, INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -151,8 +151,9 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      NB = ILAENV( 1, 'DGETRI', ' ', N, -1, -1, -1 )
 | 
			
		||||
      LWKOPT = N*NB
 | 
			
		||||
      LWKOPT = MAX( 1, N*NB )
 | 
			
		||||
      WORK( 1 ) = LWKOPT
 | 
			
		||||
*
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( N.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -127,7 +127,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1 or -2, then a workspace query is assumed.
 | 
			
		||||
*>          If LWORK = -1, the routine calculates optimal size of WORK for the
 | 
			
		||||
*>          optimal performance and returns this value in WORK(1).
 | 
			
		||||
| 
						 | 
				
			
			@ -154,7 +154,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEsolve
 | 
			
		||||
*> \ingroup getsls
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DGETSLS( TRANS, M, N, NRHS, A, LDA, B, LDB,
 | 
			
		||||
| 
						 | 
				
			
			@ -189,7 +189,7 @@
 | 
			
		|||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      DOUBLE PRECISION   DLAMCH, DLANGE
 | 
			
		||||
      EXTERNAL           LSAME, DLABAD, DLAMCH, DLANGE
 | 
			
		||||
      EXTERNAL           LSAME, DLAMCH, DLANGE
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           DGEQR, DGEMQR, DLASCL, DLASET,
 | 
			
		||||
| 
						 | 
				
			
			@ -226,7 +226,10 @@
 | 
			
		|||
*
 | 
			
		||||
*     Determine the optimum and minimum LWORK
 | 
			
		||||
*
 | 
			
		||||
       IF( M.GE.N ) THEN
 | 
			
		||||
       IF( MIN( M, N, NRHS ).EQ.0 ) THEN
 | 
			
		||||
         WSIZEM = 1
 | 
			
		||||
         WSIZEO = 1
 | 
			
		||||
       ELSE IF( M.GE.N ) THEN
 | 
			
		||||
         CALL DGEQR( M, N, A, LDA, TQ, -1, WORKQ, -1, INFO2 )
 | 
			
		||||
         TSZO = INT( TQ( 1 ) )
 | 
			
		||||
         LWO  = INT( WORKQ( 1 ) )
 | 
			
		||||
| 
						 | 
				
			
			@ -294,7 +297,6 @@
 | 
			
		|||
*
 | 
			
		||||
       SMLNUM = DLAMCH( 'S' ) / DLAMCH( 'P' )
 | 
			
		||||
       BIGNUM = ONE / SMLNUM
 | 
			
		||||
       CALL DLABAD( SMLNUM, BIGNUM )
 | 
			
		||||
*
 | 
			
		||||
*     Scale A, B if max element outside range [SMLNUM,BIGNUM]
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -130,14 +130,17 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= MAX( LWT + LW1, MAX( LWT+N*N+LW2, LWT+N*N+N ) ),
 | 
			
		||||
*>          If MIN(M,N) = 0, LWORK >= 1, else
 | 
			
		||||
*>          LWORK >= MAX( 1, LWT + LW1, MAX( LWT+N*N+LW2, LWT+N*N+N ) ),
 | 
			
		||||
*>          where
 | 
			
		||||
*>             NUM_ALL_ROW_BLOCKS = CEIL((M-N)/(MB1-N)),
 | 
			
		||||
*>             NB1LOCAL = MIN(NB1,N).
 | 
			
		||||
*>             LWT = NUM_ALL_ROW_BLOCKS * N * NB1LOCAL,
 | 
			
		||||
*>             LW1 = NB1LOCAL * N,
 | 
			
		||||
*>             LW2 = NB1LOCAL * MAX( NB1LOCAL, ( N - NB1LOCAL ) ),
 | 
			
		||||
*>             LW2 = NB1LOCAL * MAX( NB1LOCAL, ( N - NB1LOCAL ) ).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed.
 | 
			
		||||
*>          The routine only calculates the optimal size of the WORK
 | 
			
		||||
*>          array, returns this value as the first entry of the WORK
 | 
			
		||||
| 
						 | 
				
			
			@ -160,7 +163,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleOTHERcomputational
 | 
			
		||||
*> \ingroup getsqrhrt
 | 
			
		||||
*
 | 
			
		||||
*> \par Contributors:
 | 
			
		||||
*  ==================
 | 
			
		||||
| 
						 | 
				
			
			@ -212,7 +215,7 @@
 | 
			
		|||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      LQUERY  = LWORK.EQ.-1
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 .OR. M.LT.N ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -263,8 +266,9 @@
 | 
			
		|||
            LW2 = NB1LOCAL * MAX( NB1LOCAL, ( N - NB1LOCAL ) )
 | 
			
		||||
*
 | 
			
		||||
            LWORKOPT = MAX( LWT + LW1, MAX( LWT+N*N+LW2, LWT+N*N+N ) )
 | 
			
		||||
            LWORKOPT = MAX( 1, LWORKOPT )
 | 
			
		||||
*
 | 
			
		||||
            IF( ( LWORK.LT.MAX( 1, LWORKOPT ) ).AND.(.NOT.LQUERY) ) THEN
 | 
			
		||||
            IF( LWORK.LT.LWORKOPT .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
               INFO = -11
 | 
			
		||||
            END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -234,8 +234,8 @@
 | 
			
		|||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If N = 0, LWORK >= 1, else LWORK >= 8*N+16.
 | 
			
		||||
*>          For good performance , LWORK must generally be larger.
 | 
			
		||||
*>          If N = 0, LWORK >= 1, else LWORK >= MAX(8*N,6*N+16).
 | 
			
		||||
*>          For good performance, LWORK must generally be larger.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -275,7 +275,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEeigen
 | 
			
		||||
*> \ingroup gges
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DGGES( JOBVSL, JOBVSR, SORT, SELCTG, N, A, LDA, B, LDB,
 | 
			
		||||
| 
						 | 
				
			
			@ -321,9 +321,8 @@
 | 
			
		|||
      DOUBLE PRECISION   DIF( 2 )
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           DGEQRF, DGGBAK, DGGBAL, DGGHRD, DHGEQZ, DLABAD,
 | 
			
		||||
     $                   DLACPY, DLASCL, DLASET, DORGQR, DORMQR, DTGSEN,
 | 
			
		||||
     $                   XERBLA
 | 
			
		||||
      EXTERNAL           DGEQRF, DGGBAK, DGGBAL, DGGHRD, DHGEQZ, DLACPY,
 | 
			
		||||
     $                   DLASCL, DLASET, DORGQR, DORMQR, DTGSEN, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -431,7 +430,6 @@
 | 
			
		|||
      EPS = DLAMCH( 'P' )
 | 
			
		||||
      SAFMIN = DLAMCH( 'S' )
 | 
			
		||||
      SAFMAX = ONE / SAFMIN
 | 
			
		||||
      CALL DLABAD( SAFMIN, SAFMAX )
 | 
			
		||||
      SMLNUM = SQRT( SAFMIN ) / EPS
 | 
			
		||||
      BIGNUM = ONE / SMLNUM
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -234,6 +234,8 @@
 | 
			
		|||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If N = 0, LWORK >= 1, else LWORK >= 6*N+16.
 | 
			
		||||
*>          For good performance, LWORK must generally be larger.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -273,7 +275,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEeigen
 | 
			
		||||
*> \ingroup gges3
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DGGES3( JOBVSL, JOBVSR, SORT, SELCTG, N, A, LDA, B,
 | 
			
		||||
| 
						 | 
				
			
			@ -309,7 +311,8 @@
 | 
			
		|||
      LOGICAL            CURSL, ILASCL, ILBSCL, ILVSL, ILVSR, LASTSL,
 | 
			
		||||
     $                   LQUERY, LST2SL, WANTST
 | 
			
		||||
      INTEGER            I, ICOLS, IERR, IHI, IJOBVL, IJOBVR, ILEFT,
 | 
			
		||||
     $                   ILO, IP, IRIGHT, IROWS, ITAU, IWRK, LWKOPT
 | 
			
		||||
     $                   ILO, IP, IRIGHT, IROWS, ITAU, IWRK, LWKOPT,
 | 
			
		||||
     $                   LWKMIN
 | 
			
		||||
      DOUBLE PRECISION   ANRM, ANRMTO, BIGNUM, BNRM, BNRMTO, EPS, PVSL,
 | 
			
		||||
     $                   PVSR, SAFMAX, SAFMIN, SMLNUM
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -318,9 +321,8 @@
 | 
			
		|||
      DOUBLE PRECISION   DIF( 2 )
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           DGEQRF, DGGBAK, DGGBAL, DGGHD3, DLAQZ0, DLABAD,
 | 
			
		||||
     $                   DLACPY, DLASCL, DLASET, DORGQR, DORMQR, DTGSEN,
 | 
			
		||||
     $                   XERBLA
 | 
			
		||||
      EXTERNAL           DGEQRF, DGGBAK, DGGBAL, DGGHD3, DLAQZ0, DLACPY,
 | 
			
		||||
     $                   DLASCL, DLASET, DORGQR, DORMQR, DTGSEN, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -362,6 +364,12 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( N.EQ.0 ) THEN
 | 
			
		||||
         LWKMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKMIN = 6*N+16
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( IJOBVL.LE.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( IJOBVR.LE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -378,7 +386,7 @@
 | 
			
		|||
         INFO = -15
 | 
			
		||||
      ELSE IF( LDVSR.LT.1 .OR. ( ILVSR .AND. LDVSR.LT.N ) ) THEN
 | 
			
		||||
         INFO = -17
 | 
			
		||||
      ELSE IF( LWORK.LT.6*N+16 .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -19
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -386,30 +394,34 @@
 | 
			
		|||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         CALL DGEQRF( N, N, B, LDB, WORK, WORK, -1, IERR )
 | 
			
		||||
         LWKOPT = MAX( 6*N+16, 3*N+INT( WORK ( 1 ) ) )
 | 
			
		||||
         LWKOPT = MAX( LWKMIN, 3*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         CALL DORMQR( 'L', 'T', N, N, N, B, LDB, WORK, A, LDA, WORK,
 | 
			
		||||
     $                -1, IERR )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, 3*N+INT( WORK ( 1 ) ) )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, 3*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         IF( ILVSL ) THEN
 | 
			
		||||
            CALL DORGQR( N, N, N, VSL, LDVSL, WORK, WORK, -1, IERR )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 3*N+INT( WORK ( 1 ) ) )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 3*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         END IF
 | 
			
		||||
         CALL DGGHD3( JOBVSL, JOBVSR, N, 1, N, A, LDA, B, LDB, VSL,
 | 
			
		||||
     $                LDVSL, VSR, LDVSR, WORK, -1, IERR )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, 3*N+INT( WORK ( 1 ) ) )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, 3*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         CALL DLAQZ0( 'S', JOBVSL, JOBVSR, N, 1, N, A, LDA, B, LDB,
 | 
			
		||||
     $                ALPHAR, ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR,
 | 
			
		||||
     $                WORK, -1, 0, IERR )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, 2*N+INT( WORK ( 1 ) ) )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, 2*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         IF( WANTST ) THEN
 | 
			
		||||
            CALL DTGSEN( 0, ILVSL, ILVSR, BWORK, N, A, LDA, B, LDB,
 | 
			
		||||
     $                   ALPHAR, ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR,
 | 
			
		||||
     $                   SDIM, PVSL, PVSR, DIF, WORK, -1, IDUM, 1,
 | 
			
		||||
     $                   IERR )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 2*N+INT( WORK ( 1 ) ) )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 2*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         END IF
 | 
			
		||||
         IF( N.EQ.0 ) THEN
 | 
			
		||||
            WORK( 1 ) = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            WORK( 1 ) = LWKOPT
 | 
			
		||||
         END IF
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
         CALL XERBLA( 'DGGES3 ', -INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -430,7 +442,6 @@
 | 
			
		|||
      EPS = DLAMCH( 'P' )
 | 
			
		||||
      SAFMIN = DLAMCH( 'S' )
 | 
			
		||||
      SAFMAX = ONE / SAFMIN
 | 
			
		||||
      CALL DLABAD( SAFMIN, SAFMAX )
 | 
			
		||||
      SMLNUM = SQRT( SAFMIN ) / EPS
 | 
			
		||||
      BIGNUM = ONE / SMLNUM
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -188,7 +188,9 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          LWORK is INTEGER.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= MAX(1,8*N).
 | 
			
		||||
*>          For good performance, LWORK should generally be larger.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -217,7 +219,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEeigen
 | 
			
		||||
*> \ingroup ggev3
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DGGEV3( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHAR,
 | 
			
		||||
| 
						 | 
				
			
			@ -248,7 +250,8 @@
 | 
			
		|||
      LOGICAL            ILASCL, ILBSCL, ILV, ILVL, ILVR, LQUERY
 | 
			
		||||
      CHARACTER          CHTEMP
 | 
			
		||||
      INTEGER            ICOLS, IERR, IHI, IJOBVL, IJOBVR, ILEFT, ILO,
 | 
			
		||||
     $                   IN, IRIGHT, IROWS, ITAU, IWRK, JC, JR, LWKOPT
 | 
			
		||||
     $                   IN, IRIGHT, IROWS, ITAU, IWRK, JC, JR, LWKOPT,
 | 
			
		||||
     $                   LWKMIN
 | 
			
		||||
      DOUBLE PRECISION   ANRM, ANRMTO, BIGNUM, BNRM, BNRMTO, EPS,
 | 
			
		||||
     $                   SMLNUM, TEMP
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -256,9 +259,8 @@
 | 
			
		|||
      LOGICAL            LDUMMA( 1 )
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           DGEQRF, DGGBAK, DGGBAL, DGGHD3, DLAQZ0, DLABAD,
 | 
			
		||||
     $                   DLACPY, DLASCL, DLASET, DORGQR, DORMQR, DTGEVC,
 | 
			
		||||
     $                   XERBLA
 | 
			
		||||
      EXTERNAL           DGEQRF, DGGBAK, DGGBAL, DGGHD3, DLAQZ0, DLACPY,
 | 
			
		||||
     $                   DLASCL, DLASET, DORGQR, DORMQR, DTGEVC, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -299,6 +301,7 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      LWKMIN = MAX( 1, 8*N )
 | 
			
		||||
      IF( IJOBVL.LE.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( IJOBVR.LE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -313,7 +316,7 @@
 | 
			
		|||
         INFO = -12
 | 
			
		||||
      ELSE IF( LDVR.LT.1 .OR. ( ILVR .AND. LDVR.LT.N ) ) THEN
 | 
			
		||||
         INFO = -14
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, 8*N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -16
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -321,13 +324,13 @@
 | 
			
		|||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         CALL DGEQRF( N, N, B, LDB, WORK, WORK, -1, IERR )
 | 
			
		||||
         LWKOPT = MAX(1, 8*N, 3*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         LWKOPT = MAX( LWKMIN, 3*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         CALL DORMQR( 'L', 'T', N, N, N, B, LDB, WORK, A, LDA, WORK, -1,
 | 
			
		||||
     $                IERR )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, 3*N+INT( WORK ( 1 ) ) )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT, 3*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         IF( ILVL ) THEN
 | 
			
		||||
            CALL DORGQR( N, N, N, VL, LDVL, WORK, WORK, -1, IERR )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 3*N+INT( WORK ( 1 ) ) )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 3*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         END IF
 | 
			
		||||
         IF( ILV ) THEN
 | 
			
		||||
            CALL DGGHD3( JOBVL, JOBVR, N, 1, N, A, LDA, B, LDB, VL,
 | 
			
		||||
| 
						 | 
				
			
			@ -336,19 +339,22 @@
 | 
			
		|||
            CALL DLAQZ0( 'S', JOBVL, JOBVR, N, 1, N, A, LDA, B, LDB,
 | 
			
		||||
     $                   ALPHAR, ALPHAI, BETA, VL, LDVL, VR, LDVR,
 | 
			
		||||
     $                   WORK, -1, 0, IERR )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 2*N+INT( WORK ( 1 ) ) )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 2*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         ELSE
 | 
			
		||||
            CALL DGGHD3( 'N', 'N', N, 1, N, A, LDA, B, LDB, VL, LDVL,
 | 
			
		||||
     $                   VR, LDVR, WORK, -1, IERR )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 3*N+INT( WORK ( 1 ) ) )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 3*N+INT( WORK( 1 ) ) )
 | 
			
		||||
            CALL DLAQZ0( 'E', JOBVL, JOBVR, N, 1, N, A, LDA, B, LDB,
 | 
			
		||||
     $                   ALPHAR, ALPHAI, BETA, VL, LDVL, VR, LDVR,
 | 
			
		||||
     $                   WORK, -1, 0, IERR )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 2*N+INT( WORK ( 1 ) ) )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, 2*N+INT( WORK( 1 ) ) )
 | 
			
		||||
         END IF
 | 
			
		||||
 | 
			
		||||
         IF( N.EQ.0 ) THEN
 | 
			
		||||
            WORK( 1 ) = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            WORK( 1 ) = LWKOPT
 | 
			
		||||
         END IF
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
         CALL XERBLA( 'DGGEV3 ', -INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -367,7 +373,6 @@
 | 
			
		|||
      EPS = DLAMCH( 'P' )
 | 
			
		||||
      SMLNUM = DLAMCH( 'S' )
 | 
			
		||||
      BIGNUM = ONE / SMLNUM
 | 
			
		||||
      CALL DLABAD( SMLNUM, BIGNUM )
 | 
			
		||||
      SMLNUM = SQRT( SMLNUM ) / EPS
 | 
			
		||||
      BIGNUM = ONE / SMLNUM
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -179,7 +179,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (LWORK)
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -211,7 +211,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleOTHERcomputational
 | 
			
		||||
*> \ingroup gghd3
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -275,7 +275,12 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      NB = ILAENV( 1, 'DGGHD3', ' ', N, ILO, IHI, -1 )
 | 
			
		||||
      LWKOPT = MAX( 6*N*NB, 1 )
 | 
			
		||||
      NH = IHI - ILO + 1
 | 
			
		||||
      IF( NH.LE.1 ) THEN
 | 
			
		||||
         LWKOPT = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKOPT = 6*N*NB
 | 
			
		||||
      END IF
 | 
			
		||||
      WORK( 1 ) = DBLE( LWKOPT )
 | 
			
		||||
      INITQ = LSAME( COMPQ, 'I' )
 | 
			
		||||
      WANTQ = INITQ .OR. LSAME( COMPQ, 'V' )
 | 
			
		||||
| 
						 | 
				
			
			@ -325,7 +330,6 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      NH = IHI - ILO + 1
 | 
			
		||||
      IF( NH.LE.1 ) THEN
 | 
			
		||||
         WORK( 1 ) = ONE
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -885,6 +889,7 @@
 | 
			
		|||
      IF ( JCOL.LT.IHI )
 | 
			
		||||
     $   CALL DGGHRD( COMPQ2, COMPZ2, N, JCOL, IHI, A, LDA, B, LDB, Q,
 | 
			
		||||
     $                LDQ, Z, LDZ, IERR )
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = DBLE( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -173,7 +173,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleOTHERcomputational
 | 
			
		||||
*> \ingroup ggqrf
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -250,7 +250,7 @@
 | 
			
		|||
      NB2 = ILAENV( 1, 'DGERQF', ' ', N, P, -1, -1 )
 | 
			
		||||
      NB3 = ILAENV( 1, 'DORMQR', ' ', N, M, P, -1 )
 | 
			
		||||
      NB = MAX( NB1, NB2, NB3 )
 | 
			
		||||
      LWKOPT = MAX( N, M, P )*NB
 | 
			
		||||
      LWKOPT = MAX( 1, MAX( N, M, P )*NB )
 | 
			
		||||
      WORK( 1 ) = LWKOPT
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( N.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -287,6 +287,7 @@
 | 
			
		|||
*     RQ factorization of N-by-P matrix B: B = T*Z.
 | 
			
		||||
*
 | 
			
		||||
      CALL DGERQF( N, P, B, LDB, TAUB, WORK, LWORK, INFO )
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = MAX( LOPT, INT( WORK( 1 ) ) )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -172,7 +172,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleOTHERcomputational
 | 
			
		||||
*> \ingroup ggrqf
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -249,7 +249,7 @@
 | 
			
		|||
      NB2 = ILAENV( 1, 'DGEQRF', ' ', P, N, -1, -1 )
 | 
			
		||||
      NB3 = ILAENV( 1, 'DORMRQ', ' ', M, N, P, -1 )
 | 
			
		||||
      NB = MAX( NB1, NB2, NB3 )
 | 
			
		||||
      LWKOPT = MAX( N, M, P )*NB
 | 
			
		||||
      LWKOPT = MAX( 1, MAX( N, M, P )*NB )
 | 
			
		||||
      WORK( 1 ) = LWKOPT
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -278,7 +278,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -328,7 +328,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleGEsing
 | 
			
		||||
*> \ingroup ggsvd3
 | 
			
		||||
*
 | 
			
		||||
*> \par Contributors:
 | 
			
		||||
*  ==================
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -227,7 +227,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -250,7 +250,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleOTHERcomputational
 | 
			
		||||
*> \ingroup ggsvp3
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -128,16 +128,19 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If SIDE = 'L', LWORK >= max(1,NB) * MB;
 | 
			
		||||
*>          if SIDE = 'R', LWORK >= max(1,M) * MB.
 | 
			
		||||
*>
 | 
			
		||||
*>          If MIN(M,N,K) = 0, LWORK >= 1.
 | 
			
		||||
*>          If SIDE = 'L', LWORK >= max(1,NB*MB).
 | 
			
		||||
*>          If SIDE = 'R', LWORK >= max(1,M*MB).
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          only calculates the minimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
| 
						 | 
				
			
			@ -189,6 +192,8 @@
 | 
			
		|||
*>     SIAM J. Sci. Comput, vol. 34, no. 1, 2012
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \ingroup lamswlq
 | 
			
		||||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DLAMSWLQ( SIDE, TRANS, M, N, K, MB, NB, A, LDA, T,
 | 
			
		||||
     $                     LDT, C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -202,7 +207,7 @@
 | 
			
		|||
      INTEGER            INFO, LDA, M, N, K, MB, NB, LDT, LWORK, LDC
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Array Arguments ..
 | 
			
		||||
      DOUBLE PRECISION A( LDA, * ), WORK( * ), C(LDC, * ),
 | 
			
		||||
      DOUBLE PRECISION   A( LDA, * ), WORK( * ), C( LDC, * ),
 | 
			
		||||
     $                   T( LDT, * )
 | 
			
		||||
*     ..
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -211,7 +216,7 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LEFT, RIGHT, TRAN, NOTRAN, LQUERY
 | 
			
		||||
      INTEGER    I, II, KK, CTR, LW
 | 
			
		||||
      INTEGER            I, II, KK, CTR, LW, MINMNK, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -223,16 +228,23 @@
 | 
			
		|||
*
 | 
			
		||||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      LQUERY  = LWORK.LT.0
 | 
			
		||||
      LQUERY  = ( LWORK.EQ.-1 )
 | 
			
		||||
      NOTRAN  = LSAME( TRANS, 'N' )
 | 
			
		||||
      TRAN    = LSAME( TRANS, 'T' )
 | 
			
		||||
      LEFT    = LSAME( SIDE, 'L' )
 | 
			
		||||
      RIGHT   = LSAME( SIDE, 'R' )
 | 
			
		||||
      IF (LEFT) THEN
 | 
			
		||||
      IF( LEFT ) THEN
 | 
			
		||||
        LW = N * MB
 | 
			
		||||
      ELSE
 | 
			
		||||
        LW = M * MB
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      MINMNK = MIN( M, N, K )
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
        LWMIN = MAX( 1, LW )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      IF( .NOT.LEFT .AND. .NOT.RIGHT ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -245,30 +257,31 @@
 | 
			
		|||
        INFO = -3
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
        INFO = -4
 | 
			
		||||
      ELSE IF( K.LT.MB .OR. MB.LT.1) THEN
 | 
			
		||||
      ELSE IF( K.LT.MB .OR. MB.LT.1 ) THEN
 | 
			
		||||
        INFO = -6
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, K ) ) THEN
 | 
			
		||||
        INFO = -9
 | 
			
		||||
      ELSE IF( LDT.LT.MAX( 1, MB) ) THEN
 | 
			
		||||
      ELSE IF( LDT.LT.MAX( 1, MB ) ) THEN
 | 
			
		||||
        INFO = -11
 | 
			
		||||
      ELSE IF( LDC.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
        INFO = -13
 | 
			
		||||
      ELSE IF(( LWORK.LT.MAX(1,LW)).AND.(.NOT.LQUERY)) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
        INFO = -15
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = LWMIN
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
        CALL XERBLA( 'DLAMSWLQ', -INFO )
 | 
			
		||||
        WORK(1) = LW
 | 
			
		||||
        RETURN
 | 
			
		||||
      ELSE IF (LQUERY) THEN
 | 
			
		||||
        WORK(1) = LW
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN(M,N,K).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -402,7 +415,8 @@
 | 
			
		|||
*
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK(1) = LW
 | 
			
		||||
      WORK( 1 ) = LWMIN
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of DLAMSWLQ
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -129,21 +129,23 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If MIN(M,N,K) = 0, LWORK >= 1.
 | 
			
		||||
*>          If SIDE = 'L', LWORK >= max(1,N*NB).
 | 
			
		||||
*>          If SIDE = 'R', LWORK >= max(1,MB*NB).
 | 
			
		||||
*>
 | 
			
		||||
*>          If SIDE = 'L', LWORK >= max(1,N)*NB;
 | 
			
		||||
*>          if SIDE = 'R', LWORK >= max(1,MB)*NB.
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          only calculates the minimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*>
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[out] INFO
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          INFO is INTEGER
 | 
			
		||||
| 
						 | 
				
			
			@ -191,6 +193,8 @@
 | 
			
		|||
*>     SIAM J. Sci. Comput, vol. 34, no. 1, 2012
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \ingroup lamtsqr
 | 
			
		||||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DLAMTSQR( SIDE, TRANS, M, N, K, MB, NB, A, LDA, T,
 | 
			
		||||
     $                     LDT, C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -204,7 +208,7 @@
 | 
			
		|||
      INTEGER            INFO, LDA, M, N, K, MB, NB, LDT, LWORK, LDC
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Array Arguments ..
 | 
			
		||||
      DOUBLE PRECISION A( LDA, * ), WORK( * ), C(LDC, * ),
 | 
			
		||||
      DOUBLE PRECISION   A( LDA, * ), WORK( * ), C( LDC, * ),
 | 
			
		||||
     $                   T( LDT, * )
 | 
			
		||||
*     ..
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -213,7 +217,7 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LEFT, RIGHT, TRAN, NOTRAN, LQUERY
 | 
			
		||||
      INTEGER    I, II, KK, LW, CTR, Q
 | 
			
		||||
      INTEGER            I, II, KK, LW, CTR, Q, MINMNK, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -225,12 +229,13 @@
 | 
			
		|||
*
 | 
			
		||||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      LQUERY  = LWORK.LT.0
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      LQUERY  = ( LWORK.EQ.-1 )
 | 
			
		||||
      NOTRAN  = LSAME( TRANS, 'N' )
 | 
			
		||||
      TRAN    = LSAME( TRANS, 'T' )
 | 
			
		||||
      LEFT    = LSAME( SIDE, 'L' )
 | 
			
		||||
      RIGHT   = LSAME( SIDE, 'R' )
 | 
			
		||||
      IF (LEFT) THEN
 | 
			
		||||
      IF( LEFT ) THEN
 | 
			
		||||
        LW = N * NB
 | 
			
		||||
        Q = M
 | 
			
		||||
      ELSE
 | 
			
		||||
| 
						 | 
				
			
			@ -238,7 +243,13 @@
 | 
			
		|||
        Q = N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      MINMNK = MIN( M, N, K )
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
        LWMIN = MAX( 1, LW )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.LEFT .AND. .NOT.RIGHT ) THEN
 | 
			
		||||
        INFO = -1
 | 
			
		||||
      ELSE IF( .NOT.TRAN .AND. .NOT.NOTRAN ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -253,36 +264,36 @@
 | 
			
		|||
        INFO = -7
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, Q ) ) THEN
 | 
			
		||||
        INFO = -9
 | 
			
		||||
      ELSE IF( LDT.LT.MAX( 1, NB) ) THEN
 | 
			
		||||
      ELSE IF( LDT.LT.MAX( 1, NB ) ) THEN
 | 
			
		||||
        INFO = -11
 | 
			
		||||
      ELSE IF( LDC.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
        INFO = -13
 | 
			
		||||
      ELSE IF(( LWORK.LT.MAX(1,LW)).AND.(.NOT.LQUERY)) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
        INFO = -15
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Determine the block size if it is tall skinny or short and wide
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0)  THEN
 | 
			
		||||
          WORK(1) = LW
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = LWMIN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
        CALL XERBLA( 'DLAMTSQR', -INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      ELSE IF (LQUERY) THEN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN(M,N,K).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Determine the block size if it is tall skinny or short and wide
 | 
			
		||||
*
 | 
			
		||||
      IF((MB.LE.K).OR.(MB.GE.MAX(M,N,K))) THEN
 | 
			
		||||
        CALL DGEMQRT( SIDE, TRANS, M, N, K, NB, A, LDA,
 | 
			
		||||
     $        T, LDT, C, LDC, WORK, INFO)
 | 
			
		||||
     $        T, LDT, C, LDC, WORK, INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -410,7 +421,8 @@
 | 
			
		|||
*
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK(1) = LW
 | 
			
		||||
      WORK( 1 ) = LWMIN
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of DLAMTSQR
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -100,18 +100,21 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= MB*M.
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= MB*M, otherwise.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          only calculates the minimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*>
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[out] INFO
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          INFO is INTEGER
 | 
			
		||||
| 
						 | 
				
			
			@ -159,9 +162,11 @@
 | 
			
		|||
*>     SIAM J. Sci. Comput, vol. 34, no. 1, 2012
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \ingroup laswlq
 | 
			
		||||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DLASWLQ( M, N, MB, NB, A, LDA, T, LDT, WORK, LWORK,
 | 
			
		||||
     $                  INFO)
 | 
			
		||||
     $                    INFO )
 | 
			
		||||
*
 | 
			
		||||
*  -- LAPACK computational routine --
 | 
			
		||||
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 | 
			
		||||
| 
						 | 
				
			
			@ -171,7 +176,7 @@
 | 
			
		|||
      INTEGER            INFO, LDA, M, N, MB, NB, LWORK, LDT
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Array Arguments ..
 | 
			
		||||
      DOUBLE PRECISION  A( LDA, * ), WORK( * ), T( LDT, *)
 | 
			
		||||
      DOUBLE PRECISION   A( LDA, * ), WORK( * ), T( LDT, * )
 | 
			
		||||
*     ..
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
| 
						 | 
				
			
			@ -179,13 +184,15 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY
 | 
			
		||||
      INTEGER    I, II, KK, CTR
 | 
			
		||||
      INTEGER            I, II, KK, CTR, MINMN, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. EXTERNAL FUNCTIONS ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      EXTERNAL           LSAME
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. EXTERNAL SUBROUTINES ..
 | 
			
		||||
      EXTERNAL           DGELQT, DTPLQT, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. INTRINSIC FUNCTIONS ..
 | 
			
		||||
      INTRINSIC          MAX, MIN, MOD
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -196,12 +203,19 @@
 | 
			
		|||
      INFO = 0
 | 
			
		||||
*
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
*
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = M*MB
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
        INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 .OR. N.LT.M ) THEN
 | 
			
		||||
        INFO = -2
 | 
			
		||||
      ELSE IF( MB.LT.1 .OR. ( MB.GT.M .AND. M.GT.0 )) THEN
 | 
			
		||||
      ELSE IF( MB.LT.1 .OR. ( MB.GT.M .AND. M.GT.0 ) ) THEN
 | 
			
		||||
        INFO = -3
 | 
			
		||||
      ELSE IF( NB.LT.0 ) THEN
 | 
			
		||||
        INFO = -4
 | 
			
		||||
| 
						 | 
				
			
			@ -209,42 +223,43 @@
 | 
			
		|||
        INFO = -6
 | 
			
		||||
      ELSE IF( LDT.LT.MB ) THEN
 | 
			
		||||
        INFO = -8
 | 
			
		||||
      ELSE IF( ( LWORK.LT.M*MB) .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
        INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.EQ.0)  THEN
 | 
			
		||||
      WORK(1) = MB*M
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = LWMIN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
        CALL XERBLA( 'DLASWLQ', -INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      ELSE IF (LQUERY) THEN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN(M,N).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     The LQ Decomposition
 | 
			
		||||
*
 | 
			
		||||
       IF((M.GE.N).OR.(NB.LE.M).OR.(NB.GE.N)) THEN
 | 
			
		||||
        CALL DGELQT( M, N, MB, A, LDA, T, LDT, WORK, INFO)
 | 
			
		||||
      IF( (M.GE.N) .OR. (NB.LE.M) .OR. (NB.GE.N) ) THEN
 | 
			
		||||
        CALL DGELQT( M, N, MB, A, LDA, T, LDT, WORK, INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      KK = MOD((N-M),(NB-M))
 | 
			
		||||
       II=N-KK+1
 | 
			
		||||
      II = N-KK+1
 | 
			
		||||
*
 | 
			
		||||
*     Compute the LQ factorization of the first block A(1:M,1:NB)
 | 
			
		||||
*
 | 
			
		||||
       CALL DGELQT( M, NB, MB, A(1,1), LDA, T, LDT, WORK, INFO)
 | 
			
		||||
      CALL DGELQT( M, NB, MB, A(1,1), LDA, T, LDT, WORK, INFO )
 | 
			
		||||
      CTR = 1
 | 
			
		||||
*
 | 
			
		||||
       DO I = NB+1, II-NB+M , (NB-M)
 | 
			
		||||
      DO I = NB+1, II-NB+M, (NB-M)
 | 
			
		||||
*
 | 
			
		||||
*       Compute the QR factorization of the current block A(1:M,I:I+NB-M)
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -256,13 +271,14 @@
 | 
			
		|||
*
 | 
			
		||||
*     Compute the QR factorization of the last block A(1:M,II:N)
 | 
			
		||||
*
 | 
			
		||||
       IF (II.LE.N) THEN
 | 
			
		||||
      IF( II.LE.N ) THEN
 | 
			
		||||
        CALL DTPLQT( M, KK, 0, MB, A(1,1), LDA, A( 1, II ),
 | 
			
		||||
     $                 LDA, T(1, CTR * M + 1), LDT,
 | 
			
		||||
     $                 WORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = M * MB
 | 
			
		||||
      WORK( 1 ) = LWMIN
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of DLASWLQ
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -151,13 +151,17 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (LWORK).
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)).
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal size of
 | 
			
		||||
*>          WORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>
 | 
			
		||||
*>          If MIN(N,NRHS) = 0, LWORK >= 1, else
 | 
			
		||||
*>          LWORK >= MAX(1, 2*NBA * MAX(NBA, MIN(NRHS, 32)), where
 | 
			
		||||
*>          NBA = (N + NB - 1)/NB and NB is the optimal block size.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -165,6 +169,7 @@
 | 
			
		|||
*>          only calculates the optimal dimensions of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[out] INFO
 | 
			
		||||
*> \verbatim
 | 
			
		||||
| 
						 | 
				
			
			@ -181,7 +186,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleOTHERauxiliary
 | 
			
		||||
*> \ingroup latrs3
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
*  \verbatim
 | 
			
		||||
| 
						 | 
				
			
			@ -253,7 +258,7 @@
 | 
			
		|||
      LOGICAL            LQUERY, NOTRAN, NOUNIT, UPPER
 | 
			
		||||
      INTEGER            AWRK, I, IFIRST, IINC, ILAST, II, I1, I2, J,
 | 
			
		||||
     $                   JFIRST, JINC, JLAST, J1, J2, K, KK, K1, K2,
 | 
			
		||||
     $                   LANRM, LDS, LSCALE, NB, NBA, NBX, RHS
 | 
			
		||||
     $                   LANRM, LDS, LSCALE, NB, NBA, NBX, RHS, LWMIN
 | 
			
		||||
      DOUBLE PRECISION   ANRM, BIGNUM, BNRM, RSCAL, SCAL, SCALOC,
 | 
			
		||||
     $                   SCAMIN, SMLNUM, TMAX
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -292,15 +297,24 @@
 | 
			
		|||
*     row. WORK( I+KK*LDS ) is the scale factor of the vector
 | 
			
		||||
*     segment associated with the I-th block row and the KK-th vector
 | 
			
		||||
*     in the block column.
 | 
			
		||||
*
 | 
			
		||||
      LSCALE = NBA * MAX( NBA, MIN( NRHS, NBRHS ) )
 | 
			
		||||
      LDS = NBA
 | 
			
		||||
*
 | 
			
		||||
*     The second part stores upper bounds of the triangular A. There are
 | 
			
		||||
*     a total of NBA x NBA blocks, of which only the upper triangular
 | 
			
		||||
*     part or the lower triangular part is referenced. The upper bound of
 | 
			
		||||
*     the block A( I, J ) is stored as WORK( AWRK + I + J * NBA ).
 | 
			
		||||
*
 | 
			
		||||
      LANRM = NBA * NBA
 | 
			
		||||
      AWRK = LSCALE
 | 
			
		||||
      WORK( 1 ) = LSCALE + LANRM
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN( N, NRHS ).EQ.0 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = LSCALE + LANRM
 | 
			
		||||
      END IF
 | 
			
		||||
      WORK( 1 ) = LWMIN
 | 
			
		||||
*
 | 
			
		||||
*     Test the input parameters
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -322,7 +336,7 @@
 | 
			
		|||
         INFO = -8
 | 
			
		||||
      ELSE IF( LDX.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -10
 | 
			
		||||
      ELSE IF( .NOT.LQUERY .AND. LWORK.LT.WORK( 1 ) ) THEN
 | 
			
		||||
      ELSE IF( .NOT.LQUERY .AND. LWORK.LT.LWMIN ) THEN
 | 
			
		||||
         INFO = -14
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -649,6 +663,9 @@
 | 
			
		|||
            END IF
 | 
			
		||||
         END DO
 | 
			
		||||
      END DO
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = LWMIN
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of DLATRS3
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -102,14 +102,17 @@
 | 
			
		|||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= NB*N.
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= NB*N, otherwise.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          only calculates the minimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
| 
						 | 
				
			
			@ -161,9 +164,11 @@
 | 
			
		|||
*>     SIAM J. Sci. Comput, vol. 34, no. 1, 2012
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \ingroup latsqr
 | 
			
		||||
*>
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DLATSQR( M, N, MB, NB, A, LDA, T, LDT, WORK,
 | 
			
		||||
     $                    LWORK, INFO)
 | 
			
		||||
     $                    LWORK, INFO )
 | 
			
		||||
*
 | 
			
		||||
*  -- LAPACK computational routine --
 | 
			
		||||
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 | 
			
		||||
| 
						 | 
				
			
			@ -173,7 +178,7 @@
 | 
			
		|||
      INTEGER            INFO, LDA, M, N, MB, NB, LDT, LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Array Arguments ..
 | 
			
		||||
      DOUBLE PRECISION  A( LDA, * ), WORK( * ), T(LDT, *)
 | 
			
		||||
      DOUBLE PRECISION   A( LDA, * ), WORK( * ), T( LDT, * )
 | 
			
		||||
*     ..
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
| 
						 | 
				
			
			@ -181,7 +186,7 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY
 | 
			
		||||
      INTEGER    I, II, KK, CTR
 | 
			
		||||
      INTEGER            I, II, KK, CTR, MINMN, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. EXTERNAL FUNCTIONS ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -198,6 +203,13 @@
 | 
			
		|||
      INFO = 0
 | 
			
		||||
*
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
*
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
        LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
        LWMIN = N*NB
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
        INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -205,47 +217,49 @@
 | 
			
		|||
        INFO = -2
 | 
			
		||||
      ELSE IF( MB.LT.1 ) THEN
 | 
			
		||||
        INFO = -3
 | 
			
		||||
      ELSE IF( NB.LT.1 .OR. ( NB.GT.N .AND. N.GT.0 )) THEN
 | 
			
		||||
      ELSE IF( NB.LT.1 .OR. ( NB.GT.N .AND. N.GT.0 ) ) THEN
 | 
			
		||||
        INFO = -4
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
        INFO = -6
 | 
			
		||||
      ELSE IF( LDT.LT.NB ) THEN
 | 
			
		||||
        INFO = -8
 | 
			
		||||
      ELSE IF( LWORK.LT.(N*NB) .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. (.NOT.LQUERY) ) THEN
 | 
			
		||||
        INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.EQ.0)  THEN
 | 
			
		||||
        WORK(1) = NB*N
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = LWMIN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
        CALL XERBLA( 'DLATSQR', -INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      ELSE IF (LQUERY) THEN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN(M,N).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     The QR Decomposition
 | 
			
		||||
*
 | 
			
		||||
       IF ((MB.LE.N).OR.(MB.GE.M)) THEN
 | 
			
		||||
         CALL DGEQRT( M, N, NB, A, LDA, T, LDT, WORK, INFO)
 | 
			
		||||
      IF( (MB.LE.N) .OR. (MB.GE.M) ) THEN
 | 
			
		||||
        CALL DGEQRT( M, N, NB, A, LDA, T, LDT, WORK, INFO )
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      KK = MOD((M-N),(MB-N))
 | 
			
		||||
       II=M-KK+1
 | 
			
		||||
      II = M-KK+1
 | 
			
		||||
*
 | 
			
		||||
*     Compute the QR factorization of the first block A(1:MB,1:N)
 | 
			
		||||
*
 | 
			
		||||
      CALL DGEQRT( MB, N, NB, A(1,1), LDA, T, LDT, WORK, INFO )
 | 
			
		||||
*
 | 
			
		||||
      CTR = 1
 | 
			
		||||
       DO I = MB+1, II-MB+N ,  (MB-N)
 | 
			
		||||
      DO I = MB+1, II-MB+N, (MB-N)
 | 
			
		||||
*
 | 
			
		||||
*       Compute the QR factorization of the current block A(I:I+MB-N,1:N)
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -257,13 +271,13 @@
 | 
			
		|||
*
 | 
			
		||||
*     Compute the QR factorization of the last block A(II:M,1:N)
 | 
			
		||||
*
 | 
			
		||||
       IF (II.LE.M) THEN
 | 
			
		||||
      IF( II.LE.M ) THEN
 | 
			
		||||
        CALL DTPQRT( KK, N, 0, NB, A(1,1), LDA, A( II, 1 ), LDA,
 | 
			
		||||
     $                T(1, CTR * N + 1), LDT,
 | 
			
		||||
     $                WORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = N*NB
 | 
			
		||||
      WORK( 1 ) = LWMIN
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of DLATSQR
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -97,7 +97,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension LWORK
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -143,7 +143,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYeigen
 | 
			
		||||
*> \ingroup heev_2stage
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -96,8 +96,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array,
 | 
			
		||||
*>                                         dimension (LWORK)
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -160,7 +159,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYeigen
 | 
			
		||||
*> \ingroup heevd
 | 
			
		||||
*
 | 
			
		||||
*> \par Contributors:
 | 
			
		||||
*  ==================
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -271,7 +271,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= max(1,26*N).
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If N <= 1, LWORK >= 1, else LWORK >= 26*N.
 | 
			
		||||
*>          For optimal efficiency, LWORK >= (NB+6)*N,
 | 
			
		||||
*>          where NB is the max of the blocksize for DSYTRD and DORMTR
 | 
			
		||||
*>          returned by ILAENV.
 | 
			
		||||
| 
						 | 
				
			
			@ -285,13 +286,14 @@
 | 
			
		|||
*> \param[out] IWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          IWORK is INTEGER array, dimension (MAX(1,LIWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, IWORK(1) returns the optimal LWORK.
 | 
			
		||||
*>          On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LIWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LIWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array IWORK.  LIWORK >= max(1,10*N).
 | 
			
		||||
*>          The dimension of the array IWORK.
 | 
			
		||||
*>          If N <= 1, LIWORK >= 1, else LIWORK >= 10*N.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LIWORK = -1, then a workspace query is assumed; the
 | 
			
		||||
*>          routine only calculates the optimal size of the IWORK array,
 | 
			
		||||
| 
						 | 
				
			
			@ -315,7 +317,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYeigen
 | 
			
		||||
*> \ingroup heevr
 | 
			
		||||
*
 | 
			
		||||
*> \par Contributors:
 | 
			
		||||
*  ==================
 | 
			
		||||
| 
						 | 
				
			
			@ -390,8 +392,13 @@
 | 
			
		|||
*
 | 
			
		||||
      LQUERY = ( ( LWORK.EQ.-1 ) .OR. ( LIWORK.EQ.-1 ) )
 | 
			
		||||
*
 | 
			
		||||
      LWMIN = MAX( 1, 26*N )
 | 
			
		||||
      LIWMIN = MAX( 1, 10*N )
 | 
			
		||||
      IF( N.LE.1 ) THEN
 | 
			
		||||
         LWMIN  = 1
 | 
			
		||||
         LIWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN  = 26*N
 | 
			
		||||
         LIWMIN = 10*N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      IF( .NOT.( WANTZ .OR. LSAME( JOBZ, 'N' ) ) ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -450,7 +457,7 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( N.EQ.1 ) THEN
 | 
			
		||||
         WORK( 1 ) = 7
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         IF( ALLEIG .OR. INDEIG ) THEN
 | 
			
		||||
            M = 1
 | 
			
		||||
            W( 1 ) = A( 1, 1 )
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -278,6 +278,7 @@
 | 
			
		|||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If N <= 1,               LWORK must be at least 1.
 | 
			
		||||
*>          If JOBZ = 'N' and N > 1, LWORK must be queried.
 | 
			
		||||
*>                                   LWORK = MAX(1, 26*N, dimension) where
 | 
			
		||||
*>                                   dimension = max(stage1,stage2) + (KD+1)*N + 5*N
 | 
			
		||||
| 
						 | 
				
			
			@ -300,13 +301,14 @@
 | 
			
		|||
*> \param[out] IWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          IWORK is INTEGER array, dimension (MAX(1,LIWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, IWORK(1) returns the optimal LWORK.
 | 
			
		||||
*>          On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LIWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LIWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array IWORK.  LIWORK >= max(1,10*N).
 | 
			
		||||
*>          The dimension of the array IWORK.
 | 
			
		||||
*>          If N <= 1, LIWORK >= 1, else LIWORK >= 10*N.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LIWORK = -1, then a workspace query is assumed; the
 | 
			
		||||
*>          routine only calculates the optimal size of the IWORK array,
 | 
			
		||||
| 
						 | 
				
			
			@ -330,7 +332,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYeigen
 | 
			
		||||
*> \ingroup heevr_2stage
 | 
			
		||||
*
 | 
			
		||||
*> \par Contributors:
 | 
			
		||||
*  ==================
 | 
			
		||||
| 
						 | 
				
			
			@ -444,8 +446,14 @@
 | 
			
		|||
      IB     = ILAENV2STAGE( 2, 'DSYTRD_2STAGE', JOBZ, N, KD, -1, -1 )
 | 
			
		||||
      LHTRD  = ILAENV2STAGE( 3, 'DSYTRD_2STAGE', JOBZ, N, KD, IB, -1 )
 | 
			
		||||
      LWTRD  = ILAENV2STAGE( 4, 'DSYTRD_2STAGE', JOBZ, N, KD, IB, -1 )
 | 
			
		||||
*
 | 
			
		||||
      IF( N.LE.1 ) THEN
 | 
			
		||||
         LWMIN  = 1
 | 
			
		||||
         LIWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN  = MAX( 26*N, 5*N + LHTRD + LWTRD )
 | 
			
		||||
      LIWMIN = MAX( 1, 10*N )
 | 
			
		||||
         LIWMIN = 10*N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      IF( .NOT.( LSAME( JOBZ, 'N' ) ) ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -504,7 +512,7 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( N.EQ.1 ) THEN
 | 
			
		||||
         WORK( 1 ) = 7
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         IF( ALLEIG .OR. INDEIG ) THEN
 | 
			
		||||
            M = 1
 | 
			
		||||
            W( 1 ) = A( 1, 1 )
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -244,7 +244,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYeigen
 | 
			
		||||
*> \ingroup heevx
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DSYEVX( JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU,
 | 
			
		||||
| 
						 | 
				
			
			@ -338,14 +338,14 @@
 | 
			
		|||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         IF( N.LE.1 ) THEN
 | 
			
		||||
            LWKMIN = 1
 | 
			
		||||
            WORK( 1 ) = LWKMIN
 | 
			
		||||
            LWKOPT = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            LWKMIN = 8*N
 | 
			
		||||
            NB = ILAENV( 1, 'DSYTRD', UPLO, N, -1, -1, -1 )
 | 
			
		||||
            NB = MAX( NB, ILAENV( 1, 'DORMTR', UPLO, N, -1, -1, -1 ) )
 | 
			
		||||
            LWKOPT = MAX( LWKMIN, ( NB + 3 )*N )
 | 
			
		||||
            WORK( 1 ) = LWKOPT
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = LWKOPT
 | 
			
		||||
*
 | 
			
		||||
         IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY )
 | 
			
		||||
     $      INFO = -17
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -154,7 +154,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYsolve
 | 
			
		||||
*> \ingroup hesv_aa
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DSYSV_AA( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
 | 
			
		||||
| 
						 | 
				
			
			@ -177,7 +177,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY
 | 
			
		||||
      INTEGER            LWKOPT, LWKOPT_SYTRF, LWKOPT_SYTRS
 | 
			
		||||
      INTEGER            LWKMIN, LWKOPT, LWKOPT_SYTRF, LWKOPT_SYTRS
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -196,6 +196,7 @@
 | 
			
		|||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      LWKMIN = MAX( 1, 2*N, 3*N-2 )
 | 
			
		||||
      IF( .NOT.LSAME( UPLO, 'U' ) .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -206,17 +207,17 @@
 | 
			
		|||
         INFO = -5
 | 
			
		||||
      ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -8
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX(2*N, 3*N-2) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         CALL DSYTRF_AA( UPLO, N, A, LDA, IPIV, WORK, -1, INFO )
 | 
			
		||||
         LWKOPT_SYTRF = INT( WORK(1) )
 | 
			
		||||
         LWKOPT_SYTRF = INT( WORK( 1 ) )
 | 
			
		||||
         CALL DSYTRS_AA( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
 | 
			
		||||
     $                   -1, INFO )
 | 
			
		||||
         LWKOPT_SYTRS = INT( WORK(1) )
 | 
			
		||||
         LWKOPT = MAX( LWKOPT_SYTRF, LWKOPT_SYTRS )
 | 
			
		||||
         LWKOPT_SYTRS = INT( WORK( 1 ) )
 | 
			
		||||
         LWKOPT = MAX( LWKMIN, LWKOPT_SYTRF, LWKOPT_SYTRS )
 | 
			
		||||
         WORK( 1 ) = LWKOPT
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -101,14 +101,14 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] TB
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          TB is DOUBLE PRECISION array, dimension (LTB)
 | 
			
		||||
*>          TB is DOUBLE PRECISION array, dimension (MAX(1,LTB))
 | 
			
		||||
*>          On exit, details of the LU factorization of the band matrix.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LTB
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LTB is INTEGER
 | 
			
		||||
*>          The size of the array TB. LTB >= 4*N, internally
 | 
			
		||||
*>          The size of the array TB. LTB >= MAX(1,4*N), internally
 | 
			
		||||
*>          used to select NB such that LTB >= (3*NB+1)*N.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LTB = -1, then a workspace query is assumed; the
 | 
			
		||||
| 
						 | 
				
			
			@ -148,14 +148,15 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION workspace of size LWORK
 | 
			
		||||
*>          WORK is DOUBLE PRECISION workspace of size (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The size of WORK. LWORK >= N, internally used to select NB
 | 
			
		||||
*>          such that LWORK >= N*NB.
 | 
			
		||||
*>          The size of WORK. LWORK >= MAX(1,N), internally used to
 | 
			
		||||
*>          select NB such that LWORK >= N*NB.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the
 | 
			
		||||
*>          routine only calculates the optimal size of the WORK array,
 | 
			
		||||
| 
						 | 
				
			
			@ -179,7 +180,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYsolve
 | 
			
		||||
*> \ingroup hesv_aa_2stage
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DSYSV_AA_2STAGE( UPLO, N, NRHS, A, LDA, TB, LTB,
 | 
			
		||||
| 
						 | 
				
			
			@ -205,7 +206,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            UPPER, TQUERY, WQUERY
 | 
			
		||||
      INTEGER            LWKOPT
 | 
			
		||||
      INTEGER            LWKMIN, LWKOPT
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -226,6 +227,7 @@
 | 
			
		|||
      UPPER = LSAME( UPLO, 'U' )
 | 
			
		||||
      WQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      TQUERY = ( LTB.EQ.-1 )
 | 
			
		||||
      LWKMIN = MAX( 1, N )
 | 
			
		||||
      IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -234,18 +236,19 @@
 | 
			
		|||
         INFO = -3
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -5
 | 
			
		||||
      ELSE IF( LTB.LT.( 4*N ) .AND. .NOT.TQUERY ) THEN
 | 
			
		||||
      ELSE IF( LTB.LT.MAX( 1, 4*N ) .AND. .NOT.TQUERY ) THEN
 | 
			
		||||
         INFO = -7
 | 
			
		||||
      ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -11
 | 
			
		||||
      ELSE IF( LWORK.LT.N .AND. .NOT.WQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.WQUERY ) THEN
 | 
			
		||||
         INFO = -13
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         CALL DSYTRF_AA_2STAGE( UPLO, N, A, LDA, TB, -1, IPIV,
 | 
			
		||||
     $                          IPIV2, WORK, -1, INFO )
 | 
			
		||||
         LWKOPT = INT( WORK(1) )
 | 
			
		||||
         LWKOPT = MAX( LWKMIN, INT( WORK( 1 ) ) )
 | 
			
		||||
         WORK( 1 ) = LWKOPT
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -255,7 +258,6 @@
 | 
			
		|||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*
 | 
			
		||||
*     Compute the factorization A = U**T*T*U or A = L*T*L**T.
 | 
			
		||||
*
 | 
			
		||||
      CALL DSYTRF_AA_2STAGE( UPLO, N, A, LDA, TB, LTB, IPIV, IPIV2,
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -275,7 +275,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYsolve
 | 
			
		||||
*> \ingroup hesvx
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DSYSVX( FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B,
 | 
			
		||||
| 
						 | 
				
			
			@ -305,7 +305,7 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY, NOFACT
 | 
			
		||||
      INTEGER            LWKOPT, NB
 | 
			
		||||
      INTEGER            LWKMIN, LWKOPT, NB
 | 
			
		||||
      DOUBLE PRECISION   ANORM
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
| 
						 | 
				
			
			@ -327,6 +327,7 @@
 | 
			
		|||
      INFO = 0
 | 
			
		||||
      NOFACT = LSAME( FACT, 'N' )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      LWKMIN = MAX( 1, 3*N )
 | 
			
		||||
      IF( .NOT.NOFACT .AND. .NOT.LSAME( FACT, 'F' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( .NOT.LSAME( UPLO, 'U' ) .AND. .NOT.LSAME( UPLO, 'L' ) )
 | 
			
		||||
| 
						 | 
				
			
			@ -344,12 +345,12 @@
 | 
			
		|||
         INFO = -11
 | 
			
		||||
      ELSE IF( LDX.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -13
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, 3*N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -18
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         LWKOPT = MAX( 1, 3*N )
 | 
			
		||||
         LWKOPT = LWKMIN
 | 
			
		||||
         IF( NOFACT ) THEN
 | 
			
		||||
            NB = ILAENV( 1, 'DSYTRF', UPLO, N, -1, -1, -1 )
 | 
			
		||||
            LWKOPT = MAX( LWKOPT, N*NB )
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -139,7 +139,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYcomputational
 | 
			
		||||
*> \ingroup hetrd
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -247,7 +247,7 @@
 | 
			
		|||
*        Determine the block size.
 | 
			
		||||
*
 | 
			
		||||
         NB = ILAENV( 1, 'DSYTRD', UPLO, N, -1, -1, -1 )
 | 
			
		||||
         LWKOPT = N*NB
 | 
			
		||||
         LWKOPT = MAX( 1, N*NB )
 | 
			
		||||
         WORK( 1 ) = LWKOPT
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -123,7 +123,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] HOUS2
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          HOUS2 is DOUBLE PRECISION array, dimension (LHOUS2)
 | 
			
		||||
*>          HOUS2 is DOUBLE PRECISION array, dimension (MAX(1,LHOUS2))
 | 
			
		||||
*>          Stores the Householder representation of the stage2
 | 
			
		||||
*>          band to tridiagonal.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
| 
						 | 
				
			
			@ -132,6 +132,8 @@
 | 
			
		|||
*> \verbatim
 | 
			
		||||
*>          LHOUS2 is INTEGER
 | 
			
		||||
*>          The dimension of the array HOUS2.
 | 
			
		||||
*>          LHOUS2 >= 1.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, or LHOUS2 = -1,
 | 
			
		||||
*>          then a query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the HOUS2 array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -143,14 +145,17 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (LWORK)
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK. LWORK = MAX(1, dimension)
 | 
			
		||||
*>          If LWORK = -1, or LHOUS2=-1,
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If N = 0, LWORK >= 1, else LWORK = MAX(1, dimension).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, or LHOUS2 = -1,
 | 
			
		||||
*>          then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -182,7 +187,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYcomputational
 | 
			
		||||
*> \ingroup hetrd_2stage
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -265,10 +270,13 @@
 | 
			
		|||
*
 | 
			
		||||
      KD     = ILAENV2STAGE( 1, 'DSYTRD_2STAGE', VECT, N, -1, -1, -1 )
 | 
			
		||||
      IB     = ILAENV2STAGE( 2, 'DSYTRD_2STAGE', VECT, N, KD, -1, -1 )
 | 
			
		||||
      IF( N.EQ.0 ) THEN
 | 
			
		||||
         LHMIN = 1
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LHMIN = ILAENV2STAGE( 3, 'DSYTRD_2STAGE', VECT, N, KD, IB, -1 )
 | 
			
		||||
         LWMIN = ILAENV2STAGE( 4, 'DSYTRD_2STAGE', VECT, N, KD, IB, -1 )
 | 
			
		||||
*      WRITE(*,*),'DSYTRD_2STAGE N KD UPLO LHMIN LWMIN ',N, KD, UPLO,
 | 
			
		||||
*     $            LHMIN, LWMIN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.LSAME( VECT, 'N' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -324,7 +332,6 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*
 | 
			
		||||
      HOUS2( 1 ) = LHMIN
 | 
			
		||||
      WORK( 1 ) = LWMIN
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -132,15 +132,17 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] HOUS
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          HOUS is DOUBLE PRECISION array, dimension LHOUS, that
 | 
			
		||||
*>          store the Householder representation.
 | 
			
		||||
*>          HOUS is DOUBLE PRECISION array, dimension (MAX(1,LHOUS))
 | 
			
		||||
*>          Stores the Householder representation.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LHOUS
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LHOUS is INTEGER
 | 
			
		||||
*>          The dimension of the array HOUS. LHOUS = MAX(1, dimension)
 | 
			
		||||
*>          If LWORK = -1, or LHOUS=-1,
 | 
			
		||||
*>          The dimension of the array HOUS.
 | 
			
		||||
*>          If N = 0 or KD <= 1, LHOUS >= 1, else LHOUS = MAX(1, dimension).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, or LHOUS = -1,
 | 
			
		||||
*>          then a query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the HOUS array, returns
 | 
			
		||||
*>          this value as the first entry of the HOUS array, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -152,14 +154,17 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension LWORK.
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK. LWORK = MAX(1, dimension)
 | 
			
		||||
*>          If LWORK = -1, or LHOUS=-1,
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If N = 0 or KD <= 1, LWORK >= 1, else LWORK = MAX(1, dimension).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, or LHOUS = -1,
 | 
			
		||||
*>          then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -188,7 +193,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup real16OTHERcomputational
 | 
			
		||||
*> \ingroup hetrd_hb2st
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -261,7 +266,7 @@
 | 
			
		|||
      INTEGER            I, M, K, IB, SWEEPID, MYID, SHIFT, STT, ST,
 | 
			
		||||
     $                   ED, STIND, EDIND, BLKLASTIND, COLPT, THED,
 | 
			
		||||
     $                   STEPERCOL, GRSIZ, THGRSIZ, THGRNB, THGRID,
 | 
			
		||||
     $                   NBTILES, TTYPE, TID, NTHREADS, DEBUG,
 | 
			
		||||
     $                   NBTILES, TTYPE, TID, NTHREADS,
 | 
			
		||||
     $                   ABDPOS, ABOFDPOS, DPOS, OFDPOS, AWPOS,
 | 
			
		||||
     $                   INDA, INDW, APOS, SIZEA, LDA, INDV, INDTAU,
 | 
			
		||||
     $                   SIDEV, SIZETAU, LDV, LHMIN, LWMIN
 | 
			
		||||
| 
						 | 
				
			
			@ -282,7 +287,6 @@
 | 
			
		|||
*     Determine the minimal workspace size required.
 | 
			
		||||
*     Test the input parameters
 | 
			
		||||
*
 | 
			
		||||
      DEBUG   = 0
 | 
			
		||||
      INFO    = 0
 | 
			
		||||
      AFTERS1 = LSAME( STAGE1, 'Y' )
 | 
			
		||||
      WANTQ   = LSAME( VECT, 'V' )
 | 
			
		||||
| 
						 | 
				
			
			@ -292,8 +296,13 @@
 | 
			
		|||
*     Determine the block size, the workspace size and the hous size.
 | 
			
		||||
*
 | 
			
		||||
      IB       = ILAENV2STAGE( 2, 'DSYTRD_SB2ST', VECT, N, KD, -1, -1 )
 | 
			
		||||
      IF( N.EQ.0 .OR. KD.LE.1 ) THEN
 | 
			
		||||
         LHMIN = 1
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LHMIN = ILAENV2STAGE( 3, 'DSYTRD_SB2ST', VECT, N, KD, IB, -1 )
 | 
			
		||||
         LWMIN = ILAENV2STAGE( 4, 'DSYTRD_SB2ST', VECT, N, KD, IB, -1 )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.AFTERS1 .AND. .NOT.LSAME( STAGE1, 'N' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -543,7 +552,6 @@
 | 
			
		|||
  170     CONTINUE
 | 
			
		||||
      ENDIF
 | 
			
		||||
*
 | 
			
		||||
      HOUS( 1 ) = LHMIN
 | 
			
		||||
      WORK( 1 ) = LWMIN
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -123,8 +123,8 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (LWORK)
 | 
			
		||||
*>          On exit, if INFO = 0, or if LWORK=-1, 
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, or if LWORK = -1,
 | 
			
		||||
*>          WORK(1) returns the size of LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -132,7 +132,9 @@
 | 
			
		|||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK which should be calculated
 | 
			
		||||
*>          by a workspace query. LWORK = MAX(1, LWORK_QUERY)
 | 
			
		||||
*>          by a workspace query.
 | 
			
		||||
*>          If N <= KD+1, LWORK >= 1, else LWORK = MAX(1, LWORK_QUERY)
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -158,7 +160,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver 
 | 
			
		||||
*> \author NAG Ltd. 
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYcomputational
 | 
			
		||||
*> \ingroup hetrd_he2hb
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -293,8 +295,12 @@
 | 
			
		|||
      INFO   = 0
 | 
			
		||||
      UPPER  = LSAME( UPLO, 'U' )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      LWMIN  = ILAENV2STAGE( 4, 'DSYTRD_SY2SB', '', N, KD, -1, -1 )
 | 
			
		||||
      
 | 
			
		||||
      IF( N.LE.KD+1 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = ILAENV2STAGE( 4, 'DSYTRD_SY2SB', ' ', N, KD, -1, -1 )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -107,7 +107,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of WORK.  LWORK >=1.  For best performance
 | 
			
		||||
*>          The length of WORK.  LWORK >= 1.  For best performance
 | 
			
		||||
*>          LWORK >= N*NB, where NB is the block size returned by ILAENV.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
| 
						 | 
				
			
			@ -135,7 +135,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYcomputational
 | 
			
		||||
*> \ingroup hetrf
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			@ -352,6 +352,7 @@
 | 
			
		|||
      END IF
 | 
			
		||||
*
 | 
			
		||||
   40 CONTINUE
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = LWKOPT
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -101,8 +101,10 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of WORK.  LWORK >= MAX(1,2*N). For optimum performance
 | 
			
		||||
*>          LWORK >= N*(1+NB), where NB is the optimal blocksize.
 | 
			
		||||
*>          The length of WORK.
 | 
			
		||||
*>          LWORK >= 1, if N <= 1, and LWORK >= 2*N, otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= N*(1+NB), where NB is
 | 
			
		||||
*>          the optimal blocksize, returned by ILAENV.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -125,10 +127,10 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYcomputational
 | 
			
		||||
*> \ingroup hetrf_aa
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DSYTRF_AA( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
 | 
			
		||||
      SUBROUTINE DSYTRF_AA( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
 | 
			
		||||
*
 | 
			
		||||
*  -- LAPACK computational routine --
 | 
			
		||||
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 | 
			
		||||
| 
						 | 
				
			
			@ -152,7 +154,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY, UPPER
 | 
			
		||||
      INTEGER            J, LWKOPT
 | 
			
		||||
      INTEGER            J, LWKMIN, LWKOPT
 | 
			
		||||
      INTEGER            NB, MJ, NJ, K1, K2, J1, J2, J3, JB
 | 
			
		||||
      DOUBLE PRECISION   ALPHA
 | 
			
		||||
*     ..
 | 
			
		||||
| 
						 | 
				
			
			@ -179,18 +181,25 @@
 | 
			
		|||
      INFO = 0
 | 
			
		||||
      UPPER = LSAME( UPLO, 'U' )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( N.LE.1 ) THEN
 | 
			
		||||
         LWKMIN = 1
 | 
			
		||||
         LWKOPT = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKMIN = 2*N
 | 
			
		||||
         LWKOPT = (NB+1)*N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, 2*N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -7
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         LWKOPT = (NB+1)*N
 | 
			
		||||
         WORK( 1 ) = LWKOPT
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -203,11 +212,11 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return
 | 
			
		||||
*
 | 
			
		||||
      IF ( N.EQ.0 ) THEN
 | 
			
		||||
      IF( N.EQ.0 ) THEN
 | 
			
		||||
          RETURN
 | 
			
		||||
      ENDIF
 | 
			
		||||
      IPIV( 1 ) = 1
 | 
			
		||||
      IF ( N.EQ.1 ) THEN
 | 
			
		||||
      IF( N.EQ.1 ) THEN
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -87,14 +87,14 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] TB
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          TB is DOUBLE PRECISION array, dimension (LTB)
 | 
			
		||||
*>          TB is DOUBLE PRECISION array, dimension (MAX(1,LTB))
 | 
			
		||||
*>          On exit, details of the LU factorization of the band matrix.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LTB
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LTB is INTEGER
 | 
			
		||||
*>          The size of the array TB. LTB >= 4*N, internally
 | 
			
		||||
*>          The size of the array TB. LTB >= MAX(1,4*N), internally
 | 
			
		||||
*>          used to select NB such that LTB >= (3*NB+1)*N.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LTB = -1, then a workspace query is assumed; the
 | 
			
		||||
| 
						 | 
				
			
			@ -121,14 +121,14 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION workspace of size LWORK
 | 
			
		||||
*>          WORK is DOUBLE PRECISION workspace of size (MAX(1,LWORK))
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The size of WORK. LWORK >= N, internally used to select NB
 | 
			
		||||
*>          such that LWORK >= N*NB.
 | 
			
		||||
*>          The size of WORK. LWORK >= MAX(1,N), internally used
 | 
			
		||||
*>          to select NB such that LWORK >= N*NB.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the
 | 
			
		||||
*>          routine only calculates the optimal size of the WORK array,
 | 
			
		||||
| 
						 | 
				
			
			@ -152,7 +152,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYcomputational
 | 
			
		||||
*> \ingroup hetrf_aa_2stage
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DSYTRF_AA_2STAGE( UPLO, N, A, LDA, TB, LTB, IPIV,
 | 
			
		||||
| 
						 | 
				
			
			@ -211,9 +211,9 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF ( LTB .LT. 4*N .AND. .NOT.TQUERY ) THEN
 | 
			
		||||
      ELSE IF( LTB.LT.MAX( 1, 4*N ) .AND. .NOT.TQUERY ) THEN
 | 
			
		||||
         INFO = -6
 | 
			
		||||
      ELSE IF ( LWORK .LT. N .AND. .NOT.WQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, N ) .AND. .NOT.WQUERY ) THEN
 | 
			
		||||
         INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -227,10 +227,10 @@
 | 
			
		|||
      NB = ILAENV( 1, 'DSYTRF_AA_2STAGE', UPLO, N, -1, -1, -1 )
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
         IF( TQUERY ) THEN
 | 
			
		||||
            TB( 1 ) = (3*NB+1)*N
 | 
			
		||||
            TB( 1 ) = MAX( 1, (3*NB+1)*N )
 | 
			
		||||
         END IF
 | 
			
		||||
         IF( WQUERY ) THEN
 | 
			
		||||
            WORK( 1 ) = N*NB
 | 
			
		||||
            WORK( 1 ) = MAX( 1, N*NB )
 | 
			
		||||
         END IF
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( TQUERY .OR. WQUERY ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -239,7 +239,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return
 | 
			
		||||
*
 | 
			
		||||
      IF ( N.EQ.0 ) THEN
 | 
			
		||||
      IF( N.EQ.0 ) THEN
 | 
			
		||||
         RETURN
 | 
			
		||||
      ENDIF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -177,14 +177,14 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension ( MAX(1,LWORK) ).
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)).
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of WORK.  LWORK >=1.  For best performance
 | 
			
		||||
*>          The length of WORK.  LWORK >= 1.  For best performance
 | 
			
		||||
*>          LWORK >= N*NB, where NB is the block size returned
 | 
			
		||||
*>          by ILAENV.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -229,7 +229,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYcomputational
 | 
			
		||||
*> \ingroup hetrf_rk
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -118,7 +118,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of WORK.  LWORK >=1.  For best performance
 | 
			
		||||
*>          The length of WORK.  LWORK >= 1.  For best performance
 | 
			
		||||
*>          LWORK >= N*NB, where NB is the block size returned by ILAENV.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
| 
						 | 
				
			
			@ -146,7 +146,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYcomputational
 | 
			
		||||
*> \ingroup hetrf_rook
 | 
			
		||||
*
 | 
			
		||||
*> \par Further Details:
 | 
			
		||||
*  =====================
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -88,14 +88,14 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (N+NB+1)*(NB+3)
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          WORK is size >= (N+NB+1)*(NB+3)
 | 
			
		||||
*>          If N = 0, LWORK >= 1, else LWORK >= (N+NB+1)*(NB+3).
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          calculates:
 | 
			
		||||
*>              - the optimal size of the WORK array, returns
 | 
			
		||||
| 
						 | 
				
			
			@ -120,7 +120,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYcomputational
 | 
			
		||||
*> \ingroup hetri2
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DSYTRI2( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
 | 
			
		||||
| 
						 | 
				
			
			@ -159,9 +159,13 @@
 | 
			
		|||
      INFO = 0
 | 
			
		||||
      UPPER = LSAME( UPLO, 'U' )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
*
 | 
			
		||||
*     Get blocksize
 | 
			
		||||
*
 | 
			
		||||
      NBMAX = ILAENV( 1, 'DSYTRI2', UPLO, N, -1, -1, -1 )
 | 
			
		||||
      IF ( NBMAX .GE. N ) THEN
 | 
			
		||||
      IF( N.EQ.0 ) THEN
 | 
			
		||||
         MINSIZE = 1
 | 
			
		||||
      ELSE IF( NBMAX.GE.N ) THEN
 | 
			
		||||
         MINSIZE = N
 | 
			
		||||
      ELSE
 | 
			
		||||
         MINSIZE = (N+NBMAX+1)*(NBMAX+3)
 | 
			
		||||
| 
						 | 
				
			
			@ -173,28 +177,29 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF (LWORK .LT. MINSIZE .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.MINSIZE .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -7
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
         CALL XERBLA( 'DSYTRI2', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         WORK(1)=MINSIZE
 | 
			
		||||
         WORK( 1 ) = MINSIZE
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( N.EQ.0 )
 | 
			
		||||
     $   RETURN
 | 
			
		||||
 | 
			
		||||
      IF( NBMAX .GE. N ) THEN
 | 
			
		||||
      IF( NBMAX.GE.N ) THEN
 | 
			
		||||
         CALL DSYTRI( UPLO, N, A, LDA, IPIV, WORK, INFO )
 | 
			
		||||
      ELSE
 | 
			
		||||
         CALL DSYTRI2X( UPLO, N, A, LDA, IPIV, WORK, NBMAX, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of DSYTRI2
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -119,16 +119,17 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (N+NB+1)*(NB+3).
 | 
			
		||||
*>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)).
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of WORK. LWORK >= (N+NB+1)*(NB+3).
 | 
			
		||||
*>          The length of WORK.
 | 
			
		||||
*>          If N = 0, LWORK >= 1, else LWORK >= (N+NB+1)*(NB+3).
 | 
			
		||||
*>
 | 
			
		||||
*>          If LDWORK = -1, then a workspace query is assumed;
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed;
 | 
			
		||||
*>          the routine only calculates the optimal size of the optimal
 | 
			
		||||
*>          size of the WORK array, returns this value as the first
 | 
			
		||||
*>          entry of the WORK array, and no error message related to
 | 
			
		||||
| 
						 | 
				
			
			@ -152,7 +153,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYcomputational
 | 
			
		||||
*> \ingroup hetri_3
 | 
			
		||||
*
 | 
			
		||||
*> \par Contributors:
 | 
			
		||||
*  ==================
 | 
			
		||||
| 
						 | 
				
			
			@ -208,8 +209,13 @@
 | 
			
		|||
*
 | 
			
		||||
*     Determine the block size
 | 
			
		||||
*
 | 
			
		||||
      IF( N.EQ.0 ) THEN
 | 
			
		||||
         LWKOPT = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         NB = MAX( 1, ILAENV( 1, 'DSYTRI_3', UPLO, N, -1, -1, -1 ) )
 | 
			
		||||
         LWKOPT = ( N+NB+1 ) * ( NB+3 )
 | 
			
		||||
      END IF
 | 
			
		||||
      WORK( 1 ) = LWKOPT
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -217,7 +223,7 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF ( LWORK .LT. LWKOPT .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKOPT .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -8
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -225,7 +231,6 @@
 | 
			
		|||
         CALL XERBLA( 'DSYTRI_3', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         WORK( 1 ) = LWKOPT
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -105,7 +105,13 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= max(1,3*N-2).
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          If MIN(N,NRHS) = 0, LWORK >= 1, else LWORK >= 3*N-2.
 | 
			
		||||
*>
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed; the routine
 | 
			
		||||
*>          only calculates the minimal size of the WORK array, returns
 | 
			
		||||
*>          this value as the first entry of the WORK array, and no error
 | 
			
		||||
*>          message related to LWORK is issued by XERBLA.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[out] INFO
 | 
			
		||||
| 
						 | 
				
			
			@ -123,7 +129,7 @@
 | 
			
		|||
*> \author Univ. of Colorado Denver
 | 
			
		||||
*> \author NAG Ltd.
 | 
			
		||||
*
 | 
			
		||||
*> \ingroup doubleSYcomputational
 | 
			
		||||
*> \ingroup hetrs_aa
 | 
			
		||||
*
 | 
			
		||||
*  =====================================================================
 | 
			
		||||
      SUBROUTINE DSYTRS_AA( UPLO, N, NRHS, A, LDA, IPIV, B, LDB,
 | 
			
		||||
| 
						 | 
				
			
			@ -151,7 +157,7 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY, UPPER
 | 
			
		||||
      INTEGER            K, KP, LWKOPT
 | 
			
		||||
      INTEGER            K, KP, LWKMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -161,13 +167,19 @@
 | 
			
		|||
      EXTERNAL           DLACPY, DGTSV, DSWAP, DTRSM, XERBLA
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Intrinsic Functions ..
 | 
			
		||||
      INTRINSIC          MAX
 | 
			
		||||
      INTRINSIC          MIN, MAX
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. Executable Statements ..
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      UPPER = LSAME( UPLO, 'U' )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( MIN( N, NRHS ).EQ.0 ) THEN
 | 
			
		||||
         LWKMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKMIN = 3*N-2
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
      ELSE IF( N.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -178,21 +190,20 @@
 | 
			
		|||
         INFO = -5
 | 
			
		||||
      ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
 | 
			
		||||
         INFO = -8
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, 3*N-2 ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
         CALL XERBLA( 'DSYTRS_AA', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         LWKOPT = (3*N-2)
 | 
			
		||||
         WORK( 1 ) = LWKOPT
 | 
			
		||||
         WORK( 1 ) = LWKMIN
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( N.EQ.0 .OR. NRHS.EQ.0 )
 | 
			
		||||
      IF( MIN( N, NRHS ).EQ.0 )
 | 
			
		||||
     $   RETURN
 | 
			
		||||
*
 | 
			
		||||
      IF( UPPER ) THEN
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -122,7 +122,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The length of the array WORK.  LWORK >= max(1,M,N).
 | 
			
		||||
*>          The length of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= MAX(M,N), otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= (M+N)*NB, where NB
 | 
			
		||||
*>          is the optimal blocksize.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -223,8 +224,8 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LQUERY
 | 
			
		||||
      INTEGER            I, IINFO, J, LDWRKX, LDWRKY, LWKOPT, MINMN, NB,
 | 
			
		||||
     $                   NBMIN, NX, WS
 | 
			
		||||
      INTEGER            I, IINFO, J, LDWRKX, LDWRKY, LWKMIN, LWKOPT,
 | 
			
		||||
     $                   MINMN, NB, NBMIN, NX, WS
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           SGEBD2, SGEMM, SLABRD, XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -242,9 +243,16 @@
 | 
			
		|||
*     Test the input parameters
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
         LWKMIN = 1
 | 
			
		||||
         LWKOPT = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWKMIN = MAX( M, N )
 | 
			
		||||
         NB = MAX( 1, ILAENV( 1, 'SGEBRD', ' ', M, N, -1, -1 ) )
 | 
			
		||||
         LWKOPT = ( M+N )*NB
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      ENDIF
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -252,7 +260,7 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, M, N ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -10
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.LT.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -264,7 +272,6 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      MINMN = MIN( M, N )
 | 
			
		||||
      IF( MINMN.EQ.0 ) THEN
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -283,7 +290,7 @@
 | 
			
		|||
*        Determine when to switch from blocked to unblocked code.
 | 
			
		||||
*
 | 
			
		||||
         IF( NX.LT.MINMN ) THEN
 | 
			
		||||
            WS = ( M+N )*NB
 | 
			
		||||
            WS = LWKOPT
 | 
			
		||||
            IF( LWORK.LT.WS ) THEN
 | 
			
		||||
*
 | 
			
		||||
*              Not enough work space for the optimal NB, consider using
 | 
			
		||||
| 
						 | 
				
			
			@ -342,7 +349,8 @@
 | 
			
		|||
*
 | 
			
		||||
      CALL SGEBD2( M-I+1, N-I+1, A( I, I ), LDA, D( I ), E( I ),
 | 
			
		||||
     $             TAUQ( I ), TAUP( I ), WORK, IINFO )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(WS)
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( WS )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of SGEBRD
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -89,7 +89,7 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          WORK is REAL array, dimension (LWORK)
 | 
			
		||||
*>          WORK is REAL array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -222,13 +222,19 @@
 | 
			
		|||
         INFO = -8
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      NH = IHI - ILO + 1
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
*
 | 
			
		||||
*       Compute the workspace requirements
 | 
			
		||||
*
 | 
			
		||||
         NB = MIN( NBMAX, ILAENV( 1, 'SGEHRD', ' ', N, ILO, IHI, -1 ) )
 | 
			
		||||
         IF( NH.LE.1 ) THEN
 | 
			
		||||
            LWKOPT = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            NB = MIN( NBMAX, ILAENV( 1, 'SGEHRD', ' ', N, ILO, IHI,
 | 
			
		||||
     $                              -1 ) )
 | 
			
		||||
            LWKOPT = N*NB + TSIZE
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
         ENDIF
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -249,7 +255,6 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      NH = IHI - ILO + 1
 | 
			
		||||
      IF( NH.LE.1 ) THEN
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -269,7 +274,7 @@
 | 
			
		|||
*
 | 
			
		||||
*           Determine if workspace is large enough for blocked code
 | 
			
		||||
*
 | 
			
		||||
            IF( LWORK.LT.N*NB+TSIZE ) THEN
 | 
			
		||||
            IF( LWORK.LT.LWKOPT ) THEN
 | 
			
		||||
*
 | 
			
		||||
*              Not enough workspace to use optimal NB:  determine the
 | 
			
		||||
*              minimum value of NB, and reduce NB or force use of
 | 
			
		||||
| 
						 | 
				
			
			@ -345,7 +350,8 @@
 | 
			
		|||
*     Use unblocked code to reduce the rest of the matrix
 | 
			
		||||
*
 | 
			
		||||
      CALL SGEHD2( N, I, IHI, A, LDA, TAU, WORK, IINFO )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -98,7 +98,7 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1 or -2, then a workspace query is assumed. The routine
 | 
			
		||||
*>          only calculates the sizes of the T and WORK arrays, returns these
 | 
			
		||||
*>          values as the first entries of the T and WORK arrays, and no error
 | 
			
		||||
| 
						 | 
				
			
			@ -295,9 +295,9 @@
 | 
			
		|||
        T( 2 ) = MB
 | 
			
		||||
        T( 3 ) = NB
 | 
			
		||||
        IF( MINW ) THEN
 | 
			
		||||
          WORK( 1 ) = SROUNDUP_LWORK(LWMIN)
 | 
			
		||||
          WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
        ELSE
 | 
			
		||||
          WORK( 1 ) = SROUNDUP_LWORK(LWREQ)
 | 
			
		||||
          WORK( 1 ) = SROUNDUP_LWORK( LWREQ )
 | 
			
		||||
        END IF
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -322,7 +322,7 @@
 | 
			
		|||
     $                LWORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWREQ)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWREQ )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of SGELQ
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -93,7 +93,8 @@
 | 
			
		|||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.  LWORK >= max(1,M).
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= M, otherwise.
 | 
			
		||||
*>          For optimum performance LWORK >= M*NB, where NB is the
 | 
			
		||||
*>          optimal blocksize.
 | 
			
		||||
*>
 | 
			
		||||
| 
						 | 
				
			
			@ -175,9 +176,8 @@
 | 
			
		|||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      INFO = 0
 | 
			
		||||
      K = MIN( M, N )
 | 
			
		||||
      NB = ILAENV( 1, 'SGELQF', ' ', M, N, -1, -1 )
 | 
			
		||||
      LWKOPT = M*NB
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LWKOPT)
 | 
			
		||||
      LQUERY = ( LWORK.EQ.-1 )
 | 
			
		||||
      IF( M.LT.0 ) THEN
 | 
			
		||||
         INFO = -1
 | 
			
		||||
| 
						 | 
				
			
			@ -185,19 +185,25 @@
 | 
			
		|||
         INFO = -2
 | 
			
		||||
      ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
         INFO = -4
 | 
			
		||||
      ELSE IF( LWORK.LT.MAX( 1, M ) .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
         INFO = -7
 | 
			
		||||
      ELSE IF( .NOT.LQUERY ) THEN
 | 
			
		||||
         IF( LWORK.LE.0 .OR. ( N.GT.0 .AND. LWORK.LT.MAX( 1, M ) ) )
 | 
			
		||||
     $      INFO = -7
 | 
			
		||||
      END IF
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
         CALL XERBLA( 'SGELQF', -INFO )
 | 
			
		||||
         RETURN
 | 
			
		||||
      ELSE IF( LQUERY ) THEN
 | 
			
		||||
         IF( K.EQ.0 ) THEN
 | 
			
		||||
            LWKOPT = 1
 | 
			
		||||
         ELSE
 | 
			
		||||
            LWKOPT = M*NB
 | 
			
		||||
         END IF
 | 
			
		||||
         WORK( 1 ) = SROUNDUP_LWORK( LWKOPT )
 | 
			
		||||
         RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      K = MIN( M, N )
 | 
			
		||||
      IF( K.EQ.0 ) THEN
 | 
			
		||||
         WORK( 1 ) = 1
 | 
			
		||||
         RETURN
 | 
			
		||||
| 
						 | 
				
			
			@ -267,7 +273,7 @@
 | 
			
		|||
     $   CALL SGELQ2( M-I+1, N-I+1, A( I, I ), LDA, TAU( I ), WORK,
 | 
			
		||||
     $                IINFO )
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(IWS)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( IWS )
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
*     End of SGELQF
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -110,13 +110,14 @@
 | 
			
		|||
*>
 | 
			
		||||
*> \param[out] WORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>         (workspace) REAL array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
 | 
			
		||||
*>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
 | 
			
		||||
*> \endverbatim
 | 
			
		||||
*>
 | 
			
		||||
*> \param[in] LWORK
 | 
			
		||||
*> \verbatim
 | 
			
		||||
*>          LWORK is INTEGER
 | 
			
		||||
*>          The dimension of the array WORK.
 | 
			
		||||
*>          The dimension of the array WORK. LWORK >= 1.
 | 
			
		||||
*>          If LWORK = -1, then a workspace query is assumed. The routine
 | 
			
		||||
*>          only calculates the size of the WORK array, returns this
 | 
			
		||||
*>          value as WORK(1), and no error message related to WORK
 | 
			
		||||
| 
						 | 
				
			
			@ -187,7 +188,7 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LEFT, RIGHT, TRAN, NOTRAN, LQUERY
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN, MINMNK, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
| 
						 | 
				
			
			@ -207,7 +208,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      LQUERY  = LWORK.EQ.-1
 | 
			
		||||
      LQUERY  = ( LWORK.EQ.-1 )
 | 
			
		||||
      NOTRAN  = LSAME( TRANS, 'N' )
 | 
			
		||||
      TRAN    = LSAME( TRANS, 'T' )
 | 
			
		||||
      LEFT    = LSAME( SIDE, 'L' )
 | 
			
		||||
| 
						 | 
				
			
			@ -222,6 +223,13 @@
 | 
			
		|||
        LW = M * MB
 | 
			
		||||
        MN = N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      MINMNK = MIN( M, N, K )
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = MAX( 1, LW )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( ( NB.GT.K ) .AND. ( MN.GT.K ) ) THEN
 | 
			
		||||
        IF( MOD( MN - K, NB - K ) .EQ. 0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -250,12 +258,12 @@
 | 
			
		|||
        INFO = -9
 | 
			
		||||
      ELSE IF( LDC.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
        INFO = -11
 | 
			
		||||
      ELSE IF( ( LWORK.LT.MAX( 1, LW ) ) .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
        INFO = -13
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = SROUNDUP_LWORK( LW )
 | 
			
		||||
        WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -267,7 +275,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN( M, N, K ).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -280,7 +288,7 @@
 | 
			
		|||
     $                 MB, C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LW )
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -189,12 +189,13 @@
 | 
			
		|||
*     ..
 | 
			
		||||
*     .. Local Scalars ..
 | 
			
		||||
      LOGICAL            LEFT, RIGHT, TRAN, NOTRAN, LQUERY
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN
 | 
			
		||||
      INTEGER            MB, NB, LW, NBLCKS, MN, MINMNK, LWMIN
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Functions ..
 | 
			
		||||
      LOGICAL            LSAME
 | 
			
		||||
      EXTERNAL           LSAME
 | 
			
		||||
      REAL               SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           LSAME, SROUNDUP_LWORK
 | 
			
		||||
      EXTERNAL           SROUNDUP_LWORK
 | 
			
		||||
*     ..
 | 
			
		||||
*     .. External Subroutines ..
 | 
			
		||||
      EXTERNAL           SGEMQRT, SLAMTSQR, XERBLA
 | 
			
		||||
| 
						 | 
				
			
			@ -206,7 +207,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Test the input arguments
 | 
			
		||||
*
 | 
			
		||||
      LQUERY  = LWORK.EQ.-1
 | 
			
		||||
      LQUERY  = ( LWORK.EQ.-1 )
 | 
			
		||||
      NOTRAN  = LSAME( TRANS, 'N' )
 | 
			
		||||
      TRAN    = LSAME( TRANS, 'T' )
 | 
			
		||||
      LEFT    = LSAME( SIDE, 'L' )
 | 
			
		||||
| 
						 | 
				
			
			@ -221,6 +222,13 @@
 | 
			
		|||
        LW = MB * NB
 | 
			
		||||
        MN = N
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      MINMNK = MIN( M, N, K )
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
         LWMIN = 1
 | 
			
		||||
      ELSE
 | 
			
		||||
         LWMIN = MAX( 1, LW )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( ( MB.GT.K ) .AND. ( MN.GT.K ) ) THEN
 | 
			
		||||
        IF( MOD( MN - K, MB - K ).EQ.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -249,12 +257,12 @@
 | 
			
		|||
        INFO = -9
 | 
			
		||||
      ELSE IF( LDC.LT.MAX( 1, M ) ) THEN
 | 
			
		||||
        INFO = -11
 | 
			
		||||
      ELSE IF( ( LWORK.LT.MAX( 1, LW ) ) .AND. ( .NOT.LQUERY ) ) THEN
 | 
			
		||||
      ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
 | 
			
		||||
        INFO = -13
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.EQ.0 ) THEN
 | 
			
		||||
        WORK( 1 ) = SROUNDUP_LWORK(LW)
 | 
			
		||||
        WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      IF( INFO.NE.0 ) THEN
 | 
			
		||||
| 
						 | 
				
			
			@ -266,7 +274,7 @@
 | 
			
		|||
*
 | 
			
		||||
*     Quick return if possible
 | 
			
		||||
*
 | 
			
		||||
      IF( MIN( M, N, K ).EQ.0 ) THEN
 | 
			
		||||
      IF( MINMNK.EQ.0 ) THEN
 | 
			
		||||
        RETURN
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			@ -279,7 +287,7 @@
 | 
			
		|||
     $                 NB, C, LDC, WORK, LWORK, INFO )
 | 
			
		||||
      END IF
 | 
			
		||||
*
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK(LW)
 | 
			
		||||
      WORK( 1 ) = SROUNDUP_LWORK( LWMIN )
 | 
			
		||||
*
 | 
			
		||||
      RETURN
 | 
			
		||||
*
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
Some files were not shown because too many files have changed in this diff Show More
		Loading…
	
		Reference in New Issue