MAGMA
2.3.0
Matrix Algebra for GPU and Multicore Architectures

Functions  
magma_int_t  magma_cgeqr2_batched (magma_int_t m, magma_int_t n, magmaFloatComplex **dA_array, magma_int_t ldda, magmaFloatComplex **dtau_array, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue) 
CGEQR2 computes a QR factorization of a complex m by n matrix A: A = Q * R. More...  
magma_int_t  magma_dgeqr2_batched (magma_int_t m, magma_int_t n, double **dA_array, magma_int_t ldda, double **dtau_array, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue) 
DGEQR2 computes a QR factorization of a real m by n matrix A: A = Q * R. More...  
magma_int_t  magma_sgeqr2_batched (magma_int_t m, magma_int_t n, float **dA_array, magma_int_t ldda, float **dtau_array, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue) 
SGEQR2 computes a QR factorization of a real m by n matrix A: A = Q * R. More...  
magma_int_t  magma_zgeqr2_batched (magma_int_t m, magma_int_t n, magmaDoubleComplex **dA_array, magma_int_t ldda, magmaDoubleComplex **dtau_array, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue) 
ZGEQR2 computes a QR factorization of a complex m by n matrix A: A = Q * R. More...  
magma_int_t magma_cgeqr2_batched  (  magma_int_t  m, 
magma_int_t  n,  
magmaFloatComplex **  dA_array,  
magma_int_t  ldda,  
magmaFloatComplex **  dtau_array,  
magma_int_t *  info_array,  
magma_int_t  batchCount,  
magma_queue_t  queue  
) 
CGEQR2 computes a QR factorization of a complex m by n matrix A: A = Q * R.
This version implements the rightlooking QR with nonblocking.
[in]  m  INTEGER The number of rows of the matrix A. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix A. N >= 0. 
[in,out]  dA_array  Array of pointers, dimension (batchCount). Each is a COMPLEX array on the GPU, dimension (LDDA,N) On entry, the MbyN matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)byN upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Details). 
[in]  ldda  INTEGER The leading dimension of the array dA. LDDA >= max(1,M). To benefit from coalescent memory accesses LDDA must be divisible by 16. 
[out]  dtau_array  Array of pointers, dimension (batchCount). Each is a COMPLEX array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Details). 
[out]  info_array  Array of INTEGERs, dimension (batchCount), for corresponding matrices.

[in]  batchCount  INTEGER The number of matrices to operate on. 
[in]  queue  magma_queue_t Queue to execute in. 
The matrix Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(k), where k = min(m,n).
Each H(i) has the form
H(i) = I  tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(1:i1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), and tau in TAU(i).
magma_int_t magma_dgeqr2_batched  (  magma_int_t  m, 
magma_int_t  n,  
double **  dA_array,  
magma_int_t  ldda,  
double **  dtau_array,  
magma_int_t *  info_array,  
magma_int_t  batchCount,  
magma_queue_t  queue  
) 
DGEQR2 computes a QR factorization of a real m by n matrix A: A = Q * R.
This version implements the rightlooking QR with nonblocking.
[in]  m  INTEGER The number of rows of the matrix A. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix A. N >= 0. 
[in,out]  dA_array  Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array on the GPU, dimension (LDDA,N) On entry, the MbyN matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)byN upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Details). 
[in]  ldda  INTEGER The leading dimension of the array dA. LDDA >= max(1,M). To benefit from coalescent memory accesses LDDA must be divisible by 16. 
[out]  dtau_array  Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Details). 
[out]  info_array  Array of INTEGERs, dimension (batchCount), for corresponding matrices.

[in]  batchCount  INTEGER The number of matrices to operate on. 
[in]  queue  magma_queue_t Queue to execute in. 
The matrix Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(k), where k = min(m,n).
Each H(i) has the form
H(i) = I  tau * v * v'
where tau is a real scalar, and v is a real vector with v(1:i1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), and tau in TAU(i).
magma_int_t magma_sgeqr2_batched  (  magma_int_t  m, 
magma_int_t  n,  
float **  dA_array,  
magma_int_t  ldda,  
float **  dtau_array,  
magma_int_t *  info_array,  
magma_int_t  batchCount,  
magma_queue_t  queue  
) 
SGEQR2 computes a QR factorization of a real m by n matrix A: A = Q * R.
This version implements the rightlooking QR with nonblocking.
[in]  m  INTEGER The number of rows of the matrix A. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix A. N >= 0. 
[in,out]  dA_array  Array of pointers, dimension (batchCount). Each is a REAL array on the GPU, dimension (LDDA,N) On entry, the MbyN matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)byN upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Details). 
[in]  ldda  INTEGER The leading dimension of the array dA. LDDA >= max(1,M). To benefit from coalescent memory accesses LDDA must be divisible by 16. 
[out]  dtau_array  Array of pointers, dimension (batchCount). Each is a REAL array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Details). 
[out]  info_array  Array of INTEGERs, dimension (batchCount), for corresponding matrices.

[in]  batchCount  INTEGER The number of matrices to operate on. 
[in]  queue  magma_queue_t Queue to execute in. 
The matrix Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(k), where k = min(m,n).
Each H(i) has the form
H(i) = I  tau * v * v'
where tau is a real scalar, and v is a real vector with v(1:i1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), and tau in TAU(i).
magma_int_t magma_zgeqr2_batched  (  magma_int_t  m, 
magma_int_t  n,  
magmaDoubleComplex **  dA_array,  
magma_int_t  ldda,  
magmaDoubleComplex **  dtau_array,  
magma_int_t *  info_array,  
magma_int_t  batchCount,  
magma_queue_t  queue  
) 
ZGEQR2 computes a QR factorization of a complex m by n matrix A: A = Q * R.
This version implements the rightlooking QR with nonblocking.
[in]  m  INTEGER The number of rows of the matrix A. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix A. N >= 0. 
[in,out]  dA_array  Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array on the GPU, dimension (LDDA,N) On entry, the MbyN matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)byN upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Details). 
[in]  ldda  INTEGER The leading dimension of the array dA. LDDA >= max(1,M). To benefit from coalescent memory accesses LDDA must be divisible by 16. 
[out]  dtau_array  Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Details). 
[out]  info_array  Array of INTEGERs, dimension (batchCount), for corresponding matrices.

[in]  batchCount  INTEGER The number of matrices to operate on. 
[in]  queue  magma_queue_t Queue to execute in. 
The matrix Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(k), where k = min(m,n).
Each H(i) has the form
H(i) = I  tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(1:i1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), and tau in TAU(i).