geqrs:

Functions
magma_int_t	magma_cgeqrs3_gpu (magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaFloatComplex_ptr dA, magma_int_t ldda, magmaFloatComplex const *tau, magmaFloatComplex_ptr dT, magmaFloatComplex_ptr dB, magma_int_t lddb, magmaFloatComplex *hwork, magma_int_t lwork, magma_int_t *info)
	CGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by CGEQRF3_GPU. More...
magma_int_t	magma_cgeqrs_gpu (magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaFloatComplex_const_ptr dA, magma_int_t ldda, magmaFloatComplex const *tau, magmaFloatComplex_ptr dT, magmaFloatComplex_ptr dB, magma_int_t lddb, magmaFloatComplex *hwork, magma_int_t lwork, magma_int_t *info)
	CGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by CGEQRF_GPU. More...
magma_int_t	magma_dgeqrs3_gpu (magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaDouble_ptr dA, magma_int_t ldda, double const *tau, magmaDouble_ptr dT, magmaDouble_ptr dB, magma_int_t lddb, double *hwork, magma_int_t lwork, magma_int_t *info)
	DGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by DGEQRF3_GPU. More...
magma_int_t	magma_dgeqrs_gpu (magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaDouble_const_ptr dA, magma_int_t ldda, double const *tau, magmaDouble_ptr dT, magmaDouble_ptr dB, magma_int_t lddb, double *hwork, magma_int_t lwork, magma_int_t *info)
	DGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by DGEQRF_GPU. More...
magma_int_t	magma_sgeqrs3_gpu (magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaFloat_ptr dA, magma_int_t ldda, float const *tau, magmaFloat_ptr dT, magmaFloat_ptr dB, magma_int_t lddb, float *hwork, magma_int_t lwork, magma_int_t *info)
	SGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by SGEQRF3_GPU. More...
magma_int_t	magma_sgeqrs_gpu (magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaFloat_const_ptr dA, magma_int_t ldda, float const *tau, magmaFloat_ptr dT, magmaFloat_ptr dB, magma_int_t lddb, float *hwork, magma_int_t lwork, magma_int_t *info)
	SGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by SGEQRF_GPU. More...
magma_int_t	magma_zgeqrs3_gpu (magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaDoubleComplex_ptr dA, magma_int_t ldda, magmaDoubleComplex const *tau, magmaDoubleComplex_ptr dT, magmaDoubleComplex_ptr dB, magma_int_t lddb, magmaDoubleComplex *hwork, magma_int_t lwork, magma_int_t *info)
	ZGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by ZGEQRF3_GPU. More...
magma_int_t	magma_zgeqrs_gpu (magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex const *tau, magmaDoubleComplex_ptr dT, magmaDoubleComplex_ptr dB, magma_int_t lddb, magmaDoubleComplex *hwork, magma_int_t lwork, magma_int_t *info)
	ZGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by ZGEQRF_GPU. More...

Detailed Description

Function Documentation

magma_int_t magma_cgeqrs3_gpu	(	magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nrhs,
		magmaFloatComplex_ptr	dA,
		magma_int_t	ldda,
		magmaFloatComplex const *	tau,
		magmaFloatComplex_ptr	dT,
		magmaFloatComplex_ptr	dB,
		magma_int_t	lddb,
		magmaFloatComplex *	hwork,
		magma_int_t	lwork,
		magma_int_t *	info
	)

CGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by CGEQRF3_GPU.

Parameters

[in]	m	INTEGER The number of rows of the matrix A. M >= 0.
[in]	n	INTEGER The number of columns of the matrix A. M >= N >= 0.
[in]	nrhs	INTEGER The number of columns of the matrix C. NRHS >= 0.
[in]	dA	COMPLEX array on the GPU, dimension (LDDA,N) The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,n, as returned by CGEQRF3_GPU in the first n columns of its array argument A. dA is modified by the routine but restored on exit.
[in]	ldda	INTEGER The leading dimension of the array A, LDDA >= M.
[in]	tau	COMPLEX array, dimension (N) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by MAGMA_CGEQRF_GPU.
[in,out]	dB	COMPLEX array on the GPU, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
[in,out]	dT	COMPLEX array that is the output (the 6th argument) of magma_cgeqrf_gpu of size 2*MIN(M, N)*NB + ceil(N/32)*32 )* MAX(NB, NRHS). The array starts with a block of size MIN(M,N)*NB that stores the triangular T matrices used in the QR factorization, followed by MIN(M,N)*NB block storing the diagonal block matrices for the R matrix, followed by work space of size (ceil(N/32)*32)* MAX(NB, NRHS).
[in]	lddb	INTEGER The leading dimension of the array dB. LDDB >= M.
[out]	hwork	(workspace) COMPLEX array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK, LWORK >= (M - N + NB)*(NRHS + NB) + NRHS*NB, where NB is the blocksize given by magma_get_cgeqrf_nb( M, N ). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the HWORK array, returns this value as the first entry of the WORK array.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

