Developer Reference for Intel® oneAPI Math Kernel Library for Fortran
?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
m_{g} n_{g} and lda_{g} in m_array(g), n_array(g) and lda_array(g)
for j = 1 … group_size(g)
A_{i}, ipiv_{i} in A_array(i), ipiv_array(i)
A_{i} := P_{i} * L_{i} * U_{i}
i = i + 1
end for
end forwhere 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 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 , lda_{g} =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 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 (Computes the LU factorization of a group of general m-by-n matrices that are stored at a constant stride from each other in a contiguous block of memory.) , 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.