Parameters

NOTE: The remaining arguments BMAT, N, WHICH, NEV, TOL, RESID, NCV, V, IPARAM, IPNTR, WORKD, WORKL, LWORKL, RWORK, INFO must be passed directly to ZNEUPD following the last call to ZNAUPD.

These arguments MUST NOT BE MODIFIED between the the last call to ZNAUPD and the call to ZNEUPD.

Three of these parameters (V, WORKL and INFO) are also output parameters.

Description

This subroutine returns the converged approximations to eigenvalues of A*z = lambda*B*z and (optionally):

There is negligible additional cost to obtain eigenvectors. An orthonormal basis is always computed.

There is an additional storage cost of n*nev if both are requested (in this case a separate array Z must be supplied).

The approximate eigenvalues and eigenvectors of A*z = lambda*B*z are derived from approximate eigenvalues and eigenvectors of of the linear operator OP prescribed by the MODE selection in the call to ZNAUPD.

ZNAUPD must be called before this routine is called.

These approximate eigenvalues and vectors are commonly called Ritz values and Ritz vectors respectively. They are referred to as such in the comments that follow.

The computed orthonormal basis for the invariant subspace corresponding to these Ritz values is referred to as a Schur basis.

The definition of OP as well as other terms and the relation of computed Ritz values and vectors of OP with respect to the given problem A*z = lambda*B*z may be found in the header of ZNAUPD. For a brief description, see definitions of IPARAM(7), MODE and WHICH in the documentation of ZNAUPD.

Remarks

Example

 
// The following sets dimensions for this problem.

nx    = 10;

nev   = 3;
ncv   = 6;
bmat  = 'I';
which = 'LM';

maxiter = 10;

// Local Arrays

iparam  = zeros(11,1);
ipntr   = zeros(14,1);
_select = zeros(ncv,1);
d       = zeros(nev+1,1);
resid   = zeros(nx,1) + 0*%i; 
v       = zeros(nx,ncv) + 0*%i;
workd   = zeros(3*nx+1,1) + 0*%i; 
workev  = zeros(3*ncv,1);
rwork   = zeros(ncv,1);
workl   = zeros(3*ncv*ncv+5*ncv,1) + 0*%i;

// Build the complex test matrix
A            = diag(10*ones(nx,1)+%i*ones(nx,1));
A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(nx-1,1));
A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(nx-1,1));

tol    = 0;
ido    = 0;

ishfts = 1;
maxitr = 300;
mode1  = 1;

iparam(1) = ishfts;
iparam(3) = maxitr;
iparam(7) = mode1;

sigma = 0; // the real part of the shift

// M A I N   L O O P (Reverse communication)

iter = 0;
while(iter<maxiter)
  info_znaupd = 0;
  iter = iter + 1;
  // Repeatedly call the routine ZNAUPD and take actions indicated by parameter IDO until
  // either convergence is indicated or maxitr has been exceeded.

  [ido,resid,v,iparam,ipntr,workd,workl,info_znaupd] = znaupd(ido,bmat,nx,which,nev,tol,resid,ncv,v,iparam,ipntr,workd,workl,rwork,info_znaupd);
  
  if (ido==99) then
    // BE CAREFUL: DON'T CALL zneupd IF ido == 99 !!
    break;
  end
  
  if (ido==-1 | ido==1) then
    // Perform matrix vector multiplication 
    workd(ipntr(2)+1:ipntr(2)+nx) = A*workd(ipntr(1)+1:ipntr(1)+nx);
    // L O O P   B A C K to call ZNAUPD again.
    continue
  end
  
  if (info_znaupd < 0) then
    printf('\nError with znaupd, info = %d\n',info_znaupd);
    printf('Check the documentation of znaupd\n\n');
  else 
    // Post-Process using ZNEUPD.

    rvec    = 1;
    howmany = 'A';

    info_zneupd = 0;

    [d,d(1,2),v,resid,v,iparam,ipntr,workd,workl,info_zneupd] = zneupd(rvec,howmany,_select,d,d(1,2),v,sigma,workev, ...
                                                                       bmat,nx,which,nev,tol,resid,ncv,v, ...
                                                                       iparam,ipntr,workd,workl,info_zneupd);

    if (info_zneupd~=0) then
      printf('\nError with zneupd, info = %d\n', info_zneupd);
      printf('Check the documentation of zneupd.\n\n');
    end

    if (info_zneupd==1) then
      printf('\nMaximum number of iterations reached.\n\n');
    elseif (info_zneupd==3) then
      printf('\nNo shifts could be applied during implicit Arnoldi update, try increasing NCV.\n\n');
    end
  end
end

// Done with program znsimp.
printf('\nZNSIMP\n');
printf('======\n');
printf('\n');
printf('Iterations is %d\n', iter);
printf('Size of the matrix is %d\n', nx);
printf('The number of Ritz values requested is %d\n', nev);
printf('The number of Arnoldi vectors generated (NCV) is %d\n', ncv);
printf('What portion of the spectrum: %s\n', which);
printf('The number of Implicit Arnoldi update iterations taken is %d\n', iparam(3));
printf('The number of OP*x is %d\n', iparam(9));
printf('The convergence criterion is %d\n', tol);
 

      

See Also

Authors

Bibliography

1. D.C. Sorensen, "Implicit Application of Polynomial Filters in a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992), pp 357-385.

2. R.B. Lehoucq, "Analysis and Implementation of an Implicitly Restarted Arnoldi Iteration", Rice University Technical Report TR95-13, Department of Computational and Applied Mathematics.

3. B.N. Parlett and Y. Saad, "Complex Shift and Invert Strategies for Real Matrices", Linear Algebra and its Applications, vol 88/89, pp 575-595, (1987).

Used Functions

Based on ARPACK routine zneupd