Solver with incomplete Cholesky preconditioning (symmetric)

はじめる前に
新機能一覧
Maple ワークシートの作成
Mapleワークシートを共有
Maple ウィンドウのカスタマイズ
Maple システムのカスタマイズ
コネクティビティ
Mathematics
数学
物理
プログラミング
グラフィックス
Student パッケージ
Science and Engineering
科学・エンジニアリング
アプリケーションと例題
リファレンス
システム
MapleSim
MapleSim ツールボックス
MapleSim ヘルプ
Tasks
Toolboxes
- BlockImporter
- Global Optimization
- Grid Computing
- Maple-NAG Connector
  - General information
  - Computational Routines
    - a02 (Complex Arithmetic)
    - c02 (Zeros of Polynomials)
    - c05 (Roots of One or More Transcendental Equations)
    - c06 (Fourier Transforms)
    - d01 (Quadrature)
    - d02 (Ordinary Differential Equations)
    - d03 (Partial Differential Equations)
    - d06 (Mesh Generation)
    - e01 (Interpolation)
    - e02 (Curve and Surface Fitting)
    - e04 (Minimizing or Maximizing a Function)
    - f01 (Matrix Factorizations)
    - f02 (Eigenvalues and Eigenvectors)
    - f03 (Determinants)
    - f04 (Simultaneous Linear Equations)
    - f06 (Linear Algebra Support Functions)
    - f07 (Linear Equations (LAPACK))
    - f08 (Least-squares and Eigenvalue Problems (LAPACK))
    - f11 (Large Scale Linear Systems)
      - f11 Introduction
      - f11dac (nag_sparse_nsym_fac)
      - f11dcc (nag_sparse_nsym_fac_sol)
      - f11dec (nag_sparse_nsym_sol)
      - f11jac (nag_sparse_sym_chol_fac)
      - f11jcc (nag_sparse_sym_chol_sol)
      - f11jec (nag_sparse_sym_sol)
      - f11zac (nag_sparse_nsym_sort)
      - f11zbc (nag_sparse_sym_sort)
    - f16 (NAG Interface to BLAS)
    - g01 (Simple Calculations on Statistical Data)
    - g02 (Correlation and Regression Analysis)
    - g03 (Multivariate Methods)
    - g04 (Analysis of Variance)
    - g05 (Random Number Generators)
    - g07 (Univariate Estimation)
    - g08 (Nonparametric Statistics)
    - g10 (Smoothing in Statistics)
    - g11 (Contingency Table Analysis)
    - g12 (Survival Analysis)
    - g13 (Time Series Analysis)
    - h (Operations Research)
    - m01 (Sorting)
    - s (Approximations of Special Functions)
    - x01 (Mathematical Constants)
    - x02 (Machine Constants)
    - x04 (Input-Output Utilities)
  - Getting Started
  - Example Worksheet
エラーメッセージガイド
マニュアル
数学アプリ

NAG[f11jcc] NAG[nag_sparse_sym_chol_sol] - Solver with incomplete Cholesky preconditioning (symmetric)

Calling Sequence

f11jcc(method, nnz, a, irow, icol, ipiv, istr, b, tol, maxitn, x, rnorm, itn, comm, 'n'=n, 'la'=la, 'fail'=fail)

nag_sparse_sym_chol_sol(. . .)

Parameters

method - String;

On entry: specifies the iterative method to be used.

The conjugate gradient method is used.

The Lanczos method, SYMMLQ is used.

Constraint: "Nag_SparseSym_CG" or "Nag_SparseSym_Lanczos". .

nnz - integer;

On entry: the number of non-zero elements in the lower triangular part of the matrix . This must be the same value as was supplied in the preceding call to f11jac (nag_sparse_sym_chol_fac).

Constraint: . .

a - Vector(1..la, datatype=float[8]);

On entry: the values returned in array a by a previous call to f11jac (nag_sparse_sym_chol_fac).

