hide long namesshow long names
hide short namesshow short names
Integer type:  int32  int64  nag_int  show int32  show int32  show int64  show int64  show nag_int  show nag_int

PDF version (NAG web site, 64-bit version, 64-bit version)
Chapter Contents
Chapter Introduction
NAG Toolbox

NAG Toolbox: nag_sparse_complex_gen_basic_setup (f11br)


    1  Purpose
    2  Syntax
    7  Accuracy
    9  Example


nag_sparse_complex_gen_basic_setup (f11br) is a setup function, the first in a suite of three functions for the iterative solution of a complex general (non-Hermitian) system of simultaneous linear equations. nag_sparse_complex_gen_basic_setup (f11br) must be called before nag_sparse_complex_gen_basic_solver (f11bs), the iterative solver. The third function in the suite, nag_sparse_complex_gen_basic_diag (f11bt), can be used to return additional information about the computation.
These three functions are suitable for the solution of large sparse general (non-Hermitian) systems of equations.


[lwreq, work, ifail] = f11br(method, precon, n, m, tol, maxitn, anorm, sigmax, monit, lwork, 'norm_p', norm_p, 'weight', weight, 'iterm', iterm)
[lwreq, work, ifail] = nag_sparse_complex_gen_basic_setup(method, precon, n, m, tol, maxitn, anorm, sigmax, monit, lwork, 'norm_p', norm_p, 'weight', weight, 'iterm', iterm)


The suite consisting of the functions nag_sparse_complex_gen_basic_setup (f11br), nag_sparse_complex_gen_basic_solver (f11bs) and nag_sparse_complex_gen_basic_diag (f11bt) is designed to solve the general (non-Hermitian) system of simultaneous linear equations Ax=b of order n, where n is large and the coefficient matrix A is sparse.
nag_sparse_complex_gen_basic_setup (f11br) is a setup function which must be called before nag_sparse_complex_gen_basic_solver (f11bs), the iterative solver. The third function in the suite, nag_sparse_complex_gen_basic_diag (f11bt), can be used to return additional information about the computation. A choice of methods is available:

Restarted Generalized Minimum Residual Method (RGMRES)

The restarted generalized minimum residual method (RGMRES) (see Saad and Schultz (1986), Barrett et al. (1994) and Dias da Cunha and Hopkins (1994)) starts from the residual r0=b-Ax0, where x0 is an initial estimate for the solution (often x0=0). An orthogonal basis for the Krylov subspace spanAkr0, for k=0,1,, is generated explicitly: this is referred to as Arnoldi's method (see Arnoldi (1951)). The solution is then expanded onto the orthogonal basis so as to minimize the residual norm b-Ax2. The lack of symmetry of A implies that the orthogonal basis is generated by applying a ‘long’ recurrence relation, whose length increases linearly with the iteration count. For all but the most trivial problems, computational and storage costs can quickly become prohibitive as the iteration count increases. RGMRES limits these costs by employing a restart strategy: every m iterations at most, the Arnoldi process is restarted from rl=b-Axl, where the subscript l denotes the last available iterate. Each group of m iterations is referred to as a ‘super-iteration’. The value of m is chosen in advance and is fixed throughout the computation. Unfortunately, an optimum value of m cannot easily be predicted.

Conjugate Gradient Squared Method (CGS)

The conjugate gradient squared method (CGS) (see Sonneveld (1989), Barrett et al. (1994) and Dias da Cunha and Hopkins (1994)) is a development of the bi-conjugate gradient method where the nonsymmetric Lanczos method is applied to reduce the coefficients matrix to tridiagonal form: two bi-orthogonal sequences of vectors are generated starting from the residual r0=b-Ax0, where x0 is an initial estimate for the solution (often x0=0) and from the shadow residual r^0 corresponding to the arbitrary problem AHx^=b^, where b^ can be any vector, but in practice is chosen so that r0=r^0. In the course of the iteration, the residual and shadow residual ri=PiA r0 and r^i=PiAHr^0 are generated, where Pi is a polynomial of order i, and bi-orthogonality is exploited by computing the vector product ρi=r^i,ri=PiAHr^0, PiA r0=r^0,Pi2Ar0. Applying the ‘contraction’ operator PiA twice, the iteration coefficients can still be recovered without advancing the solution of the shadow problem, which is of no interest. The CGS method often provides fast convergence; however, there is no reason why the contraction operator should also reduce the once reduced vector PiAr0: this may well lead to a highly irregular convergence which may result in large cancellation errors.

