Loading...
Searching...
No Matches
or/ungqr: Generate Q from QR factorization
Dense LA » Orthogonal/unitary factorizations » 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.

## Detailed Description

## Function Documentation

## magma_cungqr()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_cungqr2()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument has an illegal value

## magma_cungqr_2stage_gpu()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_cungqr_gpu()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_cungqr_m()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_dorgqr()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_dorgqr2()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument has an illegal value

## magma_dorgqr_2stage_gpu()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_dorgqr_gpu()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_dorgqr_m()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_sorgqr()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_sorgqr2()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument has an illegal value

## magma_sorgqr_2stage_gpu()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_sorgqr_gpu()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_sorgqr_m()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_zungqr()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_zungqr2()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument has an illegal value

## magma_zungqr_2stage_gpu()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_zungqr_gpu()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_zungqr_m()

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] | 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 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] | 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
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value