MAGMA
2.3.0
Matrix Algebra for GPU and Multicore Architectures

Functions  
magma_int_t  magma_cungqr (magma_int_t m, magma_int_t n, magma_int_t k, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *tau, magmaFloatComplex_ptr dT, magma_int_t nb, magma_int_t *info) 
CUNGQR generates an MbyN COMPLEX matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_cungqr2 (magma_int_t m, magma_int_t n, magma_int_t k, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *tau, magma_int_t *info) 
CUNGQR generates an MbyN COMPLEX matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_cungqr_2stage_gpu (magma_int_t m, magma_int_t n, magma_int_t k, magmaFloatComplex_ptr dA, magma_int_t ldda, magmaFloatComplex *tau, magmaFloatComplex_ptr dT, magma_int_t nb, magma_int_t *info) 
CUNGQR generates an MbyN COMPLEX matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_cungqr_gpu (magma_int_t m, magma_int_t n, magma_int_t k, magmaFloatComplex_ptr dA, magma_int_t ldda, magmaFloatComplex *tau, magmaFloatComplex_ptr dT, magma_int_t nb, magma_int_t *info) 
CUNGQR generates an MbyN COMPLEX matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_cungqr_m (magma_int_t m, magma_int_t n, magma_int_t k, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *tau, magmaFloatComplex *T, magma_int_t nb, magma_int_t *info) 
CUNGQR generates an MbyN COMPLEX matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_dorgqr (magma_int_t m, magma_int_t n, magma_int_t k, double *A, magma_int_t lda, double *tau, magmaDouble_ptr dT, magma_int_t nb, magma_int_t *info) 
DORGQR generates an MbyN DOUBLE PRECISION matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_dorgqr2 (magma_int_t m, magma_int_t n, magma_int_t k, double *A, magma_int_t lda, double *tau, magma_int_t *info) 
DORGQR generates an MbyN DOUBLE PRECISION matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_dorgqr_2stage_gpu (magma_int_t m, magma_int_t n, magma_int_t k, magmaDouble_ptr dA, magma_int_t ldda, double *tau, magmaDouble_ptr dT, magma_int_t nb, magma_int_t *info) 
DORGQR generates an MbyN DOUBLE PRECISION matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_dorgqr_gpu (magma_int_t m, magma_int_t n, magma_int_t k, magmaDouble_ptr dA, magma_int_t ldda, double *tau, magmaDouble_ptr dT, magma_int_t nb, magma_int_t *info) 
DORGQR generates an MbyN DOUBLE PRECISION matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_dorgqr_m (magma_int_t m, magma_int_t n, magma_int_t k, double *A, magma_int_t lda, double *tau, double *T, magma_int_t nb, magma_int_t *info) 
DORGQR generates an MbyN DOUBLE PRECISION matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_sorgqr (magma_int_t m, magma_int_t n, magma_int_t k, float *A, magma_int_t lda, float *tau, magmaFloat_ptr dT, magma_int_t nb, magma_int_t *info) 
SORGQR generates an MbyN REAL matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_sorgqr2 (magma_int_t m, magma_int_t n, magma_int_t k, float *A, magma_int_t lda, float *tau, magma_int_t *info) 
SORGQR generates an MbyN REAL matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_sorgqr_2stage_gpu (magma_int_t m, magma_int_t n, magma_int_t k, magmaFloat_ptr dA, magma_int_t ldda, float *tau, magmaFloat_ptr dT, magma_int_t nb, magma_int_t *info) 
SORGQR generates an MbyN REAL matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_sorgqr_gpu (magma_int_t m, magma_int_t n, magma_int_t k, magmaFloat_ptr dA, magma_int_t ldda, float *tau, magmaFloat_ptr dT, magma_int_t nb, magma_int_t *info) 
SORGQR generates an MbyN REAL matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_sorgqr_m (magma_int_t m, magma_int_t n, magma_int_t k, float *A, magma_int_t lda, float *tau, float *T, magma_int_t nb, magma_int_t *info) 
SORGQR generates an MbyN REAL matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_zungqr (magma_int_t m, magma_int_t n, magma_int_t k, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *tau, magmaDoubleComplex_ptr dT, magma_int_t nb, magma_int_t *info) 
ZUNGQR generates an MbyN COMPLEX_16 matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_zungqr2 (magma_int_t m, magma_int_t n, magma_int_t k, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *tau, magma_int_t *info) 
ZUNGQR generates an MbyN COMPLEX_16 matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_zungqr_2stage_gpu (magma_int_t m, magma_int_t n, magma_int_t k, magmaDoubleComplex_ptr dA, magma_int_t ldda, magmaDoubleComplex *tau, magmaDoubleComplex_ptr dT, magma_int_t nb, magma_int_t *info) 
ZUNGQR generates an MbyN COMPLEX_16 matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_zungqr_gpu (magma_int_t m, magma_int_t n, magma_int_t k, magmaDoubleComplex_ptr dA, magma_int_t ldda, magmaDoubleComplex *tau, magmaDoubleComplex_ptr dT, magma_int_t nb, magma_int_t *info) 
ZUNGQR generates an MbyN COMPLEX_16 matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t  magma_zungqr_m (magma_int_t m, magma_int_t n, magma_int_t k, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *tau, magmaDoubleComplex *T, magma_int_t nb, magma_int_t *info) 
ZUNGQR generates an MbyN COMPLEX_16 matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M. More...  
magma_int_t magma_cungqr  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaFloatComplex *  A,  
magma_int_t  lda,  
magmaFloatComplex *  tau,  
magmaFloatComplex_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
CUNGQR generates an MbyN COMPLEX matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by CGEQRF.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  COMPLEX array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  COMPLEX array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGEQRF_GPU. 
[in]  dT  COMPLEX array on the GPU device. DT contains the T matrices used in blocking the elementary reflectors H(i), e.g., this can be the 6th argument of magma_cgeqrf_gpu. 
[in]  nb  INTEGER This is the block size used in CGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_cungqr2  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaFloatComplex *  A,  
magma_int_t  lda,  
magmaFloatComplex *  tau,  
magma_int_t *  info  
) 
CUNGQR generates an MbyN COMPLEX matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by CGEQRF.
This version recomputes the T matrices on the CPU and sends them to the GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  COMPLEX array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  COMPLEX array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGEQRF_GPU. 
[out]  info  INTEGER

