PARDISO Parameters in Tabular Form

FORTRAN 77: INTEGER on 32-bit architectures, INTEGER*8 on 64-bit architectures

Fortran 90: TYPE(MKL_PARDISO_HANDLE), INTENT(INOUT)

C: void*

Solver internal data address pointer

Must be initialized by zeros and never be modified later

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(IN)

C: _INTEGER_t*

Maximal number of factors in memory

Generally used value is 1

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(IN)

C: _INTEGER_t*

The number of matrix (from 1 to maxfct) to solve

[1; maxfct]

Generally used value is 1

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(IN)

C: _INTEGER_t*

Matrix type

Real and structurally symmetric

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(IN)

C: _INTEGER_t*

Controls the execution of the solver

Analysis

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(IN)

C: _INTEGER_t*

Number of equations in the sparse linear system A*X = B

FORTRAN 77: PARDISO_DATA_TYPE¹⁾

Fortran 90: PARDISO_DATA_TYPE¹⁾, INTENT(IN)

C: void*

Contains the non-zero elements of the coefficient matrix A

The size of a is the same as that of ja, and the coefficient matrix can be either real or complex. The matrix must be stored in CSR format with increasing values of ja for each row

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(IN)

C: _INTEGER_t*

rowIndex array in CSR format

ia(i) gives the index of the element in array a that contains the first non-zero element from row i of A. The last element ia(n+1) is taken to be equal to the number of non-zero elements in A, plus one.

Note: iparm(35) indicates whether row/column indexing starts from 1 or 0.

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(IN)

C: _INTEGER_t*

columns array in CSR format

The indices in each row must be sorted in increasing order. For symmetric and structurally symmetric matrices zero diagonal elements are also stored in a and ja. For symmetric matrices, the solver needs only the upper triangular part of the system.

Note: iparm(35) indicates whether row/column indexing starts from 1 or 0.

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(INOUT)

C: _INTEGER_t*

Holds the permutation vector of size n

Let B = P*A*PT be the permuted matrix. Row (column) i of A is the perm(i) row (column) of B. The numbering of the array must describe a permutation.

You can apply your own fill-in reducing ordering (iparm(5)=1) or return the permutation from the solver (iparm(5)=2 ).

Note: iparm(35) indicates whether row/column indexing starts from 1 or 0.

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(IN)

C: _INTEGER_t*

Number of right-hand sides that need to be solved for

Generally used value is 1

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(INOUT)

C: _INTEGER_t*

This array is used to pass various parameters to PARDISO and to return some useful information after execution of the solver

If iparm(1)=0 , PARDISO fills iparm(2) through iparm(64) with default values and uses them.

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(IN)

C: _INTEGER_t*

Message level information

PARDISO generates no output

FORTRAN 77: PARDISO_DATA_TYPE¹⁾

Fortran 90: PARDISO_DATA_TYPE¹⁾, INTENT(INOUT)

C: void*

Right-hand side vectors

On entry, contains the right hand side vector/matrix B, which is placed contiguously in memory. The b(i+(k-1)×nrhs) element must hold the i-th component of k-th right-hand side vector. Note that b is only accessed in the solution phase.

On output, the array is replaced with the solution if iparm(6)=1.

FORTRAN 77: PARDISO_DATA_TYPE¹⁾

Fortran 90: PARDISO_DATA_TYPE¹⁾, INTENT(OUT)

C: void*

Solution vectors

On output, if iparm(6)=1, contains solution vector/matrix X which is placed contiguously in memory. The x(i+(k-1)×nrhs) element must hold the i-th component of k-th solution vector. Note that x is only accessed in the solution phase.

FORTRAN 77: INTEGER

Fortran 90: INTEGER, INTENT(OUT)

C: _INTEGER_t*

Error indicator

No error

Real matrices, double precision

Real matrices, single precision

Complex matrices, double precision

Complex matrices, single precision

Use default values

iparm(2) -iparm(64) are filled with default values.

You must supply all values in components iparm(2) -iparm(64)

