NAG Library Function Document

nag_sparse_herm_basic_solver (f11gsc)

+− Contents

1 Purpose

nag_sparse_herm_basic_solver (f11gsc) is an iterative solver for a complex Hermitian system of simultaneous linear equations; nag_sparse_herm_basic_solver (f11gsc) is the second in a suite of three functions, where the first function, nag_sparse_herm_basic_setup (f11grc), must be called prior to nag_sparse_herm_basic_solver (f11gsc) to set up the suite, and the third function in the suite, nag_sparse_herm_basic_diagnostic (f11gtc), can be used to return additional information about the computation.

These three functions are suitable for the solution of large sparse complex Hermitian systems of equations.

For a general description of the methods employed you are referred to Section 3 in nag_sparse_herm_basic_setup (f11grc).

nag_sparse_herm_basic_solver (f11gsc) can solve the system after the first function in the suite, nag_sparse_herm_basic_setup (f11grc), has been called to initialize the computation and specify the method of solution. The third function in the suite, nag_sparse_herm_basic_diagnostic (f11gtc), can be used to return additional information generated by the computation during monitoring steps and after nag_sparse_herm_basic_solver (f11gsc) has completed its tasks.

nag_sparse_herm_basic_solver (f11gsc) uses reverse communication, i.e., nag_sparse_herm_basic_solver (f11gsc) returns repeatedly to the calling program with the argument irevcm (see Section 5) set to specified values which require the calling program to carry out a specific task: either to compute the matrix-vector product v=Au; to solve the preconditioning equation Mv=u; to notify the completion of the computation; or, to allow the calling program to monitor the solution. Through the argument 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.

5 Arguments

Note: this function uses reverse communication. Its use involves an initial entry, intermediate exits and re-entries, and a final exit, as indicated by the argument irevcm. Between intermediate exits and re-entries, all arguments other thanirevcm and v must remain unchanged.

1:
irevcm – Integer *Input/Output

On initial entry: irevcm=0, otherwise an error condition will be raised.

On intermediate re-entry: irevcm must either be unchanged from its previous exit value, or can have one of the following values.

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_herm_basic_solver (f11gsc) will then return with the termination code irevcm=4. Note that before calling nag_sparse_herm_basic_solver (f11gsc) with irevcm=5 the calling program must have performed the tasks required by the value of irevcm returned by the previous call to nag_sparse_herm_basic_solver (f11gsc), otherwise subsequently returned values may be invalid.

irevcm=6

Immediate termination: nag_sparse_herm_basic_solver (f11gsc) will return immediately with termination code irevcm=4 and with any useful information available. This includes the last iterate of the solution and, for conjugate gradient only, the last iterate of the residual vector. The residual vector is generally not available when the Lanczos method (SYMMLQ) is used. nag_sparse_herm_basic_solver (f11gsc) will then return with the termination code irevcm=4.

Immediate termination may be useful, for example, when errors are detected during matrix-vector multiplication or during the solution of the preconditioning equation.

Changing irevcm to any other value between calls will result in an error.

On intermediate exit:
has the following meanings.

irevcm=1

The calling program must compute the matrix-vector product v=Au, where u and v are stored in u and v, respectively.

irevcm=2

The calling program must solve the preconditioning equation Mv=u, where u and v are stored in u and v, respectively.

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. To return additional information nag_sparse_herm_basic_diagnostic (f11gtc) can be called at this step.

On final exit: if irevcm=4, nag_sparse_herm_basic_solver (f11gsc) has completed its tasks. The value of fail.code determines whether the iteration has been successfully completed, errors have been detected or the calling program has requested termination.

Constraint:
on initial entry, irevcm=0; on re-entry, either irevcm must remain unchanged or be reset to irevcm=5 or 6.

On final exit: if after the first call fail.code=NE_BAD_PARAM, NE_INT or NE_OUT_OF_SEQUENCE, the array u is unchanged from the initial entry to nag_sparse_herm_basic_solver (f11gsc). If after an intermediate call fail.code=NE_BAD_PARAM, NE_INT or NE_OUT_OF_SEQUENCE, the array u is unchanged from the last entry to nag_sparse_herm_basic_solver (f11gsc). Otherwise, u holds the last iterate of the solution of the system of equations, for all returned values of fail.code.

On intermediate exit:
if 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.

7 Accuracy

On completion, i.e., irevcm=4 on exit, the arrays u and v will return the solution and residual vectors, xk and rk=b-Axk, respectively, at the kth iteration, the last iteration performed, unless an immediate termination was requested and the Lanczos method (SYMMLQ) was used.

On successful completion, the termination criterion is satisfied to within the user-specified tolerance, as described in Section 3 in nag_sparse_herm_basic_setup (f11grc). The computed values of the left- and right-hand sides of the termination criterion selected can be obtained by a call to nag_sparse_herm_basic_diagnostic (f11gtc).

8 Further Comments

The number of operations carried out by nag_sparse_herm_basic_solver (f11gsc) for each iteration is likely to be principally determined by the computation of the matrix-vector products v=Au and by the solution of the preconditioning equation 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_herm_basic_solver (f11gsc) for each iteration is approximately proportional to n. Note that the Lanczos method (SYMMLQ) requires a slightly larger number of operations than the conjugate gradient method.

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-=E-1AE-H.

Additional matrix-vector products are required for the computation of A1=A∞, when this has not been supplied to nag_sparse_herm_basic_setup (f11grc) and is required by the termination criterion employed.

The number of operations required to compute σ1A- is negligible for reasonable values of sigtol and maxits (see Sections 5 and 8 in nag_sparse_herm_basic_setup (f11grc)).

If the termination criterion rkp≤τbp+Ap×xkp is used (see Section 3 in nag_sparse_herm_basic_setup (f11grc)) and x0≫xk, so that because of loss of significant digits the required accuracy could not be obtained, the iteration is restarted automatically at some suitable point: nag_sparse_herm_basic_solver (f11gsc) sets x0=xk and the computation begins again. For particularly badly scaled problems, more than one restart may be necessary. Naturally, restarting adds to computational costs: it is recommended that the iteration should start from a value x0 which is as close to the true solution x~ as can be estimated. Otherwise, the iteration should start from x0=0.