magma_int_t magma_cungqr_2stage_gpu  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaFloatComplex_ptr  dA,  
magma_int_t  ldda,  
magmaFloatComplex *  tau,  
magmaFloatComplex_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
CUNGQR generates an MbyN COMPLEX matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by CGEQRF_GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  dA  COMPLEX array A on the GPU device, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  ldda  INTEGER The first dimension of the array A. LDDA >= max(1,M). 
[in]  tau  COMPLEX array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGEQRF_GPU. 
[in]  dT  COMPLEX work space array on the GPU device, dimension (MIN(M, N) )*NB. This must be the 6th argument of magma_cgeqrf_gpu [ note that if N here is bigger than N in magma_cgeqrf_gpu, the workspace requirement DT in magma_cgeqrf_gpu must be as specified in this routine ]. 
[in]  nb  INTEGER This is the block size used in CGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_cungqr_gpu  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaFloatComplex_ptr  dA,  
magma_int_t  ldda,  
magmaFloatComplex *  tau,  
magmaFloatComplex_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
CUNGQR generates an MbyN COMPLEX matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by CGEQRF_GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  dA  COMPLEX array A on the GPU, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  ldda  INTEGER The first dimension of the array A. LDDA >= max(1,M). 
[in]  tau  COMPLEX array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGEQRF_GPU. 
[in]  dT  (workspace) COMPLEX work space array on the GPU, dimension (2*MIN(M, N) + ceil(N/32)*32 )*NB. This must be the 6th argument of magma_cgeqrf_gpu [ note that if N here is bigger than N in magma_cgeqrf_gpu, the workspace requirement DT in magma_cgeqrf_gpu must be as specified in this routine ]. 
[in]  nb  INTEGER This is the block size used in CGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_cungqr_m  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaFloatComplex *  A,  
magma_int_t  lda,  
magmaFloatComplex *  tau,  
magmaFloatComplex *  T,  
magma_int_t  nb,  
magma_int_t *  info  
) 
CUNGQR generates an MbyN COMPLEX matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by CGEQRF.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  COMPLEX array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  COMPLEX array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGEQRF_GPU. 
[in]  T  COMPLEX array, dimension (NB, min(M,N)). T contains the T matrices used in blocking the elementary reflectors H(i), e.g., this can be the 6th argument of magma_cgeqrf_gpu (except stored on the CPU, not the GPU). 
[in]  nb  INTEGER This is the block size used in CGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in T. 
[out]  info  INTEGER