irow - Vector(1..la, datatype=integer[kernelopts('wordsize')/8]);
icol - Vector(1..la, datatype=integer[kernelopts('wordsize')/8]);
ipiv - Vector(1..n, datatype=integer[kernelopts('wordsize')/8]);
istr - Vector(1.., datatype=integer[kernelopts('wordsize')/8]);

On entry: the values returned in the arrays irow, icol, ipiv and istr by a previous call to f11jac (nag_sparse_sym_chol_fac).

b - Vector(1..n, datatype=float[8]);

On entry: the right-hand side vector .

tol - float;

On entry: the required tolerance. Let denote the approximate solution at iteration , and the corresponding residual. The algorithm is considered to have converged at iteration if:

If , is used, where is the machine precision. Otherwise is used.

Constraint: . .

maxitn - integer;

On entry: the maximum number of iterations allowed.

Constraint: . .

x - Vector(1..n, datatype=float[8]);

On entry: an initial approximation to the solution vector .

On exit: an improved approximation to the solution vector .

rnorm - assignable;

Note: On exit the variable rnorm will have a value of type float.

On exit: the final value of the residual norm , where is the output value of itn.

itn - assignable;

Note: On exit the variable itn will have a value of type integer.

On exit: the number of iterations carried out.

comm - Vector;

A Maple Vector, which should be generated using NAG[Nag_Sparse_Comm], corresponding to the Nag_Sparse_Comm structure.

'n'=n - integer; (optional)

Default value: the first dimension of the arrays ipiv, b, x.

On entry: the order of the matrix . This must be the same value as was supplied in the preceding call to f11jac (nag_sparse_sym_chol_fac).

Constraint: . .

'la'=la - integer; (optional)

Default value: the dimension of the arrays a, irow, icol.

On entry: the first dimension of the arrays a, irow and icol as declared in the function from which nag_sparse_sym_chol_sol (f11jcc) is called. This must be the same value as returned by a previous call to f11jac (nag_sparse_sym_chol_fac).

Constraint: . .

'fail'=fail - table; (optional)

The NAG error argument, see the documentation for NagError.

Description

	Purpose
	nag_sparse_sym_chol_sol (f11jcc) solves a real sparse symmetric system of linear equations, represented in symmetric coordinate storage format, using a conjugate gradient or Lanczos method, with incomplete Cholesky preconditioning.

Description

nag_sparse_sym_chol_sol (f11jcc) solves a real sparse symmetric linear system of equations:

using a preconditioned conjugate gradient method (Meijerink and Van der Vorst (1977)), or a preconditioned Lanczos method based on the algorithm SYMMLQ (Paige and Saunders (1975)). The conjugate gradient method is more efficient if is positive-definite, but may fail to converge for indefinite matrices. In this case the Lanczos method should be used instead. For further details see Barrett et al. (1994).

nag_sparse_sym_chol_sol (f11jcc) uses the incomplete Cholesky factorization determined by f11jac (nag_sparse_sym_chol_fac) as the preconditioning matrix. A call to nag_sparse_sym_chol_sol (f11jcc) must always be preceded by a call to f11jac (nag_sparse_sym_chol_fac). Alternative preconditioners for the same storage scheme are available by calling f11jec (nag_sparse_sym_sol).

The matrix , and the preconditioning matrix , are represented in symmetric coordinate storage (SCS) format (see the f11 Chapter Introduction) in the arrays a, irow and icol, as returned from f11jac (nag_sparse_sym_chol_fac). The array a holds the non-zero entries in the lower triangular parts of these matrices, while irow and icol hold the corresponding row and column indices.

Error Indicators and Warnings

"NE_2_INT_ARG_LT"

On entry, while . These arguments must satisfy .

"NE_ACC_LIMIT"

The required accuracy could not be obtained. However, a reasonable accuracy has been obtained and further iterations cannot improve the result.

"NE_ALLOC_FAIL"

Dynamic memory allocation failed.

"NE_BAD_PARAM"

On entry, argument method had an illegal value.

"NE_COEFF_NOT_POS_DEF"