Bi-Conjugate Gradient Stabilized (ℓ) Method (Bi-CGSTAB(ℓ))

The bi-conjugate gradient stabilized () method (Bi-CGSTAB()) (see Van der Vorst (1989), Sleijpen and Fokkema (1993) and Dias da Cunha and Hopkins (1994)) is similar to the CGS method above. However, instead of generating the sequence Pi2 Ar0, it generates the sequence QiA PiA r0, where the QiA are polynomials chosen to minimize the residual after the application of the contraction operator PiA. Two main steps can be identified for each iteration: an OR (Orthogonal Residuals) step where a basis of order  is generated by a Bi-CG iteration and an MR (Minimum Residuals) step where the residual is minimized over the basis generated, by a method akin to GMRES. For =1, the method corresponds to the Bi-CGSTAB method of Van der Vorst (1989). For >1, more information about complex eigenvalues of the iteration matrix can be taken into account, and this may lead to improved convergence and robustness. However, as  increases, numerical instabilities may arise. For this reason, a maximum value of =10 is imposed, but probably =4 is sufficient in most cases.

Transpose-free Quasi-minimal Residual Method (TFQMR)

The transpose-free quasi-minimal residual method (TFQMR) (see Freund and Nachtigal (1991) and Freund (1993)) is conceptually derived from the CGS method. The residual is minimized over the space of the residual vectors generated by the CGS iterations under the simplifying assumption that residuals are almost orthogonal. In practice, this is not the case but theoretical analysis has proved the validity of the method. This has the effect of remedying the rather irregular convergence behaviour with wild oscillations in the residual norm that can degrade the numerical performance and robustness of the CGS method. In general, the TFQMR method can be expected to converge at least as fast as the CGS method, in terms of number of iterations, although each iteration involves a higher operation count. When the CGS method exhibits irregular convergence, the TFQMR method can produce much smoother, almost monotonic convergence curves. However, the close relationship between the CGS and TFQMR method implies that the overall speed of convergence is similar for both methods. In some cases, the TFQMR method may converge faster than the CGS method.

General Considerations

