NAG Toolbox: nag_sparseig_real_symm_proc (f12fc)

Purpose

Syntax

Description

References

Parameters

Compulsory Input Parameters

1:     $\mathrm{sigma}$ – double scalar

If one of the Shifted Inverse (see nag_sparseig_real_symm_option (f12fd)) modes has been selected then sigma contains the real shift used; otherwise sigma is not referenced.

2:     $\mathrm{resid}\left(:\right)$ – double array

The dimension of the array resid must be at least $\mathbf{n}$ (see nag_sparseig_real_symm_init (f12fa))

Must not be modified following a call to nag_sparseig_real_symm_iter (f12fb) since it contains data required by nag_sparseig_real_symm_proc (f12fc).

3:     $\mathrm{v}\left(\mathit{ldv},:\right)$ – double array

The first dimension of the array v must be at least $n$.

The second dimension of the array v must be at least $\max \left(1,\mathbf{ncv}\right)$.

The ncv columns of v contain the Lanczos basis vectors for $\mathrm{OP}$ as constructed by nag_sparseig_real_symm_iter (f12fb).

4:     $\mathrm{comm}\left(:\right)$ – double array

The dimension of the array comm must be at least $\max \left(1,\mathbf{lcomm}\right)$ (see nag_sparseig_real_symm_init (f12fa))

On initial entry: must remain unchanged from the prior call to nag_sparseig_real_symm_init (f12fa).

5:     $\mathrm{icomm}\left(:\right)$ – int64int32nag_int array

The dimension of the array icomm must be at least $\max \left(1,\mathbf{licomm}\right)$ (see nag_sparseig_real_symm_init (f12fa))

On initial entry: must remain unchanged from the prior call to nag_sparseig_real_symm_init (f12fa).

Optional Input Parameters

None.

Output Parameters

1:     $\mathrm{nconv}$ – int64int32nag_int scalar

The number of converged eigenvalues as found by nag_sparseig_real_symm_iter (f12fb).

2:     $\mathrm{d}\left(:\right)$ – double array

The dimension of the array d will be $\mathbf{ncv}$ (see nag_sparseig_real_symm_init (f12fa))

The first nconv locations of the array d contain the converged approximate eigenvalues.

3:     $\mathrm{z}\left(\mathbf{n}\times \left(\mathbf{nev}+1\right)\right)$ – double array

If the default option $\mathbf{Vectors}=\mathrm{RITZ}$ (see nag_sparseig_real_symm_option (f12fd)) has been selected then z contains the final set of eigenvectors corresponding to the eigenvalues held in d. The real eigenvector associated with an eigenvalue is stored in the corresponding column of z.

4:     $\mathrm{v}\left(\mathit{ldv},:\right)$ – double array

The first dimension of the array v will be $n$.

The second dimension of the array v will be $\max \left(1,\mathbf{ncv}\right)$.

If the option $\mathbf{Vectors}=\mathrm{SCHUR}$ has been set, or the option $\mathbf{Vectors}=\mathrm{RITZ}$ has been set and a separate array z has been passed (i.e., z does not equal v), then the first nconv columns of v will contain approximate Schur vectors that span the desired invariant subspace.

5:     $\mathrm{comm}\left(:\right)$ – double array

The dimension of the array comm will be $\max \left(1,\mathbf{lcomm}\right)$ (see nag_sparseig_real_symm_init (f12fa))

Contains data on the current state of the solution.

6:     $\mathrm{icomm}\left(:\right)$ – int64int32nag_int array

The dimension of the array icomm will be $\max \left(1,\mathbf{licomm}\right)$ (see nag_sparseig_real_symm_init (f12fa))

Contains data on the current state of the solution.

7:     $\mathrm{ifail}$ – int64int32nag_int scalar

$\mathbf{ifail}=\mathbf{0}$ unless the function detects an error (see Error Indicators and Warnings).

Error Indicators and Warnings

   $\mathbf{ifail}=1$

On entry, $\mathit{ldz}<\max \left(1,\mathbf{n}\right)$ or $\mathit{ldz}<1$ when no vectors are required.

   $\mathbf{ifail}=2$

