PDF version (NAG web site
, 64bit version, 64bit version)
NAG Toolbox: nag_sparseig_real_symm_option (f12fd)
Purpose
nag_sparseig_real_symm_option (f12fd) is an option setting function in a suite of functions consisting of
nag_sparseig_real_symm_init (f12fa),
nag_sparseig_real_symm_iter (f12fb),
nag_sparseig_real_symm_proc (f12fc),
nag_sparseig_real_symm_option (f12fd) and
nag_sparseig_real_symm_monit (f12fe), and may be used to supply individual optional parameters to
nag_sparseig_real_symm_iter (f12fb) and
nag_sparseig_real_symm_proc (f12fc). The initialization function
nag_sparseig_real_symm_init (f12fa) must have been called prior to calling
nag_sparseig_real_symm_option (f12fd).
Syntax
Description
nag_sparseig_real_symm_option (f12fd) may be used to supply values for optional parameters to
nag_sparseig_real_symm_iter (f12fb) and
nag_sparseig_real_symm_proc (f12fc). It is only necessary to call
nag_sparseig_real_symm_option (f12fd) for those parameters whose values are to be different from their default values. One call to
nag_sparseig_real_symm_option (f12fd) sets one parameter value.
Each optional parameter is defined by a single character string consisting of one or more items. The items associated with a given option must be separated by spaces, or equals signs
[ = ]
$[=]$. Alphabetic characters may be upper or lower case. The string
'Pointers = Yes'
is an example of a string used to set an optional parameter. For each option the string contains one or more of the following items:
– 
a mandatory keyword; 
– 
a phrase that qualifies the keyword; 
– 
a number that specifies an integer or double value. Such numbers may be up to 16$16$ contiguous characters in
Fortran's I, F, E or D format.

nag_sparseig_real_symm_option (f12fd) does not have an equivalent function from the ARPACK package which passes options by directly setting values to scalar parameters or to specific elements of array arguments.
nag_sparseig_real_symm_option (f12fd) is intended to make the passing of options more transparent and follows the same principle as the single option setting functions in
Chapter E04.
The setup function
nag_sparseig_real_symm_init (f12fa) must be called prior to the first call to
nag_sparseig_real_symm_option (f12fd) and all calls to
nag_sparseig_real_symm_option (f12fd) must precede the first call to
nag_sparseig_real_symm_iter (f12fb), the reverse communication iterative solver.
A complete list of optional parameters, their abbreviations, synonyms and default values is given in
Section [Optional Parameters].
References
Lehoucq R B (2001) Implicitly restarted Arnoldi methods and subspace iteration SIAM Journal on Matrix Analysis and Applications 23 551–562
Lehoucq R B and Scott J A (1996) An evaluation of software for computing eigenvalues of sparse nonsymmetric matrices Preprint MCSP5471195 Argonne National Laboratory
Lehoucq R B and Sorensen D C (1996) Deflation techniques for an implicitly restarted Arnoldi iteration SIAM Journal on Matrix Analysis and Applications 17 789–821
Lehoucq R B, Sorensen D C and Yang C (1998) ARPACK Users' Guide: Solution of Largescale Eigenvalue Problems with Implicitly Restarted Arnoldi Methods SIAM, Philidelphia
Parameters
Compulsory Input Parameters
 1:
str – string
A single valid option string (as described in
Section [Description] and
Section [Optional Parameters]).
 2:
icomm( : $:$) – int64int32nag_int array

Note: the dimension of the array
icomm
must be at least
max (1,licomm)$\mathrm{max}\phantom{\rule{0.125em}{0ex}}(1,{\mathbf{licomm}})$ (see
nag_sparseig_real_symm_init (f12fa)).
On initial entry: must remain unchanged following a call to the setup function
nag_sparseig_real_symm_init (f12fa).
 3:
comm( : $:$) – double array

Note: the dimension of the array
comm
must be at least
60$60$.
On initial entry: must remain unchanged following a call to the setup function
nag_sparseig_real_symm_init (f12fa).
Optional Input Parameters
None.
Input Parameters Omitted from the MATLAB Interface
None.
Output Parameters
 1:
