Developer Reference for Intel® oneAPI Math Kernel Library for Fortran

ID 766686
Date 3/22/2024
Public

A newer version of this document is available. Customers should click here to go to the newest version.

Document Table of Contents

?getrf_batch

Computes the LU factorization for 1 or more groups of general m-by-n matrices.

Syntax

call sgetrf_batch(m_array, n_array, A_array, lda_array, ipiv_array, group_size, group_count, info_array)

call dgetrf_batch(m_array, n_array, A_array, lda_array, ipiv_array, group_size, group_count, info_array)

call cgetrf_batch(m_array, n_array, A_array, lda_array, ipiv_array, group_size, group_count, info_array)

call zgetrf_batch(m_array, n_array, A_array, lda_array, ipiv_array, group_size, group_count, info_array)

Include Files

mkl.fi

Description

The ?getrf_batch routines are similar to the ?getrf counterparts, but instead compute the LU factorization for a group of general m-by-n matrices, processing one or more groups at once. Each group contains matrices with the same parameters.

The operation is defined as

i = 1
for g = 1 … group_count
    mg ng and ldag in m_array(g), n_array(g) and lda_array(g)
    for j = 1 … group_size(g)
	        Ai, ipivi in A_array(i), ipiv_array(i)
	        Ai := Pi * Li * Ui
	        i = i + 1
    end for
end for

where Pi is a permutation matrix, Li is lower triangular with unit diagonal elements (lower trapezoidal if mg> ng) and Ui is upper triangular (upper trapezoidal if mg< ng). These routines use partial pivoting, with row interchanges.

Ai represents matrices stored at the addresses pointed to by A_array. The dimensions of each matrix is mg-by-ng, where mg and ng are the g-th elements of m_array and n_array, respectively. Similarly, ipivi represents the pivot arrays stored at addresses pointed to by ipiv_array, where the size of the pivoting arrays is min(mg, ng).

The number of entries in A_array and ipiv_array is total_batch_count, which is equal to the sum of all the entries in the array group_size.

Refer to ?getrf for a detailed description of the LU factorization of general matrices.

Input Parameters

m_array

INTEGER. Array of size group_count. For the group g, mg = m_array(g) specifies the number of rows of the matrices Ai in group g.

The value of each element of m_array must be at least zero.

n_array

INTEGER. Array of size group_count. For the group g, ng = n_array(g) specifies the number of columns of the matrices Ai in group g.

The value of each element of n_array must be at least zero.

A_array

INTEGER*8 for Intel® 64 architecture

INTEGER*4 for IA-32 architecture

Array, size total_batch_count, of pointers to arrays used to store Ai matrices.

lda_array

INTEGER. Array of size group_count. For group g, ldag = lda_array(g) specifies the leading dimension of the matricies Ai in group g, as declared in the calling (sub)program.

The value of ldag must be at least max(1, mg).

group_count

INTEGER.

Specifies the number of groups. Must be at least 0.

group_size

INTEGER.

Array of size group_count. The element group_size(g) specifies the number of matrices in group g. Each element in group_size must be at least 0.

Output Parameters

A_array

Output array, overwritten by the total_batch_count LU-factored matrices. Each matrix Ai is overwritten by Li and Ui. The unit diagonal elements of Li are not stored.

ipiv_array

INTEGER*8 for Intel® 64 architecture

INTEGER*4 for IA-32 architecture

Array, size total_batch_count, of pointers to the pivot arrays associated with the LU-factored Ai matrices.

info_array

INTEGER.

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

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

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

If info(i) = j, the j-th diagonal element of Ui is 0. The factorization has been completed, but Ui is exactly singular. Division by 0 will occur if you use the factor Ui for solving a system of linear equations.

Related Information

Refer to ?getrf_batch_strided , which computes the LU factorization for a group of general m-by-n matrices that are allocated at a constant stride from each other in the same contiguous block of memory.