On entry, the option $\mathbf{Vectors}=\text{Select}$ was selected, but this is not yet implemented.

   $\mathbf{ifail}=3$

The number of eigenvalues found to sufficient accuracy prior to calling nag_sparseig_real_symm_proc (f12fc), as communicated through the argument icomm, is zero.

   $\mathbf{ifail}=4$

The number of converged eigenvalues as calculated by nag_sparseig_real_symm_iter (f12fb) differ from the value passed to it through the argument icomm.

   $\mathbf{ifail}=5$

Unexpected error during calculation of a tridiagonal form: there was a failure to compute all the converged eigenvalues. Please contact NAG.

   $\mathbf{ifail}=6$

The function was unable to dynamically allocate sufficient internal workspace. Please contact NAG.

   $\mathbf{ifail}=7$

An unexpected error has occurred. Please contact NAG.

   $\mathbf{ifail}=-99$

An unexpected error has been triggered by this routine. Please contact NAG.

   $\mathbf{ifail}=-399$

Your licence key may have expired or may not have been installed correctly.

   $\mathbf{ifail}=-999$

Dynamic memory allocation failed.

Accuracy

Further Comments

Example

Open in the MATLAB editor: f12fc_example

function f12fc_example


fprintf('f12fc example results\n\n');

n   = int64(100);
nev = int64(4);
ncv = int64(10);
imon = 0;

irevcm = int64(0);
resid = ones(n,1);
v     = zeros(n,ncv);
x     = zeros(n,1);
mx    = zeros(n,1);

sigma = 0;

% Setup and factorize B
h   = 1/double(n+1);
ad(1:n)  = 4*h/6;
adl(1:n) = h/6;
adu(1:n) = adl(1:n);

[adl, ad, adu, adu2, ipiv, info] = f07cd( ...
                                          adl, ad, adu);

% Initialisation Step
[icomm, comm, ifail] = f12fa( ...
                              n, nev, ncv);

% Set Optional Parameters
[icomm, comm, ifail] = f12fd( ...
                              'Generalized', icomm, comm);
% Solve
while (irevcm ~= 5)
  [irevcm, resid, v, x, mx, nshift, comm, icomm, ifail] = ...
  f12fb( ...
         irevcm, resid, v, x, mx, comm, icomm);
  if (irevcm == 1 || irevcm == -1)
    % Solve By = Ax
    mx = f12fc_Ax(n, x);
    [x, info] = f07ce( ...
                       'N', adl, ad, adu, adu2, ipiv, mx);
  elseif (irevcm == 2)
    % y = Bx
    mx = f12fc_Bx(n, x);
  elseif (irevcm == 4 && imon==1)
    [niter, nconv, ritz, rzest] = ...
    f12fe(icomm, comm);

    fprintf(['Iteration %2d, No. converged = %d, ', ...
             'norm of estimates = %10.2e\n'], ...
            niter, nconv, norm(rzest(1:nev),2));
  end
end

% Post-process to compute eigenvalues/vectors
[nconv, d, z, v, comm, icomm, ifail] = ...
f12fc( ...
       sigma, resid, v, comm, icomm);

fprintf('Largest %d Eigenvalues are:\n',nconv);
fprintf('%10.1f\n',d(1:nconv));



function [y] = f12fc_Ax(n, x)

  y = zeros(n,1);
  h = 1/double(n+1);

  y(1) = 2*x(1) - x(2);
  for j=2:n-1
    y(j) = -x(j-1) + 2*x(j) - x(j+1);
  end
  y(n) = -x(n-1) + 2*x(n);
  y = y/h;

function [y] = f12fc_Bx(n,x)

  y = zeros(n,1);
  h = 1/(6*double(n+1));

  y(1) = 4*x(1) + x(2);
  for j=2:n-1
    y(j) = x(j-1) + 4*x(j) + x(j+1);
  end
  y(n) = x(n-1) + 4*x(n);
  y = y*h;

f12fc example results

Largest 4 Eigenvalues are:
  121003.5
  121616.6
  122057.5
  122323.2