magma_int_t magma_dorgqr  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
double *  A,  
magma_int_t  lda,  
double *  tau,  
magmaDouble_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
DORGQR generates an MbyN DOUBLE PRECISION matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by DGEQRF.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  DOUBLE PRECISION array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by DGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  DOUBLE PRECISION array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEQRF_GPU. 
[in]  dT  DOUBLE PRECISION array on the GPU device. DT contains the T matrices used in blocking the elementary reflectors H(i), e.g., this can be the 6th argument of magma_dgeqrf_gpu. 
[in]  nb  INTEGER This is the block size used in DGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_dorgqr2  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
double *  A,  
magma_int_t  lda,  
double *  tau,  
magma_int_t *  info  
) 
DORGQR generates an MbyN DOUBLE PRECISION matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by DGEQRF.
This version recomputes the T matrices on the CPU and sends them to the GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  DOUBLE PRECISION array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by DGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  DOUBLE PRECISION array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEQRF_GPU. 
[out]  info  INTEGER

magma_int_t magma_dorgqr_2stage_gpu  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaDouble_ptr  dA,  
magma_int_t  ldda,  
double *  tau,  
magmaDouble_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
DORGQR generates an MbyN DOUBLE PRECISION matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by DGEQRF_GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  dA  DOUBLE PRECISION array A on the GPU device, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by DGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  ldda  INTEGER The first dimension of the array A. LDDA >= max(1,M). 
[in]  tau  DOUBLE PRECISION array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEQRF_GPU. 
[in]  dT  DOUBLE PRECISION work space array on the GPU device, dimension (MIN(M, N) )*NB. This must be the 6th argument of magma_dgeqrf_gpu [ note that if N here is bigger than N in magma_dgeqrf_gpu, the workspace requirement DT in magma_dgeqrf_gpu must be as specified in this routine ]. 
[in]  nb  INTEGER This is the block size used in DGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_dorgqr_gpu  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaDouble_ptr  dA,  
magma_int_t  ldda,  
double *  tau,  
magmaDouble_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
DORGQR generates an MbyN DOUBLE PRECISION matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by DGEQRF_GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  dA  DOUBLE PRECISION array A on the GPU, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by DGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  ldda  INTEGER The first dimension of the array A. LDDA >= max(1,M). 
[in]  tau  DOUBLE PRECISION array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEQRF_GPU. 
[in]  dT  (workspace) DOUBLE PRECISION work space array on the GPU, dimension (2*MIN(M, N) + ceil(N/32)*32 )*NB. This must be the 6th argument of magma_dgeqrf_gpu [ note that if N here is bigger than N in magma_dgeqrf_gpu, the workspace requirement DT in magma_dgeqrf_gpu must be as specified in this routine ]. 
[in]  nb  INTEGER This is the block size used in DGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_dorgqr_m  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
double *  A,  
magma_int_t  lda,  
double *  tau,  
double *  T,  
magma_int_t  nb,  
magma_int_t *  info  
) 
DORGQR generates an MbyN DOUBLE PRECISION matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by DGEQRF.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  DOUBLE PRECISION array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by DGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  DOUBLE PRECISION array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEQRF_GPU. 
[in]  T  DOUBLE PRECISION array, dimension (NB, min(M,N)). T contains the T matrices used in blocking the elementary reflectors H(i), e.g., this can be the 6th argument of magma_dgeqrf_gpu (except stored on the CPU, not the GPU). 
[in]  nb  INTEGER This is the block size used in DGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in T. 
[out]  info  INTEGER

