String; - Maple Help

はじめる前に
新機能一覧
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[f11dcc] NAG[nag_sparse_nsym_fac_sol] - Solver with incomplete preconditioning (nonsymmetric)

Calling Sequence

f11dcc(method, nnz, a, irow, icol, ipivp, ipivq, istr, idiag, b, m, tol, maxitn, x, rnorm, itn, comm, 'n'=n, 'la'=la, 'fail'=fail)

nag_sparse_nsym_fac_sol(. . .)

Parameters

method - String;

On entry: specifies the iterative method to be used.

The restarted generalized minimum residual method is used.

The conjugate gradient squared method is used.

Then the bi-conjugate gradient stabilised method is used.

Constraint: "Nag_SparseNsym_RGMRES", "Nag_SparseNsym_CGS" or "Nag_SparseNsym_BiCGSTAB". .

nnz - integer;

On entry: the number of non-zero-elements in the matrix . This must be the same value as was supplied in the preceding call to f11dac (nag_sparse_nsym_fac).

Constraint: . .

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

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

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

On entry: the values returned in the arrays irow, icol, ipivp, ipivq, istr and idiag by a previous call to f11dac (nag_sparse_nsym_fac).

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

On entry: the right-hand side vector .

m - integer;

On entry: if , m is the dimension of the restart subspace.

If , m is the order of the polynomial Bi-CGSTAB method otherwise, m is not referenced.

Constraints:

if , ;

if , .

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 ipivp, ipivq, idiag, b, x.

On entry: the order of the matrix . This must be the same value as was supplied in the preceding call to f11dac (nag_sparse_nsym_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_nsym_fac_sol (f11dcc) is called. This must be the same value as returned by a previous call to f11dac (nag_sparse_nsym_fac).

Constraint: . .

'fail'=fail - table; (optional)

The NAG error argument, see the documentation for NagError.

Description

	Purpose
	nag_sparse_nsym_fac_sol (f11dcc) solves a real sparse nonsymmetric system of linear equations, represented in coordinate storage format, using a restarted generalized minimal residual (RGMRES), conjugate gradient squared (CGS), or stabilized bi-conjugate gradient (Bi-CGSTAB) method, with incomplete preconditioning.

Description

nag_sparse_nsym_fac_sol (f11dcc) solves a real sparse nonsymmetric linear system of equations:

using a preconditioned RGMRES (see Saad and Schultz (1986)), CGS (see Sonneveld (1989)), or Bi-CGSTAB method (see Van der Vorst (1989), Sleijpen and Fokkema (1993)).

nag_sparse_nsym_fac_sol (f11dcc) uses the incomplete factorization determined by f11dac (nag_sparse_nsym_fac) as the preconditioning matrix. A call to nag_sparse_nsym_fac_sol (f11dcc) must always be preceded by a call to f11dac (nag_sparse_nsym_fac). Alternative preconditioners for the same storage scheme are available by calling f11dec (nag_sparse_nsym_sol).

The matrix , and the preconditioning matrix , are represented in coordinate storage (CS) format (see the f11 Chapter Introduction) in the arrays a, irow and icol, as returned from f11dac (nag_sparse_nsym_fac). The array a holds the non-zero entries in 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.

You should check the output value of rnorm for acceptability. 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.

"NE_ALLOC_FAIL"

Dynamic memory allocation failed.

"NE_BAD_PARAM"

On entry, argument method had an illegal value.

"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_CS"

On entry, the CS representation of is invalid. Check that the call to nag_sparse_nsym_fac_sol (f11dcc) has been preceded by a valid call to f11dac (nag_sparse_nsym_fac), and that the arrays a, irow and icol have not been corrupted between the two calls.

"NE_INVALID_CS_PRECOND"

On entry, the CS representation of the preconditioning matrix M is invalid. Check that the call to nag_sparse_nsym_fac_sol (f11dcc) has been preceded by a valid call to f11dac (nag_sparse_nsym_fac), and that the arrays a, irow, icol, ipivp, ipivq, istr and idiag have not been corrupted between the two calls.

"NE_NOT_REQ_ACC"

The required accuracy has not been obtained in maxitn iterations.

"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_nsym_fac_sol (f11dcc) for each iteration is roughly proportional to the value of nnzc returned from the preceding call to f11dac (nag_sparse_nsym_fac).

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 coefficient matrix, .

Some illustrations of the application of nag_sparse_nsym_fac_sol (f11dcc) to linear systems arising from the discretization of two-dimensional elliptic partial differential equations, and to random-valued randomly structured linear systems, can be found in Salvini and Shaw (1996).

Examples

method := "Nag_SparseNsym_CGS":
n := 8:
nnz := 24:
la := 49:
m := 4:
tol := 1e-10:
maxitn := 100:
comm := NAG:-InitializeOptions(Nag_Sparse_Comm):
a := Vector([2, -1, 1, 4, -3, 2, -7, 2, 3, -4, 5, 5, -1, 8, -3, -6, 5, 2, -5, -1, 6, -1, 2, 3, -0.1428571428571428, -0.2857142857142857, -0.7142857142857142, -0.1666666666666667, -0.5714285714285714, -0.3333333333333333, -1, -1, 0.5714285714285714, -0.5, -5, 0.2, 0.7142857142857142, 1.2, -1, -0.6666666666666666, -2, -0.3333333333333333, -0.6000000000000001, -8, 0.3333333333333333, 1, 0.3333333333333333, 2, 0.3333333333333333], datatype=float[8]):
irow := Vector([1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8], datatype=integer[kernelopts('wordsize')/8]):
icol := Vector([1, 4, 8, 1, 2, 5, 3, 6, 1, 3, 4, 7, 2, 5, 7, 1, 3, 6, 3, 5, 7, 2, 6, 8, 1, 7, 1, 2, 7, 2, 3, 8, 1, 2, 3, 4, 1, 4, 5, 2, 5, 6, 4, 5, 6, 7, 6, 7, 8], datatype=integer[kernelopts('wordsize')/8]):
ipivp := Vector([3, 6, 1, 4, 7, 2, 5, 8], datatype=integer[kernelopts('wordsize')/8]):
ipivq := Vector([3, 1, 4, 7, 5, 2, 6, 8], datatype=integer[kernelopts('wordsize')/8]):
istr := Vector([25, 27, 30, 33, 37, 40, 43, 47, 50], datatype=integer[kernelopts('wordsize')/8]):
idiag := Vector([25, 28, 31, 36, 39, 42, 46, 49], datatype=integer[kernelopts('wordsize')/8]):
b := Vector([6, 8, -9, 46, 17, 21, 22, 34], datatype=float[8]):
x := Vector([0, 0, 0, 0, 0, 0, 0, 0], datatype=float[8]):
NAG:-f11dcc(method, nnz, a, irow, icol, ipivp, ipivq, istr, idiag, b, m, tol, maxitn, x, rnorm, itn, comm, 'n' = n, 'la' = la):