MAGMA
2.3.0
Matrix Algebra for GPU and Multicore Architectures

Functions  
magma_int_t  magma_cgeev (magma_vec_t jobvl, magma_vec_t jobvr, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *w, magmaFloatComplex *VL, magma_int_t ldvl, magmaFloatComplex *VR, magma_int_t ldvr, magmaFloatComplex *work, magma_int_t lwork, float *rwork, magma_int_t *info) 
CGEEV computes for an NbyN complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. More...  
magma_int_t  magma_cgeev_m (magma_vec_t jobvl, magma_vec_t jobvr, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *w, magmaFloatComplex *VL, magma_int_t ldvl, magmaFloatComplex *VR, magma_int_t ldvr, magmaFloatComplex *work, magma_int_t lwork, float *rwork, magma_int_t *info) 
CGEEV computes for an NbyN complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. More...  
magma_int_t  magma_dgeev (magma_vec_t jobvl, magma_vec_t jobvr, magma_int_t n, double *A, magma_int_t lda, double *wr, double *wi, double *VL, magma_int_t ldvl, double *VR, magma_int_t ldvr, double *work, magma_int_t lwork, magma_int_t *info) 
DGEEV computes for an NbyN real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. More...  
magma_int_t  magma_dgeev_m (magma_vec_t jobvl, magma_vec_t jobvr, magma_int_t n, double *A, magma_int_t lda, double *wr, double *wi, double *VL, magma_int_t ldvl, double *VR, magma_int_t ldvr, double *work, magma_int_t lwork, magma_int_t *info) 
DGEEV computes for an NbyN real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. More...  
magma_int_t  magma_sgeev (magma_vec_t jobvl, magma_vec_t jobvr, magma_int_t n, float *A, magma_int_t lda, float *wr, float *wi, float *VL, magma_int_t ldvl, float *VR, magma_int_t ldvr, float *work, magma_int_t lwork, magma_int_t *info) 
SGEEV computes for an NbyN real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. More...  
magma_int_t  magma_sgeev_m (magma_vec_t jobvl, magma_vec_t jobvr, magma_int_t n, float *A, magma_int_t lda, float *wr, float *wi, float *VL, magma_int_t ldvl, float *VR, magma_int_t ldvr, float *work, magma_int_t lwork, magma_int_t *info) 
SGEEV computes for an NbyN real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. More...  
magma_int_t  magma_zgeev (magma_vec_t jobvl, magma_vec_t jobvr, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *w, magmaDoubleComplex *VL, magma_int_t ldvl, magmaDoubleComplex *VR, magma_int_t ldvr, magmaDoubleComplex *work, magma_int_t lwork, double *rwork, magma_int_t *info) 
ZGEEV computes for an NbyN complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. More...  
magma_int_t  magma_zgeev_m (magma_vec_t jobvl, magma_vec_t jobvr, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *w, magmaDoubleComplex *VL, magma_int_t ldvl, magmaDoubleComplex *VR, magma_int_t ldvr, magmaDoubleComplex *work, magma_int_t lwork, double *rwork, magma_int_t *info) 
ZGEEV computes for an NbyN complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. More...  
magma_int_t magma_cgeev  (  magma_vec_t  jobvl, 
magma_vec_t  jobvr,  
magma_int_t  n,  
magmaFloatComplex *  A,  
magma_int_t  lda,  
magmaFloatComplex *  w,  
magmaFloatComplex *  VL,  
magma_int_t  ldvl,  
magmaFloatComplex *  VR,  
magma_int_t  ldvr,  
magmaFloatComplex *  work,  
magma_int_t  lwork,  
float *  rwork,  
magma_int_t *  info  
) 
CGEEV computes for an NbyN complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)**H * A = lambda(j) * u(j)**H where u(j)**H denotes the conjugate transpose of u(j).
The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
[in]  jobvl  magma_vec_t

[in]  jobvr  magma_vec_t