magma_int_t magma_cgeqrs_gpu	(	magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nrhs,
		magmaFloatComplex_const_ptr	dA,
		magma_int_t	ldda,
		magmaFloatComplex const *	tau,
		magmaFloatComplex_ptr	dT,
		magmaFloatComplex_ptr	dB,
		magma_int_t	lddb,
		magmaFloatComplex *	hwork,
		magma_int_t	lwork,
		magma_int_t *	info
	)

CGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by CGEQRF_GPU.

Parameters

[in]	m	INTEGER The number of rows of the matrix A. M >= 0.
[in]	n	INTEGER The number of columns of the matrix A. M >= N >= 0.
[in]	nrhs	INTEGER The number of columns of the matrix C. NRHS >= 0.
[in]	dA	COMPLEX array on the GPU, dimension (LDDA,N) The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,n, as returned by CGEQRF_GPU in the first n columns of its array argument A.
[in]	ldda	INTEGER The leading dimension of the array A, LDDA >= M.
[in]	tau	COMPLEX array, dimension (N) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by MAGMA_CGEQRF_GPU.
[in,out]	dB	COMPLEX array on the GPU, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
[in,out]	dT	COMPLEX array that is the output (the 6th argument) of magma_cgeqrf_gpu of size 2*MIN(M, N)*NB + ceil(N/32)*32 )* MAX(NB, NRHS). The array starts with a block of size MIN(M,N)*NB that stores the triangular T matrices used in the QR factorization, followed by MIN(M,N)*NB block storing the diagonal block inverses for the R matrix, followed by work space of size (ceil(N/32)*32)* MAX(NB, NRHS).
[in]	lddb	INTEGER The leading dimension of the array dB. LDDB >= M.
[out]	hwork	(workspace) COMPLEX array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK, LWORK >= (M - N + NB)*(NRHS + NB) + NRHS*NB, where NB is the blocksize given by magma_get_cgeqrf_nb( M, N ). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the HWORK array, returns this value as the first entry of the WORK array.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

magma_int_t magma_dgeqrs3_gpu	(	magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nrhs,
		magmaDouble_ptr	dA,
		magma_int_t	ldda,
		double const *	tau,
		magmaDouble_ptr	dT,
		magmaDouble_ptr	dB,
		magma_int_t	lddb,
		double *	hwork,
		magma_int_t	lwork,
		magma_int_t *	info
	)

DGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by DGEQRF3_GPU.

Parameters

[in]	m	INTEGER The number of rows of the matrix A. M >= 0.
[in]	n	INTEGER The number of columns of the matrix A. M >= N >= 0.
[in]	nrhs	INTEGER The number of columns of the matrix C. NRHS >= 0.
[in]	dA	DOUBLE PRECISION array on the GPU, dimension (LDDA,N) The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,n, as returned by DGEQRF3_GPU in the first n columns of its array argument A. dA is modified by the routine but restored on exit.
[in]	ldda	INTEGER The leading dimension of the array A, LDDA >= M.
[in]	tau	DOUBLE PRECISION array, dimension (N) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by MAGMA_DGEQRF_GPU.
[in,out]	dB	DOUBLE PRECISION array on the GPU, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
[in,out]	dT	DOUBLE PRECISION array that is the output (the 6th argument) of magma_dgeqrf_gpu of size 2*MIN(M, N)*NB + ceil(N/32)*32 )* MAX(NB, NRHS). The array starts with a block of size MIN(M,N)*NB that stores the triangular T matrices used in the QR factorization, followed by MIN(M,N)*NB block storing the diagonal block matrices for the R matrix, followed by work space of size (ceil(N/32)*32)* MAX(NB, NRHS).
[in]	lddb	INTEGER The leading dimension of the array dB. LDDB >= M.
[out]	hwork	(workspace) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK, LWORK >= (M - N + NB)*(NRHS + NB) + NRHS*NB, where NB is the blocksize given by magma_get_dgeqrf_nb( M, N ). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the HWORK array, returns this value as the first entry of the WORK array.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

magma_int_t magma_dgeqrs_gpu	(	magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nrhs,
		magmaDouble_const_ptr	dA,
		magma_int_t	ldda,
		double const *	tau,
		magmaDouble_ptr	dT,
		magmaDouble_ptr	dB,
		magma_int_t	lddb,
		double *	hwork,
		magma_int_t	lwork,
		magma_int_t *	info
	)

DGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by DGEQRF_GPU.

Parameters