icomm( : $:$) – int64int32nag_int array

Note: the dimension of the array
icomm
must be at least
max (1,licomm)$\mathrm{max}\phantom{\rule{0.125em}{0ex}}(1,{\mathbf{licomm}})$ (see
nag_sparseig_real_symm_init (f12fa)).
Contains data on the current options set.
 2:
comm( : $:$) – double array

Note: the dimension of the array
comm
must be at least
60$60$.
Contains data on the current options set.
 3:
ifail – int64int32nag_int scalar
ifail = 0${\mathrm{ifail}}={\mathbf{0}}$ unless the function detects an error (see
[Error Indicators and Warnings]).
Error Indicators and Warnings
Errors or warnings detected by the function:
 ifail = 1${\mathbf{ifail}}=1$
The string passed in
str contains an ambiguous keyword.
 ifail = 2${\mathbf{ifail}}=2$
The string passed in
str contains a keyword that could not be recognized.
 ifail = 3${\mathbf{ifail}}=3$
The string passed in
str contains a second keyword that could not be recognized.
 ifail = 4${\mathbf{ifail}}=4$
The initialization function
nag_sparseig_real_symm_init (f12fa) has not been called or a communication array has become corrupted.
Accuracy
Not applicable.
Further Comments
None.
Example
Open in the MATLAB editor:
nag_sparseig_real_symm_option_example
function nag_sparseig_real_symm_option_example
n = int64(100);
nx = int64(10);
nev = int64(4);
ncv = int64(10);
irevcm = int64(0);
resid = zeros(100,1);
v = zeros(100,20);
x = zeros(100,1);
mx = zeros(100,1);
sigma = 0;
[icomm, comm, ifail] = nag_sparseig_real_symm_init(n, nev, ncv);
[icomm, comm, ifail] = ...
nag_sparseig_real_symm_option('SMALLEST MAGNITUDE', icomm, comm);
while (irevcm ~= 5)
[irevcm, resid, v, x, mx, nshift, comm, icomm, ifail] = ...
nag_sparseig_real_symm_iter(irevcm, resid, v, x, mx, comm, icomm);
if (irevcm == 1  irevcm == 1)
x = f12f_av(nx, x);
elseif (irevcm == 4)
[niter, nconv, ritz, rzest] = nag_sparseig_real_symm_monit(icomm, comm);
fprintf('Iteration %d, No. converged = %d, norm of estimates = %16.8g\n', ...
niter, nconv, norm(rzest(1:double(nev)),2));
end
end
[nconv, d, z, v, comm, icomm, ifail] = ...
nag_sparseig_real_symm_proc(sigma, resid, v, comm, icomm);
nconv, d(1:double(nconv)), ifail
function [w] = f12f_av(nx, v)
inx = double(nx); % nx is int64
w = zeros(inx*inx,1);
h2 = 1/double((inx+1)^2);
w(1:inx) = tv(inx, v(1:inx));
w(1:inx) = v(inx+1:2*inx)+w(1:inx);
for j=2:double(inx1)
lo = (j1)*inx +1;
hi = j*inx;
w(lo:hi) = tv(inx, v(lo:hi));
w(lo:hi) = v(loinx:lo1)+w(lo:hi);
w(lo:hi) = v(hi+1:hi+inx)+w(lo:hi);
end
lo = (inx1)*inx +1;
hi = inx*inx;
w(lo:hi) = tv(inx, v(lo:hi));
w(lo:hi) = v(loinx:lo1)+w(lo:hi);
w = w/h2;
function [y] = tv(inx,x)
y = zeros(inx,1);
dd = 4;
dl = 1;
du = 1;
y(1) = dd*x(1) + du*x(2);
for j=2:double(inx1)
y(j) = dl*x(j1) + dd*x(j) + du*x(j+1);
end
y(inx) = dl*x(inx1) + dd*x(inx);
Iteration 1, No. converged = 0, norm of estimates = 81.010211
Iteration 2, No. converged = 0, norm of estimates = 45.634095
Iteration 3, No. converged = 0, norm of estimates = 42.747772
Iteration 4, No. converged = 0, norm of estimates = 8.6106757
Iteration 5, No. converged = 0, norm of estimates = 0.71330195
Iteration 6, No. converged = 0, norm of estimates = 0.15050738
Iteration 7, No. converged = 0, norm of estimates = 0.015776765
Iteration 8, No. converged = 0, norm of estimates = 0.0038996544
Iteration 9, No. converged = 0, norm of estimates = 0.0004324447
Iteration 10, No. converged = 0, norm of estimates = 0.00011026365
Iteration 11, No. converged = 0, norm of estimates = 1.2358564e05
Iteration 12, No. converged = 0, norm of estimates = 3.1712519e06
Iteration 13, No. converged = 1, norm of estimates = 3.5636599e07
Iteration 14, No. converged = 1, norm of estimates = 4.2416167e08
Iteration 15, No. converged = 1, norm of estimates = 1.3069836e08
Iteration 16, No. converged = 1, norm of estimates = 5.5204749e10
Iteration 17, No. converged = 1, norm of estimates = 8.0102311e11
Iteration 18, No. converged = 1, norm of estimates = 1.9788954e10
Iteration 19, No. converged = 2, norm of estimates = 3.1175144e09
Iteration 20, No. converged = 2, norm of estimates = 3.0499643e08
Iteration 21, No. converged = 2, norm of estimates = 2.2545794e08
Iteration 22, No. converged = 2, norm of estimates = 3.8803659e09
Iteration 23, No. converged = 2, norm of estimates = 4.3299036e10
Iteration 24, No. converged = 2, norm of estimates = 1.9559537e10
Iteration 25, No. converged = 2, norm of estimates = 1.3956205e12
Iteration 26, No. converged = 2, norm of estimates = 6.7447903e13
Iteration 27, No. converged = 2, norm of estimates = 6.4140406e14
Iteration 28, No. converged = 2, norm of estimates = 8.9020339e15
Iteration 29, No. converged = 3, norm of estimates = 3.8266142e15
Iteration 30, No. converged = 3, norm of estimates = 1.3296741e16
nconv =
4
ans =
19.6054
48.2193
48.2193
76.8333
ifail =
0
Open in the MATLAB editor:
f12fd_example
function f12fd_example
n = int64(100);
nx = int64(10);
nev = int64(4);
ncv = int64(10);
irevcm = int64(0);
resid = zeros(100,1);
v = zeros(100,20);
x = zeros(100,1);
mx = zeros(100,1);
sigma = 0;
[icomm, comm, ifail] = f12fa(n, nev, ncv);
[icomm, comm, ifail] = f12fd('SMALLEST MAGNITUDE', icomm, comm);
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)
x = f12f_av(nx, x);
elseif (irevcm == 4)
[niter, nconv, ritz, rzest] = f12fe(icomm, comm);
fprintf('Iteration %d, No. converged = %d, norm of estimates = %16.8g\n', ...
niter, nconv, norm(rzest(1:double(nev)),2));
end
end
[nconv, d, z, v, comm, icomm, ifail] = f12fc(sigma, resid, v, comm, icomm);
nconv, d(1:double(nconv)), ifail
function [w] = f12f_av(nx, v)
inx = double(nx); % nx is int64
w = zeros(inx*inx,1);
h2 = 1/double((inx+1)^2);
w(1:inx) = tv(inx, v(1:inx));
w(1:inx) = v(inx+1:2*inx)+w(1:inx);
for j=2:double(inx1)
lo = (j1)*inx +1;
hi = j*inx;
w(lo:hi) = tv(inx, v(lo:hi));
w(lo:hi) = v(loinx:lo1)+w(lo:hi);
w(lo:hi) = v(hi+1:hi+inx)+w(lo:hi);
end
lo = (inx1)*inx +1;
hi = inx*inx;
w(lo:hi) = tv(inx, v(lo:hi));
w(lo:hi) = v(loinx:lo1)+w(lo:hi);
w = w/h2;
function [y] = tv(inx,x)
y = zeros(inx,1);
dd = 4;
dl = 1;
du = 1;
y(1) = dd*x(1) + du*x(2);
for j=2:double(inx1)
y(j) = dl*x(j1) + dd*x(j) + du*x(j+1);
end
y(inx) = dl*x(inx1) + dd*x(inx);
Iteration 1, No. converged = 0, norm of estimates = 81.010211
Iteration 2, No. converged = 0, norm of estimates = 45.634095
Iteration 3, No. converged = 0, norm of estimates = 42.747772
Iteration 4, No. converged = 0, norm of estimates = 8.6106757
Iteration 5, No. converged = 0, norm of estimates = 0.71330195
Iteration 6, No. converged = 0, norm of estimates = 0.15050738
Iteration 7, No. converged = 0, norm of estimates = 0.015776765
Iteration 8, No. converged = 0, norm of estimates = 0.0038996544
Iteration 9, No. converged = 0, norm of estimates = 0.0004324447
Iteration 10, No. converged = 0, norm of estimates = 0.00011026365
Iteration 11, No. converged = 0, norm of estimates = 1.2358564e05
Iteration 12, No. converged = 0, norm of estimates = 3.1712519e06
Iteration 13, No. converged = 1, norm of estimates = 3.5636599e07
Iteration 14, No. converged = 1, norm of estimates = 4.2416167e08
Iteration 15, No. converged = 1, norm of estimates = 1.3069836e08
Iteration 16, No. converged = 1, norm of estimates = 5.5204749e10
Iteration 17, No. converged = 1, norm of estimates = 8.0102311e11
Iteration 18, No. converged = 1, norm of estimates = 1.9788954e10
Iteration 19, No. converged = 2, norm of estimates = 3.1175144e09
Iteration 20, No. converged = 2, norm of estimates = 3.0499643e08
Iteration 21, No. converged = 2, norm of estimates = 2.2545794e08
Iteration 22, No. converged = 2, norm of estimates = 3.8803659e09
Iteration 23, No. converged = 2, norm of estimates = 4.3299036e10
Iteration 24, No. converged = 2, norm of estimates = 1.9559537e10
Iteration 25, No. converged = 2, norm of estimates = 1.3956205e12
Iteration 26, No. converged = 2, norm of estimates = 6.7447903e13
Iteration 27, No. converged = 2, norm of estimates = 6.4140406e14
Iteration 28, No. converged = 2, norm of estimates = 8.9020339e15
Iteration 29, No. converged = 3, norm of estimates = 3.8266142e15
Iteration 30, No. converged = 3, norm of estimates = 1.3296741e16
nconv =
4
ans =
19.6054
48.2193
48.2193
76.8333
ifail =
0
Optional Parameters
Several optional parameters for the computational functions
nag_sparseig_real_symm_iter (f12fb) and
nag_sparseig_real_symm_proc (f12fc) define choices in the problem specification or the algorithm logic. In order to reduce the number of formal parameters of
nag_sparseig_real_symm_iter (f12fb) and
nag_sparseig_real_symm_proc (f12fc) these optional parameters have associated
default values that are appropriate for most problems. Therefore, you need only specify those optional parameters whose values are to be different from their default values.
The remainder of this section can be skipped if you wish to use the default values for all optional parameters.
The following is a list of the optional parameters available. A full description of each optional parameter is provided in
Section [Description of the Optional s].
Optional parameters may be specified by calling
nag_sparseig_real_symm_option (f12fd) before a call to
nag_sparseig_real_symm_iter (f12fb), but after a call to
nag_sparseig_real_symm_init (f12fa). One call is necessary for each optional parameter.
All optional parameters you do not specify are set to their default values. Optional parameters you do specify are unaltered by
nag_sparseig_real_symm_iter (f12fb) and
nag_sparseig_real_symm_proc (f12fc) (unless they define invalid values) and so remain in effect for subsequent calls unless you alter them.
Description of the Optional Parameters
For each option, we give a summary line, a description of the optional parameter and details of constraints.
The summary line contains:
 the keywords, where the minimum abbreviation of each keyword is underlined;
 a parameter value,
