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 (2MIN(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 (2MIN(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 (2MIN(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 (2MIN(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

Functions

Detailed Description

Function Documentation

◆ magma_cungqr()

◆ magma_cungqr2()

◆ magma_cungqr_2stage_gpu()

◆ magma_cungqr_gpu()

◆ magma_cungqr_m()

◆ magma_dorgqr()

◆ magma_dorgqr2()

◆ magma_dorgqr_2stage_gpu()

◆ magma_dorgqr_gpu()

◆ magma_dorgqr_m()

◆ magma_sorgqr()

◆ magma_sorgqr2()

◆ magma_sorgqr_2stage_gpu()

◆ magma_sorgqr_gpu()

◆ magma_sorgqr_m()

◆ magma_zungqr()

◆ magma_zungqr2()

◆ magma_zungqr_2stage_gpu()

◆ magma_zungqr_gpu()

◆ magma_zungqr_m()