# pardiso

Calculates the solution of a set of sparse linear equations with multiple right-hand sides.

## Syntax

Fortran:

call pardiso (pt, maxfct, mnum, type, phase, n, a, ia, ja, perm, nrhs, iparm, msglvl, b, x, error)

C:

pardiso (pt, &maxfct, &mnum, &mtype, &phase, &n, a, ia, ja, perm, &nrhs, iparm, &msglvl, b, x, &error);

(An underscore may or may not be required after “pardiso” depending on the OS and compiler conventions for that OS).

Interface:

SUBROUTINE pardiso (pt, maxfct, mnum, mtype, phase, n, a, ia, ja, perm, nrhs, iparm, msglvl, b, x, error)

INTEGER *4 pt (64)

INTEGER *4 maxfct, mnum, mtype, phase, n, nrhs, error, ia(*), ja(*), perm(*), iparm(*)

REAL *8 a(*), b(n,nrhs), x(n,nrhs)

Note that the above interface is given for the 32-bit architectures. For 64-bit architectures, the argument pt(64) must be defined as INTEGER*8 type.

## Description

PARDISO calculates the solution of a set of sparse linear equations
`A*X = B`
with multiple right-hand sides, using a parallel LU, LDL or LLT factorization, where A is an n-by-n matrix, and X and B are n-by-nrhs matrices. PARDISO performs the following analysis steps depending on the structure of the input matrix A.

Symmetric Matrices: The solver first computes a symmetric fill-in reducing permutation P based on either the minimum degree algorithm [Liu85] or the nested dissection algorithm from the METIS package [Karypis98] (included with Intel MKL), followed by the parallel left-right looking numerical Cholesky factorization [Schenk00-2] of `PAPT = LLT` for symmetric positive-definite matrices, or PAPT = LDLT for symmetric indefinite matrices. The solver uses diagonal pivoting, or 1x1 and 2x2 Bunch and Kaufman pivoting for symmetric indefinite matrices, and an approximation of X is found by forward and backward substitution and iterative refinements.

The coefficient matrix is perturbed whenever numerically acceptable 1x1 and 2x2 pivots cannot be found within the diagonal supernode block. One or two passes of iterative refinements may be required to correct the effect of the perturbations. This restricting notion of pivoting with iterative refinements is effective for highly indefinite symmetric systems. Furthermore the accuracy of this method is for a large set of matrices from different applications areas as accurate as a direct factorization method that uses complete sparse pivoting techniques [Schenk04].

Another possibility to improve the pivoting accuracy is to use symmetric weighted matching algorithms. These methods identify large entries in the coefficient matrix A that, if permuted close to the diagonal, permit the factorization process to identify more acceptable pivots and proceed with fewer pivot perturbations. The methods are based on maximum weighted matchings and improve the quality of the factor in a complementary way to the alternative idea of using more complete pivoting techniques.

The inertia is also computed for real symmetric indefinite matrices.

Structurally Symmetric Matrices: The solver first computes a symmetric fill-in reducing permutation P followed by the parallel numerical factorization of PAPT = QLUT. The solver uses partial pivoting in the supernodes and an approximation of X is found by forward and backward substitution and iterative refinements.

Unsymmetric Matrices: The solver first computes a non-symmetric permutation PMPS and scaling matrices Dr and Dc with the aim to place large entries on the diagonal that enhances reliability of the numerical factorization process [Duff99]. In the next step the solver computes a fill-in reducing permutation P based on the matrix PMPSA + (PMPSA)T followed by the parallel numerical factorization
`QLUR = PPMPSDrADcP`
with supernode pivoting matrices Q and R. When the factorization algorithm reaches a point where it cannot factorize the supernodes with this pivoting strategy, it uses a pivoting perturbation strategy similar to [Li99]. The magnitude of the potential pivot is tested against a constant threshold of `alpha = eps*||A2||inf` , where `eps` is the machine precision, `A2 = P*PMPS*Dr*A*Dc*P`, and `||A2||inf` is the infinity norm of the scaled and permuted matrix A. Any tiny pivots encountered during elimination are set to the sign `(lII)*eps*||A2||inf`, which trades off some numerical stability for the ability to keep pivots from getting too small. Although many failures could render the factorization well-defined but essentially useless, in practice the diagonal elements are rarely modified for a large class of matrices. The result of this pivoting approach is that the factorization is, in general, not exact and iterative refinement may be needed.