[in]  n  INTEGER The order of the matrix A. N >= 0. 
[in,out]  A  COMPLEX array, dimension (LDA,N) On entry, the NbyN matrix A. On exit, A has been overwritten. 
[in]  lda  INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[out]  w  COMPLEX array, dimension (N) w contains the computed eigenvalues. 
[out]  VL  COMPLEX array, dimension (LDVL,N) If JOBVL = MagmaVec, the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues. If JOBVL = MagmaNoVec, VL is not referenced. u(j) = VL(:,j), the jth column of VL. 
[in]  ldvl  INTEGER The leading dimension of the array VL. LDVL >= 1; if JOBVL = MagmaVec, LDVL >= N. 
[out]  VR  COMPLEX array, dimension (LDVR,N) If JOBVR = MagmaVec, the right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If JOBVR = MagmaNoVec, VR is not referenced. v(j) = VR(:,j), the jth column of VR. 
[in]  ldvr  INTEGER The leading dimension of the array VR. LDVR >= 1; if JOBVR = MagmaVec, LDVR >= N. 
[out]  work  (workspace) COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. 
[in]  lwork  INTEGER The dimension of the array WORK. LWORK >= (1 + nb)*N. For optimal performance, LWORK >= (1 + 2*nb)*N. If LWORK = 1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. 
rwork  (workspace) REAL array, dimension (2*N)  
[out]  info  INTEGER

magma_int_t magma_cgeev_m  (  magma_vec_t  jobvl, 
magma_vec_t  jobvr,  
magma_int_t  n,  
magmaFloatComplex *  A,  
magma_int_t  lda,  
magmaFloatComplex *  w,  
magmaFloatComplex *  VL,  
magma_int_t  ldvl,  
magmaFloatComplex *  VR,  
magma_int_t  ldvr,  
magmaFloatComplex *  work,  
magma_int_t  lwork,  
float *  rwork,  
magma_int_t *  info  
) 
CGEEV computes for an NbyN complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)**H * A = lambda(j) * u(j)**H where u(j)**H denotes the conjugate transpose of u(j).
The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
[in]  jobvl  magma_vec_t

[in]  jobvr  magma_vec_t

[in]  n  INTEGER The order of the matrix A. N >= 0. 
[in,out]  A  COMPLEX array, dimension (LDA,N) On entry, the NbyN matrix A. On exit, A has been overwritten. 
[in]  lda  INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[out]  w  COMPLEX array, dimension (N) W contains the computed eigenvalues. 
[out]  VL  COMPLEX array, dimension (LDVL,N) If JOBVL = MagmaVec, the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues. If JOBVL = MagmaNoVec, VL is not referenced. u(j) = VL(:,j), the jth column of VL. 
[in]  ldvl  INTEGER The leading dimension of the array VL. LDVL >= 1; if JOBVL = MagmaVec, LDVL >= N. 
[out]  VR  COMPLEX array, dimension (LDVR,N) If JOBVR = MagmaVec, the right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If JOBVR = MagmaNoVec, VR is not referenced. v(j) = VR(:,j), the jth column of VR. 
[in]  ldvr  INTEGER The leading dimension of the array VR. LDVR >= 1; if JOBVR = MagmaVec, LDVR >= N. 
[out]  work  (workspace) COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. 
[in]  lwork  INTEGER The dimension of the array WORK. LWORK >= (1 + nb + nb*ngpu)*N. For optimal performance, LWORK >= (1 + 2*nb + nb*ngpu)*N. If LWORK = 1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. 
rwork  (workspace) REAL array, dimension (2*N)  
[out]  info  INTEGER

magma_int_t magma_dgeev  (  magma_vec_t  jobvl, 
magma_vec_t  jobvr,  
magma_int_t  n,  
double *  A,  
magma_int_t  lda,  
double *  wr,  
double *  wi,  
double *  VL,  
magma_int_t  ldvl,  
double *  VR,  
magma_int_t  ldvr,  
double *  work,  
magma_int_t  lwork,  
magma_int_t *  info  
) 
DGEEV computes for an NbyN real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)**T * A = lambda(j) * u(j)**T where u(j)**T denotes the transpose of u(j).
The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
[in]  jobvl  magma_vec_t

