PDF version (NAG web site
, 64bit version, 64bit version)
NAG Toolbox: nag_sparse_real_gen_basic_solver (f11be)
Purpose
nag_sparse_real_gen_basic_solver (f11be) is an iterative solver for a real general (nonsymmetric) system of simultaneous linear equations;
nag_sparse_real_gen_basic_solver (f11be) is the second in a suite of three functions, where the first function,
nag_sparse_real_gen_basic_setup (f11bd), must be called prior to
nag_sparse_real_gen_basic_solver (f11be) to set up the suite, and the third function in the suite,
nag_sparse_real_gen_basic_diag (f11bf), can be used to return additional information about the computation.
These three functions are suitable for the solution of large sparse general (nonsymmetric) systems of equations.
Syntax
[
irevcm,
u,
v,
work,
ifail] = f11be(
irevcm,
u,
v,
wgt,
work, 'lwork',
lwork)
[
irevcm,
u,
v,
work,
ifail] = nag_sparse_real_gen_basic_solver(
irevcm,
u,
v,
wgt,
work, 'lwork',
lwork)
Description
nag_sparse_real_gen_basic_solver (f11be) solves the general (nonsymmetric) system of linear simultaneous equations
Ax = b$Ax=b$ of order
n$\mathit{n}$, where
n$\mathit{n}$ is large and the coefficient matrix
A$A$ is sparse, using one of four available methods: RGMRES, the preconditioned restarted generalized minimum residual method (see
Saad and Schultz (1986)); CGS, the preconditioned conjugate gradient squared method (see
Sonneveld (1989)); BiCGSTAB(
ℓ$\ell $), the biconjugate gradient stabilized method of order
ℓ$\ell $ (see
Van der Vorst (1989) and
Sleijpen and Fokkema (1993)); or TFQMR, the transposefree quasiminimal residual method (see
Freund and Nachtigal (1991) and
Freund (1993)).
For a general description of the methods employed you are referred to
Section [Description] in
(f11bd).
nag_sparse_real_gen_basic_solver (f11be) can solve the system after the first function in the suite,
nag_sparse_real_gen_basic_setup (f11bd), has been called to initialize the computation and specify the method of solution. The third function in the suite,
nag_sparse_real_gen_basic_diag (f11bf), can be used to return additional information generated by the computation, during monitoring steps and after
nag_sparse_real_gen_basic_solver (f11be) has completed its tasks.
nag_sparse_real_gen_basic_solver (f11be) uses
reverse communication, i.e., it returns repeatedly to the calling program with the parameter
irevcm (see
Section [Parameters]) set to specified values which require the calling program to carry out one of the following tasks:
– 
compute the matrixvector product v = Au$v=Au$ or v = A^{T}u$v={A}^{\mathrm{T}}u$ (the four methods require the matrix transposevector product only if ‖A‖_{1}${\Vert A\Vert}_{1}$ or ‖A‖_{∞}${\Vert A\Vert}_{\infty}$ is estimated internally by Higham's method (see Higham (1988))); 
– 
solve the preconditioning equation Mv = u$Mv=u$; 
– 
notify the completion of the computation; 
– 
allow the calling program to monitor the solution. 
Through the parameter
irevcm the calling program can cause immediate or tidy termination of the execution. On final exit, the last iterates of the solution and of the residual vectors of the original system of equations are returned.
Reverse communication has the following advantages.
 Maximum flexibility in the representation and storage of sparse matrices: all matrix operations are performed outside the solver function, thereby avoiding the need for a complicated interface with enough flexibility to cope with all types of storage schemes and sparsity patterns. This applies also to preconditioners.
 Enhanced user interaction: you can closely monitor the progress of the solution and tidy or immediate termination can be requested. This is useful, for example, when alternative termination criteria are to be employed or in case of failure of the external functions used to perform matrix operations.
References
Freund R W (1993) A transposefree quasiminimal residual algorithm for nonHermitian linear systems SIAM J. Sci. Comput. 14 470–482
Freund R W and Nachtigal N (1991) QMR: a QuasiMinimal Residual Method for NonHermitian Linear Systems Numer. Math. 60 315–339
Higham N J (1988) FORTRAN codes for estimating the onenorm of a real or complex matrix, with applications to condition estimation ACM Trans. Math. Software 14 381–396
Saad Y and Schultz M (1986) GMRES: a generalized minimal residual algorithm for solving nonsymmetric linear systems SIAM J. Sci. Statist. Comput. 7 856–869
Sleijpen G L G and Fokkema D R (1993) BiCGSTAB(ℓ)$\left(\ell \right)$ for linear equations involving matrices with complex spectrum ETNA 1 11–32
Sonneveld P (1989) CGS, a fast Lanczostype solver for nonsymmetric linear systems SIAM J. Sci. Statist. Comput. 10 36–52
Van der Vorst H (1989) BiCGSTAB, a fast and smoothly converging variant of BiCG for the solution of nonsymmetric linear systems SIAM J. Sci. Statist. Comput. 13 631–644
Parameters
Note: this function uses
reverse communication. Its use involves an initial entry, intermediate exits and reentries, and a final exit, as indicated by the parameter
irevcm. Between intermediate exits and reentries,
all parameters other than irevcm and v must remain unchanged.
Compulsory Input Parameters
 1:
irevcm – int64int32nag_int scalar
On initial entry:
irevcm = 0${\mathbf{irevcm}}=0$, otherwise an error condition will be raised.
On intermediate reentry: must either be unchanged from its previous exit value, or can have one of the following values.
 irevcm = 5${\mathbf{irevcm}}=5$
 Tidy termination: the computation will terminate at the end of the current iteration. Further reverse communication exits may occur depending on when the termination request is issued. nag_sparse_real_gen_basic_solver (f11be) will then return with the termination code irevcm = 4${\mathbf{irevcm}}=4$. Note that before calling nag_sparse_real_gen_basic_solver (f11be) with irevcm = 5${\mathbf{irevcm}}=5$ the calling program must have performed the tasks required by the value of irevcm returned by the previous call to nag_sparse_real_gen_basic_solver (f11be), otherwise subsequently returned values may be invalid.
 irevcm = 6${\mathbf{irevcm}}=6$
 Immediate termination: nag_sparse_real_gen_basic_solver (f11be) will return immediately with termination code irevcm = 4${\mathbf{irevcm}}=4$ and with any useful information available. This includes the last iterate of the solution. The residual vector is generally not available.
Immediate termination may be useful, for example, when errors are detected during matrixvector multiplication or during the solution of the preconditioning equation.
Changing
irevcm to any other value between calls will result in an error.
Constraint:
on initial entry,
irevcm = 0${\mathbf{irevcm}}=0$; on reentry, either
irevcm must remain unchanged or be reset to
5$5$ or
6$6$.
 2:
u( : $:$) – double array

Note: the dimension of the array
u
must be at least
n$\mathit{n}$.
On initial entry: an initial estimate, x_{0}${x}_{0}$, of the solution of the system of equations Ax = b$Ax=b$.
On intermediate reentry: must remain unchanged.
 3:
v( : $:$) – double array

Note: the dimension of the array
v
must be at least
n$\mathit{n}$.
On initial entry: the righthand side b$b$ of the system of equations Ax = b$Ax=b$.
On intermediate reentry: the returned value of
irevcm determines the contents of
v in the following way:
 if irevcm = − 1${\mathbf{irevcm}}=1$, 1$1$ or 2$2$, v must store the vector v$v$, the result of the operation specified by the value of irevcm returned by the previous call to nag_sparse_real_gen_basic_solver (f11be);
 if irevcm = 3${\mathbf{irevcm}}=3$, v must remain unchanged.
 4:
wgt( : $:$) – double array

Note: the dimension of the array
wgt
must be at least
max (1,n)$\mathrm{max}\phantom{\rule{0.125em}{0ex}}(1,\mathit{n})$.
The usersupplied weights, if these are to be used in the computation of the vector norms in the termination criterion (see
Sections [Description] and
[Parameters] in
(f11bd)).
Constraint:
if weights are to be used, at least one element of
wgt must be nonzero.
 5:
work(lwork) – double array
lwork, the dimension of the array, must satisfy the constraint
lwork ≥ lwreq${\mathbf{lwork}}\ge {\mathbf{lwreq}}$, where
lwreq is returned by
nag_sparse_real_gen_basic_setup (f11bd).
On initial entry: the array
work as returned by
nag_sparse_real_gen_basic_setup (f11bd) (see also
Section [Parameters] in
(f11bd)).
lwork, the dimension of the array, must satisfy the constraint
lwork ≥ lwreq${\mathbf{lwork}}\ge {\mathbf{lwreq}}$, where
lwreq is returned by
nag_sparse_real_gen_basic_setup (f11bd).
On intermediate reentry: must remain unchanged.
Optional Input Parameters
 1:
lwork – int64int32nag_int scalar
Default:
The dimension of the array
work.
On initial entry: the dimension of the array
work as declared in the (sub)program from which
nag_sparse_real_gen_basic_solver (f11be) is called (see also
Sections [Description] and
[Parameters] in
(f11bd)).
The required amount of workspace is as follows:
Method 
Requirements 
RGMRES 
lwork = 100 + n(m + 3) + m(m + 5) + 1${\mathbf{lwork}}=100+\mathit{n}(m+3)+m(m+5)+1$, where m$m$ is the dimension of the basis. 
CGS 
lwork = 100 + 7n${\mathbf{lwork}}=100+7\mathit{n}$. 
BiCGSTAB(ℓ$\ell $) 
lwork = 100 + (2n + ℓ)(ℓ + 2) + p${\mathbf{lwork}}=100+(2\mathit{n}+\ell )(\ell +2)+p$, where ℓ$\ell $ is the order of the method. 
TFQMR 
lwork = 100 + 10n${\mathbf{lwork}}=100+10\mathit{n}$, 
where
p = 2n$p=2\mathit{n}$ 
if ℓ > 1$\ell >1$ and iterm = 2${\mathbf{iterm}}=2$ was supplied. 
p = n$p=\mathit{n}$ 
if ℓ > 1$\ell >1$ and a preconditioner is used or iterm = 2${\mathbf{iterm}}=2$ was supplied. 
p = 0$p=0$ 
otherwise. 
Constraint:
lwork ≥ lwreq${\mathbf{lwork}}\ge {\mathbf{lwreq}}$, where
lwreq is returned by
nag_sparse_real_gen_basic_setup (f11bd).
Input Parameters Omitted from the MATLAB Interface
None.
Output Parameters
 1:
irevcm – int64int32nag_int scalar
On intermediate exit:
has the following meanings.
 irevcm = − 1${\mathbf{irevcm}}=1$
 The calling program must compute the matrixvector product v = A^{T}u$v={A}^{\mathrm{T}}u$, where u$u$ and v$v$ are stored in u and v, respectively; RGMRES, CGS and BiCGSTAB(ℓ$\ell $) methods return irevcm = − 1${\mathbf{irevcm}}=1$ only if the matrix norm ‖A‖_{1}${\Vert A\Vert}_{1}$ or ‖A‖_{∞}${\Vert A\Vert}_{\infty}$ is estimated internally using Higham's method. This can only happen if iterm = 1${\mathbf{iterm}}=1$ in nag_sparse_real_gen_basic_setup (f11bd).
 irevcm = 1${\mathbf{irevcm}}=1$
 The calling program must compute the matrixvector product v = Au$v=Au$, where u$u$ and v$v$ are stored in u and v, respectively.
 irevcm = 2${\mathbf{irevcm}}=2$
 The calling program must solve the preconditioning equation Mv = u$Mv=u$, where u$u$ and v$v$ are stored in u and v, respectively.
 irevcm = 3${\mathbf{irevcm}}=3$
 Monitoring step: the solution and residual at the current iteration are returned in the arrays u and v, respectively. No action by the calling program is required. nag_sparse_real_gen_basic_diag (f11bf) can be called at this step to return additional information.
On final exit:
irevcm = 4${\mathbf{irevcm}}=4$:
nag_sparse_real_gen_basic_solver (f11be) has completed its tasks. The value of
ifail determines whether the iteration has been successfully completed, errors have been detected or the calling program has requested termination.
 2:
u( : $:$) – double array

Note: the dimension of the array
u
must be at least
n$\mathit{n}$.
On intermediate exit:
the returned value of
irevcm determines the contents of
u in the following way:
 if irevcm = − 1${\mathbf{irevcm}}=1$, 1$1$ or 2$2$, u holds the vector u$u$ on which the operation specified by irevcm is to be carried out;
 if irevcm = 3${\mathbf{irevcm}}=3$, u holds the current iterate of the solution vector.
On final exit: if
ifail = 3${\mathbf{ifail}}={\mathbf{3}}$ or
ifail < 0${\mathbf{ifail}}<{\mathbf{0}}$, the array
u is unchanged from the initial entry to
nag_sparse_real_gen_basic_solver (f11be).
If
ifail = 1${\mathbf{ifail}}={\mathbf{1}}$, the array
u is unchanged from the last entry to
nag_sparse_real_gen_basic_solver (f11be).
Otherwise,
u holds the last available iterate of the solution of the system of equations, for all returned values of
ifail.
 3:
v( : $:$) – double array

Note: the dimension of the array
v
must be at least
n$\mathit{n}$.
On intermediate exit:
if
irevcm = 3${\mathbf{irevcm}}=3$,
v holds the current iterate of the residual vector. Note that this is an approximation to the true residual vector. Otherwise, it does not contain any useful information.
On final exit: if
ifail = 3${\mathbf{ifail}}={\mathbf{3}}$ or
ifail < 0${\mathbf{ifail}}<{\mathbf{0}}$, the array
v is unchanged from the initial entry to
nag_sparse_real_gen_basic_solver (f11be).
If
ifail = 1${\mathbf{ifail}}={\mathbf{1}}$, the array
v is unchanged from the last entry to
nag_sparse_real_gen_basic_solver (f11be).
If
ifail = 0${\mathbf{ifail}}={\mathbf{0}}$ or
2${\mathbf{2}}$, the array
v contains the true residual vector of the system of equations (see also
Section [Error Indicators and Warnings]).
Otherwise,
v stores the last available iterate of the residual vector unless
ifail = 8${\mathbf{ifail}}={\mathbf{8}}$ is returned on last entry, in which case
v is set to
0.0$0.0$.
 4:
work(lwork) – double array
 5:
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:
Cases prefixed with W are classified as warnings and
do not generate an error of type NAG:error_n. See nag_issue_warnings.
 ifail = − i${\mathbf{ifail}}=i$
If
ifail = − i${\mathbf{ifail}}=i$, parameter
i$i$ had an illegal value on entry. The parameters are numbered as follows:
1:
irevcm, 2:
u, 3:
v, 4:
wgt, 5:
work, 6:
lwork, 7:
ifail.
 W ifail = 1${\mathbf{ifail}}=1$
nag_sparse_real_gen_basic_solver (f11be) has been called again after returning the termination code
irevcm = 4${\mathbf{irevcm}}=4$. No further computation has been carried out and all input data and data stored for access by
nag_sparse_real_gen_basic_diag (f11bf) have remained unchanged.
 W ifail = 2${\mathbf{ifail}}=2$
The required accuracy could not be obtained. However,
nag_sparse_real_gen_basic_solver (f11be) has terminated with reasonable accuracy: the last iterate of the residual satisfied the termination criterion but the exact residual
r = b − Ax$r=bAx$, did not. After the first occurrence of this situation, the iteration was restarted once, but
nag_sparse_real_gen_basic_solver (f11be) could not improve on the accuracy. This error code usually implies that your problem has been fully and satisfactorily solved to within or close to the accuracy available on your system. Further iterations are unlikely to improve on this situation. You should call
nag_sparse_real_gen_basic_diag (f11bf) to check the values of the left and righthand sides of the termination condition.
 ifail = 3${\mathbf{ifail}}=3$
nag_sparse_real_gen_basic_setup (f11bd) was either not called before calling
nag_sparse_real_gen_basic_solver (f11be) or it returned an error. The arguments
u and
v remain unchanged.
 W ifail = 4${\mathbf{ifail}}=4$
The calling program requested a tidy termination before the solution had converged. The arrays
u and
v return the last iterates available of the solution and of the residual vector, respectively.
 W ifail = 5${\mathbf{ifail}}=5$
The solution did not converge within the maximum number of iterations allowed. The arrays
u and
v return the last iterates available of the solution and of the residual vector, respectively.
 ifail = 6${\mathbf{ifail}}=6$
Algorithmic breakdown. The last available iterates of the solution and residuals are returned, although it is possible that they are completely inaccurate.
 W ifail = 8${\mathbf{ifail}}=8$
The calling program requested an immediate termination. However, the array
u returns the last iterate of the solution, the array
v returns the last iterate of the residual vector, for the CGS and TFQMR methods only.
 ifail = 10${\mathbf{ifail}}=10$
Usersupplied weights are to be used, but all elements of the array
wgt are zero.
Accuracy
On completion, i.e.,
irevcm = 4${\mathbf{irevcm}}=4$ on exit, the arrays
u and
v will return the solution and residual vectors,
x_{k}${x}_{k}$ and
r_{k} = b − Ax_{k}${r}_{k}=bA{x}_{k}$, respectively, at the
k$k$th iteration, the last iteration performed, unless an immediate termination was requested.
On successful completion, the termination criterion is satisfied to within the userspecified tolerance, as described in
Section [Description] in
(f11bd). The computed values of the left and righthand sides of the termination criterion selected can be obtained by a call to
nag_sparse_real_gen_basic_diag (f11bf).
Further Comments
The number of operations carried out by nag_sparse_real_gen_basic_solver (f11be) for each iteration is likely to be principally determined by the computation of the matrixvector products v = Au$v=Au$ and by the solution of the preconditioning equation Mv = u$Mv=u$ in the calling program. Each of these operations is carried out once every iteration.
The number of the remaining operations in nag_sparse_real_gen_basic_solver (f11be) for each iteration is approximately proportional to n$\mathit{n}$.
The number of iterations required to achieve a prescribed accuracy cannot be easily determined at the onset, as it can depend dramatically on the conditioning and spectrum of the preconditioned matrix of the coefficients A = M^{ − 1}A$\stackrel{}{A}={M}^{1}A$ (RGMRES, CGS and TFQMR methods) or A = AM^{ − 1}$\stackrel{}{A}=A{M}^{1}$ (BiCGSTAB(ℓ$\ell $) method).
Additional matrixvector products are required for the computation of
‖A‖_{1}${\Vert A\Vert}_{1}$ or
‖A‖_{∞}${\Vert A\Vert}_{\infty}$, when this has not been supplied to
nag_sparse_real_gen_basic_setup (f11bd) and is required by the termination criterion employed.
If the termination criterion
‖r_{k}‖_{p}
≤
τ
(‖b‖_{p} + ‖A‖_{p} × ‖x_{k}‖_{p})
${\Vert {r}_{k}\Vert}_{p}\le \tau ({\Vert b\Vert}_{p}+{\Vert A\Vert}_{p}\times {\Vert {x}_{k}\Vert}_{p})$ is used (see
Section [Description] in
(f11bd)) and
‖x_{0}‖ ≫ ‖x_{k}‖$\Vert {x}_{0}\Vert \gg \Vert {x}_{k}\Vert $, then the required accuracy cannot be obtained due to loss of significant digits. The iteration is restarted automatically at some suitable point:
nag_sparse_real_gen_basic_solver (f11be) sets
x_{0} = x_{k}${x}_{0}={x}_{k}$ and the computation begins again. For particularly badly scaled problems, more than one restart may be necessary. This does not apply to the RGMRES method which, by its own nature, selfrestarts every superiteration. Naturally, restarting adds to computational costs: it is recommended that the iteration should start from a value
x_{0}${x}_{0}$ which is as close to the true solution
x̃$\stackrel{~}{x}$ as can be estimated. Otherwise, the iteration should start from
x_{0} = 0${x}_{0}=0$.
Example
Open in the MATLAB editor:
nag_sparse_real_gen_basic_solver_example
function nag_sparse_real_gen_basic_solver_example
method = 'BICGSTAB';
precon = 'P';
n = 8;
m = int64(1);
nz = 24;
a = zeros(10000, 1);
a(1:24) = [2; 1; 1; 4; 3; 2; 7; 2; 3; 4; 5; 5; 1; 8; 3; ...
6; 5; 2; 5; 1; 6; 1; 2; 3];
irow = zeros(10000, 1, 'int64');
irow(1:24) = [int64(1);1;1;2;2;2;3;3;4;4;4;4;5;5;5;6;6;6;7;7;7;8;8;8];
icol = zeros(10000, 1, 'int64');
icol(1:24) = [int64(1);4;8;1;2;5;3;6;1;3;4;7;2;5;7;1;3;6;3;5;7;2;6;8];
lfill = int64(0);
ipivp = zeros(8, 1, 'int64');
ipivq = zeros(8, 1, 'int64');
dtol = 0;
milu = 'N';
tol = 1e08;
maxitn = int64(20);
anorm = 0;
sigmax = 0;
monit = int64(1);
lwork = int64(6000);
irevcm = int64(0);
u = zeros(8, 1);
v = [6;8;9;46;17;21;22;34];
wgt = zeros(8, 1);
[a, irow, icol, ipivp, ipivq, istr, idiag, nnzc, npivm, ifail] = ...
nag_sparse_real_gen_precon_ilu(int64(nz), a, irow, icol, lfill, ...
dtol, milu, ipivp, ipivq);
[lwreq, work, ifail] = ...
nag_sparse_real_gen_basic_setup(method, precon, int64(n), m, tol, ...
maxitn, anorm, sigmax, monit, lwork, 'norm_p', '1');
while (irevcm ~= 4)
[irevcm, u, v, work, ifail] = ...
nag_sparse_real_gen_basic_solver(irevcm, u, v, wgt, work);
if (irevcm == 1)
[v, ifail] = ...
nag_sparse_real_gen_matvec('T', a(1:nz), irow(1:nz), icol(1:nz), 'N', u);
elseif (irevcm == 1)
[v, ifail] = ...
nag_sparse_real_gen_matvec('N', a(1:nz), irow(1:nz), icol(1:nz), 'N', u);
elseif (irevcm == 2)
[v, ifail] = ...
nag_sparse_real_gen_precon_ilu_solve('N', a, irow, icol, ipivp, ipivq, ...
istr, idiag, 'N', u);
if (ifail ~= 0)
irevcm = 6;
end
elseif (irevcm == 3)
[itn, stplhs, stprhs, anorm, sigmax, ifail] = ...
nag_sparse_real_gen_basic_diag(work);
fprintf('\nMonitoring at iteration number %d\nresidual norm: %14.4e\n', ...
itn, stplhs);
fprintf('\n Solution Vector Residual Vector\n');
for i = 1:n
fprintf('%+16.4e %+16.4e\n', u(i), v(i));
end
end
end
[itn, stplhs, stprhs, anorm, sigmax, ifail] = ...
nag_sparse_real_gen_basic_diag(work);
fprintf('\nNumber of iterations for convergence: %d\n', itn);
fprintf('Residual norm: %14.4e\n', stplhs);
fprintf('Righthand side of termination criteria: %14.4e\n', stprhs);
fprintf('inorm of matrix a: %14.4e\n', anorm);
fprintf('\n Solution Vector Residual Vector\n');
for i = 1:n
fprintf('%+16.4e %+16.4e\n', u(i), v(i));
end
Monitoring at iteration number 1
residual norm: 1.4059e+02
Solution Vector Residual Vector
4.5858e+00 +1.5256e+01
+1.0154e+00 +2.6624e+01
2.2234e+00 8.7498e+00
+6.0097e+00 +1.8602e+01
+1.3827e+00 +8.2821e+00
7.9070e+00 +2.0416e+01
+4.4270e01 +9.6094e+00
+5.9248e+00 +3.3055e+01
Monitoring at iteration number 2
residual norm: 3.2742e+01
Solution Vector Residual Vector
+4.1642e+00 2.9585e+00
+4.9370e+00 5.5523e+00
+4.8101e+00 +8.2070e01
+5.4324e+00 1.6828e+01
+5.8531e+00 +5.5975e01
+1.1925e+01 1.9150e+00
+8.4826e+00 +1.0081e+00
+6.0625e+00 3.1004e+00
Number of iterations for convergence: 3
Residual norm: 5.3405e09
Righthand side of termination criteria: 5.5900e06
inorm of matrix a: 1.1000e+01
Solution Vector Residual Vector
+1.0000e+00 6.9784e10
+2.0000e+00 1.3443e09
+3.0000e+00 +1.1570e10
+4.0000e+00 1.6580e09
+5.0000e+00 +3.2460e10
+6.0000e+00 2.6996e10
+7.0000e+00 +4.9307e10
+8.0000e+00 4.3708e10
Open in the MATLAB editor:
f11be_example
function f11be_example
method = 'BICGSTAB';
precon = 'P';
n = 8;
m = int64(1);
nz = 24;
a = zeros(10000, 1);
a(1:24) = [2; 1; 1; 4; 3; 2; 7; 2; 3; 4; 5; 5; 1; 8; 3; 6; 5; 2; 5; 1; 6; 1; 2; 3];
irow = zeros(10000, 1, 'int64');
irow(1:24) = [int64(1);1;1;2;2;2;3;3;4;4;4;4;5;5;5;6;6;6;7;7;7;8;8;8];
icol = zeros(10000, 1, 'int64');
icol(1:24) = [int64(1);4;8;1;2;5;3;6;1;3;4;7;2;5;7;1;3;6;3;5;7;2;6;8];
lfill = int64(0);
ipivp = zeros(8, 1, 'int64');
ipivq = zeros(8, 1, 'int64');
dtol = 0;
milu = 'N';
tol = 1e08;
maxitn = int64(20);
anorm = 0;
sigmax = 0;
monit = int64(1);
lwork = int64(6000);
irevcm = int64(0);
u = zeros(8, 1);
v = [6;
8;
9;
46;
17;
21;
22;
34];
wgt = zeros(8, 1);
[a, irow, icol, ipivp, ipivq, istr, idiag, nnzc, npivm, ifail] = ...
f11da(int64(nz), a, irow, icol, lfill, dtol, milu, ipivp, ipivq);
[lwreq, work, ifail] = ...
f11bd(method, precon, int64(n), m, tol, maxitn, anorm, sigmax, monit, lwork, 'norm_p', '1');
while (irevcm ~= 4)
[irevcm, u, v, work, ifail] = f11be(irevcm, u, v, wgt, work);
if (irevcm == 1)
[v, ifail] = f11xa('T', a(1:nz), irow(1:nz), icol(1:nz), 'N', u);
elseif (irevcm == 1)
[v, ifail] = f11xa('N', a(1:nz), irow(1:nz), icol(1:nz), 'N', u);
elseif (irevcm == 2)
[v, ifail] = f11db('N', a, irow, icol, ipivp, ipivq, istr, idiag, 'N', u);
if (ifail ~= 0)
irevcm = 6;
end
elseif (irevcm == 3)
[itn, stplhs, stprhs, anorm, sigmax, ifail] = f11bf(work);
fprintf('\nMonitoring at iteration number %d\nresidual norm: %14.4e\n', itn, stplhs);
fprintf('\n Solution Vector Residual Vector\n');
for i = 1:n
fprintf('%+16.4e %+16.4e\n', u(i), v(i));
end
end
end
[itn, stplhs, stprhs, anorm, sigmax, ifail] = f11bf(work);
fprintf('\nNumber of iterations for convergence: %d\n', itn);
fprintf('Residual norm: %14.4e\n', stplhs);
fprintf('Righthand side of termination criteria: %14.4e\n', stprhs);
fprintf('inorm of matrix a: %14.4e\n', anorm);
fprintf('\n Solution Vector Residual Vector\n');
for i = 1:n
fprintf('%+16.4e %+16.4e\n', u(i), v(i));
end
Monitoring at iteration number 1
residual norm: 1.4059e+02
Solution Vector Residual Vector
4.5858e+00 +1.5256e+01
+1.0154e+00 +2.6624e+01
2.2234e+00 8.7498e+00
+6.0097e+00 +1.8602e+01
+1.3827e+00 +8.2821e+00
7.9070e+00 +2.0416e+01
+4.4270e01 +9.6094e+00
+5.9248e+00 +3.3055e+01
Monitoring at iteration number 2
residual norm: 3.2742e+01
Solution Vector Residual Vector
+4.1642e+00 2.9585e+00
+4.9370e+00 5.5523e+00
+4.8101e+00 +8.2070e01
+5.4324e+00 1.6828e+01
+5.8531e+00 +5.5975e01
+1.1925e+01 1.9150e+00
+8.4826e+00 +1.0081e+00
+6.0625e+00 3.1004e+00
Number of iterations for convergence: 3
Residual norm: 1.0372e08
Righthand side of termination criteria: 5.5900e06
inorm of matrix a: 1.1000e+01
Solution Vector Residual Vector
+1.0000e+00 1.3553e09
+2.0000e+00 2.6108e09
+3.0000e+00 +2.2470e10
+4.0000e+00 3.2202e09
+5.0000e+00 +6.3043e10
+6.0000e+00 5.2429e10
+7.0000e+00 +9.5766e10
+8.0000e+00 8.4886e10
PDF version (NAG web site
, 64bit version, 64bit version)
© The Numerical Algorithms Group Ltd, Oxford, UK. 2009–2013