MAGMA  2.3.0
Matrix Algebra for GPU and Multicore Architectures
 All Classes Files Functions Friends Groups Pages
or/ungqr: Generate Q from QR factorization

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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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 M-by-N 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...
 

Detailed Description

Function Documentation

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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]ACOMPLEX array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauCOMPLEX array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGEQRF_GPU.
[in]dTCOMPLEX 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]ACOMPLEX array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauCOMPLEX array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGEQRF_GPU.
[out]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument has an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]dACOMPLEX array A on the GPU device, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]lddaINTEGER The first dimension of the array A. LDDA >= max(1,M).
[in]tauCOMPLEX array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGEQRF_GPU.
[in]dTCOMPLEX 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]dACOMPLEX array A on the GPU, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]lddaINTEGER The first dimension of the array A. LDDA >= max(1,M).
[in]tauCOMPLEX 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]ACOMPLEX array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauCOMPLEX array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGEQRF_GPU.
[in]TCOMPLEX 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]ADOUBLE PRECISION array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauDOUBLE PRECISION array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEQRF_GPU.
[in]dTDOUBLE 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]ADOUBLE PRECISION array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauDOUBLE PRECISION array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEQRF_GPU.
[out]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument has an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]dADOUBLE PRECISION array A on the GPU device, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]lddaINTEGER The first dimension of the array A. LDDA >= max(1,M).
[in]tauDOUBLE PRECISION array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEQRF_GPU.
[in]dTDOUBLE 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]dADOUBLE PRECISION array A on the GPU, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]lddaINTEGER The first dimension of the array A. LDDA >= max(1,M).
[in]tauDOUBLE 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]ADOUBLE PRECISION array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauDOUBLE PRECISION array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEQRF_GPU.
[in]TDOUBLE 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]AREAL array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauREAL array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQRF_GPU.
[in]dTREAL 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]AREAL array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauREAL array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQRF_GPU.
[out]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument has an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]dAREAL array A on the GPU device, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]lddaINTEGER The first dimension of the array A. LDDA >= max(1,M).
[in]tauREAL array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQRF_GPU.
[in]dTREAL 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]dAREAL array A on the GPU, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]lddaINTEGER The first dimension of the array A. LDDA >= max(1,M).
[in]tauREAL 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]AREAL array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauREAL array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQRF_GPU.
[in]TREAL 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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]ACOMPLEX_16 array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauCOMPLEX_16 array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZGEQRF_GPU.
[in]dTCOMPLEX_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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]ACOMPLEX_16 array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauCOMPLEX_16 array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZGEQRF_GPU.
[out]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument has an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]dACOMPLEX_16 array A on the GPU device, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]lddaINTEGER The first dimension of the array A. LDDA >= max(1,M).
[in]tauCOMPLEX_16 array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZGEQRF_GPU.
[in]dTCOMPLEX_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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]dACOMPLEX_16 array A on the GPU, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]lddaINTEGER The first dimension of the array A. LDDA >= max(1,M).
[in]tauCOMPLEX_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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
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 M-by-N 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.

Parameters
[in]mINTEGER The number of rows of the matrix Q. M >= 0.
[in]nINTEGER The number of columns of the matrix Q. M >= N >= 0.
[in]kINTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in,out]ACOMPLEX_16 array A, dimension (LDDA,N). On entry, the i-th 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 M-by-N matrix Q.
[in]ldaINTEGER The first dimension of the array A. LDA >= max(1,M).
[in]tauCOMPLEX_16 array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZGEQRF_GPU.
[in]TCOMPLEX_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]nbINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value