?getri_oop_batch

Computes the inverses of a group of LU factored matrices that are stored at a constant stride from each other in a contiguous block of memory.

Syntax

call sgetri_oop_batch_strided(n, A, lda, ipiv, stride_ipiv, Ainv, ldainv, stride_ainv, batch_size, info)

call dgetri_oop_batch_strided(n, A, lda, ipiv, stride_ipiv, Ainv, ldainv, stride_ainv, batch_size, info)

call cgetri_oop_batch_strided(n, A, lda, ipiv, stride_ipiv, Ainv, ldainv, stride_ainv, batch_size, info)

call zgetri_oop_batch_strided(n, A, lda, ipiv, stride_ipiv, Ainv, ldainv, stride_ainv, batch_size, info)

Include Files

mkl.fi

Description

The ?getri_oop_batch_strided routines are similar to the ?getri counterparts, but instead compute the inverses for a group of LU factored matrices.

All matrices have the same parameters (matrix size, leading dimension) and are stored at constant stride_a from each other in a contiguous block of memory. The output arrays are stored at constant stride_ainv from each other in a contiguous block of memory. Their respective pivot arrays associated with each of the LU-factored A_i matrices are stored at constant stride_ipiv from each other.

The operation is defined as

for i = 0 … batch_size-1
	A_i is a matrix at offset i * stride_a from A
	ipiv_i is an array at offset i * stride_ipiv from ipiv
	Ainv_io is a matrix at offset i * stride_ainv from Ainv
	Ainv_i :=  inv(P_i * L_i* U_i)
end for

where P_i is a permutation matrix, L_i is lower triangular with unit diagonal elements (lower trapezoidal if m>n), and U_i is upper triangular (upper trapezoidal if m<n). The routine uses partial pivoting, with row interchanges.

Input Parameters

n

INTEGER. The number of columns in the A_i matrices; n ≥ 0.

A

REAL for sgetri_oop_batch_strided

DOUBLE PRECISION for dgetri_oop_batch_strided

COMPLEX for cgetri_oop_batch_strided

DOUBLE COMPLEX for zgetri_oop_batch_strided

Array, size total_batch_count, of pointers to the A_i matrices.

The A array of size at least stride_a * batch_size holding the A_i matrices.

lda

INTEGER. Specifies the leading dimension of the A_i matrices; lda ≥ n.

stride_a

INTEGER. Stride between two consecutive A_i matrices; ; stride_a ≥ lda * n.

ldainv

INTEGER. Specifies the leading dimension of the Ainv_i matrices; ldainv ≥ n.

stride_ainv

INTEGER. Stride between two consecutive Ainv_i matrices; ; stride_ainv ≥ ldainv * n.

stride_ipiv

INTEGER.

Stride between two consecutive pivot arrays; stride_ipiv ≥ n.

batch_size

INTEGER.

Number of A_i matrices to be factorized. Must be at least 0.

Output Parameters

Ainv

Array holding the inverses Ainv_i matrices. Each matrix is overwritten by their respective L_i and U_ifactors. The unit diagonal elements of L are not stored.

info

INTEGER.

Array of size batch_size, which reports the factorization status for each matrix.

If info(i) = 0, the execution is successful for A_i.

If info(i) = -j, the j-th parameter had an illegal value for A_i.

If info(i) = j, the j-th diagonal element of the factor U_i is 0, U_i is exactly singular. Division by - will occur if you use the factor U_i to solve a system of linear equations.