magma_int_t magma_sorgqr  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
float *  A,  
magma_int_t  lda,  
float *  tau,  
magmaFloat_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
SORGQR generates an MbyN REAL matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by SGEQRF.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  REAL array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by SGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  REAL array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQRF_GPU. 
[in]  dT  REAL array on the GPU device. DT contains the T matrices used in blocking the elementary reflectors H(i), e.g., this can be the 6th argument of magma_sgeqrf_gpu. 
[in]  nb  INTEGER This is the block size used in SGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_sorgqr2  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
float *  A,  
magma_int_t  lda,  
float *  tau,  
magma_int_t *  info  
) 
SORGQR generates an MbyN REAL matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by SGEQRF.
This version recomputes the T matrices on the CPU and sends them to the GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  REAL array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by SGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  REAL array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQRF_GPU. 
[out]  info  INTEGER

magma_int_t magma_sorgqr_2stage_gpu  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaFloat_ptr  dA,  
magma_int_t  ldda,  
float *  tau,  
magmaFloat_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
SORGQR generates an MbyN REAL matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by SGEQRF_GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  dA  REAL array A on the GPU device, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by SGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  ldda  INTEGER The first dimension of the array A. LDDA >= max(1,M). 
[in]  tau  REAL array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQRF_GPU. 
[in]  dT  REAL work space array on the GPU device, dimension (MIN(M, N) )*NB. This must be the 6th argument of magma_sgeqrf_gpu [ note that if N here is bigger than N in magma_sgeqrf_gpu, the workspace requirement DT in magma_sgeqrf_gpu must be as specified in this routine ]. 
[in]  nb  INTEGER This is the block size used in SGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_sorgqr_gpu  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaFloat_ptr  dA,  
magma_int_t  ldda,  
float *  tau,  
magmaFloat_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
SORGQR generates an MbyN REAL matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by SGEQRF_GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  dA  REAL array A on the GPU, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by SGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  ldda  INTEGER The first dimension of the array A. LDDA >= max(1,M). 
[in]  tau  REAL array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQRF_GPU. 
[in]  dT  (workspace) REAL work space array on the GPU, dimension (2*MIN(M, N) + ceil(N/32)*32 )*NB. This must be the 6th argument of magma_sgeqrf_gpu [ note that if N here is bigger than N in magma_sgeqrf_gpu, the workspace requirement DT in magma_sgeqrf_gpu must be as specified in this routine ]. 
[in]  nb  INTEGER This is the block size used in SGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_sorgqr_m  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
float *  A,  
magma_int_t  lda,  
float *  tau,  
float *  T,  
magma_int_t  nb,  
magma_int_t *  info  
) 
SORGQR generates an MbyN REAL matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by SGEQRF.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  REAL array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by SGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  REAL array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQRF_GPU. 
[in]  T  REAL array, dimension (NB, min(M,N)). T contains the T matrices used in blocking the elementary reflectors H(i), e.g., this can be the 6th argument of magma_sgeqrf_gpu (except stored on the CPU, not the GPU). 
[in]  nb  INTEGER This is the block size used in SGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in T. 
[out]  info  INTEGER

magma_int_t magma_zungqr  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaDoubleComplex *  A,  
magma_int_t  lda,  
magmaDoubleComplex *  tau,  
magmaDoubleComplex_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
ZUNGQR generates an MbyN COMPLEX_16 matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by ZGEQRF.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  COMPLEX_16 array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by ZGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  COMPLEX_16 array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZGEQRF_GPU. 
[in]  dT  COMPLEX_16 array on the GPU device. DT contains the T matrices used in blocking the elementary reflectors H(i), e.g., this can be the 6th argument of magma_zgeqrf_gpu. 
[in]  nb  INTEGER This is the block size used in ZGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_zungqr2  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaDoubleComplex *  A,  
magma_int_t  lda,  
magmaDoubleComplex *  tau,  
magma_int_t *  info  
) 
ZUNGQR generates an MbyN COMPLEX_16 matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by ZGEQRF.
This version recomputes the T matrices on the CPU and sends them to the GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  COMPLEX_16 array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by ZGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  COMPLEX_16 array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZGEQRF_GPU. 
[out]  info  INTEGER