For each method, a sequence of solution iterates xi is generated such that, hopefully, the sequence of the residual norms ri converges to a required tolerance. Note that, in general, convergence, when it occurs, is not monotonic.
In the RGMRES and Bi-CGSTAB() methods above, your program must provide the maximum number of basis vectors used, m or , respectively; however, a smaller number of basis vectors may be generated and used when the stability of the solution process requires this (see Further Comments).
Faster convergence can be achieved using a preconditioner (see Golub and Van Loan (1996) and Barrett et al. (1994)). A preconditioner maps the original system of equations onto a different system, say
A-x-=b-, (1)
with, hopefully, better characteristics with respect to its speed of convergence: for example, the condition number of the coefficients matrix can be improved or eigenvalues in its spectrum can be made to coalesce. An orthogonal basis for the Krylov subspace spanA-kr-0, for k=0,1,, is generated and the solution proceeds as outlined above. The algorithms used are such that the solution and residual iterates of the original system are produced, not their preconditioned counterparts. Note that an unsuitable preconditioner or no preconditioning at all may result in a very slow rate, or lack, of convergence. However, preconditioning involves a trade-off between the reduction in the number of iterations required for convergence and the additional computational costs per iteration. Also, setting up a preconditioner may involve non-negligible overheads.
A left preconditioner M-1 can be used by the RGMRES, CGS and TFQMR methods, such that A-=M-1AIn in (1), where In is the identity matrix of order n; a right preconditioner M-1 can be used by the Bi-CGSTAB() method, such that A-=AM-1In. These are formal definitions, used only in the design of the algorithms; in practice, only the means to compute the matrix–vector products v=Au and v=AHu (the latter only being required when an estimate of A1 or A is computed internally), and to solve the preconditioning equations Mv=u are required, i.e., explicit information about M, or its inverse is not required at any stage.
The first termination criterion
rkp τ bp + Ap × xkp (2)
is available for all four methods. In (2), p=1, ​ or ​2 and τ denotes a user-specified tolerance subject to max10,n, ετ<1, where ε is the machine precision. Facilities are provided for the estimation of the norm of the coefficients matrix A1 or A, when this is not known in advance, by applying Higham's method (see Higham (1988)). Note that A2 cannot be estimated internally. This criterion uses an error bound derived from backward error analysis to ensure that the computed solution is the exact solution of a problem as close to the original as the termination tolerance requires. Termination criteria employing bounds derived from forward error analysis are not used because any such criteria would require information about the condition number κA which is not easily obtainable.
The second termination criterion
r-k2 τ r-02 + σ1 A- × Δx-k2 (3)
is available for all methods except TFQMR. In (3), σ1A-=A-2 is the largest singular value of the (preconditioned) iteration matrix A-. This termination criterion monitors the progress of the solution of the preconditioned system of equations and is less expensive to apply than criterion (2) for the Bi-CGSTAB() method with >1. Only the RGMRES method provides facilities to estimate σ1A- internally, when this is not supplied (see Further Comments).
Termination criterion (2) is the recommended choice, despite its additional costs per iteration when using the Bi-CGSTAB() method with >1. Also, if the norm of the initial estimate is much larger than the norm of the solution, that is, if x0x, a dramatic loss of significant digits could result in complete lack of convergence. The use of criterion (2) will enable the detection of such a situation, and the iteration will be restarted at a suitable point. No such restart facilities are provided for criterion (3).
Optionally, a vector w of user-specified weights can be used in the computation of the vector norms in termination criterion (2), i.e., vpw=v w p, where v w i=wi vi, for i=1,2,,n. Note that the use of weights increases the computational costs.
The sequence of calls to the functions comprising the suite is enforced: first, the setup function nag_sparse_complex_gen_basic_setup (f11br) must be called, followed by the solver nag_sparse_complex_gen_basic_solver (f11bs). nag_sparse_complex_gen_basic_diag (f11bt) can be called either when nag_sparse_complex_gen_basic_solver (f11bs) is carrying out a monitoring step or after nag_sparse_complex_gen_basic_solver (f11bs) has completed its tasks. Incorrect sequencing will raise an error condition.
In general, it is not possible to recommend one method in preference to another. RGMRES is often used in the solution of systems arising from PDEs. On the other hand, it can easily stagnate when the size m of the orthogonal basis is too small, or the preconditioner is not good enough. CGS can be the fastest method, but the computed residuals can exhibit instability which may greatly affect the convergence and quality of the solution. Bi-CGSTAB() seems robust and reliable, but it can be slower than the other methods: if a preconditioner is used and >1, Bi-CGSTAB() computes the solution of the preconditioned system x-k=Mxk: the preconditioning equations must be solved to obtain the required solution. The algorithm employed limits to 10% or less, when no intermediate monitoring is requested, the number of times the preconditioner has to be thus applied compared with the total number of applications of the preconditioner. TFQMR can be viewed as a more robust variant of the CGS method: it shares the CGS method speed but avoids the CGS fluctuations in the residual, which may give rise to instability. Also, when the termination criterion (2) is used, the CGS, Bi-CGSTAB() and TFQMR methods will restart the iteration automatically when necessary in order to solve the given problem.


Arnoldi W (1951) The principle of minimized iterations in the solution of the matrix eigenvalue problem Quart. Appl. Math. 9 17–29
Barrett R, Berry M, Chan T F, Demmel J, Donato J, Dongarra J, Eijkhout V, Pozo R, Romine C and Van der Vorst H (1994) Templates for the Solution of Linear Systems: Building Blocks for Iterative Methods SIAM, Philadelphia
Dias da Cunha R and Hopkins T (1994) PIM 1.1 — the parallel iterative method package for systems of linear equations user's guide — Fortran 77 version Technical Report Computing Laboratory, University of Kent at Canterbury, Kent, UK
Freund R W (1993) A transpose-free quasi-minimal residual algorithm for non-Hermitian linear systems SIAM J. Sci. Comput. 14 470–482
Freund R W and Nachtigal N (1991) QMR: a Quasi-Minimal Residual Method for Non-Hermitian Linear Systems Numer. Math. 60 315–339
Golub G H and Van Loan C F (1996) Matrix Computations (3rd Edition) Johns Hopkins University Press, Baltimore
Higham N J (1988) FORTRAN codes for estimating the one-norm 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 for linear equations involving matrices with complex spectrum ETNA 1 11–32
Sonneveld P (1989) CGS, a fast Lanczos-type solver for nonsymmetric linear systems SIAM J. Sci. Statist. Comput. 10 36–52
Van der Vorst H (1989) Bi-CGSTAB, a fast and smoothly converging variant of Bi-CG for the solution of nonsymmetric linear systems SIAM J. Sci. Statist. Comput. 13 631–644