Direct-Iterative Preconditioning for Unsymmetric Linear Systems. The solver also allows for a combination of direct and iterative methods [Sonn89] to accelerate the linear solution process for transient simulation. Most of applications of sparse solvers require solutions of systems with gradually changing values of the nonzero coefficient matrix, but the same identical sparsity pattern. In these applications, the analysis phase of the solvers has to be performed only once and the numerical factorizations are the important time-consuming steps during the simulation. PARDISO uses a numerical factorization `A = LU` for the first system and applies the factors L and U for the next steps in a preconditioned Krylow-Subspace iteration. If the iteration does not converge, the solver automatically switches back to the numerical factorization. This method can be applied to unsymmetric matrices in PARDISO and the user can select the method using only one input parameter. For further details see the parameter description (iparm(4), iparm(20)).

The sparse data storage in PARDISO follows the scheme described in Sparse Matrix Storage Format section with ja standing for columns, ia for rowIndex, and a for values. The algorithms in PARDISO require column indices ja to be increasingly ordered per row and the presence of the diagonal element per row for any symmetric or structurally symmetric matrix. The unsymmetric matrices need no diagonal elements in the PARDISO solver.

PARDISO performs four tasks:

- analysis and symbolic factorization
- numerical factorization
- forward and backward substitution including iterative refinement
- termination to release all internal solver memory.

When an input data structure is not accessed in a call, a `NULL` pointer or any valid address can be passed as a place holder for that argument.

## Input Parameters

pt

  INTEGER*4 for 32 -bit operating systems;

  INTEGER*8 for 64 -bit operating systems

  Array, DIMENSION (64)

  On entry, solver internal data address pointer. These addresses are passed to the solver and all related internal memory management is organized through this pointer

  ### Note

  pt is an integer array with 64 entries. It is very important that the pointer is initialized with zero at the first call of PARDISO. After that first call you should never modify the pointer, as a serious memory leak can occur. The integer length should be 4-byte on 32-bit operating systems and 8-byte on 64-bit operating systems.

maxfct

  INTEGER

  Maximal number of factors with identical nonzero sparsity structure that the user would like to keep at the same time in memory. It is possible to store several different factorizations with the same nonzero structure at the same time in the internal data management of the solver. In most of the applications this value is equal to 1.

  PARDISO can process several matrices with identical matrix sparsity pattern and store the factors of these matrices at the same time. Matrices with a different sparsity structure can be kept in memory with different memory address pointers pt.

mnum

  INTEGER

  Actual matrix for the solution phase. With this scalar you can define the matrix that you would like to factorize. The value must be: `1 ≤ mnum ≤ maxfct`.

  In most applications this value is equal to 1.

mtype

  INTEGER

  This scalar value defines the matrix type. The PARDISO solver supports the following matrices:

  = 1
    real and structurally symmetric matrix
  = 2
    real and symmetric positive definite matrix
  = -2
    real and symmetric indefinite matrix
  = 3
    complex and structurally symmetric matrix
  = 4
    complex and Hermitian positive definite matrix
  = -4
    complex and Hermitian indefinite matrix
  = 6
    complex and symmetric matrix
  = 11
    real and unsymmetric matrix
  = 13
    complex and unsymmetric matrix

  This parameter influences the pivoting method.

phase

  INTEGER

  Controls the execution of the solver. It is a two-digit integer ij (`10I + j, 1≤ I ≤3, I<j ≤3` for normal execution modes). The I digit indicates the starting phase of execution, and j indicates the ending phase. PARDISO has the following phases of execution:

  - Phase 1: Fill-reduction analysis and symbolic factorization

  - Phase 2: Numerical factorization

  - Phase 3: Forward and Backward solve including iterative refinements

  - Termination and Memory Release Phase (phase≤ 0)

  If a previous call to the routine has computed information from previous phases, execution may start at any phase. The phase parameter can have the following values:

  phase
    Solver Execution Steps
  `11`
    Analysis
  `12`
    Analysis, numerical factorization
  `13`
    Analysis, numerical factorization, solve, iterative refinement
  `22`
    Numerical factorization
  `23`
    Numerical factorization, solve, iterative refinement
  `33`
    Solve, iterative refinement
  `0`
    Release internal memory for L and U matrix number mnum
  `-1`
    Release all internal memory for all matrices