magma_int_t magma_zungqr_2stage_gpu  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaDoubleComplex_ptr  dA,  
magma_int_t  ldda,  
magmaDoubleComplex *  tau,  
magmaDoubleComplex_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
ZUNGQR generates an MbyN COMPLEX_16 matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by ZGEQRF_GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  dA  COMPLEX_16 array A on the GPU device, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by ZGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  ldda  INTEGER The first dimension of the array A. LDDA >= max(1,M). 
[in]  tau  COMPLEX_16 array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZGEQRF_GPU. 
[in]  dT  COMPLEX_16 work space array on the GPU device, dimension (MIN(M, N) )*NB. This must be the 6th argument of magma_zgeqrf_gpu [ note that if N here is bigger than N in magma_zgeqrf_gpu, the workspace requirement DT in magma_zgeqrf_gpu must be as specified in this routine ]. 
[in]  nb  INTEGER This is the block size used in ZGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_zungqr_gpu  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaDoubleComplex_ptr  dA,  
magma_int_t  ldda,  
magmaDoubleComplex *  tau,  
magmaDoubleComplex_ptr  dT,  
magma_int_t  nb,  
magma_int_t *  info  
) 
ZUNGQR generates an MbyN COMPLEX_16 matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by ZGEQRF_GPU.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  dA  COMPLEX_16 array A on the GPU, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by ZGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  ldda  INTEGER The first dimension of the array A. LDDA >= max(1,M). 
[in]  tau  COMPLEX_16 array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZGEQRF_GPU. 
[in]  dT  (workspace) COMPLEX_16 work space array on the GPU, dimension (2*MIN(M, N) + ceil(N/32)*32 )*NB. This must be the 6th argument of magma_zgeqrf_gpu [ note that if N here is bigger than N in magma_zgeqrf_gpu, the workspace requirement DT in magma_zgeqrf_gpu must be as specified in this routine ]. 
[in]  nb  INTEGER This is the block size used in ZGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. 
[out]  info  INTEGER

magma_int_t magma_zungqr_m  (  magma_int_t  m, 
magma_int_t  n,  
magma_int_t  k,  
magmaDoubleComplex *  A,  
magma_int_t  lda,  
magmaDoubleComplex *  tau,  
magmaDoubleComplex *  T,  
magma_int_t  nb,  
magma_int_t *  info  
) 
ZUNGQR generates an MbyN COMPLEX_16 matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M.
Q = H(1) H(2) . . . H(k)
as returned by ZGEQRF.
[in]  m  INTEGER The number of rows of the matrix Q. M >= 0. 
[in]  n  INTEGER The number of columns of the matrix Q. M >= N >= 0. 
[in]  k  INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in,out]  A  COMPLEX_16 array A, dimension (LDDA,N). On entry, the ith column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by ZGEQRF_GPU in the first k columns of its array argument A. On exit, the MbyN matrix Q. 
[in]  lda  INTEGER The first dimension of the array A. LDA >= max(1,M). 
[in]  tau  COMPLEX_16 array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZGEQRF_GPU. 
[in]  T  COMPLEX_16 array, dimension (NB, min(M,N)). T contains the T matrices used in blocking the elementary reflectors H(i), e.g., this can be the 6th argument of magma_zgeqrf_gpu (except stored on the CPU, not the GPU). 
[in]  nb  INTEGER This is the block size used in ZGEQRF_GPU, and correspondingly the size of the T matrices, used in the factorization, and stored in T. 
[out]  info  INTEGER
