Calculates the solution of a set of sparse linear equations with single or multiple righthand sides.
Syntax
Fortran:

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

void pardiso (_MKL_DSS_HANDLE_t pt, MKL_INT *maxfct, MKL_INT *mnum, MKL_INT *mtype, MKL_INT *phase, MKL_INT *n, void *a, MKL_INT *ia, MKL_INT *ja, MKL_INT *perm, MKL_INT *nrhs, MKL_INT *iparm, MKL_INT *msglvl, void *b, void *x, MKL_INT *error);
Description
The routine pardiso calculates the solution of a set of sparse linear equations
A*X = Bwith single or multiple righthand sides, using a parallel LU, LDL, or LL^{T} factorization, where A is an nbyn matrix, and X and B are nbynrhs vectors or matrices.
Note
This routine supports the Progress Routine feature. See Progress Function for details.
Input Parameters

Note
The types given for parameters in this section are specified in FORTRAN 77 notation. See Intel MKL PARDISO Parameters in Tabular Form for detailed description of types of Intel MKL PARDISO parameters in Fortran 90 and C notations.
 pt

INTEGER for 32bit or 64bit architectures
INTEGER*8 for 64bit architectures
Array with dimension of 64.
Handle to internal data structure. The entries must be set to zero prior to the first call to pardiso. Unique for factorization.
Caution
After the first call to pardiso do not directly modify pt, as that could cause a serious memory leak.
Use the pardiso_handle_store or pardiso_handle_store_64 routine to store the content of pt to a file. Restore the contents of pt from the file using pardiso_handle_restore or pardiso_handle_restore_64. Use pardiso_handle_store and pardiso_handle_restore with pardiso, and pardiso_handle_store_64 and pardiso_handle_restore_64 with pardiso_64.
 maxfct

INTEGER
Maximum number of factors with identical sparsity structure that must be kept in memory at the same time. In most applications this value is equal to 1. It is possible to store several different factorizations with the same nonzero structure at the same time in the internal data structure management of the solver.
pardiso can process several matrices with an identical matrix sparsity pattern and it can 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
Indicates the actual matrix for the solution phase. With this scalar you can define which matrix to factorize. The value must be:
1 ≤ mnum ≤ maxfct
.In most applications this value is 1.
 mtype

INTEGER
Defines the matrix type, which influences the pivoting method. The Intel MKL PARDISO solver supports the following matrices:
 1

real and structurally symmetric
 2

real and symmetric positive definite
 2

real and symmetric indefinite
 3

complex and structurally symmetric
 4

complex and Hermitian positive definite
 4

complex and Hermitian indefinite
 6

complex and symmetric
 11

real and nonsymmetric
 13

complex and nonsymmetric
 phase

Controls the execution of the solver. Usually it is a two or threedigit integer. The first digit indicates the starting phase of execution and the second digit indicates the ending phase. Intel MKL PARDISO has the following phases of execution:

Phase 1: Fillreduction analysis and symbolic factorization

Phase 2: Numerical factorization

Phase 3: Forward and Backward solve including optional iterative refinement
This phase can be divided into two or three separate substitutions: forward, backward, and diagonal (see Separate Forward and Backward Substitution).

Memory release phase (phase= 0 or phase= 1)
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
331

like phase=33, but only forward substitution
332

like phase=33, but only diagonal substitution (if available)
333

like phase=33, but only backward substitution
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

DOUBLE PRECISION  for real types of matrices (mtype=1, 2, 2 and 11) and for double precision Intel MKL PARDISO (
iparm(28)
=0)REAL  for real types of matrices (mtype=1, 2, 2 and 11) and for single precision Intel MKL PARDISO (
iparm(28)
=1)DOUBLE COMPLEX  for complex types of matrices (mtype=3, 6, 13, 14 and 4) and for double precision Intel MKL PARDISO (
iparm(28)
=0)COMPLEX  for complex types of matrices (mtype=3, 6, 13, 14 and 4) and for single precision Intel MKL PARDISO (
iparm(28)
=1)Array. Contains the nonzero elements 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 the threearray variant of the compressed sparse row (CSR3) format with increasing values of ja for each row. Refer to values array description in Storage Formats for the Direct Sparse Solvers for more details.
 ia

INTEGER
Array, dimension
(n+1)
. Fori≤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 nonzero element from row i of A. The last element ia(n+1)
is taken to be equal to the number of nonzero elements in A, plus one. Refer to rowIndex array description in Storage Formats for the Direct Sparse Solvers for more details. The array ia is also accessed in all phases of the solution process.Indexing of ia is onebased by default, but it can be changed to zerobased by setting the appropriate value to the parameter
iparm(35)
.  ja