where the letters a$a$, i and r$i\text{ and}r$ denote options that take character, integer and real values respectively;
 the default value, where the symbol ε$\epsilon $ is a generic notation for machine precision (see nag_machine_precision (x02aj)).
Keywords and character values are case and white space insensitive.
Advisory i$i$Default
=
$\text{}=$ the value returned by nag_file_set_unit_advisory (x04ab)
The destination for advisory messages.
Defaults This special keyword may be used to reset all optional parameters to their default values.
Exact Shifts DefaultSupplied Shifts During the Lanczos iterative process, shifts are applied internally as part of the implicit restarting scheme. The shift strategy used by default and selected by the
Exact Shifts is strongly recommended over the alternative
Supplied Shifts (see
Lehoucq et al. (1998) for details of shift strategies).
If
Exact Shifts are used then these are computed internally by the algorithm in the implicit restarting scheme.
If
Supplied Shifts are used then, during the Lanczos iterative process, you must supply shifts through array arguments of
nag_sparseig_real_symm_iter (f12fb) when
nag_sparseig_real_symm_iter (f12fb) returns with
irevcm = 3${\mathbf{irevcm}}=3$; the real and imaginary parts of the shifts are
returned in
x and
mx respectively (or in
comm when the option
Pointers = YES${\mathbf{Pointers}}=\mathrm{YES}$ is set).
This option should only be used if you are an experienced user since this requires some algorithmic knowledge and because more operations are usually required than for the implicit shift scheme. Details on the use of explicit shifts and further references on shift strategies are available in
Lehoucq et al. (1998).
Iteration Limit i$i$
Default
=
300
$\text{}=300$ The limit on the number of Lanczositerations that can be performed before
nag_sparseig_real_symm_iter (f12fb) exits. If not all requested eigenvalues have converged to within
Tolerance and the number of Lanczositerations has reached this limit then
nag_sparseig_real_symm_iter (f12fb) exits with an error;
nag_sparseig_real_symm_proc (f12fc) can still be called subsequently to return the number of converged eigenvalues, the converged eigenvalues and, if requested, the corresponding eigenvectors.
Largest Magnitude DefaultBoth Ends Largest Algebraic Smallest Algebraic Smallest Magnitude The Lanczos iterative method converges on a number of eigenvalues with given properties. The default is for
nag_sparseig_real_symm_iter (f12fb) to compute the eigenvalues of largest magnitude using
Largest Magnitude. Alternatively, eigenvalues may be chosen which have
Largest Algebraic part,
Smallest Magnitude, or
Smallest Algebraic part; or eigenvalues which are from
Both Ends of the algebraic spectrum.
Note that these options select the eigenvalue properties for eigenvalues of
OP$\mathrm{OP}$ (and
B$B$ for
Generalized problems), the linear operator determined by the computational mode and problem type.
Nolist DefaultList Normally each optional parameter specification is not printed to
the advisory channel
as it is supplied. Optional parameter
List may be used to enable printing and optional parameter
Nolist may be used to suppress the printing.
Monitoring i$i$Default
=
− 1
$\text{}=1$If
i > 0$i>0$, monitoring information is output to channel number
i$i$ during the solution of each problem; this may be the same as the
Advisory channel number. The type of information produced is dependent on the value of
Print Level, see the description of the optional parameter
Print Level for details of the information produced. Please see
nag_file_open (x04ac) to associate a file with a given channel number.
Pointers Default
=
NO
$\text{}=\mathrm{NO}$During the iterative process and reverse communication calls to
nag_sparseig_real_symm_iter (f12fb), required data can be communicated to and from
nag_sparseig_real_symm_iter (f12fb) in one of two ways. When
Pointers = NO${\mathbf{Pointers}}=\mathrm{NO}$ is selected (the default) then the array arguments
x and
mx are used to supply you with required data and used to return computed values back to
nag_sparseig_real_symm_iter (f12fb). For example, when
irevcm = 1${\mathbf{irevcm}}=1$,
nag_sparseig_real_symm_iter (f12fb) returns the vector
x$x$ in
x and the matrixvector product
Bx$Bx$ in
mx and expects the result or the linear operation
OP(x)$\mathrm{OP}\left(x\right)$ to be returned in
x.
If
Pointers = YES${\mathbf{Pointers}}=\mathrm{YES}$ is selected then the data is passed through sections of the array argument
comm. The section corresponding to
x when
Pointers = NO${\mathbf{Pointers}}=\mathrm{NO}$ begins at a location given by the first element of
icomm; similarly the section corresponding to
mx begins at a location given by the second element of
icomm. This option allows
nag_sparseig_real_symm_iter (f12fb) to perform fewer copy operations on each intermediate exit and entry, but can also lead to less elegant code in the calling program.
Print Level i$i$Default
=
0
$\text{}=0$This controls the amount of printing produced by
nag_sparseig_real_symm_option (f12fd) as follows.
= 0$=0$ 
No output except error messages. If you want to suppress all output, set Print Level = 0${\mathbf{Print\; Level}}=0$. 
> 0$>0$ 
The set of selected options. 
= 2$=2$ 
Problem and timing statistics on final exit from nag_sparseig_real_symm_iter (f12fb). 
≥ 5$\ge 5$ 
A single line of summary output at each Lanczos iteration. 
≥ 10$\ge 10$ 
If
Monitoring > 0${\mathbf{Monitoring}}>0$,
Monitoring is set,
then at each iteration, the length and additional steps of the current Lanczos factorization and the number of converged Ritz values; during reorthogonalization, the norm of initial/restarted starting vector; on a final Lanczos iteration, the number of update iterations taken, the number of converged eigenvalues, the converged eigenvalues and their Ritz estimates. 
≥ 20$\ge 20$ 
Problem and timing statistics on final exit from nag_sparseig_real_symm_iter (f12fb). If
Monitoring > 0${\mathbf{Monitoring}}>0$,
Monitoring is set,
then at each iteration, the number of shifts being applied, the eigenvalues and estimates of the symmetric tridiagonal matrix H$H$, the size of the Lanczos basis, the wanted Ritz values and associated Ritz estimates and the shifts applied; vector norms prior to and following reorthogonalization. 
≥ 30$\ge 30$ 
If
Monitoring > 0${\mathbf{Monitoring}}>0$,
Monitoring is set,
then on final iteration, the norm of the residual; when computing the Schur form, the eigenvalues and Ritz estimates both before and after sorting; for each iteration, the norm of residual for compressed factorization and the symmetric tridiagonal matrix H$H$; during reorthogonalization, the initial/restarted starting vector; during the Lanczos iteration loop, a restart is flagged and the number of the residual requiring iterative refinement; while applying shifts, some indices. 
≥ 40$\ge 40$ 
If
Monitoring > 0${\mathbf{Monitoring}}>0$,
Monitoring is set,
then during the Lanczos iteration loop, the Lanczos vector number and norm of the current residual; while applying shifts, key measures of progress and the order of H$H$; while computing eigenvalues of H$H$, the last rows of the Schur and eigenvector matrices; when computing implicit shifts, the eigenvalues and Ritz estimates of H$H$. 
≥ 50$\ge 50$ 
If Monitoring is set, then during Lanczos iteration loop: norms of key components and the active column of H$H$, norms of residuals during iterative refinement, the final symmetric tridiagonal matrix H$H$; while applying shifts: number of shifts, shift values, block indices, updated tridiagonal matrix H$H$; while computing eigenvalues of H$H$: the diagonals of H$H$, the computed eigenvalues and Ritz estimates. 
Note that setting
Print Level ≥ 30${\mathbf{Print\; Level}}\ge 30$ can result in very lengthy
Monitoring output.
Note that setting
Print Level
≥
30
${\mathbf{Print\; Level}}\ge 30$ can result in very lengthy
Monitoring output.
Random Residual DefaultInitial Residual To begin the Lanczos iterative process,
nag_sparseig_real_symm_iter (f12fb) requires an initial residual vector. By default
nag_sparseig_real_symm_iter (f12fb) provides its own random initial residual vector; this option can also be set using optional parameter
Random Residual. Alternatively, you can supply an initial residual vector (perhaps from a previous computation) to
nag_sparseig_real_symm_iter (f12fb) through the array argument
resid; this option can be set using optional parameter
Initial Residual.
Regular DefaultRegular Inverse Shifted Inverse Buckling Cayley These options define the computational mode which in turn defines the form of operation
OP(x)$\mathrm{OP}\left(x\right)$ to be performed when
nag_sparseig_real_symm_iter (f12fb) returns with
irevcm = − 1${\mathbf{irevcm}}=1$ or
1$1$ and the matrixvector product
Bx$Bx$ when
nag_sparseig_real_symm_iter (f12fb) returns with
irevcm = 2${\mathbf{irevcm}}=2$.
Given a
Standard eigenvalue problem in the form
Ax = λx$Ax=\lambda x$ then the following modes are available with the appropriate operator
OP(x)$\mathrm{OP}\left(x\right)$.
Regular 
OP = A$\mathrm{OP}=A$ 
Shifted Inverse 
OP = (A − σI)^{ − 1}$\mathrm{OP}={(A\sigma I)}^{1}$ where σ$\sigma $ is real 
Given a
Generalized eigenvalue problem in the form
Ax = λBx$Ax=\lambda Bx$ then the following modes are available with the appropriate operator
OP(x)$\mathrm{OP}\left(x\right)$.
Regular Inverse 
OP = B^{ − 1}A$\mathrm{OP}={B}^{1}A$ 
Shifted Inverse 
OP = (A − σB)^{ − 1}B$\mathrm{OP}={(A\sigma B)}^{1}B$, where σ$\sigma $ is real 
Buckling 
OP = (B − σA)^{ − 1}A$\mathrm{OP}={\left(B\sigma A\right)}^{1}A$, where σ$\sigma $ is real 
Cayley 
OP = (A − σB)^{ − 1}(A + σB)$\mathrm{OP}={\left(A\sigma B\right)}^{1}\left(A+\sigma B\right)$, where σ$\sigma $ is real 
Standard DefaultGeneralized The problem to be solved is either a standard eigenvalue problem,
Ax = λx$Ax=\lambda x$, or a generalized eigenvalue problem,
Ax = λBx$Ax=\lambda Bx$. The optional parameter
Standard should be used when a standard eigenvalue problem is being solved and the optional parameter
Generalized should be used when a generalized eigenvalue problem is being solved.
Tolerance r$r$
Default
=
ε
$\text{}=\epsilon $ An approximate eigenvalue has deemed to have converged when the corresponding Ritz estimate is within
Tolerance relative to the magnitude of the eigenvalue.
Vectors Default
=
RITZ
$\text{}=\text{RITZ}$The function
nag_sparseig_real_symm_proc (f12fc) can optionally compute the Schur vectors and/or the eigenvectors corresponding to the converged eigenvalues. To turn off computation of any vectors the option
Vectors = NONE${\mathbf{Vectors}}=\mathrm{NONE}$ should be set. To compute only the Schur vectors (at very little extra cost), the option
Vectors = SCHUR${\mathbf{Vectors}}=\mathrm{SCHUR}$ should be set and these will be returned in the array argument
v of
nag_sparseig_real_symm_proc (f12fc). To compute the eigenvectors (Ritz vectors) corresponding to the eigenvalue estimates, the option
Vectors = RITZ${\mathbf{Vectors}}=\mathrm{RITZ}$ should be set and these will be returned in the array argument
z of
nag_sparseig_real_symm_proc (f12fc), if
z is set equal to
v (as in
Section [Example]) then the Schur vectors in
v are overwritten by the eigenvectors computed by
nag_sparseig_real_symm_proc (f12fc).
PDF version (NAG web site
, 64bit version, 64bit version)
© The Numerical Algorithms Group Ltd, Oxford, UK. 2009–2013