[in]  jobvr  magma_vec_t

[in]  n  INTEGER The order of the matrix A. N >= 0. 
[in,out]  A  DOUBLE PRECISION array, dimension (LDA,N) On entry, the NbyN matrix A. On exit, A has been overwritten. 
[in]  lda  INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[out]  wr  DOUBLE PRECISION array, dimension (N) 
[out]  wi  DOUBLE PRECISION array, dimension (N) WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. 
[out]  VL  DOUBLE PRECISION array, dimension (LDVL,N) If JOBVL = MagmaVec, the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues. If JOBVL = MagmaNoVec, VL is not referenced. u(j) = VL(:,j), the jth column of VL. 
[in]  ldvl  INTEGER The leading dimension of the array VL. LDVL >= 1; if JOBVL = MagmaVec, LDVL >= N. 
[out]  VR  DOUBLE PRECISION array, dimension (LDVR,N) If JOBVR = MagmaVec, the right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If JOBVR = MagmaNoVec, VR is not referenced. v(j) = VR(:,j), the jth column of VR. 
[in]  ldvr  INTEGER The leading dimension of the array VR. LDVR >= 1; if JOBVR = MagmaVec, LDVR >= N. 
[out]  work  (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. 
[in]  lwork  INTEGER The dimension of the array WORK. LWORK >= (2 + nb)*N. For optimal performance, LWORK >= (2 + 2*nb)*N. If LWORK = 1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. 
[out]  info  INTEGER

magma_int_t magma_dgeev_m  (  magma_vec_t  jobvl, 
magma_vec_t  jobvr,  
magma_int_t  n,  
double *  A,  
magma_int_t  lda,  
double *  wr,  
double *  wi,  
double *  VL,  
magma_int_t  ldvl,  
double *  VR,  
magma_int_t  ldvr,  
double *  work,  
magma_int_t  lwork,  
magma_int_t *  info  
) 
DGEEV computes for an NbyN real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)**T * A = lambda(j) * u(j)**T where u(j)**T denotes the transpose of u(j).
The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
[in]  jobvl  magma_vec_t

[in]  jobvr  magma_vec_t

[in]  n  INTEGER The order of the matrix A. N >= 0. 
[in,out]  A  DOUBLE PRECISION array, dimension (LDA,N) On entry, the NbyN matrix A. On exit, A has been overwritten. 
[in]  lda  INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[out]  wr  DOUBLE PRECISION array, dimension (N) 
[out]  wi  DOUBLE PRECISION array, dimension (N) WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. 
[out]  VL  DOUBLE PRECISION array, dimension (LDVL,N) If JOBVL = MagmaVec, the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues. If JOBVL = MagmaNoVec, VL is not referenced. u(j) = VL(:,j), the jth column of VL. 
[in]  ldvl  INTEGER The leading dimension of the array VL. LDVL >= 1; if JOBVL = MagmaVec, LDVL >= N. 
[out]  VR  DOUBLE PRECISION array, dimension (LDVR,N) If JOBVR = MagmaVec, the right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If JOBVR = MagmaNoVec, VR is not referenced. v(j) = VR(:,j), the jth column of VR. 
[in]  ldvr  INTEGER The leading dimension of the array VR. LDVR >= 1; if JOBVR = MagmaVec, LDVR >= N. 
[out]  work  (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. 
[in]  lwork  INTEGER The dimension of the array WORK. LWORK >= (2 + nb + nb*ngpu)*N. For optimal performance, LWORK >= (2 + 2*nb + nb*ngpu)*N. If LWORK = 1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. 
[out]  info  INTEGER

magma_int_t magma_sgeev  (  magma_vec_t  jobvl, 
magma_vec_t  jobvr,  
magma_int_t  n,  
float *  A,  
magma_int_t  lda,  
float *  wr,  
float *  wi,  
float *  VL,  
magma_int_t  ldvl,  
float *  VR,  
magma_int_t  ldvr,  
float *  work,  
magma_int_t  lwork,  
magma_int_t *  info  
) 
SGEEV computes for an NbyN real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)**T * A = lambda(j) * u(j)**T where u(j)**T denotes the transpose of u(j).
The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
[in]  jobvl  magma_vec_t