Compulsory Input Parameters

1:     method – string
The iterative method to be used.
Restarted generalized minimum residual method.
Conjugate gradient squared method.
Bi-conjugate gradient stabilized () method.
Transpose-free quasi-minimal residual method.
Constraint: method='RGMRES', 'CGS', 'BICGSTAB' or 'TFQMR'.
2:     precon – string (length ≥ 1)
Determines whether preconditioning is used.
No preconditioning.
Constraint: precon='N' or 'P'.
3:     n int64int32nag_int scalar
n, the order of the matrix A.
Constraint: n>0.
4:     m int64int32nag_int scalar
If method='RGMRES', m is the dimension m of the restart subspace.
If method='BICGSTAB', m is the order  of the polynomial Bi-CGSTAB method.
Otherwise, m is not referenced.
  • if method='RGMRES', 0<mminn,50;
  • if method='BICGSTAB', 0<mminn,10.
5:     tol – double scalar
The tolerance τ for the termination criterion. If tol0.0,τ=maxε,nε is used, where ε is the machine precision. Otherwise τ=maxtol,10ε,nε is used.
Constraint: tol<1.0.
6:     maxitn int64int32nag_int scalar
The maximum number of iterations.
Constraint: maxitn>0.
7:     anorm – double scalar
If anorm>0.0, the value of Ap to be used in the termination criterion (2) (iterm=1).
If anorm0.0, iterm=1 and norm_p='1' or 'I', then A1=A is estimated internally by nag_sparse_complex_gen_basic_solver (f11bs).
If iterm=2, anorm is not referenced.
Constraint: if iterm=1 and norm_p='2', anorm>0.0.
8:     sigmax – double scalar
If iterm=2, the largest singular value σ1 of the preconditioned iteration matrix; otherwise, sigmax is not referenced.
If sigmax0.0, iterm=2 and method='RGMRES', then the value of σ1 will be estimated internally.
Constraint: if method='CGS' or 'BICGSTAB' and iterm=2, sigmax>0.0.
9:     monit int64int32nag_int scalar
If monit>0, the frequency at which a monitoring step is executed by nag_sparse_complex_gen_basic_solver (f11bs): if method='CGS' or 'TFQMR', a monitoring step is executed every monit iterations; otherwise, a monitoring step is executed every monit super-iterations (groups of up to m or  iterations for RGMRES or Bi-CGSTAB(), respectively).
There are some additional computational costs involved in monitoring the solution and residual vectors when the Bi-CGSTAB() method is used with >1.
Constraint: monitmaxitn.
10:   lwork int64int32nag_int scalar
The dimension of the array work.
Constraint: lwork120.
Note:  although the minimum value of lwork ensures the correct functioning of nag_sparse_complex_gen_basic_setup (f11br), a larger value is required by the other functions in the suite, namely nag_sparse_complex_gen_basic_solver (f11bs) and nag_sparse_complex_gen_basic_diag (f11bt). The required value is as follows:
Method Requirements
RGMRES lwork=120+nm+3+mm+5+1, where m is the dimension of the basis.
CGS lwork=120+7n.
Bi-CGSTAB() lwork=120+2n++2+p, where  is the order of the method.
TFQMR lwork=120+10n,
p=2n if >1 and iterm=2 was supplied.
p=n if >1 and a preconditioner is used or iterm=2 was supplied.
p=0 otherwise.

Optional Input Parameters

1:     norm_p – string (length ≥ 1)
Suggested value:
  • if iterm=1, norm_p='I';
  • if iterm=2, norm_p='2'.
  • if iterm=1, 'I' ;
  • otherwise '2' .
Defines the matrix and vector norm to be used in the termination criteria.
l1 norm.
l norm.
l2 norm.
  • if iterm=1, norm_p='1', 'I' or '2';
  • if iterm=2, norm_p='2'.
2:     weight – string (length ≥ 1)
Default: 'N'
Specifies whether a vector w of user-supplied weights is to be used in the computation of the vector norms required in termination criterion (2) (iterm=1): vpw=v w p, where vi w =wi vi, for i=1,2,,n. The suffix p=1,2, denotes the vector norm used, as specified by the argument norm_p. Note that weights cannot be used when iterm=2, i.e., when criterion (3) is used.
User-supplied weights are to be used and must be supplied on initial entry to nag_sparse_complex_gen_basic_solver (f11bs).
All weights are implicitly set equal to one. Weights do not need to be supplied on initial entry to nag_sparse_complex_gen_basic_solver (f11bs).
  • if iterm=1, weight='W' or 'N';
  • if iterm=2, weight='N'.
