Moving lapack to right place

1 files changed, 0 insertions, 386 deletions

diff --git a/src/lib/lapack/ztrevc.f b/src/lib/lapack/ztrevc.f
deleted file mode 100644
index 21142f42..00000000
--- a/src/lib/lapack/ztrevc.f
+++ /dev/null
@@ -1,386 +0,0 @@
-      SUBROUTINE ZTREVC( SIDE, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR,
-     $                   LDVR, MM, M, WORK, RWORK, INFO )
-*
-*  -- LAPACK routine (version 3.1) --
-*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
-*     November 2006
-*
-*     .. Scalar Arguments ..
-      CHARACTER          HOWMNY, SIDE
-      INTEGER            INFO, LDT, LDVL, LDVR, M, MM, N
-*     ..
-*     .. Array Arguments ..
-      LOGICAL            SELECT( * )
-      DOUBLE PRECISION   RWORK( * )
-      COMPLEX*16         T( LDT, * ), VL( LDVL, * ), VR( LDVR, * ),
-     $                   WORK( * )
-*     ..
-*
-*  Purpose
-*  =======
-*
-*  ZTREVC computes some or all of the right and/or left eigenvectors of
-*  a complex upper triangular matrix T.
-*  Matrices of this type are produced by the Schur factorization of
-*  a complex general matrix:  A = Q*T*Q**H, as computed by ZHSEQR.
-*  
-*  The right eigenvector x and the left eigenvector y of T corresponding
-*  to an eigenvalue w are defined by:
-*  
-*               T*x = w*x,     (y**H)*T = w*(y**H)
-*  
-*  where y**H denotes the conjugate transpose of the vector y.
-*  The eigenvalues are not input to this routine, but are read directly
-*  from the diagonal of T.
-*  
-*  This routine returns the matrices X and/or Y of right and left
-*  eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an
-*  input matrix.  If Q is the unitary factor that reduces a matrix A to
-*  Schur form T, then Q*X and Q*Y are the matrices of right and left
-*  eigenvectors of A.
-*
-*  Arguments
-*  =========
-*
-*  SIDE    (input) CHARACTER*1
-*          = 'R':  compute right eigenvectors only;
-*          = 'L':  compute left eigenvectors only;
-*          = 'B':  compute both right and left eigenvectors.
-*
-*  HOWMNY  (input) CHARACTER*1
-*          = 'A':  compute all right and/or left eigenvectors;
-*          = 'B':  compute all right and/or left eigenvectors,
-*                  backtransformed using the matrices supplied in
-*                  VR and/or VL;
-*          = 'S':  compute selected right and/or left eigenvectors,
-*                  as indicated by the logical array SELECT.
-*
-*  SELECT  (input) LOGICAL array, dimension (N)
-*          If HOWMNY = 'S', SELECT specifies the eigenvectors to be
-*          computed.
-*          The eigenvector corresponding to the j-th eigenvalue is
-*          computed if SELECT(j) = .TRUE..
-*          Not referenced if HOWMNY = 'A' or 'B'.
-*
-*  N       (input) INTEGER
-*          The order of the matrix T. N >= 0.
-*
-*  T       (input/output) COMPLEX*16 array, dimension (LDT,N)
-*          The upper triangular matrix T.  T is modified, but restored
-*          on exit.
-*
-*  LDT     (input) INTEGER
-*          The leading dimension of the array T. LDT >= max(1,N).
-*
-*  VL      (input/output) COMPLEX*16 array, dimension (LDVL,MM)
-*          On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must
-*          contain an N-by-N matrix Q (usually the unitary matrix Q of
-*          Schur vectors returned by ZHSEQR).
-*          On exit, if SIDE = 'L' or 'B', VL contains:
-*          if HOWMNY = 'A', the matrix Y of left eigenvectors of T;
-*          if HOWMNY = 'B', the matrix Q*Y;
-*          if HOWMNY = 'S', the left eigenvectors of T specified by
-*                           SELECT, stored consecutively in the columns
-*                           of VL, in the same order as their
-*                           eigenvalues.
-*          Not referenced if SIDE = 'R'.
-*
-*  LDVL    (input) INTEGER
-*          The leading dimension of the array VL.  LDVL >= 1, and if
-*          SIDE = 'L' or 'B', LDVL >= N.
-*
-*  VR      (input/output) COMPLEX*16 array, dimension (LDVR,MM)
-*          On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must
-*          contain an N-by-N matrix Q (usually the unitary matrix Q of
-*          Schur vectors returned by ZHSEQR).
-*          On exit, if SIDE = 'R' or 'B', VR contains:
-*          if HOWMNY = 'A', the matrix X of right eigenvectors of T;
-*          if HOWMNY = 'B', the matrix Q*X;
-*          if HOWMNY = 'S', the right eigenvectors of T specified by
-*                           SELECT, stored consecutively in the columns
-*                           of VR, in the same order as their
-*                           eigenvalues.
-*          Not referenced if SIDE = 'L'.
-*
-*  LDVR    (input) INTEGER
-*          The leading dimension of the array VR.  LDVR >= 1, and if
-*          SIDE = 'R' or 'B'; LDVR >= N.
-*
-*  MM      (input) INTEGER
-*          The number of columns in the arrays VL and/or VR. MM >= M.
-*
-*  M       (output) INTEGER
-*          The number of columns in the arrays VL and/or VR actually
-*          used to store the eigenvectors.  If HOWMNY = 'A' or 'B', M
-*          is set to N.  Each selected eigenvector occupies one
-*          column.
-*
-*  WORK    (workspace) COMPLEX*16 array, dimension (2*N)
-*
-*  RWORK   (workspace) DOUBLE PRECISION array, dimension (N)
-*
-*  INFO    (output) INTEGER
-*          = 0:  successful exit
-*          < 0:  if INFO = -i, the i-th argument had an illegal value
-*
-*  Further Details
-*  ===============
-*
-*  The algorithm used in this program is basically backward (forward)
-*  substitution, with scaling to make the the code robust against
-*  possible overflow.
-*
-*  Each eigenvector is normalized so that the element of largest
-*  magnitude has magnitude 1; here the magnitude of a complex number
-*  (x,y) is taken to be |x| + |y|.
-*
-*  =====================================================================
-*
-*     .. Parameters ..
-      DOUBLE PRECISION   ZERO, ONE
-      PARAMETER          ( ZERO = 0.0D+0, ONE = 1.0D+0 )
-      COMPLEX*16         CMZERO, CMONE
-      PARAMETER          ( CMZERO = ( 0.0D+0, 0.0D+0 ),
-     $                   CMONE = ( 1.0D+0, 0.0D+0 ) )
-*     ..
-*     .. Local Scalars ..
-      LOGICAL            ALLV, BOTHV, LEFTV, OVER, RIGHTV, SOMEV
-      INTEGER            I, II, IS, J, K, KI
-      DOUBLE PRECISION   OVFL, REMAX, SCALE, SMIN, SMLNUM, ULP, UNFL
-      COMPLEX*16         CDUM
-*     ..
-*     .. External Functions ..
-      LOGICAL            LSAME
-      INTEGER            IZAMAX
-      DOUBLE PRECISION   DLAMCH, DZASUM
-      EXTERNAL           LSAME, IZAMAX, DLAMCH, DZASUM
-*     ..
-*     .. External Subroutines ..
-      EXTERNAL           XERBLA, ZCOPY, ZDSCAL, ZGEMV, ZLATRS
-*     ..
-*     .. Intrinsic Functions ..
-      INTRINSIC          ABS, DBLE, DCMPLX, DCONJG, DIMAG, MAX
-*     ..
-*     .. Statement Functions ..
-      DOUBLE PRECISION   CABS1
-*     ..
-*     .. Statement Function definitions ..
-      CABS1( CDUM ) = ABS( DBLE( CDUM ) ) + ABS( DIMAG( CDUM ) )
-*     ..
-*     .. Executable Statements ..
-*
-*     Decode and test the input parameters
-*
-      BOTHV = LSAME( SIDE, 'B' )
-      RIGHTV = LSAME( SIDE, 'R' ) .OR. BOTHV
-      LEFTV = LSAME( SIDE, 'L' ) .OR. BOTHV
-*
-      ALLV = LSAME( HOWMNY, 'A' )
-      OVER = LSAME( HOWMNY, 'B' )
-      SOMEV = LSAME( HOWMNY, 'S' )
-*
-*     Set M to the number of columns required to store the selected
-*     eigenvectors.
-*
-      IF( SOMEV ) THEN
-         M = 0
-         DO 10 J = 1, N
-            IF( SELECT( J ) )
-     $         M = M + 1
-   10    CONTINUE
-      ELSE
-         M = N
-      END IF
-*
-      INFO = 0
-      IF( .NOT.RIGHTV .AND. .NOT.LEFTV ) THEN
-         INFO = -1
-      ELSE IF( .NOT.ALLV .AND. .NOT.OVER .AND. .NOT.SOMEV ) THEN
-         INFO = -2
-      ELSE IF( N.LT.0 ) THEN
-         INFO = -4
-      ELSE IF( LDT.LT.MAX( 1, N ) ) THEN
-         INFO = -6
-      ELSE IF( LDVL.LT.1 .OR. ( LEFTV .AND. LDVL.LT.N ) ) THEN
-         INFO = -8
-      ELSE IF( LDVR.LT.1 .OR. ( RIGHTV .AND. LDVR.LT.N ) ) THEN
-         INFO = -10
-      ELSE IF( MM.LT.M ) THEN
-         INFO = -11
-      END IF
-      IF( INFO.NE.0 ) THEN
-         CALL XERBLA( 'ZTREVC', -INFO )
-         RETURN
-      END IF
-*
-*     Quick return if possible.
-*
-      IF( N.EQ.0 )
-     $   RETURN
-*
-*     Set the constants to control overflow.
-*
-      UNFL = DLAMCH( 'Safe minimum' )
-      OVFL = ONE / UNFL
-      CALL DLABAD( UNFL, OVFL )
-      ULP = DLAMCH( 'Precision' )
-      SMLNUM = UNFL*( N / ULP )
-*
-*     Store the diagonal elements of T in working array WORK.
-*
-      DO 20 I = 1, N
-         WORK( I+N ) = T( I, I )
-   20 CONTINUE
-*
-*     Compute 1-norm of each column of strictly upper triangular
-*     part of T to control overflow in triangular solver.
-*
-      RWORK( 1 ) = ZERO
-      DO 30 J = 2, N
-         RWORK( J ) = DZASUM( J-1, T( 1, J ), 1 )
-   30 CONTINUE
-*
-      IF( RIGHTV ) THEN
-*
-*        Compute right eigenvectors.
-*
-         IS = M
-         DO 80 KI = N, 1, -1
-*
-            IF( SOMEV ) THEN
-               IF( .NOT.SELECT( KI ) )
-     $            GO TO 80
-            END IF
-            SMIN = MAX( ULP*( CABS1( T( KI, KI ) ) ), SMLNUM )
-*
-            WORK( 1 ) = CMONE
-*
-*           Form right-hand side.
-*
-            DO 40 K = 1, KI - 1
-               WORK( K ) = -T( K, KI )
-   40       CONTINUE
-*
-*           Solve the triangular system:
-*              (T(1:KI-1,1:KI-1) - T(KI,KI))*X = SCALE*WORK.
-*
-            DO 50 K = 1, KI - 1
-               T( K, K ) = T( K, K ) - T( KI, KI )
-               IF( CABS1( T( K, K ) ).LT.SMIN )
-     $            T( K, K ) = SMIN
-   50       CONTINUE
-*
-            IF( KI.GT.1 ) THEN
-               CALL ZLATRS( 'Upper', 'No transpose', 'Non-unit', 'Y',
-     $                      KI-1, T, LDT, WORK( 1 ), SCALE, RWORK,
-     $                      INFO )
-               WORK( KI ) = SCALE
-            END IF
-*
-*           Copy the vector x or Q*x to VR and normalize.
-*
-            IF( .NOT.OVER ) THEN
-               CALL ZCOPY( KI, WORK( 1 ), 1, VR( 1, IS ), 1 )
-*
-               II = IZAMAX( KI, VR( 1, IS ), 1 )
-               REMAX = ONE / CABS1( VR( II, IS ) )
-               CALL ZDSCAL( KI, REMAX, VR( 1, IS ), 1 )
-*
-               DO 60 K = KI + 1, N
-                  VR( K, IS ) = CMZERO
-   60          CONTINUE
-            ELSE
-               IF( KI.GT.1 )
-     $            CALL ZGEMV( 'N', N, KI-1, CMONE, VR, LDVR, WORK( 1 ),
-     $                        1, DCMPLX( SCALE ), VR( 1, KI ), 1 )
-*
-               II = IZAMAX( N, VR( 1, KI ), 1 )
-               REMAX = ONE / CABS1( VR( II, KI ) )
-               CALL ZDSCAL( N, REMAX, VR( 1, KI ), 1 )
-            END IF
-*
-*           Set back the original diagonal elements of T.
-*
-            DO 70 K = 1, KI - 1
-               T( K, K ) = WORK( K+N )
-   70       CONTINUE
-*
-            IS = IS - 1
-   80    CONTINUE
-      END IF
-*
-      IF( LEFTV ) THEN
-*
-*        Compute left eigenvectors.
-*
-         IS = 1
-         DO 130 KI = 1, N
-*
-            IF( SOMEV ) THEN
-               IF( .NOT.SELECT( KI ) )
-     $            GO TO 130
-            END IF
-            SMIN = MAX( ULP*( CABS1( T( KI, KI ) ) ), SMLNUM )
-*
-            WORK( N ) = CMONE
-*
-*           Form right-hand side.
-*
-            DO 90 K = KI + 1, N
-               WORK( K ) = -DCONJG( T( KI, K ) )
-   90       CONTINUE
-*
-*           Solve the triangular system:
-*              (T(KI+1:N,KI+1:N) - T(KI,KI))'*X = SCALE*WORK.
-*
-            DO 100 K = KI + 1, N
-               T( K, K ) = T( K, K ) - T( KI, KI )
-               IF( CABS1( T( K, K ) ).LT.SMIN )
-     $            T( K, K ) = SMIN
-  100       CONTINUE
-*
-            IF( KI.LT.N ) THEN
-               CALL ZLATRS( 'Upper', 'Conjugate transpose', 'Non-unit',
-     $                      'Y', N-KI, T( KI+1, KI+1 ), LDT,
-     $                      WORK( KI+1 ), SCALE, RWORK, INFO )
-               WORK( KI ) = SCALE
-            END IF
-*
-*           Copy the vector x or Q*x to VL and normalize.
-*
-            IF( .NOT.OVER ) THEN
-               CALL ZCOPY( N-KI+1, WORK( KI ), 1, VL( KI, IS ), 1 )
-*
-               II = IZAMAX( N-KI+1, VL( KI, IS ), 1 ) + KI - 1
-               REMAX = ONE / CABS1( VL( II, IS ) )
-               CALL ZDSCAL( N-KI+1, REMAX, VL( KI, IS ), 1 )
-*
-               DO 110 K = 1, KI - 1
-                  VL( K, IS ) = CMZERO
-  110          CONTINUE
-            ELSE
-               IF( KI.LT.N )
-     $            CALL ZGEMV( 'N', N, N-KI, CMONE, VL( 1, KI+1 ), LDVL,
-     $                        WORK( KI+1 ), 1, DCMPLX( SCALE ),
-     $                        VL( 1, KI ), 1 )
-*
-               II = IZAMAX( N, VL( 1, KI ), 1 )
-               REMAX = ONE / CABS1( VL( II, KI ) )
-               CALL ZDSCAL( N, REMAX, VL( 1, KI ), 1 )
-            END IF
-*
-*           Set back the original diagonal elements of T.
-*
-            DO 120 K = KI + 1, N
-               T( K, K ) = WORK( K+N )
-  120       CONTINUE
-*
-            IS = IS + 1
-  130    CONTINUE
-      END IF
-*
-      RETURN
-*
-*     End of ZTREVC
-*
-      END