[in]  jobvr  magma_vec_t

[in]  n  INTEGER The order of the matrix A. N >= 0. 
[in,out]  A  REAL array, dimension (LDA,N) On entry, the NbyN matrix A. On exit, A has been overwritten. 
[in]  lda  INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[out]  wr  REAL array, dimension (N) 
[out]  wi  REAL array, dimension (N) WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. 
[out]  VL  REAL array, dimension (LDVL,N) If JOBVL = MagmaVec, the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues. If JOBVL = MagmaNoVec, VL is not referenced. u(j) = VL(:,j), the jth column of VL. 
[in]  ldvl  INTEGER The leading dimension of the array VL. LDVL >= 1; if JOBVL = MagmaVec, LDVL >= N. 
[out]  VR  REAL array, dimension (LDVR,N) If JOBVR = MagmaVec, the right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If JOBVR = MagmaNoVec, VR is not referenced. v(j) = VR(:,j), the jth column of VR. 
[in]  ldvr  INTEGER The leading dimension of the array VR. LDVR >= 1; if JOBVR = MagmaVec, LDVR >= N. 
[out]  work  (workspace) REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. 
[in]  lwork  INTEGER The dimension of the array WORK. LWORK >= (2 + nb)*N. For optimal performance, LWORK >= (2 + 2*nb)*N. If LWORK = 1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. 
[out]  info  INTEGER

magma_int_t magma_sgeev_m  (  magma_vec_t  jobvl, 
magma_vec_t  jobvr,  
magma_int_t  n,  
float *  A,  
magma_int_t  lda,  
float *  wr,  
float *  wi,  
float *  VL,  
magma_int_t  ldvl,  
float *  VR,  
magma_int_t  ldvr,  
float *  work,  
magma_int_t  lwork,  
magma_int_t *  info  
) 
SGEEV computes for an NbyN real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)**T * A = lambda(j) * u(j)**T where u(j)**T denotes the transpose of u(j).
The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
[in]  jobvl  magma_vec_t

[in]  jobvr  magma_vec_t

[in]  n  INTEGER The order of the matrix A. N >= 0. 
[in,out]  A  REAL array, dimension (LDA,N) On entry, the NbyN matrix A. On exit, A has been overwritten. 
[in]  lda  INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[out]  wr  REAL array, dimension (N) 
[out]  wi  REAL array, dimension (N) WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. 
[out]  VL  REAL array, dimension (LDVL,N) If JOBVL = MagmaVec, the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues. If JOBVL = MagmaNoVec, VL is not referenced. u(j) = VL(:,j), the jth column of VL. 
[in]  ldvl  INTEGER The leading dimension of the array VL. LDVL >= 1; if JOBVL = MagmaVec, LDVL >= N. 
[out]  VR  REAL array, dimension (LDVR,N) If JOBVR = MagmaVec, the right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If JOBVR = MagmaNoVec, VR is not referenced. v(j) = VR(:,j), the jth column of VR. 
[in]  ldvr  INTEGER The leading dimension of the array VR. LDVR >= 1; if JOBVR = MagmaVec, LDVR >= N. 
[out]  work  (workspace) REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. 
[in]  lwork  INTEGER The dimension of the array WORK. LWORK >= (2 + nb + nb*ngpu)*N. For optimal performance, LWORK >= (2 + 2*nb + nb*ngpu)*N. If LWORK = 1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. 
[out]  info  INTEGER

magma_int_t magma_zgeev  (  magma_vec_t  jobvl, 
magma_vec_t  jobvr,  
magma_int_t  n,  
magmaDoubleComplex *  A,  
magma_int_t  lda,  
magmaDoubleComplex *  w,  
magmaDoubleComplex *  VL,  
magma_int_t  ldvl,  
magmaDoubleComplex *  VR,  
magma_int_t  ldvr,  
magmaDoubleComplex *  work,  
magma_int_t  lwork,  
double *  rwork,  
magma_int_t *  info  
) 
ZGEEV computes for an NbyN complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)**H * A = lambda(j) * u(j)**H where u(j)**H denotes the conjugate transpose of u(j).
The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
[in]  jobvl  magma_vec_t

