sy/heevd: Solves using divide-and-conquer (driver)

Functions
magma_int_t	magma_cheevd (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, float *w, magmaFloatComplex *work, magma_int_t lwork, float *rwork, magma_int_t lrwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	CHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
magma_int_t	magma_cheevd_gpu (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex_ptr dA, magma_int_t ldda, float *w, magmaFloatComplex *wA, magma_int_t ldwa, magmaFloatComplex *work, magma_int_t lwork, float *rwork, magma_int_t lrwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	CHEEVD_GPU computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
magma_int_t	magma_cheevd_m (magma_int_t ngpu, magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, float *w, magmaFloatComplex *work, magma_int_t lwork, float *rwork, magma_int_t lrwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	CHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
magma_int_t	magma_dsyevd (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, double *A, magma_int_t lda, double *w, double *work, magma_int_t lwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	DSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
magma_int_t	magma_dsyevd_gpu (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaDouble_ptr dA, magma_int_t ldda, double *w, double *wA, magma_int_t ldwa, double *work, magma_int_t lwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	DSYEVD_GPU computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
magma_int_t	magma_dsyevd_m (magma_int_t ngpu, magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, double *A, magma_int_t lda, double *w, double *work, magma_int_t lwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	DSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
magma_int_t	magma_ssyevd (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, float *A, magma_int_t lda, float *w, float *work, magma_int_t lwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	SSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
magma_int_t	magma_ssyevd_gpu (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, float *w, float *wA, magma_int_t ldwa, float *work, magma_int_t lwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	SSYEVD_GPU computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
magma_int_t	magma_ssyevd_m (magma_int_t ngpu, magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, float *A, magma_int_t lda, float *w, float *work, magma_int_t lwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	SSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
magma_int_t	magma_zheevd (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, double *w, magmaDoubleComplex *work, magma_int_t lwork, double *rwork, magma_int_t lrwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	ZHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
magma_int_t	magma_zheevd_gpu (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex_ptr dA, magma_int_t ldda, double *w, magmaDoubleComplex *wA, magma_int_t ldwa, magmaDoubleComplex *work, magma_int_t lwork, double *rwork, magma_int_t lrwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	ZHEEVD_GPU computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
magma_int_t	magma_zheevd_m (magma_int_t ngpu, magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, double *w, magmaDoubleComplex *work, magma_int_t lwork, double *rwork, magma_int_t lrwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
	ZHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
magma_int_t	magma_cheevj_batched_expert_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex **dA_array, magma_int_t ldda, float **dW_array, magma_int_t *info_array, int *batch_mask, int *num_sweeps, float heevj_tol, magma_int_t sort_flag, magma_int_t max_sweeps, magma_int_t nthreads, magma_int_t batchCount, magma_queue_t queue)
	CHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.
magma_int_t	magma_cheevj_batched_strided_expert_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex *dA, magma_int_t ldda, magma_int_t strideA, float *dW, magma_int_t strideW, magma_int_t *info_array, int *batch_mask, int *num_sweeps, float heevj_tol, magma_int_t sort_flag, magma_int_t max_sweeps, magma_int_t nthreads, magma_int_t batchCount, magma_queue_t queue)
	CHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.
magma_int_t	magma_cheevj_batched_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex **dA_array, magma_int_t ldda, float **dW_array, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
	CHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.
magma_int_t	magma_cheevj_batched_strided_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex *dA, magma_int_t ldda, magma_int_t strideA, float *dW, magma_int_t strideW, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
	CHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.
magma_int_t	magma_dsyevj_batched_expert_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, double **dA_array, magma_int_t ldda, double **dW_array, magma_int_t *info_array, int *batch_mask, int *num_sweeps, double heevj_tol, magma_int_t sort_flag, magma_int_t max_sweeps, magma_int_t nthreads, magma_int_t batchCount, magma_queue_t queue)
	DSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.
magma_int_t	magma_dsyevj_batched_strided_expert_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, double *dA, magma_int_t ldda, magma_int_t strideA, double *dW, magma_int_t strideW, magma_int_t *info_array, int *batch_mask, int *num_sweeps, double heevj_tol, magma_int_t sort_flag, magma_int_t max_sweeps, magma_int_t nthreads, magma_int_t batchCount, magma_queue_t queue)
	DSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.
magma_int_t	magma_dsyevj_batched_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, double **dA_array, magma_int_t ldda, double **dW_array, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
	DSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.
magma_int_t	magma_dsyevj_batched_strided_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, double *dA, magma_int_t ldda, magma_int_t strideA, double *dW, magma_int_t strideW, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
	DSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.
magma_int_t	magma_ssyevj_batched_expert_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, float **dA_array, magma_int_t ldda, float **dW_array, magma_int_t *info_array, int *batch_mask, int *num_sweeps, float heevj_tol, magma_int_t sort_flag, magma_int_t max_sweeps, magma_int_t nthreads, magma_int_t batchCount, magma_queue_t queue)
	SSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.
magma_int_t	magma_ssyevj_batched_strided_expert_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, float *dA, magma_int_t ldda, magma_int_t strideA, float *dW, magma_int_t strideW, magma_int_t *info_array, int *batch_mask, int *num_sweeps, float heevj_tol, magma_int_t sort_flag, magma_int_t max_sweeps, magma_int_t nthreads, magma_int_t batchCount, magma_queue_t queue)
	SSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.
magma_int_t	magma_ssyevj_batched_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, float **dA_array, magma_int_t ldda, float **dW_array, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
	SSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.
magma_int_t	magma_ssyevj_batched_strided_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, float *dA, magma_int_t ldda, magma_int_t strideA, float *dW, magma_int_t strideW, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
	SSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.
magma_int_t	magma_zheevj_batched_expert_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex **dA_array, magma_int_t ldda, double **dW_array, magma_int_t *info_array, int *batch_mask, int *num_sweeps, double heevj_tol, magma_int_t sort_flag, magma_int_t max_sweeps, magma_int_t nthreads, magma_int_t batchCount, magma_queue_t queue)
	ZHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.
magma_int_t	magma_zheevj_batched_strided_expert_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex *dA, magma_int_t ldda, magma_int_t strideA, double *dW, magma_int_t strideW, magma_int_t *info_array, int *batch_mask, int *num_sweeps, double heevj_tol, magma_int_t sort_flag, magma_int_t max_sweeps, magma_int_t nthreads, magma_int_t batchCount, magma_queue_t queue)
	ZHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.
magma_int_t	magma_zheevj_batched_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex **dA_array, magma_int_t ldda, double **dW_array, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
	ZHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.
magma_int_t	magma_zheevj_batched_strided_small_sm (magma_vec_t jobz, magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex *dA, magma_int_t ldda, magma_int_t strideA, double *dW, magma_int_t strideW, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
	ZHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.

Detailed Description

Function Documentation

magma_cheevd()

magma_int_t magma_cheevd	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaFloatComplex *	A,
		magma_int_t	lda,
		float *	w,
		magmaFloatComplex *	work,
		magma_int_t	lwork,
		float *	rwork,
		magma_int_t	lrwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

CHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	A	COMPLEX array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	lda	INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]	w	REAL array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
[out]	work	(workspace) COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( N + N*NB, 2*N + N**2 ). NB can be obtained through magma_get_chetrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	rwork	(workspace) REAL array, dimension (LRWORK) On exit, if INFO = 0, RWORK[0] returns the optimal LRWORK.
[in]	lrwork	INTEGER The dimension of the array RWORK. If N <= 1, LRWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LRWORK >= N. If JOBZ = MagmaVec and N > 1, LRWORK >= 1 + 5*N + 2*N**2. If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_cheevd_gpu()

magma_int_t magma_cheevd_gpu	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaFloatComplex_ptr	dA,
		magma_int_t	ldda,
		float *	w,
		magmaFloatComplex *	wA,
		magma_int_t	ldwa,
		magmaFloatComplex *	work,
		magma_int_t	lwork,
		float *	rwork,
		magma_int_t	lrwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

CHEEVD_GPU computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	COMPLEX array on the GPU, dimension (LDDA, N). On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	ldda	INTEGER The leading dimension of the array DA. LDDA >= max(1,N).
[out]	w	REAL array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
	wA	(workspace) COMPLEX array, dimension (LDWA, N)
[in]	ldwa	INTEGER The leading dimension of the array wA. LDWA >= max(1,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 length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( N + N*NB, 2*N + N**2 ). NB can be obtained through magma_get_chetrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	rwork	(workspace) REAL array, dimension (LRWORK) On exit, if INFO = 0, RWORK[0] returns the optimal LRWORK.
[in]	lrwork	INTEGER The dimension of the array RWORK. If N <= 1, LRWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LRWORK >= N. If JOBZ = MagmaVec and N > 1, LRWORK >= 1 + 5*N + 2*N**2. If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_cheevd_m()

magma_int_t magma_cheevd_m	(	magma_int_t	ngpu,
		magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaFloatComplex *	A,
		magma_int_t	lda,
		float *	w,
		magmaFloatComplex *	work,
		magma_int_t	lwork,
		float *	rwork,
		magma_int_t	lrwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

CHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	ngpu	INTEGER Number of GPUs to use. ngpu > 0.
[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	A	COMPLEX array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	lda	INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]	w	REAL array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
[out]	work	(workspace) COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( N + N*NB, 2*N + N**2 ). NB can be obtained through magma_get_chetrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	rwork	(workspace) REAL array, dimension (LRWORK) On exit, if INFO = 0, RWORK[0] returns the optimal LRWORK.
[in]	lrwork	INTEGER The dimension of the array RWORK. If N <= 1, LRWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LRWORK >= N. If JOBZ = MagmaVec and N > 1, LRWORK >= 1 + 5*N + 2*N**2. If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_dsyevd()

magma_int_t magma_dsyevd	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		double *	A,
		magma_int_t	lda,
		double *	w,
		double *	work,
		magma_int_t	lwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

DSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	A	DOUBLE PRECISION array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	lda	INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]	w	DOUBLE PRECISION array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
[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 length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= 2*N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( 2*N + N*NB, 1 + 6*N + 2*N**2 ). NB can be obtained through magma_get_dsytrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK and IWORK arrays, returns these values as the first entries of the WORK and IWORK arrays, and no error message related to LWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK and IWORK arrays, returns these values as the first entries of the WORK and IWORK arrays, and no error message related to LWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_dsyevd_gpu()

magma_int_t magma_dsyevd_gpu	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaDouble_ptr	dA,
		magma_int_t	ldda,
		double *	w,
		double *	wA,
		magma_int_t	ldwa,
		double *	work,
		magma_int_t	lwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

DSYEVD_GPU computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	DOUBLE PRECISION array on the GPU, dimension (LDDA, N). On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	ldda	INTEGER The leading dimension of the array DA. LDDA >= max(1,N).
[out]	w	DOUBLE PRECISION array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
	wA	(workspace) DOUBLE PRECISION array, dimension (LDWA, N)
[in]	ldwa	INTEGER The leading dimension of the array wA. LDWA >= max(1,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 length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= 2*N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( 2*N + N*NB, 1 + 6*N + 2*N**2 ). NB can be obtained through magma_get_dsytrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK and IWORK arrays, returns these values as the first entries of the WORK and IWORK arrays, and no error message related to LWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK and IWORK arrays, returns these values as the first entries of the WORK and IWORK arrays, and no error message related to LWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_dsyevd_m()

magma_int_t magma_dsyevd_m	(	magma_int_t	ngpu,
		magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		double *	A,
		magma_int_t	lda,
		double *	w,
		double *	work,
		magma_int_t	lwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

DSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	ngpu	INTEGER Number of GPUs to use. ngpu > 0.
[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	A	DOUBLE PRECISION array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	lda	INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]	w	DOUBLE PRECISION array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
[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 length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= 2*N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( 2*N + N*NB, 1 + 6*N + 2*N**2 ). NB can be obtained through magma_get_dsytrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_ssyevd()

magma_int_t magma_ssyevd	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		float *	A,
		magma_int_t	lda,
		float *	w,
		float *	work,
		magma_int_t	lwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

SSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	A	REAL array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	lda	INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]	w	REAL array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
[out]	work	(workspace) REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= 2*N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( 2*N + N*NB, 1 + 6*N + 2*N**2 ). NB can be obtained through magma_get_ssytrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK and IWORK arrays, returns these values as the first entries of the WORK and IWORK arrays, and no error message related to LWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK and IWORK arrays, returns these values as the first entries of the WORK and IWORK arrays, and no error message related to LWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_ssyevd_gpu()

magma_int_t magma_ssyevd_gpu	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaFloat_ptr	dA,
		magma_int_t	ldda,
		float *	w,
		float *	wA,
		magma_int_t	ldwa,
		float *	work,
		magma_int_t	lwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

SSYEVD_GPU computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	REAL array on the GPU, dimension (LDDA, N). On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	ldda	INTEGER The leading dimension of the array DA. LDDA >= max(1,N).
[out]	w	REAL array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
	wA	(workspace) REAL array, dimension (LDWA, N)
[in]	ldwa	INTEGER The leading dimension of the array wA. LDWA >= max(1,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 length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= 2*N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( 2*N + N*NB, 1 + 6*N + 2*N**2 ). NB can be obtained through magma_get_ssytrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK and IWORK arrays, returns these values as the first entries of the WORK and IWORK arrays, and no error message related to LWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK and IWORK arrays, returns these values as the first entries of the WORK and IWORK arrays, and no error message related to LWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_ssyevd_m()

magma_int_t magma_ssyevd_m	(	magma_int_t	ngpu,
		magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		float *	A,
		magma_int_t	lda,
		float *	w,
		float *	work,
		magma_int_t	lwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

SSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	ngpu	INTEGER Number of GPUs to use. ngpu > 0.
[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	A	REAL array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	lda	INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]	w	REAL array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
[out]	work	(workspace) REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= 2*N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( 2*N + N*NB, 1 + 6*N + 2*N**2 ). NB can be obtained through magma_get_ssytrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_zheevd()

magma_int_t magma_zheevd	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaDoubleComplex *	A,
		magma_int_t	lda,
		double *	w,
		magmaDoubleComplex *	work,
		magma_int_t	lwork,
		double *	rwork,
		magma_int_t	lrwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

ZHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	A	COMPLEX_16 array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	lda	INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]	w	DOUBLE PRECISION array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
[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 length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( N + N*NB, 2*N + N**2 ). NB can be obtained through magma_get_zhetrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	rwork	(workspace) DOUBLE PRECISION array, dimension (LRWORK) On exit, if INFO = 0, RWORK[0] returns the optimal LRWORK.
[in]	lrwork	INTEGER The dimension of the array RWORK. If N <= 1, LRWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LRWORK >= N. If JOBZ = MagmaVec and N > 1, LRWORK >= 1 + 5*N + 2*N**2. If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_zheevd_gpu()

magma_int_t magma_zheevd_gpu	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaDoubleComplex_ptr	dA,
		magma_int_t	ldda,
		double *	w,
		magmaDoubleComplex *	wA,
		magma_int_t	ldwa,
		magmaDoubleComplex *	work,
		magma_int_t	lwork,
		double *	rwork,
		magma_int_t	lrwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

ZHEEVD_GPU computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	COMPLEX_16 array on the GPU, dimension (LDDA, N). On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	ldda	INTEGER The leading dimension of the array DA. LDDA >= max(1,N).
[out]	w	DOUBLE PRECISION array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
	wA	(workspace) COMPLEX_16 array, dimension (LDWA, N)
[in]	ldwa	INTEGER The leading dimension of the array wA. LDWA >= max(1,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 length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( N + N*NB, 2*N + N**2 ). NB can be obtained through magma_get_zhetrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	rwork	(workspace) DOUBLE PRECISION array, dimension (LRWORK) On exit, if INFO = 0, RWORK[0] returns the optimal LRWORK.
[in]	lrwork	INTEGER The dimension of the array RWORK. If N <= 1, LRWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LRWORK >= N. If JOBZ = MagmaVec and N > 1, LRWORK >= 1 + 5*N + 2*N**2. If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_zheevd_m()

magma_int_t magma_zheevd_m	(	magma_int_t	ngpu,
		magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaDoubleComplex *	A,
		magma_int_t	lda,
		double *	w,
		magmaDoubleComplex *	work,
		magma_int_t	lwork,
		double *	rwork,
		magma_int_t	lrwork,
		magma_int_t *	iwork,
		magma_int_t	liwork,
		magma_int_t *	info )

ZHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Parameters

[in]	ngpu	INTEGER Number of GPUs to use. ngpu > 0.
[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	A	COMPLEX_16 array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then on exit the lower triangle (if UPLO=MagmaLower) or the upper triangle (if UPLO=MagmaUpper) of A, including the diagonal, is destroyed.
[in]	lda	INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]	w	DOUBLE PRECISION array, dimension (N) If INFO = 0, the eigenvalues in ascending order.
[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 length of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LWORK >= N + N*NB. If JOBZ = MagmaVec and N > 1, LWORK >= max( N + N*NB, 2*N + N**2 ). NB can be obtained through magma_get_zhetrd_nb(N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	rwork	(workspace) DOUBLE PRECISION array, dimension (LRWORK) On exit, if INFO = 0, RWORK[0] returns the optimal LRWORK.
[in]	lrwork	INTEGER The dimension of the array RWORK. If N <= 1, LRWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LRWORK >= N. If JOBZ = MagmaVec and N > 1, LRWORK >= 1 + 5*N + 2*N**2. If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	iwork	(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]	liwork	INTEGER The dimension of the array IWORK. If N <= 1, LIWORK >= 1. If JOBZ = MagmaNoVec and N > 1, LIWORK >= 1. If JOBZ = MagmaVec and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i and JOBZ = MagmaNoVec, then the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero; if INFO = i and JOBZ = MagmaVec, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details

Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Modified description of INFO. Sven, 16 Feb 05.

magma_cheevj_batched_expert_small_sm()

magma_int_t magma_cheevj_batched_expert_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaFloatComplex **	dA_array,
		magma_int_t	ldda,
		float **	dW_array,
		magma_int_t *	info_array,
		int *	batch_mask,
		int *	num_sweeps,
		float	heevj_tol,
		magma_int_t	sort_flag,
		magma_int_t	max_sweeps,
		magma_int_t	nthreads,
		magma_int_t	batchCount,
		magma_queue_t	queue )

CHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts pointer arrays. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA_array	Array of pointers, length (batchCount). Each is a COMPLEX array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion
[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[out]	dW_array	Array of pointers, length (batchCount) Each is a REAL array, dimension (N) The eigenvalues of each matrix A, sorted so that S(i) >= S(i+1).
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	heevj_tol	REAL A scalar controlling the tolerance upon which Jacobi rotations are generated for an off-diagonal element ajk. During a Jacobi sweep, Jacobi rotations are generated for an off-diagonal element ajk if the condition below is true: |ajk| > heevj_tol * eps * sqrt( |ajj| * |akk| ), where eps is the machine epsilon.
[in]	sort_flag	INTEGER = 0: Do not sort the eigenvalues/eigenvectors = 1: Sort eigenvalues/eigenvectors in ascending order
[in]	nthreads	INTEGER Number of threads assigned for each off-diagonal element during a parallel Jacobi sweep. Minimum is 2 threads.
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_cheevj_batched_strided_expert_small_sm()

magma_int_t magma_cheevj_batched_strided_expert_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaFloatComplex *	dA,
		magma_int_t	ldda,
		magma_int_t	strideA,
		float *	dW,
		magma_int_t	strideW,
		magma_int_t *	info_array,
		int *	batch_mask,
		int *	num_sweeps,
		float	heevj_tol,
		magma_int_t	sort_flag,
		magma_int_t	max_sweeps,
		magma_int_t	nthreads,
		magma_int_t	batchCount,
		magma_queue_t	queue )

CHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts a base pointer and a constant stride. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	REAL base pointer for the matrices in the batch, such that: dAi = dA + i * strideA, i = 0, 1, 2, ..., batchCount-1

Each dAi is a COMPLEX array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion

Parameters

[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[in]	strideA	INTEGER Specifies the distance between two consecutive matrices in the batch.
[out]	dW	REAL base pointer for the eigenvalues in the batch, such that: dWi = dW + i * strideW, i = 0, 1, 2, ..., batchCount-1 Each dWi is a REAL array, dimension (N) The eigenvalues of each matrix A, If sort_flag = 1, eigenvalues are sorted so that S(i) >= S(i+1). If sort_flag = 0, eigenvalues are unsorted.
[in]	strideW	INTEGER Specifies the distance between two consecutive eigenvalue arrays in the batch.
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	heevj_tol	REAL A scalar controlling the tolerance upon which Jacobi rotations are generated for an off-diagonal element ajk. During a Jacobi sweep, Jacobi rotations are generated for an off-diagonal element ajk if the condition below is true: |ajk| > heevj_tol * eps * sqrt( |ajj| * |akk| ), where eps is the machine epsilon.
[in]	sort_flag	INTEGER = 0: Do not sort the eigenvalues/eigenvectors = 1: Sort eigenvalues/eigenvectors in ascending order
[in]	nthreads	INTEGER Number of threads assigned for each off-diagonal element during a parallel Jacobi sweep. Minimum is 2 threads.
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_cheevj_batched_small_sm()

magma_int_t magma_cheevj_batched_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaFloatComplex **	dA_array,
		magma_int_t	ldda,
		float **	dW_array,
		magma_int_t *	info_array,
		magma_int_t	batchCount,
		magma_queue_t	queue )

CHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in]	dA_array	Array of pointers, length (batchCount). Each is a COMPLEX array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion
[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[out]	dW_array	Array of pointers, length (batchCount) Each is a REAL array, dimension (N) The eigenvalues of each matrix A, sorted so that S(i) >= S(i+1).
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_cheevj_batched_strided_small_sm()

magma_int_t magma_cheevj_batched_strided_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaFloatComplex *	dA,
		magma_int_t	ldda,
		magma_int_t	strideA,
		float *	dW,
		magma_int_t	strideW,
		magma_int_t *	info_array,
		magma_int_t	batchCount,
		magma_queue_t	queue )

CHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts a base pointer and a constant stride. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	REAL base pointer for the matrices in the batch, such that: dAi = dA + i * strideA, i = 0, 1, 2, ..., batchCount-1

Each dAi is a COMPLEX array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion

Parameters

[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[in]	strideA	INTEGER Specifies the distance between two consecutive matrices in the batch.
[out]	dW	REAL base pointer for the eigenvalues in the batch, such that: dWi = dW + i * strideW, i = 0, 1, 2, ..., batchCount-1 Each dWi is a REAL array, dimension (N) The eigenvalues of each matrix A, If sort_flag = 1, eigenvalues are sorted so that S(i) >= S(i+1). If sort_flag = 0, eigenvalues are unsorted.
[in]	strideW	INTEGER Specifies the distance between two consecutive eigenvalue arrays in the batch.
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_dsyevj_batched_expert_small_sm()

magma_int_t magma_dsyevj_batched_expert_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		double **	dA_array,
		magma_int_t	ldda,
		double **	dW_array,
		magma_int_t *	info_array,
		int *	batch_mask,
		int *	num_sweeps,
		double	heevj_tol,
		magma_int_t	sort_flag,
		magma_int_t	max_sweeps,
		magma_int_t	nthreads,
		magma_int_t	batchCount,
		magma_queue_t	queue )

DSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts pointer arrays. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA_array	Array of pointers, length (batchCount). Each is a DOUBLE PRECISION array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion
[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[out]	dW_array	Array of pointers, length (batchCount) Each is a DOUBLE PRECISION array, dimension (N) The eigenvalues of each matrix A, sorted so that S(i) >= S(i+1).
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	heevj_tol	DOUBLE PRECISION A scalar controlling the tolerance upon which Jacobi rotations are generated for an off-diagonal element ajk. During a Jacobi sweep, Jacobi rotations are generated for an off-diagonal element ajk if the condition below is true: |ajk| > heevj_tol * eps * sqrt( |ajj| * |akk| ), where eps is the machine epsilon.
[in]	sort_flag	INTEGER = 0: Do not sort the eigenvalues/eigenvectors = 1: Sort eigenvalues/eigenvectors in ascending order
[in]	nthreads	INTEGER Number of threads assigned for each off-diagonal element during a parallel Jacobi sweep. Minimum is 2 threads.
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_dsyevj_batched_strided_expert_small_sm()

magma_int_t magma_dsyevj_batched_strided_expert_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		double *	dA,
		magma_int_t	ldda,
		magma_int_t	strideA,
		double *	dW,
		magma_int_t	strideW,
		magma_int_t *	info_array,
		int *	batch_mask,
		int *	num_sweeps,
		double	heevj_tol,
		magma_int_t	sort_flag,
		magma_int_t	max_sweeps,
		magma_int_t	nthreads,
		magma_int_t	batchCount,
		magma_queue_t	queue )

DSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts a base pointer and a constant stride. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	DOUBLE PRECISION base pointer for the matrices in the batch, such that: dAi = dA + i * strideA, i = 0, 1, 2, ..., batchCount-1

Each dAi is a DOUBLE PRECISION array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion

Parameters

[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[in]	strideA	INTEGER Specifies the distance between two consecutive matrices in the batch.
[out]	dW	DOUBLE PRECISION base pointer for the eigenvalues in the batch, such that: dWi = dW + i * strideW, i = 0, 1, 2, ..., batchCount-1 Each dWi is a DOUBLE PRECISION array, dimension (N) The eigenvalues of each matrix A, If sort_flag = 1, eigenvalues are sorted so that S(i) >= S(i+1). If sort_flag = 0, eigenvalues are unsorted.
[in]	strideW	INTEGER Specifies the distance between two consecutive eigenvalue arrays in the batch.
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	heevj_tol	DOUBLE PRECISION A scalar controlling the tolerance upon which Jacobi rotations are generated for an off-diagonal element ajk. During a Jacobi sweep, Jacobi rotations are generated for an off-diagonal element ajk if the condition below is true: |ajk| > heevj_tol * eps * sqrt( |ajj| * |akk| ), where eps is the machine epsilon.
[in]	sort_flag	INTEGER = 0: Do not sort the eigenvalues/eigenvectors = 1: Sort eigenvalues/eigenvectors in ascending order
[in]	nthreads	INTEGER Number of threads assigned for each off-diagonal element during a parallel Jacobi sweep. Minimum is 2 threads.
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_dsyevj_batched_small_sm()

magma_int_t magma_dsyevj_batched_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		double **	dA_array,
		magma_int_t	ldda,
		double **	dW_array,
		magma_int_t *	info_array,
		magma_int_t	batchCount,
		magma_queue_t	queue )

DSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in]	dA_array	Array of pointers, length (batchCount). Each is a DOUBLE PRECISION array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion
[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[out]	dW_array	Array of pointers, length (batchCount) Each is a DOUBLE PRECISION array, dimension (N) The eigenvalues of each matrix A, sorted so that S(i) >= S(i+1).
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_dsyevj_batched_strided_small_sm()

magma_int_t magma_dsyevj_batched_strided_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		double *	dA,
		magma_int_t	ldda,
		magma_int_t	strideA,
		double *	dW,
		magma_int_t	strideW,
		magma_int_t *	info_array,
		magma_int_t	batchCount,
		magma_queue_t	queue )

DSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts a base pointer and a constant stride. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	DOUBLE PRECISION base pointer for the matrices in the batch, such that: dAi = dA + i * strideA, i = 0, 1, 2, ..., batchCount-1

Each dAi is a DOUBLE PRECISION array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion

Parameters

[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[in]	strideA	INTEGER Specifies the distance between two consecutive matrices in the batch.
[out]	dW	DOUBLE PRECISION base pointer for the eigenvalues in the batch, such that: dWi = dW + i * strideW, i = 0, 1, 2, ..., batchCount-1 Each dWi is a DOUBLE PRECISION array, dimension (N) The eigenvalues of each matrix A, If sort_flag = 1, eigenvalues are sorted so that S(i) >= S(i+1). If sort_flag = 0, eigenvalues are unsorted.
[in]	strideW	INTEGER Specifies the distance between two consecutive eigenvalue arrays in the batch.
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_ssyevj_batched_expert_small_sm()

magma_int_t magma_ssyevj_batched_expert_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		float **	dA_array,
		magma_int_t	ldda,
		float **	dW_array,
		magma_int_t *	info_array,
		int *	batch_mask,
		int *	num_sweeps,
		float	heevj_tol,
		magma_int_t	sort_flag,
		magma_int_t	max_sweeps,
		magma_int_t	nthreads,
		magma_int_t	batchCount,
		magma_queue_t	queue )

SSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts pointer arrays. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA_array	Array of pointers, length (batchCount). Each is a REAL array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion
[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[out]	dW_array	Array of pointers, length (batchCount) Each is a REAL array, dimension (N) The eigenvalues of each matrix A, sorted so that S(i) >= S(i+1).
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	heevj_tol	REAL A scalar controlling the tolerance upon which Jacobi rotations are generated for an off-diagonal element ajk. During a Jacobi sweep, Jacobi rotations are generated for an off-diagonal element ajk if the condition below is true: |ajk| > heevj_tol * eps * sqrt( |ajj| * |akk| ), where eps is the machine epsilon.
[in]	sort_flag	INTEGER = 0: Do not sort the eigenvalues/eigenvectors = 1: Sort eigenvalues/eigenvectors in ascending order
[in]	nthreads	INTEGER Number of threads assigned for each off-diagonal element during a parallel Jacobi sweep. Minimum is 2 threads.
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_ssyevj_batched_strided_expert_small_sm()

magma_int_t magma_ssyevj_batched_strided_expert_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		float *	dA,
		magma_int_t	ldda,
		magma_int_t	strideA,
		float *	dW,
		magma_int_t	strideW,
		magma_int_t *	info_array,
		int *	batch_mask,
		int *	num_sweeps,
		float	heevj_tol,
		magma_int_t	sort_flag,
		magma_int_t	max_sweeps,
		magma_int_t	nthreads,
		magma_int_t	batchCount,
		magma_queue_t	queue )

SSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts a base pointer and a constant stride. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	REAL base pointer for the matrices in the batch, such that: dAi = dA + i * strideA, i = 0, 1, 2, ..., batchCount-1

Each dAi is a REAL array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion

Parameters

[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[in]	strideA	INTEGER Specifies the distance between two consecutive matrices in the batch.
[out]	dW	REAL base pointer for the eigenvalues in the batch, such that: dWi = dW + i * strideW, i = 0, 1, 2, ..., batchCount-1 Each dWi is a REAL array, dimension (N) The eigenvalues of each matrix A, If sort_flag = 1, eigenvalues are sorted so that S(i) >= S(i+1). If sort_flag = 0, eigenvalues are unsorted.
[in]	strideW	INTEGER Specifies the distance between two consecutive eigenvalue arrays in the batch.
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	heevj_tol	REAL A scalar controlling the tolerance upon which Jacobi rotations are generated for an off-diagonal element ajk. During a Jacobi sweep, Jacobi rotations are generated for an off-diagonal element ajk if the condition below is true: |ajk| > heevj_tol * eps * sqrt( |ajj| * |akk| ), where eps is the machine epsilon.
[in]	sort_flag	INTEGER = 0: Do not sort the eigenvalues/eigenvectors = 1: Sort eigenvalues/eigenvectors in ascending order
[in]	nthreads	INTEGER Number of threads assigned for each off-diagonal element during a parallel Jacobi sweep. Minimum is 2 threads.
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_ssyevj_batched_small_sm()

magma_int_t magma_ssyevj_batched_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		float **	dA_array,
		magma_int_t	ldda,
		float **	dW_array,
		magma_int_t *	info_array,
		magma_int_t	batchCount,
		magma_queue_t	queue )

SSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in]	dA_array	Array of pointers, length (batchCount). Each is a REAL array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion
[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[out]	dW_array	Array of pointers, length (batchCount) Each is a REAL array, dimension (N) The eigenvalues of each matrix A, sorted so that S(i) >= S(i+1).
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_ssyevj_batched_strided_small_sm()

magma_int_t magma_ssyevj_batched_strided_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		float *	dA,
		magma_int_t	ldda,
		magma_int_t	strideA,
		float *	dW,
		magma_int_t	strideW,
		magma_int_t *	info_array,
		magma_int_t	batchCount,
		magma_queue_t	queue )

SSYEVJ computes all eigenvalues and, optionally, eigenvectors of a symmetric matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts a base pointer and a constant stride. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	REAL base pointer for the matrices in the batch, such that: dAi = dA + i * strideA, i = 0, 1, 2, ..., batchCount-1

Each dAi is a REAL array, dimension (LDA, N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion

Parameters

[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[in]	strideA	INTEGER Specifies the distance between two consecutive matrices in the batch.
[out]	dW	REAL base pointer for the eigenvalues in the batch, such that: dWi = dW + i * strideW, i = 0, 1, 2, ..., batchCount-1 Each dWi is a REAL array, dimension (N) The eigenvalues of each matrix A, If sort_flag = 1, eigenvalues are sorted so that S(i) >= S(i+1). If sort_flag = 0, eigenvalues are unsorted.
[in]	strideW	INTEGER Specifies the distance between two consecutive eigenvalue arrays in the batch.
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_zheevj_batched_expert_small_sm()

magma_int_t magma_zheevj_batched_expert_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaDoubleComplex **	dA_array,
		magma_int_t	ldda,
		double **	dW_array,
		magma_int_t *	info_array,
		int *	batch_mask,
		int *	num_sweeps,
		double	heevj_tol,
		magma_int_t	sort_flag,
		magma_int_t	max_sweeps,
		magma_int_t	nthreads,
		magma_int_t	batchCount,
		magma_queue_t	queue )

ZHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts pointer arrays. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA_array	Array of pointers, length (batchCount). Each is a COMPLEX_16 array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion
[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[out]	dW_array	Array of pointers, length (batchCount) Each is a DOUBLE PRECISION array, dimension (N) The eigenvalues of each matrix A, sorted so that S(i) >= S(i+1).
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	heevj_tol	DOUBLE PRECISION A scalar controlling the tolerance upon which Jacobi rotations are generated for an off-diagonal element ajk. During a Jacobi sweep, Jacobi rotations are generated for an off-diagonal element ajk if the condition below is true: |ajk| > heevj_tol * eps * sqrt( |ajj| * |akk| ), where eps is the machine epsilon.
[in]	sort_flag	INTEGER = 0: Do not sort the eigenvalues/eigenvectors = 1: Sort eigenvalues/eigenvectors in ascending order
[in]	nthreads	INTEGER Number of threads assigned for each off-diagonal element during a parallel Jacobi sweep. Minimum is 2 threads.
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_zheevj_batched_strided_expert_small_sm()

magma_int_t magma_zheevj_batched_strided_expert_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaDoubleComplex *	dA,
		magma_int_t	ldda,
		magma_int_t	strideA,
		double *	dW,
		magma_int_t	strideW,
		magma_int_t *	info_array,
		int *	batch_mask,
		int *	num_sweeps,
		double	heevj_tol,
		magma_int_t	sort_flag,
		magma_int_t	max_sweeps,
		magma_int_t	nthreads,
		magma_int_t	batchCount,
		magma_queue_t	queue )

ZHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts a base pointer and a constant stride. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	DOUBLE PRECISION base pointer for the matrices in the batch, such that: dAi = dA + i * strideA, i = 0, 1, 2, ..., batchCount-1

Each dAi is a COMPLEX_16 array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion

Parameters

[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[in]	strideA	INTEGER Specifies the distance between two consecutive matrices in the batch.
[out]	dW	DOUBLE PRECISION base pointer for the eigenvalues in the batch, such that: dWi = dW + i * strideW, i = 0, 1, 2, ..., batchCount-1 Each dWi is a DOUBLE PRECISION array, dimension (N) The eigenvalues of each matrix A, If sort_flag = 1, eigenvalues are sorted so that S(i) >= S(i+1). If sort_flag = 0, eigenvalues are unsorted.
[in]	strideW	INTEGER Specifies the distance between two consecutive eigenvalue arrays in the batch.
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	heevj_tol	DOUBLE PRECISION A scalar controlling the tolerance upon which Jacobi rotations are generated for an off-diagonal element ajk. During a Jacobi sweep, Jacobi rotations are generated for an off-diagonal element ajk if the condition below is true: |ajk| > heevj_tol * eps * sqrt( |ajj| * |akk| ), where eps is the machine epsilon.
[in]	sort_flag	INTEGER = 0: Do not sort the eigenvalues/eigenvectors = 1: Sort eigenvalues/eigenvectors in ascending order
[in]	nthreads	INTEGER Number of threads assigned for each off-diagonal element during a parallel Jacobi sweep. Minimum is 2 threads.
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_zheevj_batched_small_sm()

magma_int_t magma_zheevj_batched_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaDoubleComplex **	dA_array,
		magma_int_t	ldda,
		double **	dW_array,
		magma_int_t *	info_array,
		magma_int_t	batchCount,
		magma_queue_t	queue )

ZHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in]	dA_array	Array of pointers, length (batchCount). Each is a COMPLEX_16 array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion
[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[out]	dW_array	Array of pointers, length (batchCount) Each is a DOUBLE PRECISION array, dimension (N) The eigenvalues of each matrix A, sorted so that S(i) >= S(i+1).
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.

magma_zheevj_batched_strided_small_sm()

magma_int_t magma_zheevj_batched_strided_small_sm	(	magma_vec_t	jobz,
		magma_uplo_t	uplo,
		magma_int_t	n,
		magmaDoubleComplex *	dA,
		magma_int_t	ldda,
		magma_int_t	strideA,
		double *	dW,
		magma_int_t	strideW,
		magma_int_t *	info_array,
		magma_int_t	batchCount,
		magma_queue_t	queue )

ZHEEVJ computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix A based on the Jacobi method.

NOTES:

This is the batch version of the routine, which accepts a base pointer and a constant stride. It solves the eigenvalue problem on a batch of matrices having the same dimensions.

This is an experimental routine, currently supporting matrices that fit in the shared memory of the GPU. If the eigenvectors are required, additional shared memory workspace is required.

This is an expert interface, through which the user can control several aspects of the eigensolver

Parameters

[in]	jobz	magma_vec_t = MagmaNoVec: Compute eigenvalues only; = MagmaVec: Compute eigenvalues and eigenvectors.
[in]	uplo	magma_uplo_t = MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	n	INTEGER The order of the matrix A. N >= 0.
[in,out]	dA	DOUBLE PRECISION base pointer for the matrices in the batch, such that: dAi = dA + i * strideA, i = 0, 1, 2, ..., batchCount-1

Each dAi is a COMPLEX_16 array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = MagmaVec, then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = MagmaNoVec, then A is unchanged upon completion

Parameters

[in]	ldda	INTEGER The leading dimension of each array A. LDA >= max(1,M).
[in]	strideA	INTEGER Specifies the distance between two consecutive matrices in the batch.
[out]	dW	DOUBLE PRECISION base pointer for the eigenvalues in the batch, such that: dWi = dW + i * strideW, i = 0, 1, 2, ..., batchCount-1 Each dWi is a DOUBLE PRECISION array, dimension (N) The eigenvalues of each matrix A, If sort_flag = 1, eigenvalues are sorted so that S(i) >= S(i+1). If sort_flag = 0, eigenvalues are unsorted.
[in]	strideW	INTEGER Specifies the distance between two consecutive eigenvalue arrays in the batch.
[out]	info_array	INTEGER array, dimension(batchCount) = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed to converge;
[in]	batchCount	INTEGER The number of matrices to operate on.
[in]	queue	magma_queue_t Queue to execute in.