Loading...
Searching...
No Matches
gels: Least squares solves Ax = b using QR factorization (driver)
Dense LA » Linear system solvers » General matrices: least squares

## Functions

magma_int_t | magma_cgels (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaFloatComplex_ptr A, magma_int_t lda, magmaFloatComplex_ptr B, magma_int_t ldb, magmaFloatComplex *hwork, magma_int_t lwork, magma_int_t *info)
| CGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.
magma_int_t | magma_cgels3_gpu (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaFloatComplex_ptr dA, magma_int_t ldda, magmaFloatComplex_ptr dB, magma_int_t lddb, magmaFloatComplex *hwork, magma_int_t lwork, magma_int_t *info)
| CGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.
magma_int_t | magma_cgels_gpu (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaFloatComplex_ptr dA, magma_int_t ldda, magmaFloatComplex_ptr dB, magma_int_t lddb, magmaFloatComplex *hwork, magma_int_t lwork, magma_int_t *info)
| CGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.
magma_int_t | magma_dgels (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaDouble_ptr A, magma_int_t lda, magmaDouble_ptr B, magma_int_t ldb, double *hwork, magma_int_t lwork, magma_int_t *info)
| DGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.
magma_int_t | magma_dgels3_gpu (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaDouble_ptr dA, magma_int_t ldda, magmaDouble_ptr dB, magma_int_t lddb, double *hwork, magma_int_t lwork, magma_int_t *info)
| DGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.
magma_int_t | magma_dgels_gpu (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaDouble_ptr dA, magma_int_t ldda, magmaDouble_ptr dB, magma_int_t lddb, double *hwork, magma_int_t lwork, magma_int_t *info)
| DGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.
magma_int_t | magma_sgels (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaFloat_ptr A, magma_int_t lda, magmaFloat_ptr B, magma_int_t ldb, float *hwork, magma_int_t lwork, magma_int_t *info)
| SGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.
magma_int_t | magma_sgels3_gpu (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaFloat_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, float *hwork, magma_int_t lwork, magma_int_t *info)
| SGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.
magma_int_t | magma_sgels_gpu (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaFloat_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, float *hwork, magma_int_t lwork, magma_int_t *info)
| SGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.
magma_int_t | magma_zgels (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaDoubleComplex_ptr A, magma_int_t lda, magmaDoubleComplex_ptr B, magma_int_t ldb, magmaDoubleComplex *hwork, magma_int_t lwork, magma_int_t *info)
| ZGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.
magma_int_t | magma_zgels3_gpu (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaDoubleComplex_ptr dA, magma_int_t ldda, magmaDoubleComplex_ptr dB, magma_int_t lddb, magmaDoubleComplex *hwork, magma_int_t lwork, magma_int_t *info)
| ZGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.
magma_int_t | magma_zgels_gpu (magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t nrhs, magmaDoubleComplex_ptr dA, magma_int_t ldda, magmaDoubleComplex_ptr dB, magma_int_t lddb, magmaDoubleComplex *hwork, magma_int_t lwork, magma_int_t *info)
| ZGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

## Detailed Description

## Function Documentation

## magma_cgels()

magma_int_t magma_cgels | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaFloatComplex_ptr | A,
|  | magma_int_t | lda,
|  | magmaFloatComplex_ptr | B,
|  | magma_int_t | ldb,
|  | magmaFloatComplex * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

CGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | A | COMPLEX array, dimension (LDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by CGEQRF.
  [in] | lda | INTEGER The leading dimension of the array A, LDA >= M.
  [in,out] | B | COMPLEX array, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= M.
  [out] | hwork | (workspace) COMPLEX array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, LWORK >= max( N*NB, 2*NB*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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_cgels3_gpu()

magma_int_t magma_cgels3_gpu | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaFloatComplex_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloatComplex_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaFloatComplex * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

CGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | dA | COMPLEX array, dimension (LDDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by CGEQRF3.
  [in] | ldda | INTEGER The leading dimension of the array A, LDDA >= M.
  [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] | lddb | INTEGER The leading dimension of the array dB. LDDB >= M.
  [out] | hwork | (workspace) COMPLEX array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, 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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_cgels_gpu()

magma_int_t magma_cgels_gpu | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaFloatComplex_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloatComplex_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaFloatComplex * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

CGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | dA | COMPLEX array on the GPU, dimension (LDDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by CGEQRF.
  [in] | ldda | INTEGER The leading dimension of the array A, LDDA >= M.
  [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] | lddb | INTEGER The leading dimension of the array dB. LDDB >= M.
  [out] | hwork | (workspace) COMPLEX array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, 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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_dgels()

magma_int_t magma_dgels | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaDouble_ptr | A,
|  | magma_int_t | lda,
|  | magmaDouble_ptr | B,
|  | magma_int_t | ldb,
|  | double * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

DGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | A | DOUBLE PRECISION array, dimension (LDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by DGEQRF.
  [in] | lda | INTEGER The leading dimension of the array A, LDA >= M.
  [in,out] | B | DOUBLE PRECISION array, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= M.
  [out] | hwork | (workspace) DOUBLE PRECISION array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, LWORK >= max( N*NB, 2*NB*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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_dgels3_gpu()

magma_int_t magma_dgels3_gpu | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaDouble_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDouble_ptr | dB,
|  | magma_int_t | lddb,
|  | double * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

DGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | dA | DOUBLE PRECISION array, dimension (LDDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by DGEQRF3.
  [in] | ldda | INTEGER The leading dimension of the array A, LDDA >= M.
  [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] | lddb | INTEGER The leading dimension of the array dB. LDDB >= M.
  [out] | hwork | (workspace) DOUBLE PRECISION array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, 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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_dgels_gpu()

magma_int_t magma_dgels_gpu | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaDouble_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDouble_ptr | dB,
|  | magma_int_t | lddb,
|  | double * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

DGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | dA | DOUBLE PRECISION array on the GPU, dimension (LDDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by DGEQRF.
  [in] | ldda | INTEGER The leading dimension of the array A, LDDA >= M.
  [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] | lddb | INTEGER The leading dimension of the array dB. LDDB >= M.
  [out] | hwork | (workspace) DOUBLE PRECISION array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, 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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_sgels()

magma_int_t magma_sgels | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaFloat_ptr | A,
|  | magma_int_t | lda,
|  | magmaFloat_ptr | B,
|  | magma_int_t | ldb,
|  | float * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

SGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | A | REAL array, dimension (LDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by SGEQRF.
  [in] | lda | INTEGER The leading dimension of the array A, LDA >= M.
  [in,out] | B | REAL array, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= M.
  [out] | hwork | (workspace) REAL array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, LWORK >= max( N*NB, 2*NB*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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_sgels3_gpu()

magma_int_t magma_sgels3_gpu | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaFloat_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloat_ptr | dB,
|  | magma_int_t | lddb,
|  | float * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

SGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | dA | REAL array, dimension (LDDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by SGEQRF3.
  [in] | ldda | INTEGER The leading dimension of the array A, LDDA >= M.
  [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] | lddb | INTEGER The leading dimension of the array dB. LDDB >= M.
  [out] | hwork | (workspace) REAL array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, 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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_sgels_gpu()

magma_int_t magma_sgels_gpu | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaFloat_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloat_ptr | dB,
|  | magma_int_t | lddb,
|  | float * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

SGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | dA | REAL array on the GPU, dimension (LDDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by SGEQRF.
  [in] | ldda | INTEGER The leading dimension of the array A, LDDA >= M.
  [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] | lddb | INTEGER The leading dimension of the array dB. LDDB >= M.
  [out] | hwork | (workspace) REAL array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, 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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_zgels()

magma_int_t magma_zgels | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaDoubleComplex_ptr | A,
|  | magma_int_t | lda,
|  | magmaDoubleComplex_ptr | B,
|  | magma_int_t | ldb,
|  | magmaDoubleComplex * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

ZGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | A | COMPLEX_16 array, dimension (LDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by ZGEQRF.
  [in] | lda | INTEGER The leading dimension of the array A, LDA >= M.
  [in,out] | B | COMPLEX_16 array, dimension (LDDB,NRHS) On entry, the M-by-NRHS matrix C. On exit, the N-by-NRHS solution matrix X.
  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= M.
  [out] | hwork | (workspace) COMPLEX_16 array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, LWORK >= max( N*NB, 2*NB*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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_zgels3_gpu()

magma_int_t magma_zgels3_gpu | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaDoubleComplex_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaDoubleComplex * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

ZGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | dA | COMPLEX_16 array, dimension (LDDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by ZGEQRF3.
  [in] | ldda | INTEGER The leading dimension of the array A, LDDA >= M.
  [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] | lddb | INTEGER The leading dimension of the array dB. LDDB >= M.
  [out] | hwork | (workspace) COMPLEX_16 array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, 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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value

## magma_zgels_gpu()

magma_int_t magma_zgels_gpu | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | nrhs,
|  | magmaDoubleComplex_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaDoubleComplex * | hwork,
|  | magma_int_t | lwork,
|  | magma_int_t * | info )

ZGELS solves the overdetermined, least squares problem min || A*X - C || using the QR factorization A.

The underdetermined problem (m < n) is not currently handled.

Parameters

  [in]

  trans

  magma_trans_t
  - = MagmaNoTrans: the linear system involves A. Only TRANS=MagmaNoTrans is currently handled.

  [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,out] | dA | COMPLEX_16 array on the GPU, dimension (LDDA,N) On entry, the M-by-N matrix A. On exit, A is overwritten by details of its QR factorization as returned by ZGEQRF.
  [in] | ldda | INTEGER The leading dimension of the array A, LDDA >= M.
  [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] | lddb | INTEGER The leading dimension of the array dB. LDDB >= M.
  [out] | hwork | (workspace) COMPLEX_16 array, dimension MAX(1,LWORK). On exit, if INFO = 0, HWORK[0] returns the optimal LWORK.
  [in] | lwork | INTEGER The dimension of the array HWORK, 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 HWORK array.

  [out]

  info

  INTEGER
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value