Numérotation des lignes :

C DSAUPD    SOURCE    GF238795  18/02/01    21:15:18     9724           c-----------------------------------------------------------------------c\BeginDoccc\Name: dsaupdcc\Description:cc  Reverse communication interface for the Implicitly Restarted Arnoldic  Iteration.  For symmetric problems this reduces to a variant of the Lanczosc  method.  This method has been designed to compute approximations to ac  few eigenpairs of a linear operator OP that is real and symmetricc  with respect to a real positive semi-definite symmetric matrix B,c  i.e.cc       B*OP = (OP)*B.cc  Another way to express this condition iscc       &lt; x,OPy > = &lt; OPx,y >  where &lt; z,w > = zBw  .cc  In the standard eigenproblem B is the identity matrix.c  ( A denotes transpose of A)cc  The computed approximate eigenvalues are called Ritz values andc  the corresponding approximate eigenvectors are called Ritz vectors.cc  dsaupd  is usually called iteratively to solve one of thec  following problems:cc  Mode 1:  A*x = lambda*x, A symmetricc           ===> OP = A  and  B = I.cc  Mode 2:  A*x = lambda*M*x, A symmetric, M symmetric positive definitec           ===> OP = inv[M]*A  and  B = M.c           ===> (If M can be factored see remark 3 below)cc  Mode 3:  K*x = lambda*M*x, K symmetric, M symmetric positive semi-definitec           ===> OP = (inv[K - sigma*M])*M  and  B = M.c           ===> Shift-and-Invert modecc  Mode 4:  K*x = lambda*KG*x, K symmetric positive semi-definite,c           KG symmetric indefinitec           ===> OP = (inv[K - sigma*KG])*K  and  B = K.c           ===> Buckling modecc  Mode 5:  A*x = lambda*M*x, A symmetric, M symmetric positive semi-definitec           ===> OP = inv[A - sigma*M]*[A + sigma*M]  and  B = M.c           ===> Cayley transformed modecc  NOTE: The action of w &lt;- inv[A - sigma*M]*v or w &lt;- inv[M]*vc        should be accomplished either by a direct methodc        using a sparse matrix factorization and solvingcc           [A - sigma*M]*w = v  or M*w = v,cc        or through an iterative method for solving thesec        systems.  If an iterative method is used, thec        convergence test must be more stringent thanc        the accuracy requirements for the eigenvaluec        approximations.cc\Usage:c  call dsaupdc     ( IDO, BMAT, N, WHICH, NEV, TOL, RESID, NCV, V, LDV, IPARAM,c       IPNTR, WORKD, WORKL, LWORKL, INFO )cc\Argumentsc  IDO     Integer.  (INPUT/OUTPUT)c          Reverse communication flag.  IDO must be zero on the firstc          call to dsaupd .  IDO will be set internally toc          indicate the type of operation to be performed.  Control isc          then given back to the calling routine which has thec          responsibility to carry out the requested operation and callc          dsaupd  with the result.  The operand is given inc          WORKD(IPNTR(1)), the result must be put in WORKD(IPNTR(2)).c          (If Mode = 2 see remark 5 below)c          -------------------------------------------------------------c          IDO =  0: first call to the reverse communication interfacec          IDO = -1: compute  Y = OP * X  wherec                    IPNTR(1) is the pointer into WORKD for X,c                    IPNTR(2) is the pointer into WORKD for Y.c                    This is for the initialization phase to force thec                    starting vector into the range of OP.c          IDO =  1: compute  Y = OP * X wherec                    IPNTR(1) is the pointer into WORKD for X,c                    IPNTR(2) is the pointer into WORKD for Y.c                    In mode 3,4 and 5, the vector B * X is alreadyc                    available in WORKD(ipntr(3)).  It does notc                    need to be recomputed in forming OP * X.c          IDO =  2: compute  Y = B * X  wherec                    IPNTR(1) is the pointer into WORKD for X,c                    IPNTR(2) is the pointer into WORKD for Y.c          IDO =  3: compute the IPARAM(8) shifts wherec                    IPNTR(11) is the pointer into WORKL forc                    placing the shifts. See remark 6 below.c          IDO = 99: donec          -------------------------------------------------------------cc  BMAT    Character*1.  (INPUT)c          BMAT specifies the type of the matrix B that defines thec          semi-inner product for the operator OP.c          B = 'I' -> standard eigenvalue problem A*x = lambda*xc          B = 'G' -> generalized eigenvalue problem A*x = lambda*B*xcc  N       Integer.  (INPUT)c          Dimension of the eigenproblem.cc  WHICH   Character*2.  (INPUT)c          Specify which of the Ritz values of OP to compute.cc          'LA' - compute the NEV largest (algebraic) eigenvalues.c          'SA' - compute the NEV smallest (algebraic) eigenvalues.c          'LM' - compute the NEV largest (in magnitude) eigenvalues.c          'SM' - compute the NEV smallest (in magnitude) eigenvalues.c          'BE' - compute NEV eigenvalues, half from each end of thec                 spectrum.  When NEV is odd, compute one more from thec                 high end than from the low end.c           (see remark 1 below)cc  NEV     Integer.  (INPUT)c          Number of eigenvalues of OP to be computed. 0 &lt; NEV &lt; N.cc  TOL     Double precision  scalar.  (INPUT)c          Stopping criterion: the relative accuracy of the Ritz valuec          is considered acceptable if BOUNDS(I) .LE. TOL*ABS(RITZ(I)).c          If TOL .LE. 0. is passed a default is set:c          DEFAULT = DLAMCH ('EPS')  (machine precision as computedc                    by the LAPACK auxiliary subroutine DLAMCH ).cc  RESID   Double precision  array of length N.  (INPUT/OUTPUT)c          On INPUT:c          If INFO .EQ. 0, a random initial residual vector is used.c          If INFO .NE. 0, RESID contains the initial residual vector,c                          possibly from a previous run.c          On OUTPUT:c          RESID contains the final residual vector.cc  NCV     Integer.  (INPUT)c          Number of columns of the matrix V (less than or equal to N).c          This will indicate how many Lanczos vectors are generatedc          at each iteration.  After the startup phase in which NEVc          Lanczos vectors are generated, the algorithm generatesc          NCV-NEV Lanczos vectors at each subsequent update iteration.c          Most of the cost in generating each Lanczos vector is in thec          matrix-vector product OP*x. (See remark 4 below).cc  V       REAL*8  N by NCV array.  (OUTPUT)c          The NCV columns of V contain the Lanczos basis vectors.cc  LDV     Integer.  (INPUT)c          Leading dimension of V exactly as declared in the callingc          program.cc  IPARAM  Integer array of length 11.  (INPUT/OUTPUT)c          IPARAM(1) = ISHIFT: method for selecting the implicit shifts.c          The shifts selected at each iteration are used to restartc          the Arnoldi iteration in an implicit fashion.c          -------------------------------------------------------------c          ISHIFT = 0: the shifts are provided by the user viac                      reverse communication.  The NCV eigenvalues ofc                      the current tridiagonal matrix T are returned inc                      the part of WORKL array corresponding to RITZ.c                      See remark 6 below.c          ISHIFT = 1: exact shifts with respect to the reducedc                      tridiagonal matrix T.  This is equivalent toc                      restarting the iteration with a starting vectorc                      that is a linear combination of Ritz vectorsc                      associated with the "wanted" Ritz values.c          -------------------------------------------------------------cc          IPARAM(2) = LEVECc          No longer referenced. See remark 2 below.cc          IPARAM(3) = MXITERc          On INPUT:  maximum number of Arnoldi update iterations allowed.c          On OUTPUT: actual number of Arnoldi update iterations taken.cc          IPARAM(4) = NB: blocksize to be used in the recurrence.c          The code currently works only for NB = 1.cc          IPARAM(5) = NCONV: number of "converged" Ritz values.c          This represents the number of Ritz values that satisfyc          the convergence criterion.cc          IPARAM(6) = IUPDc          No longer referenced. Implicit restarting is ALWAYS used.cc          IPARAM(7) = MODEc          On INPUT determines what type of eigenproblem is being solved.c          Must be 1,2,3,4,5; See under \Description of dsaupd  for thec          five modes available.cc          IPARAM(8) = NPc          When ido = 3 and the user provides shifts through reversec          communication (IPARAM(1)=0), dsaupd  returns NP, the numberc          of shifts the user is to provide. 0 &lt; NP &lt;=NCV-NEV. See Remarkc          6 below.cc          IPARAM(9) = NUMOP, IPARAM(10) = NUMOPB, IPARAM(11) = NUMREO,c          OUTPUT: NUMOP  = total number of OP*x operations,c                  NUMOPB = total number of B*x operations if BMAT='G',c                  NUMREO = total number of steps of re-orthogonalization.cc  IPNTR   Integer array of length 11.  (OUTPUT)c          Pointer to mark the starting locations in the WORKD and WORKLc          arrays for matrices/vectors used by the Lanczos iteration.c          -------------------------------------------------------------c          IPNTR(1): pointer to the current operand vector X in WORKD.c          IPNTR(2): pointer to the current result vector Y in WORKD.c          IPNTR(3): pointer to the vector B * X in WORKD when used inc                    the shift-and-invert mode.c          IPNTR(4): pointer to the next available location in WORKLc                    that is untouched by the program.c          IPNTR(5): pointer to the NCV by 2 tridiagonal matrix T in WORKL.c          IPNTR(6): pointer to the NCV RITZ values array in WORKL.c          IPNTR(7): pointer to the Ritz estimates in array WORKL associatedc                    with the Ritz values located in RITZ in WORKL.c          IPNTR(11): pointer to the NP shifts in WORKL. See Remark 6 below.cc          Note: IPNTR(8:10) is only referenced by dseupd . See Remark 2.c          IPNTR(8): pointer to the NCV RITZ values of the original system.c          IPNTR(9): pointer to the NCV corresponding error bounds.c          IPNTR(10): pointer to the NCV by NCV matrix of eigenvectorsc                     of the tridiagonal matrix T. Only referenced byc                     dseupd  if RVEC = .TRUE. See Remarks.c          -------------------------------------------------------------cc  WORKD   Double precision  work array of length 3*N.  (REVERSE COMMUNICATION)c          Distributed array to be used in the basic Arnoldi iterationc          for reverse communication.  The user should not use WORKDc          as temporary workspace during the iteration. Upon terminationc          WORKD(1:N) contains B*RESID(1:N). If the Ritz vectors are desiredc          subroutine dseupd  uses this output.c          See Data Distribution Note below.cc  WORKL   Double precision  work array of length LWORKL.  (OUTPUT/WORKSPACE)c          Private (replicated) array on each PE or array allocated onc          the front end.  See Data Distribution Note below.cc  LWORKL  Integer.  (INPUT)c          LWORKL must be at least NCV**2 + 8*NCV .cc  INFO    Integer.  (INPUT/OUTPUT)c          If INFO .EQ. 0, a randomly initial residual vector is used.c          If INFO .NE. 0, RESID contains the initial residual vector,c                          possibly from a previous run.c          Error flag on output.c          =  0: Normal exit.c          =  1: Maximum number of iterations taken.c                All possible eigenvalues of OP has been found. IPARAM(5)c                returns the number of wanted converged Ritz values.c          =  2: No longer an informational error. Deprecated startingc                with release 2 of ARPACK.c          =  3: No shifts could be applied during a cycle of thec                Implicitly restarted Arnoldi iteration. One possibilityc                is to increase the size of NCV relative to NEV.c                See remark 4 below.c          = -1: N must be positive.c          = -2: NEV must be positive.c          = -3: NCV must be greater than NEV and less than or equal to N.c          = -4: The maximum number of Arnoldi update iterations allowedc                must be greater than zero.c          = -5: WHICH must be one of 'LM', 'SM', 'LA', 'SA' or 'BE'.c          = -6: BMAT must be one of 'I' or 'G'.c          = -7: Length of private work array WORKL is not sufficient.c          = -8: Error return from trid. eigenvalue calculation;c                Informatinal error from LAPACK routine dsteqr .c          = -9: Starting vector is zero.c          = -10: IPARAM(7) must be 1,2,3,4,5.c          = -11: IPARAM(7) = 1 and BMAT = 'G' are incompatable.c          = -12: IPARAM(1) must be equal to 0 or 1.c          = -13: NEV and WHICH = 'BE' are incompatable.c          = -9999: Could not build an Arnoldi factorization.c                   IPARAM(5) returns the size of the current Arnoldic                   factorization. The user is advised to check thatc                   enough workspace and array storage has been allocated.ccc\Remarksc  1. The converged Ritz values are always returned in ascendingc     algebraic order.  The computed Ritz values are approximatec     eigenvalues of OP.  The selection of WHICH should be madec     with this in mind when Mode = 3,4,5.  After convergence,c     approximate eigenvalues of the original problem may be obtainedc     with the ARPACK subroutine dseupd .cc  2. If the Ritz vectors corresponding to the converged Ritz valuesc     are needed, the user must call dseupd  immediately following completionc     of dsaupd . This is new starting with version 2.1 of ARPACK.cc  3. If M can be factored into a Cholesky factorization M = LLc     then Mode = 2 should not be selected.  Instead one should usec     Mode = 1 with  OP = inv(L)*A*inv(L).  Appropriate triangularc     linear systems should be solved with L and L ratherc     than computing inverses.  After convergence, an approximatec     eigenvector z of the original problem is recovered by solvingc     Lz = x  where x is a Ritz vector of OP.cc  4. At present there is no a-priori analysis to guide the selectionc     of NCV relative to NEV.  The only formal requrement is that NCV > NEV.c     However, it is recommended that NCV .ge. 2*NEV.  If many problems ofc     the same type are to be solved, one should experiment with increasingc     NCV while keeping NEV fixed for a given test problem.  This willc     usually decrease the required number of OP*x operations but itc     also increases the work and storage required to maintain the orthogonalc     basis vectors.   The optimal "cross-over" with respect to CPU timec     is problem dependent and must be determined empirically.cc  5. If IPARAM(7) = 2 then in the Reverse commuication interface the userc     must do the following. When IDO = 1, Y = OP * X is to be computed.c     When IPARAM(7) = 2 OP = inv(B)*A. After computing A*X the userc     must overwrite X with A*X. Y is then the solution to the linear setc     of equations B*Y = A*X.cc  6. When IPARAM(1) = 0, and IDO = 3, the user needs to provide thec     NP = IPARAM(8) shifts in locations:c     1   WORKL(IPNTR(11))c     2   WORKL(IPNTR(11)+1)c                        .c                        .c                        .c     NP  WORKL(IPNTR(11)+NP-1).cc     The eigenvalues of the current tridiagonal matrix are located inc     WORKL(IPNTR(6)) through WORKL(IPNTR(6)+NCV-1). They are in thec     order defined by WHICH. The associated Ritz estimates are located inc     WORKL(IPNTR(8)), WORKL(IPNTR(8)+1), ... , WORKL(IPNTR(8)+NCV-1).cc-----------------------------------------------------------------------cc\Data Distribution Note:cc  Fortran-D syntax:c  ================c  REAL       RESID(N), V(LDV,NCV), WORKD(3*N), WORKL(LWORKL)c  DECOMPOSE  D1(N), D2(N,NCV)c  ALIGN      RESID(I) with D1(I)c  ALIGN      V(I,J)   with D2(I,J)c  ALIGN      WORKD(I) with D1(I)     range (1:N)c  ALIGN      WORKD(I) with D1(I-N)   range (N+1:2*N)c  ALIGN      WORKD(I) with D1(I-2*N) range (2*N+1:3*N)c  DISTRIBUTE D1(BLOCK), D2(BLOCK,:)c  REPLICATED WORKL(LWORKL)cc  Cray MPP syntax:c  ===============c  REAL       RESID(N), V(LDV,NCV), WORKD(N,3), WORKL(LWORKL)c  SHARED     RESID(BLOCK), V(BLOCK,:), WORKD(BLOCK,:)c  REPLICATED WORKL(LWORKL)ccc\BeginLibcc\References:c  1. D.C. Sorensen, "Implicit Application of Polynomial Filters inc     a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992),c     pp 357-385.c  2. R.B. Lehoucq, "Analysis and Implementation of an Implicitlyc     Restarted Arnoldi Iteration", Rice University Technical Reportc     TR95-13, Department of Computational and Applied Mathematics.c  3. B.N. Parlett, "The Symmetric Eigenvalue Problem". Prentice-Hall,c     1980.c  4. B.N. Parlett, B. Nour-Omid, "Towards a Black Box Lanczos Program",c     Computer Physics Communications, 53 (1989), pp 169-179.c  5. B. Nour-Omid, B.N. Parlett, T. Ericson, P.S. Jensen, "How toc     Implement the Spectral Transformation", Math. Comp., 48 (1987),c     pp 663-673.c  6. R.G. Grimes, J.G. Lewis and H.D. Simon, "A Shifted Block Lanczosc     Algorithm for Solving Sparse Symmetric Generalized Eigenproblems",c     SIAM J. Matr. Anal. Apps.,  January (1993).c  7. L. Reichel, W.B. Gragg, "Algorithm 686: FORTRAN Subroutinesc     for Updating the QR decomposition", ACM TOMS, December 1990,c     Volume 16 Number 4, pp 369-377.c  8. R.B. Lehoucq, D.C. Sorensen, "Implementation of Some Spectralc     Transformations in a k-Step Arnoldi Method". In Preparation.cc\Routines called:c     dsaup2   ARPACK routine that implements the Implicitly Restartedc             Arnoldi Iteration.c     dstats   ARPACK routine that initialize timing and other statisticsc             variables.c     ivout   ARPACK utility routine that prints integers.c     arscnd  ARPACK utility routine for timing.c     dvout    ARPACK utility routine that prints vectors.c     dlamch   LAPACK routine that determines machine constants.cc\Authorsc     Danny Sorensen               Phuong Vuc     Richard Lehoucq              CRPC / Rice Universityc     Dept. of Computational &     Houston, Texasc     Applied Mathematicsc     Rice Universityc     Houston, Texascc\Revision history:c     12/15/93: Version ' 2.4'cc\SCCS Information: @(#)c FILE: saupd.F   SID: 2.8   DATE OF SID: 04/10/01   RELEASE: 2cc\Remarksc     1. Nonecc\EndLibcc-----------------------------------------------------------------------c      subroutine dsaupd     &   ( ido, bmat, n, which, nev, tol, resid, ncv, v, ldv, iparam,     &     ipntr, workd, workl, lworkl, info )cc     %----------------------------------------------------%c     | Include files for debugging and timing information |-INC TARTRAKc     %----------------------------------------------------%ccc     %------------------%c     | Scalar Arguments |c     %------------------%c      character  bmat*1, which*2      integer    ido, info, ldv, lworkl, n, ncv, nev      REAL*8     &           tol      real*8     T0,T1cc     %-----------------%c     | Array Arguments |c     %-----------------%c      integer    iparam(11), ipntr(11)      REAL*8     &           resid(n), v(ldv,ncv), workd(3*n), workl(lworkl)cc     %------------%c     | Parameters |c     %------------%c      REAL*8     &           one, zero      parameter (one = 1.0D+0 , zero = 0.0D+0 )cc     %---------------%c     | Local Scalars |c     %---------------%c      integer    bounds, ierr, ih, iq, ishift, iupd, iw,     &           ldh, ldq, msglvl, mxiter, mode, nb,     &           nev0, next, np, ritz, j      save       bounds, ierr, ih, iq, ishift, iupd, iw,     &           ldh, ldq, msglvl, mxiter, mode, nb,     &           nev0, next, np, ritzcc     %----------------------%c     | External Subroutines |c     %----------------------%c      external   dsaup2 ,  dvout , ivout, arscnd, dstatscc     %--------------------%c     | External Functions |c     %--------------------%c      REAL*8     &           dlamch      external   dlamchcc     %-----------------------%c     | Executable Statements |c     %-----------------------%      T0=0.D0      T1=0.D0c      if (ido .eq. 0) thencc        %-------------------------------%c        | Initialize timing statistics  |c        | & message level for debugging |c        %-------------------------------%c         call dstats*         call arscnd (t0)         msglvl = msaupdc         ierr   = 0         ishift = iparam(1)         mxiter = iparam(3)c         nb     = iparam(4)         nb     = 1cc        %--------------------------------------------%c        | Revision 2 performs only implicit restart. |c        %--------------------------------------------%c         iupd   = 1         mode   = iparam(7)cc        %----------------%c        | Error checking |c        %----------------%c         if (n .le. 0) then            ierr = -1         else if (nev .le. 0) then            ierr = -2         else if (ncv .le. nev .or.  ncv .gt. n) then            ierr = -3         end ifcc        %----------------------------------------------%c        | NP is the number of additional steps to      |c        | extend the length NEV Lanczos factorization. |c        %----------------------------------------------%c         np     = ncv - nevc         if (mxiter .le. 0)                     ierr = -4         if (which .ne. 'LM' .and.     &       which .ne. 'SM' .and.     &       which .ne. 'LA' .and.     &       which .ne. 'SA' .and.     &       which .ne. 'BE')                   ierr = -5         if (bmat .ne. 'I' .and. bmat .ne. 'G') ierr = -6c         if (lworkl .lt. ncv**2 + 8*ncv)        ierr = -7         if (mode .lt. 1 .or. mode .gt. 5) then                                                ierr = -10         else if (mode .eq. 1 .and. bmat .eq. 'G') then                                                ierr = -11         else if (ishift .lt. 0 .or. ishift .gt. 1) then                                                ierr = -12         else if (nev .eq. 1 .and. which .eq. 'BE') then                                                ierr = -13         end ifcc        %------------%c        | Error Exit |c        %------------%c         if (ierr .ne. 0) then            info = ierr            ido  = 99            go to 9000         end ifcc        %------------------------%c        | Set default parameters |c        %------------------------%c         if (nb .le. 0)                         nb = 1         if (tol .le. zero)                     tol = dlamch ('EpsMach')cc        %----------------------------------------------%c        | NP is the number of additional steps to      |c        | extend the length NEV Lanczos factorization. |c        | NEV0 is the local variable designating the   |c        | size of the invariant subspace desired.      |c        %----------------------------------------------%c         np     = ncv - nev         nev0   = nevcc        %-----------------------------%c        | Zero out internal workspace |c        %-----------------------------%c         do 10 j = 1, ncv**2 + 8*ncv            workl(j) = zero 10      continuecc        %-------------------------------------------------------%c        | Pointer into WORKL for address of H, RITZ, BOUNDS, Q  |c        | etc... and the remaining workspace.                   |c        | Also update pointer to be used on output.             |c        | Memory is laid out as follows:                        |c        | workl(1:2*ncv) := generated tridiagonal matrix        |c        | workl(2*ncv+1:2*ncv+ncv) := ritz values               |c        | workl(3*ncv+1:3*ncv+ncv) := computed error bounds     |c        | workl(4*ncv+1:4*ncv+ncv*ncv) := rotation matrix Q     |c        | workl(4*ncv+ncv*ncv+1:7*ncv+ncv*ncv) := workspace     |c        %-------------------------------------------------------%c         ldh    = ncv         ldq    = ncv         ih     = 1         ritz   = ih     + 2*ldh         bounds = ritz   + ncv         iq     = bounds + ncv         iw     = iq     + ncv**2         next   = iw     + 3*ncvc         ipntr(4) = next         ipntr(5) = ih         ipntr(6) = ritz         ipntr(7) = bounds         ipntr(11) = iw      end ifcc     %-------------------------------------------------------%c     | Carry out the Implicitly restarted Lanczos Iteration. |c     %-------------------------------------------------------%c      call dsaup2     &   ( ido, bmat, n, which, nev0, np, tol, resid, mode, iupd,     &     ishift, mxiter, v, ldv, workl(ih), ldh, workl(ritz),     &     workl(bounds), workl(iq), ldq, workl(iw), ipntr, workd,     &     info )cc     %--------------------------------------------------%c     | ido .ne. 99 implies use of reverse communication |c     | to compute operations involving OP or shifts.    |c     %--------------------------------------------------%c      if (ido .eq. 3) iparam(8) = np      if (ido .ne. 99) go to 9000c      iparam(3) = mxiter      iparam(5) = np      iparam(9) = nopx      iparam(10) = nbx      iparam(11) = nrorthcc     %------------------------------------%c     | Exit if there was an informational |c     | error within dsaup2 .               |c     %------------------------------------%c      if (info .lt. 0) go to 9000      if (info .eq. 2) info = 3c      if (msglvl .gt. 0) then         call ivout (logfil, 1, mxiter, ndigit,     &               '_saupd: number of update iterations taken')         call ivout (logfil, 1, np, ndigit,     &               '_saupd: number of "converged" Ritz values')         call dvout  (logfil, np, workl(Ritz), ndigit,     &               '_saupd: final Ritz values')         call dvout  (logfil, np, workl(Bounds), ndigit,     &               '_saupd: corresponding error bounds')      end ifc*      call arscnd (t1)      tsaupd = t1 - t0c      if (msglvl .gt. 0) thencc        %--------------------------------------------------------%c        | Version Number & Version Date are defined in version.h |c        %--------------------------------------------------------%c         write (6,1000)         write (6,1100) mxiter, nopx, nbx, nrorth, nitref, nrstrt,     &                  tmvopx, tmvbx, tsaupd, tsaup2, tsaitr, titref,     &                  tgetv0, tseigt, tsgets, tsapps, tsconv 1000    format (//,     &      5x, '==========================================',/     &      5x, '= Symmetric implicit Arnoldi update code =',/     &      5x, '= Version Number:', ' 2.4' , 19x, ' =',/     &      5x, '= Version Date:  ', ' 07/31/96' , 14x, ' =',/     &      5x, '==========================================',/     &      5x, '= Summary of timing statistics           =',/     &      5x, '==========================================',//) 1100    format (     &      5x, 'Total number update iterations             = ', i5,/     &      5x, 'Total number of OP*x operations            = ', i5,/     &      5x, 'Total number of B*x operations             = ', i5,/     &      5x, 'Total number of reorthogonalization steps  = ', i5,/     &      5x, 'Total number of iterative refinement steps = ', i5,/     &      5x, 'Total number of restart steps              = ', i5,/     &      5x, 'Total time in user OP*x operation          = ', f12.6,/     &      5x, 'Total time in user B*x operation           = ', f12.6,/     &      5x, 'Total time in Arnoldi update routine       = ', f12.6,/     &      5x, 'Total time in saup2 routine                = ', f12.6,/     &      5x, 'Total time in basic Arnoldi iteration loop = ', f12.6,/     &      5x, 'Total time in reorthogonalization phase    = ', f12.6,/     &      5x, 'Total time in (re)start vector generation  = ', f12.6,/     &      5x, 'Total time in trid eigenvalue subproblem   = ', f12.6,/     &      5x, 'Total time in getting the shifts           = ', f12.6,/     &      5x, 'Total time in applying the shifts          = ', f12.6,/     &      5x, 'Total time in convergence testing          = ', f12.6)      end ifc 9000 continuec      returncc     %---------------%c     | End of dsaupd  |c     %---------------%c      end   `

© Cast3M 2003 - Tous droits réservés.
Mentions légales