3:     iterm int64int32nag_int scalar
Default: 1
Defines the termination criterion to be used.
Use the termination criterion defined in (2).
Use the termination criterion defined in (3).
  • if method='TFQMR' or weight='W' or norm_p'2', iterm=1;
  • otherwise iterm=1 or 2.
Note: iterm=2 is only appropriate for a restricted set of choices for method, norm_p and weight; that is norm_p='2', weight='N' and method'TFQMR'.

Output Parameters

1:     lwreq int64int32nag_int scalar
The minimum amount of workspace required by nag_sparse_complex_gen_basic_solver (f11bs). (See also Arguments in nag_sparse_complex_gen_basic_solver (f11bs).)
2:     worklwork – complex array
The array work is initialized by nag_sparse_complex_gen_basic_setup (f11br). It must not be modified before calling the next function in the suite, namely nag_sparse_complex_gen_basic_solver (f11bs).
3:     ifail int64int32nag_int scalar
ifail=0 unless the function detects an error (see Error Indicators and Warnings).

Error Indicators and Warnings

Errors or warnings detected by the function:
If ifail=-i, parameter i had an illegal value on entry. The parameters are numbered as follows:
1: method, 2: precon, 3: norm_p, 4: weight, 5: iterm, 6: n, 7: m, 8: tol, 9: maxitn, 10: anorm, 11: sigmax, 12: monit, 13: lwreq, 14: work, 15: lwork, 16: ifail.
nag_sparse_complex_gen_basic_setup (f11br) has been called out of sequence.
An unexpected error has been triggered by this routine. Please contact NAG.
Your licence key may have expired or may not have been installed correctly.
Dynamic memory allocation failed.


Not applicable.

Further Comments

RGMRES can estimate internally the maximum singular value σ1 of the iteration matrix, using σ1T1, where T is the upper triangular matrix obtained by QR factorization of the upper Hessenberg matrix generated by the Arnoldi process. The computational costs of this computation are negligible when compared to the overall costs.
Loss of orthogonality in the RGMRES method, or of bi-orthogonality in the Bi-CGSTAB() method may degrade the solution and speed of convergence. For both methods, the algorithms employed include checks on the basis vectors so that the number of basis vectors used for a given super-iteration may be less than the value specified in the input argument m. Also, if termination criterion (2) is used, the CGS, Bi-CGSTAB() and TFQMR methods will restart automatically the computation from the last available iterates, when the stability of the solution process requires it.
Termination criterion (3), when available, involves only the residual (or norm of the residual) produced directly by the iteration process: this may differ from the norm of the true residual r~k=b-Axk, particularly when the norm of the residual is very small. Also, if the norm of the initial estimate of the solution is much larger than the norm of the exact solution, convergence can be achieved despite very large errors in the solution. On the other hand, termination criterion (3) is cheaper to use and inspects the progress of the actual iteration. Termination criterion (2) should be preferred in most cases, despite its slightly larger costs.


This example solves an 8×8 non-Hermitian system of simultaneous linear equations using the TFQMR method where the coefficients matrix A has a random sparsity pattern. An incomplete LU preconditioner is used (routines nag_sparse_complex_gen_precon_ilu (f11dn) and nag_sparse_complex_gen_precon_ilu_solve (f11dp)).
function f11br_example

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

% Solve sparse system Ax = b iteratively using ILU preconditioner

% Define sparse matrix A and RHS B
nz   = int64(24);
n    = int64(8);
a    = complex(zeros(3*nz,1));
irow = zeros(3*nz,1,'int64');
icol = zeros(3*nz,1,'int64');
a(1:nz) = [ 2 + 1i, -1 + 1i,  1 - 3i,  4 + 7i, -3 + 0i,  2 + 4i, ...
           -7 - 5i,  2 + 1i,  3 + 2i, -4 + 2i,  0 + 1i,  5 - 3i, ...
           -1 + 2i,  8 + 6i, -3 - 4i, -6 - 2i,  5 - 2i,  2 + 0i, ...
            0 - 5i, -1 + 5i,  6 + 2i, -1 + 4i,  2 + 0i,  3 + 3i];
b       = [ 7 + 11i;
            1 + 24i;
          -13 - 18i;
          -10 +  3i;
           23 + 14i;
           17 -  7i;
           15 -  3i;
           -3 + 20i];
