rocsolver_sgebrd_batched Interface Reference

rocsolver_sgebrd_batched Interface Reference#

HIPFORT API Reference: hipfort_rocsolver::rocsolver_sgebrd_batched Interface Reference

The GEBRD_BATCHED functions compute the bidiagonal form of a batch of general m-by-n matrices. More...

Public Member Functions
integer(kind(rocblas_status_success)) function	rocsolver_sgebrd_batched_ (handle, m, n, a, lda, d, strided, e, stridee, tauq, strideq, taup, stridep, batch_count)

integer(kind(rocblas_status_success)) function	rocsolver_sgebrd_batched_rank_0 (handle, m, n, a, lda, d, strided, e, stridee, tauq, strideq, taup, stridep, batch_count)

integer(kind(rocblas_status_success)) function	rocsolver_sgebrd_batched_rank_1 (handle, m, n, a, lda, d, strided, e, stridee, tauq, strideq, taup, stridep, batch_count)

Detailed Description

The GEBRD_BATCHED functions compute the bidiagonal form of a batch of general m-by-n matrices.

(This is the blocked version of the algorithm.)

For each instance in the batch, the bidiagonal form is given by:

\[ B_l^{} = Q_l^H A_l^{} P_l^{} \]

where \(B_l\) is upper bidiagonal if m >= n and lower bidiagonal if m < n, and \(Q_l\) and \(P_l\) are orthogonal/unitary matrices represented as the product of Householder matrices

\[ \begin{array}{cl} Q_l = H_l(1)H_l(2)\cdots H_l(n)\: \text{and} \: P_l = G_l(1)G_l(2)\cdots G_l(n-1), & \: \text{if}\: m >= n, \:\text{or}\\% Q_l = H_l(1)H_l(2)\cdots H_l(m-1)\: \text{and} \: P_l = G_l(1)G_l(2)\cdots G_l(m), & \: \text{if}\: m < n. \end{array} \]

Each Householder matrix \(H_l(i)\) and \(G_l(i)\) is given by

\[ \begin{array}{cl} H_l^{}(i) = I - \text{tauq}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H, & \: \text{and}\\% G_l^{}(i) = I - \text{taup}_l^{}[i] \cdot u_{l_i}^H u_{l_i}^{}. \end{array} \]

If m >= n, the first i-1 elements of the Householder vector \(v_{l_i}\) are zero, and \(v_{l_i}[i] = 1\), while the first i elements of the Householder vector \(u_{l_i}\) are zero, and \(u_{l_i}[i+1] = 1\). If m < n, the first i elements of the Householder vector \(v_{l_i}\) are zero, and \(v_{l_i}[i+1] = 1\), while the first i-1 elements of the Householder vector \(u_{l_i}\) are zero, and \(u_{l_i}[i] = 1\).

Parameters

[in]	handle	- rocblas_handle.
[in]	m	- rocblas_int. m >= 0. The number of rows of all the matrices A_l in the batch.
[in]	n	- rocblas_int. n >= 0. The number of columns of all the matrices A_l in the batch.
[in,out]	A	- Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n. On entry, the m-by-n matrices A_l to be factored. On exit, the elements on the diagonal and superdiagonal (if m >= n), or subdiagonal (if m < n) contain the bidiagonal form B_l. If m >= n, the elements below the diagonal are the last m - i elements of Householder vector v_(l_i), and the elements above the superdiagonal are the last n - i - 1 elements of Householder vector u_(l_i). If m < n, the elements below the subdiagonal are the last m - i - 1 elements of Householder vector v_(l_i), and the elements above the diagonal are the last n - i elements of Householder vector u_(l_i).
[in]	lda	- rocblas_int. lda >= m. Specifies the leading dimension of matrices A_l.
[out]	D	- pointer to real type. Array on the GPU (the size depends on the value of strideD). The diagonal elements of B_l.
[in]	strideD	- rocblas_stride. Stride from the start of one vector D_l to the next one D_(l+1). There is no restriction for the value of strideD. The normal use case is strideD >= min(m,n).
[out]	E	- pointer to real type. Array on the GPU (the size depends on the value of strideE). The off-diagonal elements of B_l.
[in]	strideE	- rocblas_stride. Stride from the start of one vector E_l to the next one E_(l+1). There is no restriction for the value of strideE. The normal use case is strideE >= min(m,n)-1.
[out]	tauq	- pointer to type. Array on the GPU (the size depends on the value of strideQ). Contains the vectors tauq_l of Householder scalars associated with matrices Q_l.
[in]	strideQ	- rocblas_stride. Stride from the start of one vector tauq_l to the next one tauq_(l+1). There is no restriction for the value of strideQ. Normal usage is strideQ >= min(m,n).
[out]	taup	- pointer to type. Array on the GPU (the size depends on the value of strideP). Contains the vectors taup_l of Householder scalars associated with matrices P_l.
[in]	strideP	- rocblas_stride. Stride from the start of one vector taup_l to the next one taup_(l+1). There is no restriction for the value of strideP. Normal usage is strideP >= min(m,n).
[in]	batch_count	- rocblas_int. batch_count >= 0. Number of matrices in the batch.

Member Function/Subroutine Documentation