The matrix of coefficients appears not to be positive-definite.

"NE_INT_2"

On entry, , . Constraint: .

"NE_INT_ARG_LT"

On entry, n must not be less than 1: .

"NE_INTERNAL_ERROR"

An internal error has occurred in this function. Check the function call and any array sizes. If the call is correct then please consult NAG for assistance.

"NE_INVALID_SCS"

The SCS representation of the matrix is invalid. Check that the call to nag_sparse_sym_chol_sol (f11jcc) has been preceded by a valid call to f11jac (nag_sparse_sym_chol_fac), and that the arrays a, irow and icol have not been corrupted between the two calls.

"NE_INVALID_SCS_PRECOND"

The SCS representation of the preconditioning matrix is invalid. Check that the call to nag_sparse_sym_chol_sol (f11jcc) has been preceded by a valid call to f11jac (nag_sparse_sym_chol_fac), and that the arrays a, irow, icol, ipiv and istr have not been corrupted between the two calls.

"NE_NOT_REQ_ACC"

The required accuracy has not been obtained in maxitn iterations.

"NE_PRECOND_NOT_POS_DEF"

The preconditioner appears not to be positive-definite.

"NE_REAL_ARG_GE"

On entry, tol must not be greater than or equal to 1.0: .

	Accuracy
	On successful termination, the final residual , where , satisfies the termination criterion The value of the final residual norm is returned in rnorm.

Further Comments

The time taken by nag_sparse_sym_chol_sol (f11jcc) for each iteration is roughly proportional to the value of nnzc returned from the preceding call to f11jac (nag_sparse_sym_chol_fac). One iteration with the Lanczos method (SYMMLQ) requires a slightly larger number of operations than one iteration with the conjugate gradient method.

The number of iterations required to achieve a prescribed accuracy cannot be easily determined a priori, as it can depend dramatically on the conditioning and spectrum of the preconditioned matrix of the coefficients .

Some illustrations of the application of nag_sparse_sym_chol_sol (f11jcc) to linear systems arising from the discretization of two-dimensional elliptic partial differential equations, and to random-valued randomly structured symmetric positive-definite linear systems, can be found in Salvini and Shaw (1995).

Examples

method := "Nag_SparseSym_CG":
n := 7:
nnz := 16:
la := 33:
tol := 1e-06:
maxitn := 100:
comm := NAG:-Nag_Sparse_Comm():
a := Vector([4, 1, 5, 2, 2, 3, -1, 1, 4, 1, -2, 3, 2, -1, -2, 5, 0.5, 0.3333333333333333, 0.3333333333333333, -1, 0.3333333333333333, 0.6666666666666666, 0.3333333333333333, -0.3333333333333333, 0.3333333333333333, 0.3333333333333333, -0.6666666666666666, 0.4285714285714286, 0.6666666666666666, 0.5555555555555555, -0.4285714285714286, 0.762096774193548, 0.762096774193548], datatype=float[8]):
irow := Vector([1, 2, 2, 3, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 1, 2, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 7], datatype=integer[kernelopts('wordsize')/8]):
icol := Vector([1, 1, 2, 3, 2, 4, 1, 4, 5, 2, 5, 6, 1, 2, 3, 7, 1, 2, 3, 1, 4, 2, 3, 4, 5, 2, 3, 6, 4, 5, 6, 7, 7], datatype=integer[kernelopts('wordsize')/8]):
ipiv := Vector([3, 4, 6, 7, 2, 5, 1], datatype=integer[kernelopts('wordsize')/8]):
istr := Vector([17, 18, 19, 20, 22, 26, 29, 33], datatype=integer[kernelopts('wordsize')/8]):
b := Vector([15, 18, -8, 21, 11, 10, 29], datatype=float[8]):
x := Vector([0, 0, 0, 0, 0, 0, 0], datatype=float[8]):
NAG:-f11jcc(method, nnz, a, irow, icol, ipiv, istr, b, tol, maxitn, x, rnorm, itn, comm, 'n' = n, 'la' = la):