Fill-in reducing ordering for the input matrix

The minimum degree algorithm.

The nested dissection algorithm from the METIS package

The parallel (OpenMP) version of the nested dissection algorithm.

Preconditioned CGS/CG

Do not perform preconditioned Krylow-Subspace iterations.

CGS iteration replaces the computation of LU. The preconditioner is LU that is computed at the previous step (the first step or last step with a failure) in a sequence of solutions needed for identical sparsity patterns.

L controls the stopping criterion of the Krylow-Subspace iteration: epsCGS = 10^(-L) is used in the stopping criterion ||dxi|| / ||dx0|| < epsCGS, with ||dxi|| = ||inv(L*U)*ri|| and ri is the residuum at iteration i of the preconditioned Krylow-Subspace iteration.

Same as above, but CG iteration replaces the computation of LU. Designed for symmetric positive definite matrices.

User permutation

User permutation in perm array is ignored.

PARDISO uses the user supplied fill-in reducing permutation from perm array. iparm(2) is ignored.

PARDISO returns the permutation vector computed at phase 1 into perm array

Write solution on x

The array x contains the solution; right-hand side vector b is kept unchanged.

The solver stores the solution on the right-hand side b.

Note that the array x is always used.

Iterative refinement step

The solver automatically performs two steps of iterative refinements when perturbed pivots are obtained during the numerical factorization.

Maximum number of iterative refinement steps that the solver performs. The solver performs not more than the absolute value of iparm(8) steps of iterative refinement and stops the process if a satisfactory level of accuracy of the solution in terms of backward error is achieved.

The number of executed iterations is reported in iparm(7).

Same as above, but the accumulation of the residuum uses extended precision real and complex data types.

Pivoting perturbation

This parameter instructs PARDISO how to handle small pivots or zero pivots for unsymmetric matrices (mtype =11, mtype =13) and symmetric matrices (mtype =-2, mtype =-4, mtype =6).

Small pivots are perturbed with eps = 10^(-iparm(10)).

The default value for unsymmetric matrices(mtype =11, mtype=13), eps = 10^(-13).

The default value for symmetric indefinite matrices (mtype =-2, mtype=-4, mtype=6), eps = 10^(-8).

Scaling

Disable scaling. Default for symmetric indefinite matrices.

Enable scaling. Default for unsymmetric matrices.

Scale the matrix so that the diagonal elements are equal to 1 and the absolute values of the off-diagonal entries are less or equal to 1. This scaling method is applied to unsymmetric matrices (mtype = 11, mtype = 13). The scaling can also be used for symmetric indefinite matrices (mtype = -2, mtype = -4, mtype = 6) when the symmetric weighted matchings are applied (iparm(13)= 1).

Note that in the analysis phase (phase=11) you must provide the numerical values of the matrix A in case of scaling.

Solving with conjugate or transposed matrix A

Solve a Ax=b linear system.

Solve a conjugate system A^Hx = b based on the factorization of the matrix A.

Solve a transposed system A^Tx = b based on the factorization of the matrix A.

Improved accuracy using (non-) symmetric weighted matching

Disable matching. Default for symmetric indefinite matrices.

Enable matching. Default for symmetric indefinite matrices.

Maximum weighted matching algorithm to permute large elements close to the diagonal.

It is recommended to use iparm(11)= 1 (scaling) and iparm(13)= 1 (matching) for highly indefinite symmetric matrices, for example from interior point optimizations or saddle point problems.

Note that in the analysis phase (phase=11) you must provide the numerical values of the matrix A in case of symmetric weighted matching.

Report the number of non-zero elements in the factors

Enable reporting if iparm(18) < 0 on entry. The default value is -1.

Disable reporting.

Report Mflops that are necessary to factor the matrix A.

Enable report if iparm(18) < 0 on entry. This increases the reordering time.

Disable report. 0 is a default value.

Pivoting for symmetric indefinite matrices

Apply 1x1 diagonal pivoting during the factorization process.