[in]	m	INTEGER The number of rows of the matrix A. M >= 0.
[in]	n	INTEGER The number of columns of the matrix A. M >= N >= 0.
[in]	nrhs	INTEGER The number of columns of the matrix C. NRHS >= 0.
[in]	dA	DOUBLE PRECISION array on the GPU, dimension (LDDA,N) The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,n, as returned by DGEQRF_GPU in the first n columns of its array argument A.
[in]	ldda	INTEGER The leading dimension of the array A, LDDA >= M.
[in]	tau	DOUBLE PRECISION array, dimension (N) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by MAGMA_DGEQRF_GPU.
[in,out]	dB	DOUBLE PRECISION array on the GPU, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
[in,out]	dT	DOUBLE PRECISION array that is the output (the 6th argument) of magma_dgeqrf_gpu of size 2*MIN(M, N)*NB + ceil(N/32)*32 )* MAX(NB, NRHS). The array starts with a block of size MIN(M,N)*NB that stores the triangular T matrices used in the QR factorization, followed by MIN(M,N)*NB block storing the diagonal block inverses for the R matrix, followed by work space of size (ceil(N/32)*32)* MAX(NB, NRHS).
[in]	lddb	INTEGER The leading dimension of the array dB. LDDB >= M.
[out]	hwork	(workspace) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK, LWORK >= (M - N + NB)*(NRHS + NB) + NRHS*NB, where NB is the blocksize given by magma_get_dgeqrf_nb( M, N ). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the HWORK array, returns this value as the first entry of the WORK array.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

magma_int_t magma_sgeqrs3_gpu	(	magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nrhs,
		magmaFloat_ptr	dA,
		magma_int_t	ldda,
		float const *	tau,
		magmaFloat_ptr	dT,
		magmaFloat_ptr	dB,
		magma_int_t	lddb,
		float *	hwork,
		magma_int_t	lwork,
		magma_int_t *	info
	)

SGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by SGEQRF3_GPU.

Parameters

[in]	m	INTEGER The number of rows of the matrix A. M >= 0.
[in]	n	INTEGER The number of columns of the matrix A. M >= N >= 0.
[in]	nrhs	INTEGER The number of columns of the matrix C. NRHS >= 0.
[in]	dA	REAL array on the GPU, dimension (LDDA,N) The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,n, as returned by SGEQRF3_GPU in the first n columns of its array argument A. dA is modified by the routine but restored on exit.
[in]	ldda	INTEGER The leading dimension of the array A, LDDA >= M.
[in]	tau	REAL array, dimension (N) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by MAGMA_SGEQRF_GPU.
[in,out]	dB	REAL array on the GPU, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
[in,out]	dT	REAL array that is the output (the 6th argument) of magma_sgeqrf_gpu of size 2*MIN(M, N)*NB + ceil(N/32)*32 )* MAX(NB, NRHS). The array starts with a block of size MIN(M,N)*NB that stores the triangular T matrices used in the QR factorization, followed by MIN(M,N)*NB block storing the diagonal block matrices for the R matrix, followed by work space of size (ceil(N/32)*32)* MAX(NB, NRHS).
[in]	lddb	INTEGER The leading dimension of the array dB. LDDB >= M.
[out]	hwork	(workspace) REAL array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK, LWORK >= (M - N + NB)*(NRHS + NB) + NRHS*NB, where NB is the blocksize given by magma_get_sgeqrf_nb( M, N ). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the HWORK array, returns this value as the first entry of the WORK array.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

magma_int_t magma_sgeqrs_gpu	(	magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nrhs,
		magmaFloat_const_ptr	dA,
		magma_int_t	ldda,
		float const *	tau,
		magmaFloat_ptr	dT,
		magmaFloat_ptr	dB,
		magma_int_t	lddb,
		float *	hwork,
		magma_int_t	lwork,
		magma_int_t *	info
	)

SGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by SGEQRF_GPU.

Parameters

[in]	m	INTEGER The number of rows of the matrix A. M >= 0.
[in]	n	INTEGER The number of columns of the matrix A. M >= N >= 0.
[in]	nrhs	INTEGER The number of columns of the matrix C. NRHS >= 0.
[in]	dA	REAL array on the GPU, dimension (LDDA,N) The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,n, as returned by SGEQRF_GPU in the first n columns of its array argument A.
[in]	ldda	INTEGER The leading dimension of the array A, LDDA >= M.
[in]	tau	REAL array, dimension (N) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by MAGMA_SGEQRF_GPU.
[in,out]	dB	REAL array on the GPU, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
[in,out]	dT	REAL array that is the output (the 6th argument) of magma_sgeqrf_gpu of size 2*MIN(M, N)*NB + ceil(N/32)*32 )* MAX(NB, NRHS). The array starts with a block of size MIN(M,N)*NB that stores the triangular T matrices used in the QR factorization, followed by MIN(M,N)*NB block storing the diagonal block inverses for the R matrix, followed by work space of size (ceil(N/32)*32)* MAX(NB, NRHS).
[in]	lddb	INTEGER The leading dimension of the array dB. LDDB >= M.
[out]	hwork	(workspace) REAL array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK, LWORK >= (M - N + NB)*(NRHS + NB) + NRHS*NB, where NB is the blocksize given by magma_get_sgeqrf_nb( M, N ). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the HWORK array, returns this value as the first entry of the WORK array.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