n

  INTEGER

  Number of equations in the sparse linear systems of equations `A*X = B`. Constraint: `n > 0`.

a

  REAL/COMPLEX

  Array. Contains the nonzero values of the coefficient matrix A corresponding to the indices in ja. 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 compressed sparse row format with increasing values of ja for each row. Refer to values array description in Sparse Matrix Storage Format for more details.

  ### Note

  The nonzeros of each row of the matrix A must be stored in increasing order. For symmetric or structural symmetric matrices, it is also important that the diagonal elements are available and stored in the matrix. If the matrix is symmetric, the array a is only accessed in the factorization phase, in the triangular solution and iterative refinement phase. Unsymmetric matrices are accessed in all phases of the solution process.

ia

  INTEGER

  Array, dimension `(n+1)`. For `I≤n`, ia(I) points to the first column index of row I in the array ja in compressed sparse row format. That is, 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-zeros in A, plus one. Refer to rowIndex array description in Sparse Matrix Storage Format for more details. The array ia is also accessed in all phases of the solution process. Note that the row and columns numbers start from 1.

ja

  INTEGER

  Array. `ja(*)` contains column indices of the sparse matrix A stored in compressed sparse row format. The indices in each row must be sorted in increasing order. The array ja is also accessed in all phases of the solution process. For symmetric and structurally symmetric matrices it is assumed that zero diagonal elements are also stored in the list of nonzeros in a and ja. For symmetric matrices, the solver needs only the upper triangular part of the system as is shown for columns array in Sparse Matrix Storage Format.