INTEGER
Array
ja(*)
contains column indices of the sparse matrix A stored in compressed sparse row format. It is important that the indices are in increasing order per row. The array ja is also accessed in all phases of the solution process. For structurally symmetric matrices it is assumed that all diagonal elements are stored (even if they are zeros) in the list of nonzero elements 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 Storage Formats for the Direct Sparse Solvers.Indexing of ja is onebased by default, but it can be changed to zerobased by setting the appropriate value to the parameter
iparm(35)
.  perm

INTEGER
Array, dimension (n). Depending on the value of
iparm(5)
andiparm(31)
, either holds the permutation vector of size n or specifies elements used for computing a partial solution.
If
iparm(5)
= 1 andiparm(31)
= 0, perm specifies the fillin reducing ordering to the solver. Let A be the original matrix andC = P*A*P^{T}
be the permuted matrix. Row (column)i
of C is theperm(i)
row (column) of A. The array perm is also used to return the permutation vector calculated during fillin reducing ordering stage.Note
Be aware that setting
iparm(5)
= 1 prevents use of a parallel algorithm for the solve step. 
If
iparm(5)
= 2 andiparm(31)
= 0, the computed permutation vector is returned in the perm array. 
If
iparm(5)
= 0 andiparm(31)
> 0, perm specifies elements of the righthand side to use or of the solution to compute for a partial solution.
See
iparm(5)
andiparm(31)
for more details.Indexing of perm is onebased by default, but it can be changed to zerobased by setting the appropriate value to the parameter
iparm(35)
. 
 nrhs

INTEGER
Number of righthand sides that need to be solved for.
 iparm

INTEGER
Array, dimension (
64
). This array is used to pass various parameters to Intel MKL PARDISO and to return some useful information after execution of the solver.See pardiso iparm Parameter for more details about the iparm parameters.
 msglvl

INTEGER
Message level information. If
msglvl = 0
thenpardiso
generates no output, ifmsglvl = 1
the solver prints statistical information to the screen.  b

DOUBLE PRECISION  for real types of matrices (mtype=1, 2, 2 and 11) and for double precision Intel MKL PARDISO (
iparm(28)
=0)REAL  for real types of matrices (mtype=1, 2, 2 and 11) and for single precision Intel MKL PARDISO (
iparm(28)
=1)DOUBLE COMPLEX  for complex types of matrices (mtype=3, 6, 13, 14 and 4) and for double precision Intel MKL PARDISO (
iparm(28)
=0)COMPLEX  for complex types of matrices (mtype=3, 6, 13, 14 and 4) and for single precision Intel MKL PARDISO (
iparm(28)
=1)Array, dimension (n, nrhs). On entry, contains the righthand side vector/matrix B, which is placed in memory contiguously. The
b(i+(k1)×nrhs)
must hold the ith component of kth righthand side vector. Note that b is only accessed in the solution phase.
Output Parameters

(See also Intel MKL PARDISO Parameters in Tabular Form.)
 pt

Handle to internal data structure.
 iparm

On output, some iparm values report information such as the numbers of nonzero elements in the factors.
See pardiso iparm Parameter for more details about the iparm parameters.
 b

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

DOUBLE PRECISION  for real types of matrices (mtype=1, 2, 2 and 11) and for double precision Intel MKL PARDISO (
iparm(28)
=0)REAL  for real types of matrices (mtype=1, 2, 2 and 11) and for single precision Intel MKL PARDISO (
iparm(28)
=1)DOUBLE COMPLEX  for complex types of matrices (mtype=3, 6, 13, 14 and 4) and for double precision Intel MKL PARDISO (
iparm(28)
=0)COMPLEX  for complex types of matrices (mtype=3, 6, 13, 14 and 4) and for single precision Intel MKL PARDISO (
iparm(28)
=1)Array, dimension (n,nrhs). If
iparm
=0 it contains solution vector/matrix X, which is placed contiguously in memory. The(6)
x(i+(k1)× n)
element must hold the ith component of the kth solution vector. 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

reordering failed (matrix types 11 and 13 only)
7

diagonal matrix is singular
8

32bit integer overflow problem
9

not enough memory for OOC
10

error opening OOC files
11

read/write error with OOC files
12

(pardiso_64 only) pardiso_64 called from 32bit library