magma_int_t magma_zgeqrs3_gpu	(	magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nrhs,
		magmaDoubleComplex_ptr	dA,
		magma_int_t	ldda,
		magmaDoubleComplex const *	tau,
		magmaDoubleComplex_ptr	dT,
		magmaDoubleComplex_ptr	dB,
		magma_int_t	lddb,
		magmaDoubleComplex *	hwork,
		magma_int_t	lwork,
		magma_int_t *	info
	)

ZGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by ZGEQRF3_GPU.

Parameters

[in]	m	INTEGER The number of rows of the matrix A. M >= 0.
[in]	n	INTEGER The number of columns of the matrix A. M >= N >= 0.
[in]	nrhs	INTEGER The number of columns of the matrix C. NRHS >= 0.
[in]	dA	COMPLEX_16 array on the GPU, dimension (LDDA,N) The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,n, as returned by ZGEQRF3_GPU in the first n columns of its array argument A. dA is modified by the routine but restored on exit.
[in]	ldda	INTEGER The leading dimension of the array A, LDDA >= M.
[in]	tau	COMPLEX_16 array, dimension (N) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by MAGMA_ZGEQRF_GPU.
[in,out]	dB	COMPLEX_16 array on the GPU, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
[in,out]	dT	COMPLEX_16 array that is the output (the 6th argument) of magma_zgeqrf_gpu of size 2*MIN(M, N)*NB + ceil(N/32)*32 )* MAX(NB, NRHS). The array starts with a block of size MIN(M,N)*NB that stores the triangular T matrices used in the QR factorization, followed by MIN(M,N)*NB block storing the diagonal block matrices for the R matrix, followed by work space of size (ceil(N/32)*32)* MAX(NB, NRHS).
[in]	lddb	INTEGER The leading dimension of the array dB. LDDB >= M.
[out]	hwork	(workspace) COMPLEX_16 array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK, LWORK >= (M - N + NB)*(NRHS + NB) + NRHS*NB, where NB is the blocksize given by magma_get_zgeqrf_nb( M, N ). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the HWORK array, returns this value as the first entry of the WORK array.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

magma_int_t magma_zgeqrs_gpu	(	magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nrhs,
		magmaDoubleComplex_const_ptr	dA,
		magma_int_t	ldda,
		magmaDoubleComplex const *	tau,
		magmaDoubleComplex_ptr	dT,
		magmaDoubleComplex_ptr	dB,
		magma_int_t	lddb,
		magmaDoubleComplex *	hwork,
		magma_int_t	lwork,
		magma_int_t *	info
	)

ZGEQRS solves the least squares problem min || A*X - C || using the QR factorization A = Q*R computed by ZGEQRF_GPU.

Parameters

[in]	m	INTEGER The number of rows of the matrix A. M >= 0.
[in]	n	INTEGER The number of columns of the matrix A. M >= N >= 0.
[in]	nrhs	INTEGER The number of columns of the matrix C. NRHS >= 0.
[in]	dA	COMPLEX_16 array on the GPU, dimension (LDDA,N) The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,n, as returned by ZGEQRF_GPU in the first n columns of its array argument A.
[in]	ldda	INTEGER The leading dimension of the array A, LDDA >= M.
[in]	tau	COMPLEX_16 array, dimension (N) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by MAGMA_ZGEQRF_GPU.
[in,out]	dB	COMPLEX_16 array on the GPU, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
[in,out]	dT	COMPLEX_16 array that is the output (the 6th argument) of magma_zgeqrf_gpu of size 2*MIN(M, N)*NB + ceil(N/32)*32 )* MAX(NB, NRHS). The array starts with a block of size MIN(M,N)*NB that stores the triangular T matrices used in the QR factorization, followed by MIN(M,N)*NB block storing the diagonal block inverses for the R matrix, followed by work space of size (ceil(N/32)*32)* MAX(NB, NRHS).
[in]	lddb	INTEGER The leading dimension of the array dB. LDDB >= M.
[out]	hwork	(workspace) COMPLEX_16 array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK, LWORK >= (M - N + NB)*(NRHS + NB) + NRHS*NB, where NB is the blocksize given by magma_get_zgeqrf_nb( M, N ). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the HWORK array, returns this value as the first entry of the WORK array.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value