Apply 1x1 and 2x2 Bunch and Kaufman pivoting during the factorization process.

parallel factorization control

PARDISO uses the previous algorithm for factorization. Default value.

PARDISO uses new two-level factorization algorithm.

Parallel forward/backward solve control

PARDISO uses the parallel algorithm for solve step. Default value.

PARDISO uses the sequential forward and backward solve.

Matrix checker

PARDISO does not check the sparse matrix representation.

PARDISO checks integer arrays ia and ja. In particular, PARDISO checks whether column indices are sorted in increasing order within each row.

Single or double precision of PARDISO

Input arrays (a, x and b) and all internal arrays must be presented in double precision.

Input arrays (a, x and b) must be presented in single precision.

In this case all internal computations are performed in single precision.

Enables to solve partially for sparse right-hand sides and sparse solution

Disables this option. Default value.

The right hand side is assumed to be sparse, perm(i)=1 means that the i-th component of the right hand side is nonzero, and this component of the solution vector is computed.

The right hand side is assumed to be sparse, perm(i)=1 means that the i-th component of the right hand side is nonzero, and all components of the solution vector are computed.

One- or zero-based indexing of columns and rows

One-based indexing: columns and rows indexing in arrays ia, ja, and perm starts from 1. Default value.

Zero-based indexing: columns and rows indexing in arrays ia, ja, and perm starts from 0.

PARDISO mode

In-core PARDISO

In-core PARDISO is used if the total memory needed for storing the matrix factors is less than the value of the environment variable MKL_PARDISO_OOC_MAX_CORE_SIZE. Otherwise out-of-core (OOC) PARDISO is used.

Out-of-core (OOC) PARDISO

The OOC PARDISO can solve very large problems by holding the matrix factors in files on the disk. Hence the amount of RAM required by OOC PARDISO is significantly reduced.

Number of performed iterative refinement steps

Reports the number of iterative refinement steps that were actually performed during the solve step.

Number of perturbed pivots

After factorization, contains the number of perturbed pivots for the matrix types: 11, 13, -2, -4 and -6.

Peak memory on symbolic factorization

The total peak memory in kilobytes that the solver needs during the analysis and symbolic factorization phase.

This value is only computed in phase 1.

Permanent memory on symbolic factorization

Permanent memory from the analysis and symbolic factorization phase in kilobytes that the solver needs in the factorization and solve phases.

This value is only computed in phase 1.

Size of factors/Peak memory on numerical factorization and solution

This parameter provides the size in kilobytes of the total memory consumed by in-core PARDISO for internal float point arrays. This parameter is computed in phase 1. See iparm(63) for the OOC mode.

The total peak memory consumed by PARDISO is max(iparm(15), iparm(16)+iparm(17))

CG/CGS diagnostics

CGS succeeded, reports the number of completed iterations.

CG/CGS failed (error=-4 after the solution phase)

iparm(20)= - it_cgs*10 - cgs_error.

Possible values of cgs_error:

1 - fluctuations of the residuum are too large

2 - ||dx at max_it_cgs/2|| is too large (slow convergence)

3 - stopping criterion is not reached at max_it_cgs

4 - perturbed pivots causes iterative refinement

Inertia: number of positive eigenvalues

PARDISO reports the number of positive eigenvalues for symmetric indefinite matrices

Inertia: number of negative eigenvalues

PARDISO reports the number of negative eigenvalues for symmetric indefinite matrices.

Number of zero or negative pivots

If PARDISO detects zero or negative pivot for mtype=2 or mtype=4 types, the factorization is stopped, PARDISO returns immediately with an error = -4, and iparm(30) reports the number of the equation where the first zero or negative pivot is detected.

Size of the minimum OOC memory for numerical factorization and solution

This parameter provides the size in kilobytes of the minimum memory required by OOC PARDISO for internal float point arrays. This parameter is computed in phase 1.

Total peak memory consumption of OOC PARDISO can be estimated as max(iparm(15), iparm(16)+iparm(63))