perm

  INTEGER

  Array, dimension (n). Holds the permutation vector of size n. The array perm is defined as follows. Let A be the original matrix and `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 start with 1 and must describe a permutation.

  On entry, you can apply your own fill-in reducing ordering to the solver. The permutation vector perm is only accessed if `iparm(5) = 1`.

nrhs

  INTEGER

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

iparm

  INTEGER

  Array, dimension (`64`). 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`(1)`, and iparm`(4)` through iparm`(64)`with default values and uses them. Note that there is no default value for iparm`(3)` and the user should supply this value, whether iparm`(1)` is 0 or 1.

  Individual components of the iparm array are described below (some of them are described in the Output Parameters section).

  iparm`(1)`- use default values.

  If `iparm`(1)` = 0`, iparm`(2)` and iparm`(4)` through iparm`(64)` are filled with default values, otherwise the user has to supply all values in iparm from iparm`(2)` to iparm`(64)`.

  iparm`(2)` - fill-in reducing ordering.

  iparm`(2)` controls the fill-in reducing ordering for the input matrix. If iparm`(2)` is 0, the minimum degree algorithm is applied [Li99], if iparm`(2)` is 2, the solver uses the nested dissection algorithm from the METIS package [Karypis98]. The default value of iparm`(2)` is 2.

  iparm`(3)`- number of processors.

  iparm`(3)` must contain the number of processors that are available for the parallel execution. The number must be equal to the MKL environment variable `MKL_NUM_THREADS`.

  ### Caution

  User is supposed to control the parallel execution of the solver by explicitly setting `MKL_NUM_THREADS`. If less processors are available than specified, the execution may slow down instead of speeding up.

  There is no default value for iparm`(3)`.

  iparm`(4)` - preconditioned CGS.

  This parameter controls preconditioned CGS [Sonn89] for unsymmetric or structural symmetric matrices and Conjugate-Gradients for symmetric matrices. iparm`(4)` has the form
  `iparm`(4)`= `10*L+K``

  The K and L values have the meanings as follow.

  Value of K
    Description
  `0`
    The factorization is always computed as required by phase.
  `1`
    CGS iteration replaces the computation of LU. The preconditioner is LU that was computed at a previous step (the first step or last step with a failure) in a sequence of solutions needed for identical sparsity patterns.
  `2`
    CG iteration for symmetric matrices replaces the computation of LU. The preconditioner is LU that was computed at a previous step (the first step or last step with a failure) in a sequence of solutions needed for identical sparsity patterns.

  Value L:

  The value L controls the stopping criterion of the Krylow-Subspace iteration:

  `epsCGS = 10-L` is used in the stopping criterion
  `||dxI|| / ||dx1|| < epsCGS`
  with `||dxI|| = ||inv(L*U)*rI||` and rI is the residuum at iteration I of the preconditioned Krylow-Subspace iteration.

  Strategy: A maximum number of 150 iterations is fixed by expecting that the iteration will converge before consuming half the factorization time. Intermediate convergence rates and residuum excursions are checked and can terminate the iteration process. If `phase =23`, then the factorization for a given A is automatically recomputed in these cases where the Krylow-Subspace iteration failed, and the corresponding direct solution is returned. Otherwise the solution from the preconditioned Krylow-Subspace iteration is returned. Using `phase =33` results in an error message (`error =4`) if the stopping criteria for the Krylow-Subspace iteration can not be reached. More information on the failure can be obtained from iparm`(20)`.

  The default is iparm`(4)=0`, and other values are only recommended for an advanced user. iparm`(4)` must be greater or equal to zero.

  Examples:

  iparm`(4)`
    Description
  `31`
    LU-preconditioned CGS iteration with a stopping criterion of 1.0E-3 for unsymmetric matrices
  `61`
    LU-preconditioned CGS iteration with a stopping criterion of 1.0E-6 for unsymmetric matrices
  `62`
    LU-preconditioned CGS iteration with a stopping criterion of 1.0E-6 for symmetric matrices

  iparm`(5)`- user permutation.

  This parameter controls whether the user supplied fill-in reducing permutation is used instead of the integrated multiple-minimum degree or nested dissection algorithms.

  This option may be useful for testing reordering algorithms or adapting the code to special applications problems (for instance, to move zero diagonal elements to the end `P*A*PT`). For definition of the permutation, see description of the perm parameter.

  The default value of iparm`(5)` is 0.

  iparm`(6)`- write solution on x.

  If iparm`(6)`is 0 (which is the default), then the array x contains the solution and the value of b is not changed. If iparm`(6)` is 1, then the solver will store the solution on the right hand side b.

  Note that the array x is always used. The default value of iparm`(6)` is 0.

  iparm`(8)`

  On entry to the solve and iterative refinement step, iparm`(8)`should be set to the maximum number of iterative refinement steps that the solver will perform. The solver will not perform more than the absolute value of iparm`(8)`steps of iterative refinement and will stop the process if a satisfactory level of accuracy of the solution in terms of backward error has been achieved.

  Note that if iparm`(8)`< 0, the accumulation of the residuum is using extended precision real and complex data types. Perturbed pivots result in iterative refinement (independent of `iparm`(8)`=0`) and the iteration number executed is reported on iparm`(7)`.

  The solver will automatically perform two steps of iterative refinements when perturbed pivots have been obtained during the numerical factorization and iparm`(8)` was equal to zero.

  The number of performed iterative refinement steps is reported on iparm`(8)`.

  The default value for iparm`(8)` is 0.

  iparm`(9)`

  This parameter is reserved for future use. Its value must be set to 0.

  iparm`(10)`- pivoting perturbation.

  This parameter instructs PARDISO how to handle small pivots or zero pivots for unsymmetric matrices (`mtype =11` or `mtype =13`) and symmetric matrices (`mtype =-2`, `mtype =-4`, or `mtype =6`). For these matrices the solver uses a complete supernode pivoting approach. When the factorization algorithm reaches a point where it cannot factorize the supernodes with this pivoting strategy, it uses a pivoting perturbation strategy similar to [Li99], [Schenk04].

  The magnitude of the potential pivot is tested against a constant threshold of
  `alpha = eps*||A2||inf,`
  where `eps = 10`(-iparm(10))``, `A2 = P*PMPS*Dr*A*Dc*P`, and `||A2||inf` is the infinity norm of the scaled and permuted matrix A. Any tiny pivots encountered during elimination are set to the sign `(l`I``I`)*eps*||A2||inf` - this trades off some numerical stability for the ability to keep pivots from getting too small. Small pivots are therefore perturbed with `eps = 10`(-iparm(10))``.

  The default value of iparm`(10)` is 13 and therefore `eps = 1.0E-13` for unsymmetric matrices (`mtype =11` or `mtype =13`).

  The default value of iparm`(10)` is 8, and therefore `eps = 1.0E-8` for symmetric indefinite matrices (`mtype =-2`, `mtype =-4`, or `mtype =6`).

  iparm`(11)`- scaling vectors.

  PARDISO uses a maximum weight matching algorithm to permute large elements on the diagonal and to 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 only to unsymmetric matrices (`mtype =11` or `mtype =13`). The scaling can also be used for symmetric indefinite matrices (`mtype =-2`, `mtype =-4`, or `mtype =6`) when the symmetric weighted matchings are applied (`iparm`(13)`= 1`).

  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 scaling and symmetric weighted matching.

  The default value of iparm`(11)` is 1 for unsymmetric matrices (`mtype =11` or `mtype =13`). The default value of iparm`(11)` is 0 for symmetric indefinite matrices (`mtype =-2`, `mtype =-4`, or `mtype =6`).

  iparm`(12)`

  This parameter is reserved for future use. Its value must be set to 0.

  iparm`(13)` - improved accuracy using (non-)symmetric weighted matchings.

  PARDISO can use a maximum weighted matching algorithm to permute large elements close the diagonal. This strategy adds an additional level of reliability to our factorization methods and can be seen as a complement to the alternative idea of using more complete pivoting techniques during the numerical factorization.

  It is recommended to use iparm`(11)`=1 (scalings) and iparm`(13)`=1 (matchings) for highly indefinite symmetric matrices, for example from interior point optimizations or saddle point problems. It is also very important to note that in the analysis phase (phase `=11`) you must provide the numerical values of the matrix A in the case of scalings and symmetric weighted matchings.

  The default value of iparm`(13)` is 1 for unsymmetric matrices (`mtype =11` or `mtype =13`). The default value of iparm`(13)` is 0 for symmetric matrices (`mtype =-2`, `mtype =-4`, or `mtype =6`).

  iparm`(18)`

  The solver will report the numbers of nonzeros on the factors if `iparm`(18)`< 0` on entry.

  The default value of iparm`(18)` is -1.

  iparm`(19)`- MFlops of factorization.

  If `iparm`(19)`< 0` on entry, the solver will report MFlop (1.0E6) that are necessary to factor the matrix A. This will increase the reordering time.

  The default value of iparm`(19)` is 0.

  iparm`(21)` - pivoting for symmetric indefinite matrices

  iparm`(21)`controls the pivoting method for sparse symmetric indefinite matrices. If iparm`(21)` is 0, then 1x1 diagonal pivoting is used. If iparm`(21)` is 1, then 1x1 and 2x2 Bunch and Kaufman pivoting will be used in the factorization process. If iparm`(21)` is 2, a very robust preprocessing method based on symmetric weighted matchings and 1x1 and 2x2 Bunch and Kaufman pivoting will be used in the factorization process. The default value of iparm(21) is 1. Bunch and Kaufman pivoting is available for matrices: `mtype=-2`, `mtype=-4`, or `mtype=6`.

  iparm`(60)`

  iparm`(60)` controls what version of PARDISO - out-of-core (OOC) version or in-core version - is used. The OOC PARDISO can solve very large problems by holding the matrix factors in files on the disk. Because of that the amount of main memory required by OOC PARDISO is significantly reduced.

  ### Warning

  The current OOC version does not use threading, thus both the parameter `iparm(3)` and the variable MKL_NUM_THREADS must be set to 1 when iparm`(60)` is equal to 1 or 2.

  If iparm`(60)` is set to 0, then the in-core PARDISO is used. If iparm`(60)` is set to 2 - the OOC PARDISO is used. If iparm`(60)` is set to 1 - the in-core PARDISO is used if the total memory (in MBytes) needed for storing the matrix factors is less than the value of the environment variable MKL_PARDISO_OOC_MAX_CORE_SIZE (its default value is 2000), and OOC PARDISO is used otherwise.

  The default value of iparm`(60)` is 0.

  Note that if iparm`(60)` is equal to 1 or 2, and the total peak memory needed for strong local arrays is less than MKL_PARDISO_OOC_MAX_CORE_SIZE, the program stops with error -9. In this case, increase of MKL_PARDISO_OOC_MAX_CORE_SIZE is recommended.

  OOC parameters can be set in the configuration file. You can set the path to this file and its name via environmental variable MKL_PARDISO_OOC_CFG_PATH and MKL_PARDISO_OOC_CFG_FILE_NAME.

  Path and name are as follows:

  <MKL_PARDISO_OOC_CFG_PATH >/< MKL_PARDISO_OOC_CFG_FILE_NAME> for Linux* OS, and

  <MKL_PARDISO_OOC_CFG_PATH >\< MKL_PARDISO_OOC_CFG_FILE_NAME> for Windows* OS.

  By default, the name of the file is pardiso_ooc.cfg and it is placed to the current directory.

  All temporary data files can be deleted or stored when the calculations are completed in accordance with the value of the environmental variable MKL_PARDISO_OOC_KEEP_FILE. If it is set to 1 (default value) - all files are deleted, if it is set to 0 - all files are stored.

  By default, the OOC PARDISO uses the current directory for storing data, and all work arrays associated with the matrix factors are stored in files named ooc_temp with different extensions. These default values can be changed by using the environmental variable MKL_PARDISO_OOC_PATH.

  To set the environmental variables MKL_PARDISO_OOC_MAX_CORE_SIZE, MKL_PARDISO_OOC_KEEP_FILE, and MKL_PARDISO_OOC_PATH, the configuration file should be created with the following lines:

  `MKL_PARDISO_OOC_PATH = <path>\ooc_file`

  `MKL_PARDISO_OOC_MAX_CORE_SIZE = N`

  `MKL_PARDISO_OOC_KEEP_FILE = 0 (or 1)`

  where `<path>` - the directory for storing data, `ooc_file` - file name without extension, N - memory size in MBytes, it is not recommended to set this value greater than the size of the available RAM (default value - 2000 MBytes).

  Alternatively the environment variables can be set via command line:

  `export MKL_PARDISO_OOC_PATH = <path>/ooc_file`

  `export MKL_PARDISO_OOC_MAX_CORE_SIZE = N`

  `export MKL_PARDISO_OOC_KEEP_FILE = 0 (or 1)`

  for Linux* OS, and

  `set MKL_PARDISO_OOC_PATH = <path>\ooc_file`

  `set MKL_PARDISO_OOC_MAX_CORE_SIZE = N`

  `set MKL_PARDISO_OOC_KEEP_FILE = 0 (or 1)`

  for Windows* OS.

  ### Note

  The values specified in a command line have higher priorities - it means that if variable is changed in the configuration file and in the command line, OOC PARDISO uses only value defined in the command line. Setting OOC parameters via command line is recommended.

msglvl

  INTEGER

  Message level information. If `msglvl = 0` then PARDISO generates no output, if `msglvl = 1` the solver prints statistical information to the screen.

b

  REAL/COMPLEX

  Array, dimension (n,nrhs). On entry, contains the right hand side vector/matrix B. Note that b is only accessed in the solution phase.

## Output Parameters

pt

  This parameter contains internal address pointers.

iparm

  On output, some iparm values will report useful information, for example, numbers of nonzeros in the factors, and so on.

  iparm`(7)`- number of performed iterative refinement steps.

  The number of iterative refinement steps that are actually performed during the solve step.

  iparm`(14)`- number of perturbed pivots.

  After factorization, iparm`(14)` contains the number of perturbed pivots during the elimination process for `mtype =11`, `mtype =13`, `mtype =-2`, `mtype =-4`, or `mtype =-6`.

  iparm`(15)` - peak memory symbolic factorization.

  The parameter iparm`(15)` provides the user with the total peak memory in KBytes that the solver needed during the analysis and symbolic factorization phase. This value is only computed in phase 1.

  iparm`(16)` - permanent memory symbolic factorization.

  The parameter iparm`(16)` provides the user with the permanent memory in KBytes that the solver needed from the analysis and symbolic factorization phase in the factorization and solve phases. This value is only computed in phase 1.

  iparm`(17)` - memory numerical factorization and solution.

  The parameter iparm`(17)` provides the user with the total double precision memory consumption (KBytes) of the solver for the factorization and solve phases. This value is only computed in phase 2.

  Note that the total peak memory solver consumption is max(iparm`(15)`, iparm`(16)`+iparm`(17)`)

  iparm`(18)` - number of nonzeros in factors.

  The solver will report the numbers of nonzeros on the factors if iparm`(18)` < 0 on entry.

  iparm`(19)` - MFlops of factorization.

  Number of operations in MFlop (1.0E6 operations) that are necessary to factor the matrix A are returned to the user if iparm`(19)` < 0 on entry.

  iparm`(20)` - CG/CGS diagnostics.

  The value is used to give CG/CGS diagnostics (for example, the number of iterations and cause of failure):

  If `iparm(20)> 0`, CGS succeeded, and the number of iterations executed are reported in iparm`(20)`.

  If `iparm(20)< 0`, iterations executed, but CG/CGS failed. The error report details in iparm`(20)` are of the form: `iparm`(20)`= - it_cgs*10 - cgs_error`.

  If phase is 23, then the factors L, U are recomputed for the matrix A and the error flag error is zero in case of a successful factorization. If phase is `33`, then `error = -4` signals the failure.

  Description of `cgs_error` is given in the table below:

  cgs_error
    Description
  `1`
    - fluctuations of the residuum are too large
  `2`
    - `||dxmax_it_cgs/2||` too large (slow convergence)
  `3`
    - stopping criterion not reached at `max_it_cgs`
  `4`
    - perturbed pivots caused iterative refinement
  `5`
    - factorization is too fast for this matrix. It is better to use the factorization method with iparm`(4)`=0

  iparm`(22)`- inertia: number of positive eigenvalues.

  The parameter iparm`(22)` reports the number of positive eigenvalues for symmetric indefinite matrices.

  iparm`(23)`- inertia: number of negative eigenvalues.

  The parameter iparm`(23)` reports the number of negative eigenvalues for symmetric indefinite matrices.

  iparm`(24)` to iparm`(59)`

  These parameters are reserved for future use. Their values must be set to 0.

  iparm`(61)` - the total peak memory in MBytes that the solver used during the analysis and symbolic factorization phases if the in-core PARDISO is used. iparm(61) is similar to iparm(15), but iparm(15) returns the value of the total peak memory if the OOC PARDISO is used.

  iparm`(62)` - the total double precision memory consumption in MBytes that the solver used during the analysis and symbolic factorization phase in the factorization and solver phases if the in-core PARDISO is used. iparm(62) is similar to iparm(16), but iparm(16) returns the value of the memory consumption if the OOC PARDISO is used.

  iparm`(63)` - the total double precision memory consumption in MBytes that the solver used for factorization and solution phases if the in-core PARDISO is used. Value of iparm(63) is similar to iparm(17), but iparm(17) returns the value of the memory consumption if the OOC PARDISO is used.

b

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

x

  REAL/COMPLEX

  Array, dimension (n,nrhs). On output, contains solution if iparm`(6)=0`. Note that x is only accessed in the solution phase.

error

  INTEGER

  The error indicator according to the below table:

  error
    Information
  `0`
    no error
  `-1`
    input inconsistent
  `-2`
    not enough memory
  `-3`
    reordering problem
  `-4`
    zero pivot, numerical factorization or iterative refinement problem
  `-5`
    unclassified (internal) error
  `-6`
    preordering failed (matrix types 11, 13 only)
  `-7`
    diagonal matrix problem
  `-8`
    32-bit integer overflow problem
  `-9`
    not enough memory for OOC
  `-10`
    problems with opening OOC temporary files
  `-11`
    read/write problems with the OOC data file

Parent topic: PARDISO* - Parallel Direct Sparse Solver Interface