irow(1:nz) = 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(1:nz) = 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]);

% ILU preconditioner
%     Input parameters
lfill = int64(0);
dtol  = 0;
milu  = 'No modification';
ipivp = zeros(n, 1, 'int64');
ipivq = zeros(n, 1, 'int64');
% Compute preconditioner
[a, irow, icol, ipivp, ipivq, istr, idiag, nnzc, npivm, ifail] = ...
          nz, a, irow, icol, lfill, dtol, milu, ipivp, ipivq);

% Iterative Solution Setup
%      Input parameters
method = 'TFQMR   ';
precon = 'P';
lpoly  = int64(1);
tol    = sqrt(x02aj);
maxitn = int64(20);
anorm  = 0;
sigmax = 0;
monit  = int64(2);
lwork  = int64(6000);

[lwreq, work, ifail] = ...
           method, precon, n, lpoly, tol, maxitn, anorm, sigmax, ...
           monit, lwork, 'norm_p', '1');

irevcm = int64(0);
wgt    = zeros(n,1);
u      = complex(zeros(n,1));
v      = b;

while (irevcm ~= 4)
  [irevcm, u, v, work, ifail] = f11bs(...
                                      irevcm, u, v, wgt, work);

  if (irevcm == -1)
    % v = A^Hu
    [v, ifail] = f11xn(...
                       'T', a(1:nz), irow(1:nz), icol(1:nz), 'N', u);
  elseif (irevcm == 1)
    % v = Au
    [v, ifail] = f11xn(...
                       'N', a(1:nz), irow(1:nz), icol(1:nz), 'N', u);
  elseif (irevcm == 2)
    % Solve ILU v = u  
    [v, ifail] = f11dp(...
                       'N', a, irow, icol, ipivp, ipivq, istr, idiag, 'N', u);
  elseif (irevcm == 3)
    % Monitoring stage
    [itn, stplhs, stprhs, anorm, sigmax, work, ifail] = ...
    fprintf('\nMonitoring at iteration number %2d\n',itn);
    fprintf('residual norm:              %14.4e\n', stplhs);
    fprintf('\n   Solution Vector\n');
    fprintf('\n   Residual Vector\n');

% Get information about the computation
[itn, stplhs, stprhs, anorm, sigmax, work, ifail] = ...

fprintf('\nNumber of iterations for convergence:     %4d\n', itn);
fprintf('Residual norm:                           %14.4e\n', stplhs);
fprintf('Right-hand side of termination criteria: %14.4e\n', stprhs);
fprintf('i-norm of matrix a:                      %14.4e\n', anorm);
fprintf('\n   Solution Vector\n');
fprintf('\n   Residual Vector\n');

f11br example results

Monitoring at iteration number  2
residual norm:                  8.2345e+01

   Solution Vector
   0.6905 + 1.4236i
   0.0739 - 1.1880i
   1.4778 + 0.4785i
   5.6572 - 3.0786i
   1.4243 - 1.1246i
   0.1037 + 1.9740i
   0.4498 - 1.2715i
   2.5704 + 1.7578i

   Residual Vector
   1.7772 + 4.6797i
   1.0774 + 6.4600i
  -3.2812 -11.3135i
  -3.8698 - 1.6438i
   8.9912 +11.1004i
   9.7428 - 0.4622i
   3.1668 + 2.8721i
 -10.3231 + 1.5837i

Number of iterations for convergence:        4
Residual norm:                               1.3396e-11
Right-hand side of termination criteria:     9.3882e-06
i-norm of matrix a:                          2.7000e+01

   Solution Vector
   1.0000 + 1.0000i
   2.0000 - 1.0000i
   3.0000 + 1.0000i
   4.0000 - 1.0000i
   3.0000 - 1.0000i
   2.0000 + 1.0000i
   1.0000 - 1.0000i
  -0.0000 + 3.0000i

   Residual Vector
   1.0e-11 *

  -0.0060 - 0.0782i
   0.1551 - 0.1364i
   0.0822 + 0.0703i
   0.0988 - 0.0218i
  -0.1254 - 0.0417i
  -0.0735 + 0.0527i
   0.0284 + 0.0162i
   0.1112 + 0.2416i

PDF version (NAG web site, 64-bit version, 64-bit version)
Chapter Contents
Chapter Introduction
NAG Toolbox

© The Numerical Algorithms Group Ltd, Oxford, UK. 2009–2015