diff --git a/testing/input/trmm.in b/testing/input/trmm.in
index 6c6228f1430fae996d28e3f4588d2cff4764f665..7c49f154023ae710463482f19f4f5d946ec5a54c 100644
--- a/testing/input/trmm.in
+++ b/testing/input/trmm.in
@@ -4,8 +4,8 @@
# TRMM
# nb: Tile size
# ib: Inner tile size
-# n: Order of the matrix A
-# k: the number of columns of the matrix B if side = ChamLeft and the number of rows of the matrix B if side = ChamRight
+# m: Number of rows of the matrix B and order of the matrix A if side = ChamLeft
+# n: Number of columns of the matrix B and order of the matrix A if side = ChamRight
# lda: Leading dimension of matrix A
# ldb: Leading dimension of matrix B
# uplo: Matrix part to be considered (0: Upper, 1: Lower)
@@ -18,8 +18,8 @@ alpha = 0., 3.45
op = trmm
nb = 16, 17
ib = 8
+m = 13, 21, 33
n = 15, 19, 35
-k = 13, 21, 33
lda = 38
ldb = 37
uplo = 0,1
diff --git a/testing/testing_zcheck.c b/testing/testing_zcheck.c
index f3ba7d628eb9da15c5f7bbf993055b82d98524d6..b5dc2a3356a3c8cca6eadd7b27b031e455c861f3 100644
--- a/testing/testing_zcheck.c
+++ b/testing/testing_zcheck.c
@@ -138,39 +138,7 @@ int check_zmatrices( run_arg_list_t *args, cham_uplo_t uplo, CHAM_desc_t *descA,
return info_solution;
}
-/**
- ********************************************************************************
- *
- * @ingroup testing
- *
- * @brief Compares the Chameleon computed norm with a Lapack computed one.
- *
- *******************************************************************************
- *
- * @param[in] matrix_type
- * Wether it is a general, triangular or symmetric matrix.
- *
- * @param[in] norm_type
- * Wether it should compare a Max, One, Inf or Frobenius norm.
- *
- * @param[in] uplo
- * Wether it is a upper triangular matrix, a lower triangular matrix or a general matrix.
- *
- * @param[in] diag
- * Wether it is a unitary diagonal matrix or not.
- *
- * @param[in] norm_cham
- * The Chameleon computed norm.
- *
- * @param[in] descA
- * The matrix descriptor.
- *
- * @retval 0 successfull comparison
- *
- *******************************************************************************
- */
-
-int check_znorm_std( cham_mtxtype_t matrix_type, cham_normtype_t norm_type, cham_uplo_t uplo,
+int check_znorm_std( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_normtype_t norm_type, cham_uplo_t uplo,
cham_diag_t diag, double norm_cham, int M, int N, CHAMELEON_Complex64_t *A, int LDA )
{
int info_solution = 0;
@@ -227,9 +195,41 @@ int check_znorm_std( cham_mtxtype_t matrix_type, cham_normtype_t norm_type, cham
free(work);
+ (void)args;
return info_solution;
}
+/**
+ ********************************************************************************
+ *
+ * @ingroup testing
+ *
+ * @brief Compares the Chameleon computed norm with a Lapack computed one.
+ *
+ *******************************************************************************
+ *
+ * @param[in] matrix_type
+ * Wether it is a general, triangular or symmetric matrix.
+ *
+ * @param[in] norm_type
+ * Wether it should compare a Max, One, Inf or Frobenius norm.
+ *
+ * @param[in] uplo
+ * Wether it is a upper triangular matrix, a lower triangular matrix or a general matrix.
+ *
+ * @param[in] diag
+ * Wether it is a unitary diagonal matrix or not.
+ *
+ * @param[in] norm_cham
+ * The Chameleon computed norm.
+ *
+ * @param[in] descA
+ * The matrix descriptor.
+ *
+ * @retval 0 successfull comparison
+ *
+ *******************************************************************************
+ */
int check_znorm( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_normtype_t norm_type, cham_uplo_t uplo,
cham_diag_t diag, double norm_cham, CHAM_desc_t *descA )
{
@@ -247,7 +247,7 @@ int check_znorm( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_normtype
/* Converts the matrix to LAPACK layout in order to use the LAPACK norm function */
CHAMELEON_zDesc2Lap( uplo, descA, A, LDA );
if ( rank == 0 ) {
- info_solution = check_znorm_std( matrix_type, norm_type, uplo, diag, norm_cham, M, N, A, LDA );
+ info_solution = check_znorm_std( args, matrix_type, norm_type, uplo, diag, norm_cham, M, N, A, LDA );
}
/* Broadcasts the result from the main processus */
@@ -454,43 +454,6 @@ int check_zscale( run_arg_list_t *args, cham_uplo_t uplo, CHAMELEON_Complex64_t
return info_solution;
}
-/**
- ********************************************************************************
- *
- * @ingroup testing
- *
- * @brief Compares a Chameleon computed product with a core function computed one.
- *
- *******************************************************************************
- *
- * @param[in] transA
- * Wether the first product element is transposed, conjugate transposed or not transposed.
- *
- * @param[in] transB
- * Wether the second product element is transposed, conjugate transposed or not transposed.
- *
- * @param[in] alpha
- * The scalar alpha.
- *
- * @param[in] descA
- * The descriptor of the matrix A.
- *
- * @param[in] descBref
- * The descriptor of the matrix B.
- *
- * @param[in] beta
- * The scalar beta.
- *
- * @param[in] descCref
- * The descriptor of the matrix C.
- *
- * @param[in] descC
- * The matrix descriptor of the Chameleon computed result alpha*A*B+beta*C.
- *
- * @retval 0 successfull comparison
- *
- *******************************************************************************
- */
int check_zgemm_std( run_arg_list_t *args, cham_trans_t transA, cham_trans_t transB, CHAMELEON_Complex64_t alpha, int M, int N, int K, CHAMELEON_Complex64_t *A, int LDA,
CHAMELEON_Complex64_t *B, int LDB, CHAMELEON_Complex64_t beta, CHAMELEON_Complex64_t *Cref, CHAMELEON_Complex64_t *C, int LDC )
{
@@ -544,6 +507,44 @@ int check_zgemm_std( run_arg_list_t *args, cham_trans_t transA, cham_trans_t tra
return info_solution;
}
+
+/**
+ ********************************************************************************
+ *
+ * @ingroup testing
+ *
+ * @brief Compares a Chameleon computed product with a core function computed one.
+ *
+ *******************************************************************************
+ *
+ * @param[in] transA
+ * Wether the first product element is transposed, conjugate transposed or not transposed.
+ *
+ * @param[in] transB
+ * Wether the second product element is transposed, conjugate transposed or not transposed.
+ *
+ * @param[in] alpha
+ * The scalar alpha.
+ *
+ * @param[in] descA
+ * The descriptor of the matrix A.
+ *
+ * @param[in] descBref
+ * The descriptor of the matrix B.
+ *
+ * @param[in] beta
+ * The scalar beta.
+ *
+ * @param[in] descCref
+ * The descriptor of the matrix C.
+ *
+ * @param[in] descC
+ * The matrix descriptor of the Chameleon computed result alpha*A*B+beta*C.
+ *
+ * @retval 0 successfull comparison
+ *
+ *******************************************************************************
+ */
int check_zgemm( run_arg_list_t *args, cham_trans_t transA, cham_trans_t transB, CHAMELEON_Complex64_t alpha, CHAM_desc_t *descA,
CHAM_desc_t *descB, CHAMELEON_Complex64_t beta, CHAM_desc_t *descCref, CHAM_desc_t *descC )
{
@@ -589,9 +590,9 @@ int check_zgemm( run_arg_list_t *args, cham_trans_t transA, cham_trans_t transB,
CHAMELEON_zDesc2Lap( ChamUpperLower, descC, C, LDC );
if ( rank == 0 ) {
-
+
info_solution = check_zgemm_std( args, transA, transB, alpha, M, N, K, A, LDA, B, LDB, beta, Cref, C, LDC );
-
+
free(A);
free(B);
free(C);
@@ -607,6 +608,88 @@ int check_zgemm( run_arg_list_t *args, cham_trans_t transA, cham_trans_t transB,
return info_solution;
}
+int check_zsymm_std( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_side_t side, cham_uplo_t uplo, int M, int N,
+ CHAMELEON_Complex64_t alpha, CHAMELEON_Complex64_t *A, int LDA, CHAMELEON_Complex64_t *B, int LDB,
+ CHAMELEON_Complex64_t beta, CHAMELEON_Complex64_t *Cref, CHAMELEON_Complex64_t *C, int LDC )
+{
+ int info_solution = 0;
+ int An;
+ double Anorm, Bnorm, Crefnorm, Cchamnorm, Clapacknorm, Rnorm, result;
+ CHAMELEON_Complex64_t mzone = -1.0;
+ double *work;
+ char normTypeA, normTypeB;
+
+ if ( side == ChamLeft ) {
+ normTypeA = 'I';
+ normTypeB = 'O';
+ An = M;
+ }
+ else {
+ normTypeA = '0';
+ normTypeB = 'I';
+ An = N;
+ }
+
+ work = malloc( sizeof(double) * An );
+#if defined(PRECISION_z) || defined(PRECISION_c)
+ if ( matrix_type == ChamHermitian ) {
+ Anorm = LAPACKE_zlanhe_work( LAPACK_COL_MAJOR, normTypeA, chameleon_lapack_const(uplo), An, A, LDA, work );
+ }
+ else
+#endif
+ {
+ Anorm = LAPACKE_zlansy_work( LAPACK_COL_MAJOR, normTypeA, chameleon_lapack_const(uplo), An, A, LDA, work );
+ }
+ Bnorm = LAPACKE_zlange( LAPACK_COL_MAJOR, normTypeB, M, N, B, LDB );
+ free( work );
+
+ /* Computes the norms for comparing */
+ Crefnorm = LAPACKE_zlange_work( LAPACK_COL_MAJOR, 'M', M, N, Cref, LDC, NULL );
+ Cchamnorm = LAPACKE_zlange_work( LAPACK_COL_MAJOR, 'M', M, N, C, LDC, NULL );
+
+ double eps = LAPACKE_dlamch_work('e');
+
+ /* Makes the multiplication with the core function */
+#if defined(PRECISION_z) || defined(PRECISION_c)
+ if ( matrix_type == ChamHermitian ) {
+ cblas_zhemm( CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
+ M, N, CBLAS_SADDR(alpha),
+ A, LDA, B, LDB, CBLAS_SADDR(beta), Cref, LDC );
+ }
+ else
+#endif
+ {
+ cblas_zsymm( CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo, M, N, CBLAS_SADDR(alpha), A, LDA, B, LDB,
+ CBLAS_SADDR(beta), Cref, LDC );
+ }
+ cblas_zaxpy(LDC * N, CBLAS_SADDR(mzone), C, 1, Cref, 1);
+
+ /* Computes the norm with the core function's result */
+ Clapacknorm = LAPACKE_zlange_work( LAPACK_COL_MAJOR, 'M', M, N, Cref, LDC, NULL );
+ Rnorm = LAPACKE_zlange_work( LAPACK_COL_MAJOR, 'M', M, N, Cref, LDC, NULL );
+
+ if ( ( alpha != 0. ) || (beta != 0. ) ) {
+ result = Rnorm / ((cabs(alpha) * max(Anorm, Bnorm) + cabs(beta) * Crefnorm) * An * eps);
+ }
+ else {
+ result = Rnorm;
+ }
+
+ /* Verifies if the result is inside a threshold */
+ if ( isnan(Rnorm) || isinf(Rnorm) || isnan(result) || isinf(result) || (result > 10.0) ) {
+ info_solution = 1;
+ }
+ else {
+ info_solution = 0 ;
+ }
+
+ (void)Clapacknorm;
+ (void)Cchamnorm;
+ (void)matrix_type;
+ (void)args;
+ return info_solution;
+}
+
/**
********************************************************************************
*
@@ -649,56 +732,30 @@ int check_zsymm( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_side_t s
CHAMELEON_Complex64_t beta, CHAM_desc_t *descCref, CHAM_desc_t *descC )
{
int info_solution = 0;
+ int M = descC->m;
+ int N = descC->n;
+ int LDB = M;
+ int LDC = M;
+ int rank = CHAMELEON_Comm_rank();
int An, LDA;
- int M = descC->m;
- int N = descC->n;
- int LDB = M;
- int LDC = M;
- int rank = CHAMELEON_Comm_rank();
- double Anorm, Bnorm, Crefnorm, Cchamnorm, Clapacknorm, Rnorm, result;
CHAMELEON_Complex64_t *A = NULL;
CHAMELEON_Complex64_t *B = NULL;
CHAMELEON_Complex64_t *Cref = NULL;
CHAMELEON_Complex64_t *C = NULL;
- CHAMELEON_Complex64_t mzone = -1.0;
if ( side == ChamLeft ) {
-#if defined(PRECISION_z) || defined(PRECISION_c)
- if ( matrix_type == ChamHermitian ) {
- Anorm = CHAMELEON_zlanhe_Tile(ChamInfNorm, uplo, descA);
- }
- else
-#endif
- {
- Anorm = CHAMELEON_zlansy_Tile(ChamInfNorm, uplo, descA);
- }
- Bnorm = CHAMELEON_zlange_Tile(ChamOneNorm, descB);
LDA = M;
An = M;
} else {
-#if defined(PRECISION_z) || defined(PRECISION_c)
- if ( matrix_type == ChamHermitian ) {
- Anorm = CHAMELEON_zlanhe_Tile(ChamOneNorm, uplo, descA);
- }
- else
-#endif
- {
- Anorm = CHAMELEON_zlansy_Tile(ChamOneNorm, uplo, descA);
- }
- Bnorm = CHAMELEON_zlange_Tile(ChamInfNorm, descB);
LDA = N;
An = N;
}
- /* Computes the norms for comparing */
- Crefnorm = CHAMELEON_zlange_Tile( ChamMaxNorm, descCref );
- Cchamnorm = CHAMELEON_zlange_Tile( ChamMaxNorm, descC );
-
if ( rank == 0 ) {
- A = (CHAMELEON_Complex64_t *)malloc(LDA * An * sizeof(CHAMELEON_Complex64_t));
- B = (CHAMELEON_Complex64_t *)malloc(LDB * N * sizeof(CHAMELEON_Complex64_t));
- Cref = (CHAMELEON_Complex64_t *)malloc(LDC * N * sizeof(CHAMELEON_Complex64_t));
- C = (CHAMELEON_Complex64_t *)malloc(LDC * N * sizeof(CHAMELEON_Complex64_t));
+ A = ( CHAMELEON_Complex64_t * ) malloc( LDA*An*sizeof( CHAMELEON_Complex64_t ) );
+ B = ( CHAMELEON_Complex64_t * ) malloc( LDB*N *sizeof( CHAMELEON_Complex64_t ) );
+ Cref = ( CHAMELEON_Complex64_t * ) malloc( LDC*N *sizeof( CHAMELEON_Complex64_t ) );
+ C = ( CHAMELEON_Complex64_t * ) malloc( LDC*N *sizeof( CHAMELEON_Complex64_t ) );
}
/* Creates the LAPACK version of the matrices */
@@ -708,56 +765,121 @@ int check_zsymm( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_side_t s
CHAMELEON_zDesc2Lap( ChamUpperLower, descC, C, LDC );
if ( rank == 0 ) {
- double eps = LAPACKE_dlamch_work('e');
+ info_solution = check_zsymm_std( args, matrix_type, side, uplo,
+ M, N, alpha, A, LDA, B, LDB,
+ beta, Cref, C, LDC );
+ free(A);
+ free(B);
+ free(C);
+ free(Cref);
+ }
- /* Makes the multiplication with the core function */
-#if defined(PRECISION_z) || defined(PRECISION_c)
- if ( matrix_type == ChamHermitian ) {
- cblas_zhemm( CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
- M, N, CBLAS_SADDR(alpha),
- A, LDA, B, LDB, CBLAS_SADDR(beta), Cref, LDC );
- }
- else
+ /* Broadcasts the result from the main processus */
+#if defined(CHAMELEON_USE_MPI)
+ MPI_Bcast(&info_solution, 1, MPI_INT, 0, MPI_COMM_WORLD);
#endif
- {
- cblas_zsymm( CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
- M, N, CBLAS_SADDR(alpha),
- A, LDA, B, LDB, CBLAS_SADDR(beta), Cref, LDC );
+
+ (void)args;
+ return info_solution;
+}
+
+int check_zsyrk_std( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_uplo_t uplo, cham_trans_t trans, int N, int K, CHAMELEON_Complex64_t alpha,
+ CHAMELEON_Complex64_t *A, CHAMELEON_Complex64_t *B, int LDA, CHAMELEON_Complex64_t beta, CHAMELEON_Complex64_t *Cref,
+ CHAMELEON_Complex64_t *C, int LDC )
+{
+ int info_solution = 0;
+ double Anorm, Bnorm, Crefnorm, Cchamnorm, Clapacknorm, Rnorm, result;
+ double *work = malloc(sizeof(double)*N);
+
+ Bnorm = 0.;
+ if ( trans == ChamNoTrans ) {
+ Anorm = LAPACKE_zlange( LAPACK_COL_MAJOR, 'I', N, K, A, LDA );
+ if ( B != NULL ) {
+ Bnorm = LAPACKE_zlange( LAPACK_COL_MAJOR, 'I', N, K, B, LDA );
+ }
+ }
+ else {
+ Anorm = LAPACKE_zlange( LAPACK_COL_MAJOR, 'O', K, N, A, LDA );
+ if ( B != NULL ) {
+ Bnorm = LAPACKE_zlange( LAPACK_COL_MAJOR, 'O', K, N, B, LDA );
}
- cblas_zaxpy(LDC * N, CBLAS_SADDR(mzone), C, 1, Cref, 1);
+ }
+
+ /* Computes the norms for comparing */
+#if defined(PRECISION_z) || defined(PRECISION_c)
+ if ( matrix_type == ChamHermitian ) {
+ Crefnorm = LAPACKE_zlanhe_work( LAPACK_COL_MAJOR, 'I', chameleon_lapack_const(uplo), N, Cref, LDC, work );
+ Cchamnorm = LAPACKE_zlanhe_work( LAPACK_COL_MAJOR, 'I', chameleon_lapack_const(uplo), N, C, LDC, work );
+ }
+ else
+#endif
+ {
+ Crefnorm = LAPACKE_zlansy_work( LAPACK_COL_MAJOR, 'I', chameleon_lapack_const(uplo), N, Cref, LDC, work );
+ Cchamnorm = LAPACKE_zlansy_work( LAPACK_COL_MAJOR, 'I', chameleon_lapack_const(uplo), N, C, LDC, work );
+ }
- /* Computes the norm with the core function's result */
- Clapacknorm = LAPACKE_zlange_work( LAPACK_COL_MAJOR, 'M', M, N, Cref, LDC, NULL );
- Rnorm = LAPACKE_zlange_work( LAPACK_COL_MAJOR, 'M', M, N, Cref, LDC, NULL );
+ double eps = LAPACKE_dlamch_work('e');
+ double ABnorm;
- if ( ( alpha != 0. ) || (beta != 0. ) ) {
- result = Rnorm / ((cabs(alpha) * max(Anorm, Bnorm) + cabs(beta) * Crefnorm) * An * eps);
+ /* Makes the multiplication with the core function */
+#if defined(PRECISION_z) || defined(PRECISION_c)
+ if ( matrix_type == ChamHermitian ) {
+ if ( B == NULL ) {
+ cblas_zherk( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
+ N, K, creal(alpha), A, LDA, creal(beta), Cref, LDC );
+ ABnorm = Anorm * Anorm;
}
else {
- result = Rnorm;
+ cblas_zher2k( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
+ N, K, CBLAS_SADDR(alpha), A, LDA, B, LDA, creal(beta), Cref, LDC );
+ ABnorm = 2. * Anorm * Bnorm;
}
- /* Verifies if the result is inside a threshold */
- if ( isnan(Rnorm) || isinf(Rnorm) || isnan(result) || isinf(result) || (result > 10.0) ) {
- info_solution = 1;
+ Clapacknorm = LAPACKE_zlanhe_work( LAPACK_COL_MAJOR, 'I', chameleon_lapack_const(uplo), N, Cref, LDC, work );
+ }
+ else
+#endif
+ {
+ if ( B == NULL ) {
+ cblas_zsyrk( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
+ N, K, CBLAS_SADDR(alpha), A, LDA, CBLAS_SADDR(beta), Cref, LDC );
+ ABnorm = Anorm * Anorm;
}
else {
- info_solution= 0 ;
+ cblas_zsyr2k( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
+ N, K, CBLAS_SADDR(alpha), A, LDA, B, LDA, CBLAS_SADDR(beta), Cref, LDC );
+ ABnorm = 2. * Anorm * Bnorm;
}
- free(A);
- free(B);
- free(C);
- free(Cref);
+ Clapacknorm = LAPACKE_zlansy_work( LAPACK_COL_MAJOR, 'I', chameleon_lapack_const(uplo), N, Cref, LDC, work );
}
- /* Broadcasts the result from the main processus */
-#if defined(CHAMELEON_USE_MPI)
- MPI_Bcast(&info_solution, 1, MPI_INT, 0, MPI_COMM_WORLD);
+ CORE_ztradd( uplo, ChamNoTrans, N, N,
+ -1., C, LDC,
+ 1., Cref, LDC );
+
+ /* Computes the norm with the core function's result */
+#if defined(PRECISION_z) || defined(PRECISION_c)
+ if ( matrix_type == ChamHermitian ) {
+ Rnorm = LAPACKE_zlanhe_work( LAPACK_COL_MAJOR, 'M', chameleon_lapack_const(uplo), N, Cref, LDC, NULL );
+ }
+ else
#endif
+ {
+ Rnorm = LAPACKE_zlansy_work( LAPACK_COL_MAJOR, 'M', chameleon_lapack_const(uplo), N, Cref, LDC, NULL );
+ }
+ result = Rnorm / ((ABnorm + Crefnorm) * K * eps);
+
+ /* Verifies if the result is inside a threshold */
+ if ( isinf(Clapacknorm) || isinf(Cchamnorm) || isnan(result) || isinf(result) || (result > 10.0) ) {
+ info_solution = 1;
+ }
+ else {
+ info_solution = 0;
+ }
+
+ free(work);
- (void)Clapacknorm;
- (void)Cchamnorm;
(void)matrix_type;
(void)args;
return info_solution;
@@ -804,49 +926,26 @@ int check_zsyrk( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_uplo_t u
CHAMELEON_Complex64_t alpha, CHAM_desc_t *descA, CHAM_desc_t *descB,
CHAMELEON_Complex64_t beta, CHAM_desc_t *descCref, CHAM_desc_t *descC )
{
- int LDA, info_solution = 0;
- int An, K, N = descC->n;
- int LDC = N;
- int rank = CHAMELEON_Comm_rank();
- double Anorm, Bnorm, Crefnorm, Cchamnorm, Clapacknorm, Rnorm, result;
+ int LDA, info_solution = 0;
+ int An, K, N = descC->n;
+ int LDC = N;
+ int rank = CHAMELEON_Comm_rank();
CHAMELEON_Complex64_t *A = NULL;
CHAMELEON_Complex64_t *B = NULL;
CHAMELEON_Complex64_t *Cref = NULL;
CHAMELEON_Complex64_t *C = NULL;
- Bnorm = 0.;
if ( trans == ChamNoTrans ) {
- Anorm = CHAMELEON_zlange_Tile( ChamInfNorm, descA );
- if ( descB != NULL ) {
- Bnorm = CHAMELEON_zlange_Tile( ChamInfNorm, descB );
- }
- K = descA->n;
+ K = descA->n;
LDA = N;
An = K;
}
else {
- Anorm = CHAMELEON_zlange_Tile( ChamOneNorm, descA );
- if ( descB != NULL ) {
- Bnorm = CHAMELEON_zlange_Tile( ChamOneNorm, descB );
- }
- K = descA->m;
+ K = descA->m;
LDA = K;
An = N;
}
- /* Computes the norms for comparing */
-#if defined(PRECISION_z) || defined(PRECISION_c)
- if ( matrix_type == ChamHermitian ) {
- Crefnorm = CHAMELEON_zlanhe_Tile( ChamInfNorm, uplo, descCref );
- Cchamnorm = CHAMELEON_zlanhe_Tile( ChamInfNorm, uplo, descC );
- }
- else
-#endif
- {
- Crefnorm = CHAMELEON_zlansy_Tile( ChamInfNorm, uplo, descCref );
- Cchamnorm = CHAMELEON_zlansy_Tile( ChamInfNorm, uplo, descC );
- }
-
if ( rank == 0 ) {
A = (CHAMELEON_Complex64_t *)malloc(LDA * An * sizeof(CHAMELEON_Complex64_t));
if ( descB != NULL ) {
@@ -865,68 +964,9 @@ int check_zsyrk( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_uplo_t u
}
if ( rank == 0 ) {
- double eps = LAPACKE_dlamch_work('e');
- double ABnorm;
- double *work = malloc(sizeof(double)*N);
-
- /* Makes the multiplication with the core function */
-#if defined(PRECISION_z) || defined(PRECISION_c)
- if ( matrix_type == ChamHermitian ) {
- if ( descB == NULL ) {
- cblas_zherk( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
- N, K, creal(alpha), A, LDA, creal(beta), Cref, LDC );
- ABnorm = Anorm * Anorm;
- }
- else {
- cblas_zher2k( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
- N, K, CBLAS_SADDR(alpha), A, LDA, B, LDA, creal(beta), Cref, LDC );
- ABnorm = 2. * Anorm * Bnorm;
- }
-
- Clapacknorm = LAPACKE_zlanhe_work( LAPACK_COL_MAJOR, 'I', chameleon_lapack_const(uplo), N, Cref, LDC, work );
- }
- else
-#endif
- {
- if ( descB == NULL ) {
- cblas_zsyrk( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
- N, K, CBLAS_SADDR(alpha), A, LDA, CBLAS_SADDR(beta), Cref, LDC );
- ABnorm = Anorm * Anorm;
- }
- else {
- cblas_zsyr2k( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
- N, K, CBLAS_SADDR(alpha), A, LDA, B, LDA, CBLAS_SADDR(beta), Cref, LDC );
- ABnorm = 2. * Anorm * Bnorm;
- }
-
- Clapacknorm = LAPACKE_zlansy_work( LAPACK_COL_MAJOR, 'I', chameleon_lapack_const(uplo), N, Cref, LDC, work );
- }
-
- CORE_ztradd( uplo, ChamNoTrans, N, N,
- -1., C, LDC,
- 1., Cref, LDC );
- /* Computes the norm with the core function's result */
-#if defined(PRECISION_z) || defined(PRECISION_c)
- if ( matrix_type == ChamHermitian ) {
- Rnorm = LAPACKE_zlanhe_work( LAPACK_COL_MAJOR, 'M', chameleon_lapack_const(uplo), N, Cref, LDC, NULL );
- }
- else
-#endif
- {
- Rnorm = LAPACKE_zlansy_work( LAPACK_COL_MAJOR, 'M', chameleon_lapack_const(uplo), N, Cref, LDC, NULL );
- }
- result = Rnorm / ((ABnorm + Crefnorm) * K * eps);
-
- /* Verifies if the result is inside a threshold */
- if ( isinf(Clapacknorm) || isinf(Cchamnorm) || isnan(result) || isinf(result) || (result > 10.0) ) {
- info_solution = 1;
- }
- else {
- info_solution = 0;
- }
+ info_solution = check_zsyrk_std( args, matrix_type, uplo, trans, N, K, alpha, A, B, LDA, beta, Cref, C, LDC );
- free(work);
free(A);
free(C);
free(Cref);
@@ -940,7 +980,75 @@ int check_zsyrk( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_uplo_t u
MPI_Bcast(&info_solution, 1, MPI_INT, 0, MPI_COMM_WORLD);
#endif
- (void)matrix_type;
+ (void)args;
+ return info_solution;
+}
+
+int check_ztrmm_std( run_arg_list_t *args, int check_func, cham_side_t side, cham_uplo_t uplo, cham_trans_t trans, cham_diag_t diag, int M, int N,
+ CHAMELEON_Complex64_t alpha, CHAMELEON_Complex64_t *A, int LDA, CHAMELEON_Complex64_t *B, CHAMELEON_Complex64_t *Bref, int LDB )
+{
+ int info_solution = 0;
+ int An = M;
+ double Anorm, Bnorm, Brefnorm, Rnorm, result;
+ CHAMELEON_Complex64_t mzone = -1.0;
+ char normTypeA, normTypeB;
+ double *work;
+ double eps = LAPACKE_dlamch_work('e');
+
+ /* Computes the norms for comparing */
+ if ( side == ChamLeft ) {
+ normTypeA = 'O';
+ if ( trans == ChamNoTrans ) {
+ normTypeA = 'I';
+ }
+ normTypeB = 'O';
+ An = M;
+ LDA = M;
+ }
+ else {
+ normTypeA = '0';
+ if ( trans != ChamNoTrans ) {
+ normTypeA = 'I';
+ }
+ normTypeB = 'I';
+ An = N;
+ LDA = N;
+ }
+
+ work = malloc( sizeof(double) * An );
+ Anorm = LAPACKE_zlantr_work( LAPACK_COL_MAJOR, normTypeA,
+ chameleon_lapack_const(uplo), chameleon_lapack_const(diag),
+ An, An, A, LDA, work );
+ free( work );
+
+ Brefnorm = LAPACKE_zlange( LAPACK_COL_MAJOR, normTypeB, M, N, Bref, LDB );
+ Bnorm = LAPACKE_zlange( LAPACK_COL_MAJOR, normTypeB, M, N, B, LDB );
+
+ /* Makes the multiplication with the core function */
+ if (check_func == CHECK_TRMM) {
+ cblas_ztrmm(CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
+ (CBLAS_DIAG)diag, M, N, CBLAS_SADDR(alpha), A, LDA, Bref, LDB);
+ }
+ else {
+ cblas_ztrsm(CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
+ (CBLAS_DIAG)diag, M, N, CBLAS_SADDR(alpha), A, LDA, Bref, LDB);
+ }
+
+ /* Computes the norm with the core function's result */
+ cblas_zaxpy( LDB * N, CBLAS_SADDR(mzone), B, 1, Bref, 1 );
+ Rnorm = LAPACKE_zlange_work( LAPACK_COL_MAJOR, 'M', M, N, Bref, LDB, NULL );
+
+ result = Rnorm / ((Anorm + Brefnorm) * An * eps);
+
+ /* Verifies if the result is inside a threshold */
+ if ( isnan(Rnorm) || isinf(Rnorm) || isnan(result) || isinf(result) || (result > 10.0) ) {
+ info_solution = 1;
+ }
+ else {
+ info_solution = 0;
+ }
+
+ (void)Bnorm;
(void)args;
return info_solution;
}
@@ -991,36 +1099,22 @@ int check_zsyrk( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_uplo_t u
int check_ztrmm( run_arg_list_t *args, int check_func, cham_side_t side, cham_uplo_t uplo, cham_trans_t trans, cham_diag_t diag,
CHAMELEON_Complex64_t alpha, CHAM_desc_t *descA, CHAM_desc_t *descB, CHAM_desc_t *descBref )
{
- int info_solution = 0;
- int M = descB->m;
- int N = descB->n;
- int An, LDA, LDB = M;
- int rank = CHAMELEON_Comm_rank();
- double Anorm, Bnorm, Brefnorm, Rnorm, result;
+ int info_solution = 0;
+ int M = descB->m;
+ int N = descB->n;
+ int An, LDA, LDB = M;
+ int rank = CHAMELEON_Comm_rank();
CHAMELEON_Complex64_t *A = NULL;
CHAMELEON_Complex64_t *Bref = NULL;
CHAMELEON_Complex64_t *B = NULL;
- CHAMELEON_Complex64_t mzone = -1.0;
- /* Computes the norms for comparing */
- if ( ((side == ChamLeft) && (trans == ChamNoTrans)) ||
- ((side == ChamRight) && (trans != ChamNoTrans)) ) {
- Anorm = CHAMELEON_zlantr_Tile( ChamInfNorm, uplo, diag, descA );
- }
- else {
- Anorm = CHAMELEON_zlantr_Tile( ChamOneNorm, uplo, diag, descA );
- }
if ( side == ChamLeft ) {
- An = M;
+ An = M;
LDA = M;
- Brefnorm = CHAMELEON_zlange_Tile( ChamOneNorm, descBref );
- Bnorm = CHAMELEON_zlange_Tile( ChamOneNorm, descB );
}
else {
- An = N;
+ An = N;
LDA = N;
- Brefnorm = CHAMELEON_zlange_Tile( ChamInfNorm, descBref );
- Bnorm = CHAMELEON_zlange_Tile( ChamInfNorm, descB );
}
if ( rank == 0 ) {
@@ -1030,36 +1124,13 @@ int check_ztrmm( run_arg_list_t *args, int check_func, cham_side_t side, cham_up
}
/* Creates the LAPACK version of the matrices */
- CHAMELEON_zDesc2Lap( uplo, descA, A, LDA);
- CHAMELEON_zDesc2Lap( ChamUpperLower, descB, B, LDB);
- CHAMELEON_zDesc2Lap( ChamUpperLower, descBref, Bref, LDB);
+ CHAMELEON_zDesc2Lap( uplo, descA, A, LDA );
+ CHAMELEON_zDesc2Lap( ChamUpperLower, descB, B, LDB );
+ CHAMELEON_zDesc2Lap( ChamUpperLower, descBref, Bref, LDB );
if ( rank == 0 ) {
- double eps = LAPACKE_dlamch_work('e');
-
- /* Makes the multiplication with the core function */
- if (check_func == CHECK_TRMM) {
- cblas_ztrmm(CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
- (CBLAS_DIAG)diag, M, N, CBLAS_SADDR(alpha), A, LDA, Bref, LDB);
- }
- else {
- cblas_ztrsm(CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
- (CBLAS_DIAG)diag, M, N, CBLAS_SADDR(alpha), A, LDA, Bref, LDB);
- }
-
- /* Computes the norm with the core function's result */
- cblas_zaxpy( LDB * N, CBLAS_SADDR(mzone), B, 1, Bref, 1 );
- Rnorm = LAPACKE_zlange_work( LAPACK_COL_MAJOR, 'M', M, N, Bref, LDB, NULL );
- result = Rnorm / ((Anorm + Brefnorm) * An * eps);
-
- /* Verifies if the result is inside a threshold */
- if ( isnan(Rnorm) || isinf(Rnorm) || isnan(result) || isinf(result) || (result > 10.0) ) {
- info_solution = 1;
- }
- else {
- info_solution = 0;
- }
+ info_solution = check_ztrmm_std( args, check_func, side, uplo, trans, diag, M, N, alpha, A, LDA, B, Bref, LDB );
free(A);
free(B);
@@ -1071,7 +1142,6 @@ int check_ztrmm( run_arg_list_t *args, int check_func, cham_side_t side, cham_up
MPI_Bcast(&info_solution, 1, MPI_INT, 0, MPI_COMM_WORLD);
#endif
- (void)Bnorm;
(void)args;
return info_solution;
}
@@ -1176,7 +1246,7 @@ int check_zlauum( run_arg_list_t *args, cham_uplo_t uplo, CHAM_desc_t *descA, CH
*******************************************************************************
*/
int check_zxxtrf( run_arg_list_t *args, cham_mtxtype_t mtxtype, cham_uplo_t uplo,
- CHAM_desc_t *descA, CHAM_desc_t *descLU )
+ CHAM_desc_t *descA, CHAM_desc_t *descLU )
{
int info_local, info_global;
int M = descA->m;
diff --git a/testing/testing_zcheck.h b/testing/testing_zcheck.h
index 11762a3d04e4329498161dd46a96c9525a322917..f34ca857919e3aa14d8595e6daeddc83408596ae 100644
--- a/testing/testing_zcheck.h
+++ b/testing/testing_zcheck.h
@@ -37,7 +37,7 @@
#if defined(CHAMELEON_SIMULATION)
static inline int check_zmatrices ( run_arg_list_t *args, cham_uplo_t uplo, CHAM_desc_t *descA, CHAM_desc_t *descB ) { return 0; }
-static inline int check_znorm_std ( cham_mtxtype_t matrix_type, cham_normtype_t norm_type, cham_uplo_t uplo,
+static inline int check_znorm_std ( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_normtype_t norm_type, cham_uplo_t uplo,
cham_diag_t diag, double norm_cham, int M, int N, CHAMELEON_Complex64_t *A, int LDA ) { return 0; }
static inline int check_znorm ( run_arg_list_t *args, cham_mtxtype_t mtxtype, cham_normtype_t norm_type, cham_uplo_t uplo,
cham_diag_t diag, double norm_cham, CHAM_desc_t *descA ) { return 0; }
@@ -48,10 +48,16 @@ static inline int check_zgemm_std ( run_arg_list_t *args, cham_trans_t trans
CHAMELEON_Complex64_t *B, int LDB, CHAMELEON_Complex64_t beta, CHAMELEON_Complex64_t *Cref, CHAMELEON_Complex64_t *C, int LDC ) { return 0; }
static inline int check_zgemm ( run_arg_list_t *args, cham_trans_t transA, cham_trans_t transB, CHAMELEON_Complex64_t alpha, CHAM_desc_t *descA,
CHAM_desc_t *descB, CHAMELEON_Complex64_t beta, CHAM_desc_t *descCref, CHAM_desc_t *descC ) { return 0; }
+static inline int check_zsymm_std ( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_side_t side, cham_uplo_t uplo, int M, int N, CHAMELEON_Complex64_t alpha, CHAMELEON_Complex64_t *A, int LDA,
+ CHAMELEON_Complex64_t *B, int LDB, CHAMELEON_Complex64_t beta, CHAMELEON_Complex64_t *Cref, CHAMELEON_Complex64_t *C, int LDC ) { return 0; }
static inline int check_zsymm ( run_arg_list_t *args, cham_mtxtype_t mtxtype, cham_side_t side, cham_uplo_t uplo, CHAMELEON_Complex64_t alpha, CHAM_desc_t *descA, CHAM_desc_t *descB,
CHAMELEON_Complex64_t beta, CHAM_desc_t *descCref, CHAM_desc_t *descC ) { return 0; }
+static inline int check_zsyrk_std ( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_uplo_t uplo, cham_trans_t trans, int N, int K, CHAMELEON_Complex64_t alpha, CHAMELEON_Complex64_t *A,
+ CHAMELEON_Complex64_t *B, int LDA, CHAMELEON_Complex64_t beta, CHAMELEON_Complex64_t *Cref, CHAMELEON_Complex64_t *C, int LDC ) { return 0; }
static inline int check_zsyrk ( run_arg_list_t *args, cham_mtxtype_t mtxtype, cham_uplo_t uplo, cham_trans_t trans, CHAMELEON_Complex64_t alpha, CHAM_desc_t *descA,
CHAM_desc_t *descB, CHAMELEON_Complex64_t beta, CHAM_desc_t *descCref, CHAM_desc_t *descC ) { return 0; }
+static inline int check_ztrmm_std ( run_arg_list_t *args, int check_func, cham_side_t side, cham_uplo_t uplo, cham_trans_t trans, cham_diag_t diag, int M, int N, CHAMELEON_Complex64_t alpha,
+ CHAMELEON_Complex64_t *A, int LDA, CHAMELEON_Complex64_t *B, CHAMELEON_Complex64_t *Bref, int LDB ) { return 0; }
static inline int check_ztrmm ( run_arg_list_t *args, int check_func, cham_side_t side, cham_uplo_t uplo, cham_trans_t trans, cham_diag_t diag,
CHAMELEON_Complex64_t alpha, CHAM_desc_t *descA, CHAM_desc_t *descB, CHAM_desc_t *descBref ) { return 0; }
static inline int check_zlauum ( run_arg_list_t *args, cham_uplo_t uplo, CHAM_desc_t *descA1, CHAM_desc_t *descA2 ) { return 0; }
@@ -77,12 +83,12 @@ static inline int check_zrankk ( run_arg_list_t *args, int K, CHAM_desc_t
static inline int check_zgepdf_qr ( run_arg_list_t *args, CHAM_desc_t *descA1, CHAM_desc_t *descA2,
CHAM_desc_t *descQ1, CHAM_desc_t *descQ2, CHAM_desc_t *descAF1 ) { return 0; }
static inline int check_zxxpd ( run_arg_list_t *args,
- CHAM_desc_t *descA, CHAM_desc_t *descU, CHAM_desc_t *descH ) { return 0; }
+ CHAM_desc_t *descA, CHAM_desc_t *descU, CHAM_desc_t *descH ) { return 0; }
#else /* !defined(CHAMELEON_SIMULATION) */
int check_zmatrices ( run_arg_list_t *args, cham_uplo_t uplo, CHAM_desc_t *descA, CHAM_desc_t *descB );
-int check_znorm_std ( cham_mtxtype_t matrix_type, cham_normtype_t norm_type, cham_uplo_t uplo,
+int check_znorm_std ( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_normtype_t norm_type, cham_uplo_t uplo,
cham_diag_t diag, double norm_cham, int M, int N, CHAMELEON_Complex64_t *A, int LDA );
int check_znorm ( run_arg_list_t *args, cham_mtxtype_t mtxtype, cham_normtype_t norm_type, cham_uplo_t uplo,
cham_diag_t diag, double norm_cham, CHAM_desc_t *descA );
@@ -93,10 +99,16 @@ int check_zgemm_std ( run_arg_list_t *args, cham_trans_t transA, cham_trans_
CHAMELEON_Complex64_t *B, int LDB, CHAMELEON_Complex64_t beta, CHAMELEON_Complex64_t *Cref, CHAMELEON_Complex64_t *C, int LDC );
int check_zgemm ( run_arg_list_t *args, cham_trans_t transA, cham_trans_t transB, CHAMELEON_Complex64_t alpha, CHAM_desc_t *descA,
CHAM_desc_t *descB, CHAMELEON_Complex64_t beta, CHAM_desc_t *descCref, CHAM_desc_t *descC );
+int check_zsymm_std ( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_side_t side, cham_uplo_t uplo, int M, int N, CHAMELEON_Complex64_t alpha, CHAMELEON_Complex64_t *A, int LDA,
+ CHAMELEON_Complex64_t *B, int LDB, CHAMELEON_Complex64_t beta, CHAMELEON_Complex64_t *Cref, CHAMELEON_Complex64_t *C, int LDC );
int check_zsymm ( run_arg_list_t *args, cham_mtxtype_t mtxtype, cham_side_t side, cham_uplo_t uplo, CHAMELEON_Complex64_t alpha, CHAM_desc_t *descA, CHAM_desc_t *descB,
CHAMELEON_Complex64_t beta, CHAM_desc_t *descCref, CHAM_desc_t *descC );
+int check_zsyrk_std ( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_uplo_t uplo, cham_trans_t trans, int N, int K, CHAMELEON_Complex64_t alpha, CHAMELEON_Complex64_t *A,
+ CHAMELEON_Complex64_t *B, int LDA, CHAMELEON_Complex64_t beta, CHAMELEON_Complex64_t *Cref, CHAMELEON_Complex64_t *C, int LDC );
int check_zsyrk ( run_arg_list_t *args, cham_mtxtype_t mtxtype, cham_uplo_t uplo, cham_trans_t trans, CHAMELEON_Complex64_t alpha, CHAM_desc_t *descA,
CHAM_desc_t *descB, CHAMELEON_Complex64_t beta, CHAM_desc_t *descCref, CHAM_desc_t *descC );
+int check_ztrmm_std ( run_arg_list_t *args, int check_func, cham_side_t side, cham_uplo_t uplo, cham_trans_t trans, cham_diag_t diag, int M, int N, CHAMELEON_Complex64_t alpha,
+ CHAMELEON_Complex64_t *A, int LDA, CHAMELEON_Complex64_t *B, CHAMELEON_Complex64_t *Bref, int LDB );
int check_ztrmm ( run_arg_list_t *args, int check_func, cham_side_t side, cham_uplo_t uplo, cham_trans_t trans, cham_diag_t diag,
CHAMELEON_Complex64_t alpha, CHAM_desc_t *descA, CHAM_desc_t *descB, CHAM_desc_t *descBref );
int check_zlauum ( run_arg_list_t *args, cham_uplo_t uplo, CHAM_desc_t *descA1, CHAM_desc_t *descA2 );
diff --git a/testing/testing_zhemm.c b/testing/testing_zhemm.c
index 9fc0006429ccc736f71de8b0d27cb726a76d014d..b89b2bb3ce1d32f322547ec4a91f500e9fa3a088 100644
--- a/testing/testing_zhemm.c
+++ b/testing/testing_zhemm.c
@@ -156,8 +156,8 @@ testing_zhemm_std( run_arg_list_t *args, int check )
/* Create the matrices */
A = malloc( LDA*Am*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( LDB*N*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ B = malloc( LDB*N *sizeof(CHAMELEON_Complex64_t) );
+ C = malloc( LDC*N *sizeof(CHAMELEON_Complex64_t) );
/* Fills the matrix with random values */
CHAMELEON_zplghe( bump, uplo, N, A, LDA, seedA );
@@ -175,8 +175,7 @@ testing_zhemm_std( run_arg_list_t *args, int check )
Cinit = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplrnt( M, N, Cinit, LDC, seedC );
- // hres += check_zsymm( args, ChamHermitian, side, uplo, alpha, descA, descB,
- // beta, descCinit, descC );
+ hres += check_zsymm_std( args, ChamHermitian, side, uplo, M, N, alpha, A, LDA, B, LDB, beta, Cinit, C, LDC );
free( Cinit );
}
diff --git a/testing/testing_zher2k.c b/testing/testing_zher2k.c
index 1507b35e719c4c394215aaee6c362046d37158fd..79509cd0809c5fbf7493c5e36edeb7685c53bb3a 100644
--- a/testing/testing_zher2k.c
+++ b/testing/testing_zher2k.c
@@ -161,11 +161,11 @@ testing_zher2k_std( run_arg_list_t *args, int check )
/* Create the matrices */
A = malloc( LDA*An*sizeof(CHAMELEON_Complex64_t) );
B = malloc( LDB*An*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ C = malloc( LDC*N *sizeof(CHAMELEON_Complex64_t) );
/* Fill the matrix with random values */
CHAMELEON_zplrnt( Am, An, B, LDA, seedA );
- CHAMELEON_zplrnt( K, An, B, LDB, seedB );
+ CHAMELEON_zplrnt( K, An, B, LDB, seedB );
CHAMELEON_zplghe( bump, uplo, N, C, LDC, seedC );
/* Calculate the product */
@@ -179,8 +179,7 @@ testing_zher2k_std( run_arg_list_t *args, int check )
Cinit = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplghe( bump, uplo, N, Cinit, LDC, seedC );
- // hres += check_zsyrk( args, ChamHermitian, uplo, trans, alpha, descA, descB,
- // beta, descCinit, descC );
+ hres += check_zsyrk_std( args, ChamHermitian, uplo, trans, N, K, alpha, A, B, LDA, beta, Cinit, C, LDC );
free( Cinit );
}
diff --git a/testing/testing_zherk.c b/testing/testing_zherk.c
index 3f6a02f32af8b7e1b70b66d2c5b4fd90ae194ef2..83ade364b25c4e19b90d1ddad0e11a257bc44f10 100644
--- a/testing/testing_zherk.c
+++ b/testing/testing_zherk.c
@@ -152,7 +152,7 @@ testing_zherk_std( run_arg_list_t *args, int check )
/* Creates the matrices */
A = malloc( LDA*An*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ C = malloc( LDC*N *sizeof(CHAMELEON_Complex64_t) );
/* Fills the matrix with random values */
CHAMELEON_zplrnt( Am, An, A, LDA, seedA );
@@ -169,8 +169,7 @@ testing_zherk_std( run_arg_list_t *args, int check )
Cinit = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplghe( bump, uplo, N, Cinit, LDC, seedC );
- // hres += check_zsyrk( args, ChamHermitian, uplo, trans, alpha, descA, NULL,
- // beta, descCinit, descC );
+ hres += check_zsyrk_std( args, ChamHermitian, uplo, trans, N, K, alpha, A, NULL, LDA, beta, Cinit, C, LDC );
free( Cinit );
}
diff --git a/testing/testing_zlange.c b/testing/testing_zlange.c
index 404c7d3f5fe475b43eacf7cadf9f3fa2dde05413..16906f8422fbfb89dd9f9763e5529f10e6b8fd82 100644
--- a/testing/testing_zlange.c
+++ b/testing/testing_zlange.c
@@ -136,13 +136,13 @@ testing_zlange_std( run_arg_list_t *args, int check )
/* Calculates the norm */
testing_start( &test_data );
- norm = CHAMELEON_zlange( norm_type, M, N, A, LDA );
+ norm = CHAMELEON_zlange( norm_type, M, N, A, LDA );
test_data.hres = hres;
testing_stop( &test_data, flops_zlange( norm_type, M, N ) );
/* Checks the solution */
if ( check ) {
- hres = check_znorm_std( ChamGeneral, norm_type, ChamUpperLower, ChamNonUnit, norm, M, N, A, LDA );
+ hres = check_znorm_std( args, ChamGeneral, norm_type, ChamUpperLower, ChamNonUnit, norm, M, N, A, LDA );
}
free( A );
diff --git a/testing/testing_zlanhe.c b/testing/testing_zlanhe.c
index a761f5a0c7e19be5486a9973eee6bd8ef99af4c8..bc714cb6aae835053ebcc956fe0b23c827216df7 100644
--- a/testing/testing_zlanhe.c
+++ b/testing/testing_zlanhe.c
@@ -138,13 +138,13 @@ testing_zlanhe_std( run_arg_list_t *args, int check )
/* Calculates the norm */
testing_start( &test_data );
- norm = CHAMELEON_zlanhe( norm_type, uplo, N, A, LDA );
+ norm = CHAMELEON_zlanhe( norm_type, uplo, N, A, LDA );
test_data.hres = hres;
testing_stop( &test_data, flops_zlanhe( norm_type, N ) );
/* Checks the solution */
if ( check ) {
- hres = check_znorm_std( ChamHermitian, norm_type, uplo, ChamNonUnit, norm, N, N, A, LDA );
+ hres = check_znorm_std( args, ChamHermitian, norm_type, uplo, ChamNonUnit, norm, N, N, A, LDA );
}
free( A );
diff --git a/testing/testing_zlansy.c b/testing/testing_zlansy.c
index aaef481f2b93404ae2f5b726ec5ded3214ac1c26..572cbdb55ba7f73d5c30fff583925df979561064 100644
--- a/testing/testing_zlansy.c
+++ b/testing/testing_zlansy.c
@@ -144,7 +144,7 @@ testing_zlansy_std( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
- hres = check_znorm_std( ChamSymmetric, norm_type, uplo, ChamNonUnit, norm, N, N, A, LDA );
+ hres = check_znorm_std( args, ChamSymmetric, norm_type, uplo, ChamNonUnit, norm, N, N, A, LDA );
}
free( A );
diff --git a/testing/testing_zlantr.c b/testing/testing_zlantr.c
index ce6ce9e7f80b930bf5c085b9c695046bbe10e5b6..fcbb174b39f84da2ba143b9185ad5001cb9c47ac 100644
--- a/testing/testing_zlantr.c
+++ b/testing/testing_zlantr.c
@@ -165,7 +165,7 @@ testing_zlantr_std( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
- hres = check_znorm_std( ChamTriangular, norm_type, uplo, diag, norm, M, N, A, LDA );
+ hres = check_znorm_std( args, ChamTriangular, norm_type, uplo, diag, norm, M, N, A, LDA );
}
free( A );
diff --git a/testing/testing_zsymm.c b/testing/testing_zsymm.c
index a8d8bf0c0a9668f62cda2de9c27fabe660a59da5..f87066a874863646f478a512ae5e527d82db09bb 100644
--- a/testing/testing_zsymm.c
+++ b/testing/testing_zsymm.c
@@ -175,8 +175,7 @@ testing_zsymm_std( run_arg_list_t *args, int check )
Cinit = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplrnt( M, N, Cinit, LDC, seedC );
- // hres += check_zsymm( args, ChamSymmetric, side, uplo, alpha, descA, descB,
- // beta, descCinit, descC );
+ hres += check_zsymm_std( args, ChamSymmetric, side, uplo, M, N, alpha, A, LDA, B, LDB, beta, Cinit, C, LDC );
free( Cinit );
}
diff --git a/testing/testing_zsyr2k.c b/testing/testing_zsyr2k.c
index 49f2047908ca69f0f748fa760cb04d7d04e821c2..1db847448215cc36c36887e438c7d3c2bed9ec40 100644
--- a/testing/testing_zsyr2k.c
+++ b/testing/testing_zsyr2k.c
@@ -161,7 +161,7 @@ testing_zsyr2k_std( run_arg_list_t *args, int check )
/* Create the matrices */
A = malloc( LDA*An*sizeof(CHAMELEON_Complex64_t) );
B = malloc( LDB*An*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ C = malloc( LDC*N *sizeof(CHAMELEON_Complex64_t) );
/* Fill the matrix with random values */
CHAMELEON_zplrnt( Am, An, A, LDA, seedA );
@@ -179,8 +179,7 @@ testing_zsyr2k_std( run_arg_list_t *args, int check )
Cinit = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplgsy( bump, uplo, N, Cinit, LDC, seedC );
- // hres += check_zsyrk( args, ChamSymmetric, uplo, trans, alpha, descA, descB,
- // beta, descCinit, descC );
+ hres += check_zsyrk_std( args, ChamSymmetric, uplo, trans, N, K, alpha, A, B, LDA, beta, Cinit, C, LDC );
free( Cinit );
}
diff --git a/testing/testing_zsyrk.c b/testing/testing_zsyrk.c
index 164d8ff5fed4aab73a3ddb7cba6c05a2cb5894e3..87be0bd64561a4cff298d4ce36b3b3fb1be252b8 100644
--- a/testing/testing_zsyrk.c
+++ b/testing/testing_zsyrk.c
@@ -151,7 +151,7 @@ testing_zsyrk_std( run_arg_list_t *args, int check )
/* Creates the matrices */
A = malloc( LDA*An*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ C = malloc( LDC*N *sizeof(CHAMELEON_Complex64_t) );
/* Fills the matrix with random values */
CHAMELEON_zplrnt( Am, An, A, LDA, seedA );
@@ -168,8 +168,7 @@ testing_zsyrk_std( run_arg_list_t *args, int check )
Cinit = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplgsy( bump, uplo, N, Cinit, LDC, seedC );
- // hres += check_zsyrk( args, ChamSymmetric, uplo, trans, alpha, descA, NULL,
- // beta, descCinit, descC );
+ hres += check_zsyrk_std( args, ChamSymmetric, uplo, trans, N, K, alpha, A, NULL, LDA, beta, Cinit, C, LDC );
free( Cinit );
}
diff --git a/testing/testing_ztrmm.c b/testing/testing_ztrmm.c
index dced32a2e51699cbea23e26bbaae0455835279ea..9809931fc2d5bf586bcabb1e9ed549e1b40ea6dc 100644
--- a/testing/testing_ztrmm.c
+++ b/testing/testing_ztrmm.c
@@ -39,16 +39,15 @@ testing_ztrmm_desc( run_arg_list_t *args, int check )
cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
cham_diag_t diag = run_arg_get_diag( args, "diag", ChamNonUnit );
int N = run_arg_get_int( args, "N", 1000 );
- int K = run_arg_get_int( args, "K", N );
+ int M = run_arg_get_int( args, "M", N );
int LDA = run_arg_get_int( args, "LDA", N );
- int LDB = run_arg_get_int( args, "LDB", N );
+ int LDB = run_arg_get_int( args, "LDB", M );
CHAMELEON_Complex64_t alpha = testing_zalea();
int seedA = run_arg_get_int( args, "seedA", random() );
int seedB = run_arg_get_int( args, "seedB", random() );
int Q = parameters_compute_q( P );
/* Descriptors */
- int Bm, Bn;
CHAM_desc_t *descA, *descB, *descBinit;
alpha = run_arg_get_complex64( args, "alpha", alpha );
@@ -57,19 +56,19 @@ testing_ztrmm_desc( run_arg_list_t *args, int check )
/* Calculates the dimensions according to the side */
if ( side == ChamLeft ) {
- Bm = N;
- Bn = K;
+ LDA = M;
+ CHAMELEON_Desc_Create(
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, M, 0, 0, M, M, P, Q );
}
else {
- Bm = K;
- Bn = N;
+ LDA = N;
+ CHAMELEON_Desc_Create(
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
}
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
- CHAMELEON_Desc_Create(
- &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, Bn, 0, 0, Bm, Bn, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -87,12 +86,12 @@ testing_ztrmm_desc( run_arg_list_t *args, int check )
hres = CHAMELEON_ztrmm_Tile( side, uplo, trans, diag, alpha, descA, descB );
}
test_data.hres = hres;
- testing_stop( &test_data, flops_ztrmm( side, N, K ) );
+ testing_stop( &test_data, flops_ztrmm( side, N, M ) );
/* Checks the solution */
if ( check ) {
CHAMELEON_Desc_Create(
- &descBinit, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, Bn, 0, 0, Bm, Bn, P, Q );
+ &descBinit, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
CHAMELEON_zplrnt_Tile( descBinit, seedB );
hres += check_ztrmm( args, CHECK_TRMM, side, uplo, trans, diag,
@@ -120,15 +119,15 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
cham_diag_t diag = run_arg_get_diag( args, "diag", ChamNonUnit );
int N = run_arg_get_int( args, "N", 1000 );
- int K = run_arg_get_int( args, "K", N );
+ int M = run_arg_get_int( args, "M", N );
int LDA = run_arg_get_int( args, "LDA", N );
- int LDB = run_arg_get_int( args, "LDB", N );
+ int LDB = run_arg_get_int( args, "LDB", M );
CHAMELEON_Complex64_t alpha = testing_zalea();
int seedA = run_arg_get_int( args, "seedA", random() );
int seedB = run_arg_get_int( args, "seedB", random() );
/* Descriptors */
- int Bm, Bn;
+ int An;
CHAMELEON_Complex64_t *A, *B, *Binit;
alpha = run_arg_get_complex64( args, "alpha", alpha );
@@ -137,35 +136,35 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
/* Calculates the dimensions according to the side */
if ( side == ChamLeft ) {
- Bm = N;
- Bn = K;
+ An = M;
+ LDA = M;
+ A = malloc( LDA*N *sizeof(CHAMELEON_Complex64_t) );
}
else {
- Bm = K;
- Bn = N;
+ An = N;
+ LDA = N;
+ A = malloc( LDA*N *sizeof(CHAMELEON_Complex64_t) );
}
/* Creates the matrices */
- A = malloc( LDA*N*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( LDB*Bn*sizeof(CHAMELEON_Complex64_t) );
+ B = malloc( LDB*N*sizeof(CHAMELEON_Complex64_t) );
/* Fills the matrix with random values */
- CHAMELEON_zplrnt( K, N, A, LDA, seedA );
- CHAMELEON_zplrnt( Bm, Bn, B, LDB, seedB );
+ CHAMELEON_zplrnt( An, An, A, LDA, seedA );
+ CHAMELEON_zplrnt( M, N, B, LDB, seedB );
/* Calculates the product */
testing_start( &test_data );
- hres = CHAMELEON_ztrmm( side, uplo, trans, diag, N, K, alpha, A, LDA, B, LDB );
+ hres = CHAMELEON_ztrmm( side, uplo, trans, diag, N, M, alpha, A, LDA, B, LDB );
test_data.hres = hres;
- testing_stop( &test_data, flops_ztrmm( side, N, K ) );
+ testing_stop( &test_data, flops_ztrmm( side, N, M ) );
/* Checks the solution */
if ( check ) {
- Binit = malloc( LDB*Bn*sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_zplrnt( Bm, Bn, Binit, LDB, seedB );
+ Binit = malloc( LDB*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_zplrnt( M, N, Binit, LDB, seedB );
- // hres += check_ztrmm( args, CHECK_TRMM, side, uplo, trans, diag,
- // alpha, descA, descB, descBinit );
+ hres += check_ztrmm_std( args, CHECK_TRMM, side, uplo, trans, diag, N, M, alpha, A, LDA, B, Binit, LDB );
free( Binit );
}
@@ -177,8 +176,8 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
}
testing_t test_ztrmm;
-const char *ztrmm_params[] = { "mtxfmt", "nb", "trans", "side", "uplo", "diag", "n",
- "k", "lda", "ldb", "alpha", "seedA", "seedB", NULL };
+const char *ztrmm_params[] = { "mtxfmt", "nb", "trans", "side", "uplo", "diag", "m",
+ "n", "lda", "ldb", "alpha", "seedA", "seedB", NULL };
const char *ztrmm_output[] = { NULL };
const char *ztrmm_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_ztrsm.c b/testing/testing_ztrsm.c
index 851df92b88960469fbcf3515ecbdd73f2b2ee037..89cd4f73354a488301ab2d5b266f7726b1626996 100644
--- a/testing/testing_ztrsm.c
+++ b/testing/testing_ztrsm.c
@@ -128,7 +128,7 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
/* Creates the matrices */
A = malloc( LDA*Ak*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( LDB*N*sizeof(CHAMELEON_Complex64_t) );
+ B = malloc( LDB*N *sizeof(CHAMELEON_Complex64_t) );
/* Fills the matrix with random values */
/* We bump a little bit the diagonal to make it stable */
@@ -146,8 +146,7 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
Binit = malloc( LDB*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplrnt( M, N, Binit, LDB, seedB );
- // hres += check_ztrmm( args, CHECK_TRSM, side, uplo, trans, diag,
- // alpha, descA, descB, descBinit );
+ hres += check_ztrmm_std( args, CHECK_TRSM, side, uplo, trans, diag, M, N, alpha, A, LDA, B, Binit, LDB );
free( Binit );
}