[in]  jobvr  magma_vec_t

[in]  n  INTEGER The order of the matrix A. N >= 0. 
[in,out]  A  COMPLEX_16 array, dimension (LDA,N) On entry, the NbyN matrix A. On exit, A has been overwritten. 
[in]  lda  INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[out]  w  COMPLEX_16 array, dimension (N) w contains the computed eigenvalues. 
[out]  VL  COMPLEX_16 array, dimension (LDVL,N) If JOBVL = MagmaVec, the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues. If JOBVL = MagmaNoVec, VL is not referenced. u(j) = VL(:,j), the jth column of VL. 
[in]  ldvl  INTEGER The leading dimension of the array VL. LDVL >= 1; if JOBVL = MagmaVec, LDVL >= N. 
[out]  VR  COMPLEX_16 array, dimension (LDVR,N) If JOBVR = MagmaVec, the right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If JOBVR = MagmaNoVec, VR is not referenced. v(j) = VR(:,j), the jth column of VR. 
[in]  ldvr  INTEGER The leading dimension of the array VR. LDVR >= 1; if JOBVR = MagmaVec, LDVR >= N. 
[out]  work  (workspace) COMPLEX_16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. 
[in]  lwork  INTEGER The dimension of the array WORK. LWORK >= (1 + nb)*N. For optimal performance, LWORK >= (1 + 2*nb)*N. If LWORK = 1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. 
rwork  (workspace) DOUBLE PRECISION array, dimension (2*N)  
[out]  info  INTEGER

magma_int_t magma_zgeev_m  (  magma_vec_t  jobvl, 
magma_vec_t  jobvr,  
magma_int_t  n,  
magmaDoubleComplex *  A,  
magma_int_t  lda,  
magmaDoubleComplex *  w,  
magmaDoubleComplex *  VL,  
magma_int_t  ldvl,  
magmaDoubleComplex *  VR,  
magma_int_t  ldvr,  
magmaDoubleComplex *  work,  
magma_int_t  lwork,  
double *  rwork,  
magma_int_t *  info  
) 
ZGEEV computes for an NbyN complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)**H * A = lambda(j) * u(j)**H where u(j)**H denotes the conjugate transpose of u(j).
The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
[in]  jobvl  magma_vec_t

[in]  jobvr  magma_vec_t

[in]  n  INTEGER The order of the matrix A. N >= 0. 
[in,out]  A  COMPLEX_16 array, dimension (LDA,N) On entry, the NbyN matrix A. On exit, A has been overwritten. 
[in]  lda  INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[out]  w  COMPLEX_16 array, dimension (N) W contains the computed eigenvalues. 
[out]  VL  COMPLEX_16 array, dimension (LDVL,N) If JOBVL = MagmaVec, the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues. If JOBVL = MagmaNoVec, VL is not referenced. u(j) = VL(:,j), the jth column of VL. 
[in]  ldvl  INTEGER The leading dimension of the array VL. LDVL >= 1; if JOBVL = MagmaVec, LDVL >= N. 
[out]  VR  COMPLEX_16 array, dimension (LDVR,N) If JOBVR = MagmaVec, the right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If JOBVR = MagmaNoVec, VR is not referenced. v(j) = VR(:,j), the jth column of VR. 
[in]  ldvr  INTEGER The leading dimension of the array VR. LDVR >= 1; if JOBVR = MagmaVec, LDVR >= N. 
[out]  work  (workspace) COMPLEX_16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. 
[in]  lwork  INTEGER The dimension of the array WORK. LWORK >= (1 + nb + nb*ngpu)*N. For optimal performance, LWORK >= (1 + 2*nb + nb*ngpu)*N. If LWORK = 1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. 
rwork  (workspace) DOUBLE PRECISION array, dimension (2*N)  
[out]  info  INTEGER
