diff --git a/lapack_api/CMakeLists.txt b/lapack_api/CMakeLists.txt
index c5380b814c193929b86205143c6e626cab3b9397..5fcdd04507c678d1f5f9944ad7092c3a7e5d5705 100644
--- a/lapack_api/CMakeLists.txt
+++ b/lapack_api/CMakeLists.txt
@@ -57,7 +57,15 @@ install( FILES ${CHAMELEON_LAPACK_HDRS}
set(LAPACK_SRCS_GENERATED "")
set(ZSRC
src/lapack_zgemm.c
+ src/lapack_zhemm.c
+ src/lapack_zher2k.c
+ src/lapack_zherk.c
+ src/lapack_zlauum.c
src/lapack_zsymm.c
+ src/lapack_zsyr2k.c
+ src/lapack_zsyrk.c
+ src/lapack_ztrmm.c
+ src/lapack_ztrsm.c
)
precisions_rules_py(LAPACK_SRCS_GENERATED "${ZSRC}"
PRECISIONS "${CHAMELEON_PRECISION}")
diff --git a/lapack_api/include/chameleon/chameleon_zlapack.h b/lapack_api/include/chameleon/chameleon_zlapack.h
index 465327f4e474811288a4f423e01b350b7fd83721..10e4763afdb0191db7616ce4d3edc948afc7a42d 100644
--- a/lapack_api/include/chameleon/chameleon_zlapack.h
+++ b/lapack_api/include/chameleon/chameleon_zlapack.h
@@ -27,18 +27,61 @@ BEGIN_C_DECLS
/**
* Declarations of math functions (LAPACK layout, Cblas/Lapacke interface) - alphabetical order
*/
-void CHAMELEON_cblas_zgemm( const CBLAS_ORDER Order, const CBLAS_TRANSPOSE TransA, const CBLAS_TRANSPOSE TransB,
+void CHAMELEON_cblas_zgemm( const CBLAS_ORDER order, const CBLAS_TRANSPOSE transA, const CBLAS_TRANSPOSE transB,
const int M, const int N, const int K,
const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
const CHAMELEON_Complex64_t *B, const int ldb,
const void *beta, CHAMELEON_Complex64_t *C, const int ldc );
-void CHAMELEON_cblas_zsymm( const CBLAS_ORDER Order, const CBLAS_SIDE Side, const CBLAS_UPLO Uplo,
+void CHAMELEON_cblas_zhemm( const CBLAS_ORDER order, const CBLAS_SIDE side, const CBLAS_UPLO uplo,
const int M, const int N,
const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
const CHAMELEON_Complex64_t *B, const int ldb,
const void *beta, CHAMELEON_Complex64_t *C, const int ldc );
+void CHAMELEON_cblas_zher2k( const CBLAS_ORDER order, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans,
+ const int N, const int K,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const CHAMELEON_Complex64_t *B, const int ldb,
+ const double beta, CHAMELEON_Complex64_t *C, const int ldc );
+
+void CHAMELEON_cblas_zherk( const CBLAS_ORDER order, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans,
+ const int N, const int K,
+ const double alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const double beta, CHAMELEON_Complex64_t *C, const int ldc );
+
+void CHAMELEON_cblas_zsymm( const CBLAS_ORDER order, const CBLAS_SIDE side, const CBLAS_UPLO uplo,
+ const int M, const int N,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const CHAMELEON_Complex64_t *B, const int ldb,
+ const void *beta, CHAMELEON_Complex64_t *C, const int ldc );
+
+void CHAMELEON_cblas_zsyr2k( const CBLAS_ORDER order, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans,
+ const int N, const int K,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const CHAMELEON_Complex64_t *B, const int ldb,
+ const void *beta, CHAMELEON_Complex64_t *C, const int ldc );
+
+void CHAMELEON_cblas_zsyrk( const CBLAS_ORDER order, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans,
+ const int N, const int K,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const void *beta, CHAMELEON_Complex64_t *C, const int ldc );
+
+void CHAMELEON_cblas_ztrmm( const CBLAS_ORDER order, const CBLAS_SIDE side, const CBLAS_UPLO uplo,
+ const CBLAS_TRANSPOSE trans, const CBLAS_DIAG diag,
+ const int M, const int N,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const CHAMELEON_Complex64_t *B, const int ldb );
+
+void CHAMELEON_cblas_ztrsm( const CBLAS_ORDER order, const CBLAS_SIDE side, const CBLAS_UPLO uplo,
+ const CBLAS_TRANSPOSE trans, const CBLAS_DIAG diag,
+ const int M, const int N,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const CHAMELEON_Complex64_t *B, const int ldb );
+
+int CHAMELEON_lapacke_zlauum( int matrix_layout, char uplo, int N,
+ CHAMELEON_Complex64_t *A, int lda );
+
END_C_DECLS
#endif /* _chameleon_zlapack_h_ */
diff --git a/lapack_api/include/lapack_api_common.h b/lapack_api/include/lapack_api_common.h
index 7dddd8f3ba5d761166187bacf418f784f6f42fa0..c298574fbc46808d995b1d1352c07fe16fa9c121 100644
--- a/lapack_api/include/lapack_api_common.h
+++ b/lapack_api/include/lapack_api_common.h
@@ -30,8 +30,9 @@
*
*/
-int chameleon_blastocblas_trans(const char* value);
+int chameleon_blastocblas_trans(const char* trans);
int chameleon_blastocblas_side(const char* side);
int chameleon_blastocblas_uplo(const char* uplo);
+int chameleon_blastocblas_diag(const char* diag);
#endif /* _lapack_api_common_h_ */
diff --git a/lapack_api/src/lapack_api_common.c b/lapack_api/src/lapack_api_common.c
index 097362d868d7d9ac09e4eeb40c6bf2ffceb79dec..eaab7c29aec61b3873ec8590b2235603e4770332 100644
--- a/lapack_api/src/lapack_api_common.c
+++ b/lapack_api/src/lapack_api_common.c
@@ -73,3 +73,21 @@ int chameleon_blastocblas_uplo(const char* uplo)
return CHAMELEON_ERR_ILLEGAL_VALUE;
}
}
+
+/**
+ * @brief Convert the input char BLAS diag parameter to a compatible parameter
+ * for the Cblas API.
+ * @param[in] diag The input char BLAS diag parameter
+ * @return The CBLAS equivalent parameter (CblasUnit or CblasNonUnit).
+ */
+int chameleon_blastocblas_diag(const char* diag)
+{
+ if ( (*diag == 'U') || (*diag == 'u') ) {
+ return CblasUnit;
+ } else if ( (*diag == 'N') || (*diag == 'n') ) {
+ return CblasNonUnit;
+ } else {
+ fprintf(stderr, "CHAMELEON ERROR: %s(): %s\n", "chameleon_blastocblas_diag", "illegal value of BLAS diag parameter");
+ return CHAMELEON_ERR_ILLEGAL_VALUE;
+ }
+}
\ No newline at end of file
diff --git a/lapack_api/src/lapack_zgemm.c b/lapack_api/src/lapack_zgemm.c
index dccd819335479ae189d19250946fd52313eb3fa5..1ac81eb6de2481571448a7a9a96186aca1506ea5 100644
--- a/lapack_api/src/lapack_zgemm.c
+++ b/lapack_api/src/lapack_zgemm.c
@@ -58,21 +58,21 @@ void CHAMELEON_blas_zgemm ( const char* transa, const char* transb,
*
*******************************************************************************
*
- * @param[in] Order
+ * @param[in] order
* Specifies whether the matrices are row or column major, it must be
* set to CblasColMajor, the order supported in Chameleon.
*
* @param[in] TransA
* Specifies whether the matrix A is transposed, not transposed or conjugate transposed:
- * = ChamNoTrans: A is not transposed;
- * = ChamTrans: A is transposed;
- * = ChamConjTrans: A is conjugate transposed.
+ * = CblasNoTrans: A is not transposed;
+ * = CblasTrans: A is transposed;
+ * = CblasConjTrans: A is conjugate transposed.
*
* @param[in] TransB
* Specifies whether the matrix B is transposed, not transposed or conjugate transposed:
- * = ChamNoTrans: B is not transposed;
- * = ChamTrans: B is transposed;
- * = ChamConjTrans: B is conjugate transposed.
+ * = CblasNoTrans: B is not transposed;
+ * = CblasTrans: B is transposed;
+ * = CblasConjTrans: B is conjugate transposed.
*
* @param[in] M
* M specifies the number of rows of the matrix op( A ) and of the matrix C. M >= 0.
@@ -88,14 +88,14 @@ void CHAMELEON_blas_zgemm ( const char* transa, const char* transb,
* alpha specifies the scalar alpha
*
* @param[in] A
- * A is a LDA-by-ka matrix, where ka is K when transA = ChamNoTrans,
+ * A is a LDA-by-ka matrix, where ka is K when transA = CblasNoTrans,
* and is M otherwise.
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,M).
*
* @param[in] B
- * B is a LDB-by-kb matrix, where kb is N when transB = ChamNoTrans,
+ * B is a LDB-by-kb matrix, where kb is N when transB = CblasNoTrans,
* and is K otherwise.
*
* @param[in] LDB
@@ -119,13 +119,13 @@ void CHAMELEON_blas_zgemm ( const char* transa, const char* transb,
* @sa CHAMELEON_cblas_sgemm
*
*/
-void CHAMELEON_cblas_zgemm( const CBLAS_ORDER Order, const CBLAS_TRANSPOSE TransA, const CBLAS_TRANSPOSE TransB,
+void CHAMELEON_cblas_zgemm( const CBLAS_ORDER order, const CBLAS_TRANSPOSE transA, const CBLAS_TRANSPOSE transB,
const int M, const int N, const int K,
const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
const CHAMELEON_Complex64_t *B, const int ldb,
const void *beta, CHAMELEON_Complex64_t *C, const int ldc )
{
- if (Order != CblasColMajor){
+ if (order != CblasColMajor){
fprintf(stderr, "CHAMELEON ERROR: %s(): %s\n", "CHAMELEON_cblas_zgemm", "illegal value of order");
}
@@ -137,7 +137,7 @@ void CHAMELEON_cblas_zgemm( const CBLAS_ORDER Order, const CBLAS_TRANSPOSE Trans
CHAMELEON_Complex64_t betac = beta;
#endif
- CHAMELEON_zgemm( (cham_trans_t)TransA, (cham_trans_t)TransB, M, N, K,
+ CHAMELEON_zgemm( (cham_trans_t)transA, (cham_trans_t)transB, M, N, K,
alphac, (CHAMELEON_Complex64_t *)A, lda,
(CHAMELEON_Complex64_t *)B, ldb,
betac, (CHAMELEON_Complex64_t *)C, ldc );
diff --git a/lapack_api/src/lapack_zhemm.c b/lapack_api/src/lapack_zhemm.c
new file mode 100644
index 0000000000000000000000000000000000000000..10b31432607c6b76840470c1ba3374e08f4a1ea9
--- /dev/null
+++ b/lapack_api/src/lapack_zhemm.c
@@ -0,0 +1,142 @@
+/**
+ *
+ * @file lapack_zhemm.c
+ *
+ * @copyright 2022 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ * Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief Chameleon blas and cblas api for hemm
+ *
+ * @version 1.2.0
+ * @author Mathieu Faverge
+ * @author Florent Pruvost
+ * @date 2022-08-19
+ * @precisions normal z -> c
+ *
+ */
+
+#include "chameleon_lapack.h"
+#include "lapack_api_common.h"
+
+/* Fortran BLAS interface */
+
+#define CHAMELEON_blas_zhemm CHAMELEON_GLOBAL( chameleon_blas_zhemm, CHAMELEON_BLAS_Zhemm )
+void CHAMELEON_blas_zhemm ( const char* side, const char* uplo,
+ const int* m, const int* n,
+ const CHAMELEON_Complex64_t* alpha, const CHAMELEON_Complex64_t* a, const int* lda,
+ const CHAMELEON_Complex64_t* b, const int* ldb,
+ const CHAMELEON_Complex64_t* beta, CHAMELEON_Complex64_t* c, const int* ldc )
+{
+ CHAMELEON_cblas_zhemm( CblasColMajor,
+ chameleon_blastocblas_side(side),
+ chameleon_blastocblas_uplo(uplo),
+ *m, *n,
+ CBLAS_SADDR(*alpha), a, *lda,
+ b, *ldb,
+ CBLAS_SADDR(*beta), c, *ldc );
+}
+
+/* C CBLAS interface */
+
+/**
+ ********************************************************************************
+ *
+ * @ingroup CHAMELEON_LAPACK_API
+ *
+ * CHAMELEON_cblas_zhemm - Performs one of the matrix-matrix operations
+ *
+ * \f[ C = \alpha \times A \times B + \beta \times C \f]
+ *
+ * or
+ *
+ * \f[ C = \alpha \times B \times A + \beta \times C \f]
+ *
+ * where alpha and beta are scalars, A is an hermitian matrix and B and
+ * C are m by n matrices.
+ *
+ *******************************************************************************
+ *
+ * @param[in] order
+ * Specifies whether the matrices are row or column major, it must be
+ * set to CblasColMajor, the order supported in Chameleon.
+ *
+ * @param[in] side
+ * Specifies whether the hermitian matrix A appears on the
+ * left or right in the operation as follows:
+ * = CblasLeft: \f[ C = \alpha \times A \times B + \beta \times C \f]
+ * = CblasRight: \f[ C = \alpha \times B \times A + \beta \times C \f]
+ *
+ * @param[in] uplo
+ * Specifies whether the upper or lower triangular part of
+ * the hermitian matrix A is to be referenced as follows:
+ * = CblasLower: Only the lower triangular part of the
+ * hermitian matrix A is to be referenced.
+ * = CblasUpper: Only the upper triangular part of the
+ * hermitian matrix A is to be referenced.
+ *
+ * @param[in] M
+ * Specifies the number of rows of the matrix C. M >= 0.
+ *
+ * @param[in] N
+ * Specifies the number of columns of the matrix C. N >= 0.
+ *
+ * @param[in] alpha
+ * Specifies the scalar alpha.
+ *
+ * @param[in] A
+ * A is a LDA-by-ka matrix, where ka is M when side = CblasLeft,
+ * and is N otherwise. Only the uplo triangular part is referenced.
+ *
+ * @param[in] LDA
+ * The leading dimension of the array A. LDA >= max(1,ka).
+ *
+ * @param[in] B
+ * B is a LDB-by-N matrix, where the leading M-by-N part of
+ * the array B must contain the matrix B.
+ *
+ * @param[in] LDB
+ * The leading dimension of the array B. LDB >= max(1,M).
+ *
+ * @param[in] beta
+ * Specifies the scalar beta.
+ *
+ * @param[in,out] C
+ * C is a LDC-by-N matrix.
+ * On exit, the array is overwritten by the M by N updated matrix.
+ *
+ * @param[in] LDC
+ * The leading dimension of the array C. LDC >= max(1,M).
+ *
+ *******************************************************************************
+ *
+ * @sa CHAMELEON_cblas_zhemm
+ * @sa CHAMELEON_cblas_chemm
+ * @sa CHAMELEON_cblas_dhemm
+ * @sa CHAMELEON_cblas_shemm
+ *
+ */
+void CHAMELEON_cblas_zhemm( const CBLAS_ORDER order, const CBLAS_SIDE side, const CBLAS_UPLO uplo,
+ const int M, const int N,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const CHAMELEON_Complex64_t *B, const int ldb,
+ const void *beta, CHAMELEON_Complex64_t *C, const int ldc )
+{
+ if (order != CblasColMajor){
+ fprintf(stderr, "CHAMELEON ERROR: %s(): %s\n", "CHAMELEON_cblas_zhemm", "illegal value of order");
+ }
+
+#if defined(PRECISION_z) || defined(PRECISION_c)
+ CHAMELEON_Complex64_t alphac = *(CHAMELEON_Complex64_t *)alpha;
+ CHAMELEON_Complex64_t betac = *(CHAMELEON_Complex64_t *)beta;
+#else
+ CHAMELEON_Complex64_t alphac = alpha;
+ CHAMELEON_Complex64_t betac = beta;
+#endif
+
+ CHAMELEON_zhemm( (cham_side_t)side, (cham_uplo_t)uplo, M, N,
+ alphac, (CHAMELEON_Complex64_t *)A, lda,
+ (CHAMELEON_Complex64_t *)B, ldb,
+ betac, (CHAMELEON_Complex64_t *)C, ldc );
+}
diff --git a/lapack_api/src/lapack_zher2k.c b/lapack_api/src/lapack_zher2k.c
new file mode 100644
index 0000000000000000000000000000000000000000..b1c1541723b81d73a5d5548f6f19f53e9cff26ed
--- /dev/null
+++ b/lapack_api/src/lapack_zher2k.c
@@ -0,0 +1,142 @@
+/**
+ *
+ * @file lapack_zher2k.c
+ *
+ * @copyright 2022 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ * Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief Chameleon blas and cblas api for her2k
+ *
+ * @version 1.2.0
+ * @author Mathieu Faverge
+ * @author Florent Pruvost
+ * @date 2022-08-19
+ * @precisions normal z -> c
+ *
+ */
+
+#include "chameleon_lapack.h"
+#include "lapack_api_common.h"
+
+/* Fortran BLAS interface */
+
+#define CHAMELEON_blas_zher2k CHAMELEON_GLOBAL( chameleon_blas_zher2k, CHAMELEON_BLAS_Zher2k )
+void CHAMELEON_blas_zher2k ( const char* uplo, const char* trans,
+ const int* n, const int* k,
+ const CHAMELEON_Complex64_t* alpha, const CHAMELEON_Complex64_t* a, const int* lda,
+ const CHAMELEON_Complex64_t* b, const int* ldb,
+ const double* beta, CHAMELEON_Complex64_t* c, const int* ldc )
+{
+ CHAMELEON_cblas_zher2k( CblasColMajor,
+ chameleon_blastocblas_uplo(uplo),
+ chameleon_blastocblas_trans(trans),
+ *n, *k,
+ CBLAS_SADDR(*alpha), a, *lda,
+ b, *ldb,
+ *beta, c, *ldc );
+}
+
+/* C CBLAS interface */
+
+/**
+ ********************************************************************************
+ *
+ * @ingroup CHAMELEON_LAPACK_API
+ *
+ * CHAMELEON_cblas_zher2k - Performs one of the hermitian rank 2k operations
+ *
+ * \f[ C = \alpha [ op( A ) \times conjg( op( B )' )] + conjg( \alpha ) [ op( B ) \times conjg( op( A )' )] + \beta C \f],
+ * or
+ * \f[ C = \alpha [ conjg( op( A )' ) \times op( B ) ] + conjg( \alpha ) [ conjg( op( B )' ) \times op( A ) ] + \beta C \f],
+ *
+ * where op( X ) is one of
+ *
+ * op( X ) = X or op( X ) = conjg( X' )
+ *
+ * where alpha and beta are real scalars, C is an n-by-n hermitian
+ * matrix and A and B are an n-by-k matrices the first case and k-by-n
+ * matrices in the second case.
+ *
+ *******************************************************************************
+ *
+ * @param[in] order
+ * Specifies whether the matrices are row or column major, it must be
+ * set to CblasColMajor, the order supported in Chameleon.
+ *
+ * @param[in] uplo
+ * = CblasUpper: Upper triangle of C is stored;
+ * = CblasLower: Lower triangle of C is stored.
+ *
+ * @param[in] trans
+ * Specifies whether the matrix A is transposed or conjugate transposed:
+ * = CblasNoTrans: \f[ C = \alpha [ op( A ) \times conjg( op( B )' )] + conjg( \alpha ) [ op( B ) \times conjg( op( A )' )] + \beta C \f]
+ * = CblasConjTrans: \f[ C = \alpha [ conjg( op( A )' ) \times op( B ) ] + conjg( \alpha ) [ conjg( op( B )' ) \times op( A ) ] + \beta C \f]
+ *
+ * @param[in] N
+ * N specifies the order of the matrix C. N must be at least zero.
+ *
+ * @param[in] K
+ * K specifies the number of columns of the A and B matrices with trans = CblasNoTrans.
+ * K specifies the number of rows of the A and B matrices with trans = CblasTrans.
+ *
+ * @param[in] alpha
+ * alpha specifies the scalar alpha.
+ *
+ * @param[in] A
+ * A is a LDA-by-ka matrix, where ka is K when trans = CblasNoTrans,
+ * and is N otherwise.
+ *
+ * @param[in] LDA
+ * The leading dimension of the array A. LDA must be at least
+ * max( 1, N ), otherwise LDA must be at least max( 1, K ).
+ *
+ * @param[in] B
+ * B is a LDB-by-kb matrix, where kb is K when trans = CblasNoTrans,
+ * and is N otherwise.
+ *
+ * @param[in] LDB
+ * The leading dimension of the array B. LDB must be at least
+ * max( 1, N ), otherwise LDB must be at least max( 1, K ).
+ *
+ * @param[in] beta
+ * beta specifies the scalar beta.
+ *
+ * @param[in,out] C
+ * C is a LDC-by-N matrix.
+ * On exit, the array uplo part of the matrix is overwritten
+ * by the uplo part of the updated matrix.
+ *
+ * @param[in] LDC
+ * The leading dimension of the array C. LDC >= max( 1, N ).
+ *
+ *******************************************************************************
+ *
+ * @sa CHAMELEON_cblas_zher2k
+ * @sa CHAMELEON_cblas_cher2k
+ * @sa CHAMELEON_cblas_dher2k
+ * @sa CHAMELEON_cblas_sher2k
+ *
+ */
+void CHAMELEON_cblas_zher2k( const CBLAS_ORDER order, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans,
+ const int N, const int K,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const CHAMELEON_Complex64_t *B, const int ldb,
+ const double beta, CHAMELEON_Complex64_t *C, const int ldc )
+{
+ if (order != CblasColMajor){
+ fprintf(stderr, "CHAMELEON ERROR: %s(): %s\n", "CHAMELEON_cblas_zher2k", "illegal value of order");
+ }
+
+#if defined(PRECISION_z) || defined(PRECISION_c)
+ CHAMELEON_Complex64_t alphac = *(CHAMELEON_Complex64_t *)alpha;
+#else
+ CHAMELEON_Complex64_t alphac = alpha;
+#endif
+
+ CHAMELEON_zher2k( (cham_uplo_t)uplo, (cham_trans_t)trans, N, K,
+ alphac, (CHAMELEON_Complex64_t *)A, lda,
+ (CHAMELEON_Complex64_t *)B, ldb,
+ beta, (CHAMELEON_Complex64_t *)C, ldc );
+}
diff --git a/lapack_api/src/lapack_zherk.c b/lapack_api/src/lapack_zherk.c
new file mode 100644
index 0000000000000000000000000000000000000000..67f7ab904e28c8e9d840d56dab7225812ecd7664
--- /dev/null
+++ b/lapack_api/src/lapack_zherk.c
@@ -0,0 +1,122 @@
+/**
+ *
+ * @file lapack_zherk.c
+ *
+ * @copyright 2022 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ * Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief Chameleon blas and cblas api for herk
+ *
+ * @version 1.2.0
+ * @author Mathieu Faverge
+ * @author Florent Pruvost
+ * @date 2022-08-19
+ * @precisions normal z -> c
+ *
+ */
+
+#include "chameleon_lapack.h"
+#include "lapack_api_common.h"
+
+/* Fortran BLAS interface */
+
+#define CHAMELEON_blas_zherk CHAMELEON_GLOBAL( chameleon_blas_zherk, CHAMELEON_BLAS_Zherk )
+void CHAMELEON_blas_zherk ( const char* uplo, const char* trans,
+ const int* n, const int* k,
+ const double* alpha, const CHAMELEON_Complex64_t* a, const int* lda,
+ const double* beta, CHAMELEON_Complex64_t* c, const int* ldc )
+{
+ CHAMELEON_cblas_zherk( CblasColMajor,
+ chameleon_blastocblas_uplo(uplo),
+ chameleon_blastocblas_trans(trans),
+ *n, *k,
+ *alpha, a, *lda,
+ *beta, c, *ldc );
+}
+
+/* C CBLAS interface */
+
+/**
+ ********************************************************************************
+ *
+ * @ingroup CHAMELEON_LAPACK_API
+ *
+ * CHAMELEON_cblas_zherk - Performs one of the hermitian rank k operations
+ *
+ * \f[ C = \alpha [ op( A ) \times conjg( op( A )' )] + \beta C \f],
+ *
+ * where op( X ) is one of
+ *
+ * op( X ) = X or op( X ) = conjg( X' )
+ *
+ * where alpha and beta are real scalars, C is an n-by-n hermitian
+ * matrix and A is an n-by-k matrix in the first case and a k-by-n
+ * matrix in the second case.
+ *
+ *******************************************************************************
+ *
+ * @param[in] order
+ * Specifies whether the matrices are row or column major, it must be
+ * set to CblasColMajor, the order supported in Chameleon.
+ *
+ * @param[in] uplo
+ * = CblasUpper: Upper triangle of C is stored;
+ * = CblasLower: Lower triangle of C is stored.
+ *
+ * @param[in] trans
+ * Specifies whether the matrix A is transposed or conjugate transposed:
+ * = CblasNoTrans: A is not transposed;
+ * = CblasConjTrans: A is conjugate transposed.
+ *
+ * @param[in] N
+ * N specifies the order of the matrix C. N must be at least zero.
+ *
+ * @param[in] K
+ * K specifies the number of columns of the matrix op( A ).
+ *
+ * @param[in] alpha
+ * alpha specifies the scalar alpha.
+ *
+ * @param[in] A
+ * A is a LDA-by-ka matrix, where ka is K when trans = CblasNoTrans,
+ * and is N otherwise.
+ *
+ * @param[in] LDA
+ * The leading dimension of the array A. LDA must be at least
+ * max( 1, N ) if trans == CblasNoTrans, otherwise LDA must
+ * be at least max( 1, K ).
+ *
+ * @param[in] beta
+ * beta specifies the scalar beta
+ *
+ * @param[in,out] C
+ * C is a LDC-by-N matrix.
+ * On exit, the array uplo part of the matrix is overwritten
+ * by the uplo part of the updated matrix.
+ *
+ * @param[in] LDC
+ * The leading dimension of the array C. LDC >= max( 1, N ).
+ *
+ *******************************************************************************
+ *
+ * @sa CHAMELEON_cblas_zherk
+ * @sa CHAMELEON_cblas_cherk
+ * @sa CHAMELEON_cblas_dherk
+ * @sa CHAMELEON_cblas_sherk
+ *
+ */
+void CHAMELEON_cblas_zherk( const CBLAS_ORDER order, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans,
+ const int N, const int K,
+ const double alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const double beta, CHAMELEON_Complex64_t *C, const int ldc )
+{
+ if (order != CblasColMajor){
+ fprintf(stderr, "CHAMELEON ERROR: %s(): %s\n", "CHAMELEON_cblas_zherk", "illegal value of order");
+ }
+
+ CHAMELEON_zherk( (cham_uplo_t)uplo, (cham_trans_t)trans, N, K,
+ alpha, (CHAMELEON_Complex64_t *)A, lda,
+ beta, (CHAMELEON_Complex64_t *)C, ldc );
+}
diff --git a/lapack_api/src/lapack_zlauum.c b/lapack_api/src/lapack_zlauum.c
new file mode 100644
index 0000000000000000000000000000000000000000..a0a3f2d243ea1c97d9279049c71ea6cbe7543056
--- /dev/null
+++ b/lapack_api/src/lapack_zlauum.c
@@ -0,0 +1,96 @@
+/**
+ *
+ * @file lapack_zlauum.c
+ *
+ * @copyright 2022 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ * Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief Chameleon lapack and lapacke api for lauum
+ *
+ * @version 1.2.0
+ * @author Mathieu Faverge
+ * @author Florent Pruvost
+ * @date 2022-08-19
+ * @precisions normal z -> s d c
+ *
+ */
+
+#include "chameleon_lapack.h"
+#include "lapack_api_common.h"
+
+/* Fortran LAPACK interface */
+
+#define CHAMELEON_lapack_zlauum CHAMELEON_GLOBAL( chameleon_lapack_zlauum, CHAMELEON_BLAS_Zlauum )
+void CHAMELEON_lapack_zlauum ( const char* uplo, const int* n,
+ CHAMELEON_Complex64_t* a, const int* lda,
+ int* info )
+{
+ *info = CHAMELEON_lapacke_zlauum( CblasColMajor,
+ *uplo, *n, a, *lda );
+}
+
+/* C CBLAS interface */
+
+/**
+ ********************************************************************************
+ *
+ * @ingroup CHAMELEON_LAPACK_API
+ *
+ * CHAMELEON_lapacke_zlauum - Computes the product U * U' or L' * L, where the triangular
+ * factor U or L is stored in the upper or lower triangular part of
+ * the array A.
+ *
+ * If UPLO = 'U' or 'u' then the upper triangle of the result is stored,
+ * overwriting the factor U in A.
+ * If UPLO = 'L' or 'l' then the lower triangle of the result is stored,
+ * overwriting the factor L in A.
+ *
+ *******************************************************************************
+ *
+ * @param[in] matrix_layout
+ * Specifies whether the matrices are row or column major, it must be
+ * set to LAPACK_COL_MAJOR or CblasColMajor (102), the matrix_layout
+ * supported in Chameleon.
+ *
+ * @param[in] uplo
+ * = 'U' or 'u': Upper triangular
+ * = 'L' or 'l': Lower triangular
+ *
+ * @param[in] N
+ * The order of the triangular factor U or L. N >= 0.
+ *
+ * @param[in,out] A
+ * On entry, the triangular factor U or L.
+ * On exit, if UPLO = 'U', the upper triangle of A is
+ * overwritten with the upper triangle of the product U * U';
+ * if UPLO = 'L', the lower triangle of A is overwritten with
+ * the lower triangle of the product L' * L.
+ *
+ * @param[in] LDA
+ * The leading dimension of the array A. LDA >= max(1,N).
+ *
+ *******************************************************************************
+ *
+ * @retval =0 successful exit
+ * @retval <0 if -i, the i-th argument had an illegal value
+ *
+ *******************************************************************************
+ *
+ * @sa CHAMELEON_lapacke_zlauum
+ * @sa CHAMELEON_lapacke_clauum
+ * @sa CHAMELEON_lapacke_dlauum
+ * @sa CHAMELEON_lapacke_slauum
+ *
+ */
+int CHAMELEON_lapacke_zlauum( int matrix_layout, char uplo, int N,
+ CHAMELEON_Complex64_t *A, int lda )
+{
+ if (matrix_layout != CblasColMajor){
+ fprintf(stderr, "CHAMELEON ERROR: %s(): %s\n", "CHAMELEON_lapacke_zlauum", "illegal value of matrix_layout");
+ }
+
+ return CHAMELEON_zlauum( (cham_uplo_t)chameleon_blastocblas_uplo(&uplo), N,
+ (CHAMELEON_Complex64_t *)A, lda );
+}
diff --git a/lapack_api/src/lapack_zsymm.c b/lapack_api/src/lapack_zsymm.c
index 1f5985406e2ef3085feb98d5f69c0b59a5f327a2..410eac0f14be18405afdacc008392161e68ce4c6 100644
--- a/lapack_api/src/lapack_zsymm.c
+++ b/lapack_api/src/lapack_zsymm.c
@@ -58,22 +58,22 @@ void CHAMELEON_blas_zsymm ( const char* side, const char* uplo,
*
*******************************************************************************
*
- * @param[in] Order
+ * @param[in] order
* Specifies whether the matrices are row or column major, it must be
* set to CblasColMajor, the order supported in Chameleon.
*
- * @param[in] Side
+ * @param[in] side
* Specifies whether the symmetric matrix A appears on the
* left or right in the operation as follows:
- * = ChamLeft: \f[ C = \alpha \times A \times B + \beta \times C \f]
- * = ChamRight: \f[ C = \alpha \times B \times A + \beta \times C \f]
+ * = CblasLeft: \f[ C = \alpha \times A \times B + \beta \times C \f]
+ * = CblasRight: \f[ C = \alpha \times B \times A + \beta \times C \f]
*
- * @param[in] Uplo
+ * @param[in] uplo
* Specifies whether the upper or lower triangular part of
* the symmetric matrix A is to be referenced as follows:
- * = ChamLower: Only the lower triangular part of the
+ * = CblasLower: Only the lower triangular part of the
* symmetric matrix A is to be referenced.
- * = ChamUpper: Only the upper triangular part of the
+ * = CblasUpper: Only the upper triangular part of the
* symmetric matrix A is to be referenced.
*
* @param[in] M
@@ -86,7 +86,7 @@ void CHAMELEON_blas_zsymm ( const char* side, const char* uplo,
* Specifies the scalar alpha.
*
* @param[in] A
- * A is a LDA-by-ka matrix, where ka is M when side = ChamLeft,
+ * A is a LDA-by-ka matrix, where ka is M when side = CblasLeft,
* and is N otherwise. Only the uplo triangular part is referenced.
*
* @param[in] LDA
@@ -117,13 +117,13 @@ void CHAMELEON_blas_zsymm ( const char* side, const char* uplo,
* @sa CHAMELEON_cblas_ssymm
*
*/
-void CHAMELEON_cblas_zsymm( const CBLAS_ORDER Order, const CBLAS_SIDE Side, const CBLAS_UPLO Uplo,
+void CHAMELEON_cblas_zsymm( const CBLAS_ORDER order, const CBLAS_SIDE side, const CBLAS_UPLO uplo,
const int M, const int N,
const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
const CHAMELEON_Complex64_t *B, const int ldb,
const void *beta, CHAMELEON_Complex64_t *C, const int ldc )
{
- if (Order != CblasColMajor){
+ if (order != CblasColMajor){
fprintf(stderr, "CHAMELEON ERROR: %s(): %s\n", "CHAMELEON_cblas_zsymm", "illegal value of order");
}
@@ -135,7 +135,7 @@ void CHAMELEON_cblas_zsymm( const CBLAS_ORDER Order, const CBLAS_SIDE Side, cons
CHAMELEON_Complex64_t betac = beta;
#endif
- CHAMELEON_zsymm( (cham_side_t)Side, (cham_uplo_t)Uplo, M, N,
+ CHAMELEON_zsymm( (cham_side_t)side, (cham_uplo_t)uplo, M, N,
alphac, (CHAMELEON_Complex64_t *)A, lda,
(CHAMELEON_Complex64_t *)B, ldb,
betac, (CHAMELEON_Complex64_t *)C, ldc );
diff --git a/lapack_api/src/lapack_zsyr2k.c b/lapack_api/src/lapack_zsyr2k.c
new file mode 100644
index 0000000000000000000000000000000000000000..a25540b32e224f032eb7268492ee832651f6ac9e
--- /dev/null
+++ b/lapack_api/src/lapack_zsyr2k.c
@@ -0,0 +1,140 @@
+/**
+ *
+ * @file lapack_zsyr2k.c
+ *
+ * @copyright 2022 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ * Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief Chameleon blas and cblas api for syr2k
+ *
+ * @version 1.2.0
+ * @author Mathieu Faverge
+ * @author Florent Pruvost
+ * @date 2022-08-19
+ * @precisions normal z -> s d c
+ *
+ */
+
+#include "chameleon_lapack.h"
+#include "lapack_api_common.h"
+
+/* Fortran BLAS interface */
+
+#define CHAMELEON_blas_zsyr2k CHAMELEON_GLOBAL( chameleon_blas_zsyr2k, CHAMELEON_BLAS_Zsyr2k )
+void CHAMELEON_blas_zsyr2k ( const char* uplo, const char* trans,
+ const int* n, const int* k,
+ const CHAMELEON_Complex64_t* alpha, const CHAMELEON_Complex64_t* a, const int* lda,
+ const CHAMELEON_Complex64_t* b, const int* ldb,
+ const CHAMELEON_Complex64_t* beta, CHAMELEON_Complex64_t* c, const int* ldc )
+{
+ CHAMELEON_cblas_zsyr2k( CblasColMajor,
+ chameleon_blastocblas_uplo(uplo),
+ chameleon_blastocblas_trans(trans),
+ *n, *k,
+ CBLAS_SADDR(*alpha), a, *lda,
+ b, *ldb,
+ CBLAS_SADDR(*beta), c, *ldc );
+}
+
+/* C CBLAS interface */
+
+/**
+ ********************************************************************************
+ *
+ * @ingroup CHAMELEON_LAPACK_API
+ *
+ * CHAMELEON_cblas_zsyr2k - Performs one of the symmetric rank 2k operations
+ *
+ * \f[ C = \alpha [ A \times B' ] + \alpha [ B \times A' ] + \beta C \f],
+ * or
+ * \f[ C = \alpha [ A' \times B ] + \alpha [ B' \times A ] + \beta C \f],
+ *
+ * where alpha and beta are real scalars, C is an n-by-n symmetric
+ * matrix and A and B are an n-by-k matrices the first case and k-by-n
+ * matrices in the second case.
+ *
+ *******************************************************************************
+ *
+ * @param[in] order
+ * Specifies whether the matrices are row or column major, it must be
+ * set to CblasColMajor, the order supported in Chameleon.
+ *
+ * @param[in] uplo
+ * = CblasUpper: Upper triangle of C is stored;
+ * = CblasLower: Lower triangle of C is stored.
+ *
+ * @param[in] trans
+ * Specifies the operation to be performed as follows:
+ * = CblasNoTrans: \f[ C = \alpha [ A \times B' ] + \alpha [ B \times A' ] + \beta C \f]
+ * = CblasTrans: \f[ C = \alpha [ A' \times B ] + \alpha [ B' \times A ] + \beta C \f]
+ *
+ * @param[in] N
+ * N specifies the order of the matrix C. N must be at least zero.
+ *
+ * @param[in] K
+ * K specifies the number of columns of the A and B matrices with trans = CblasNoTrans.
+ * K specifies the number of rows of the A and B matrices with trans = CblasTrans.
+ *
+ * @param[in] alpha
+ * alpha specifies the scalar alpha.
+ *
+ * @param[in] A
+ * A is a LDA-by-ka matrix, where ka is K when trans = CblasNoTrans,
+ * and is N otherwise.
+ *
+ * @param[in] LDA
+ * The leading dimension of the array A. LDA must be at least
+ * max( 1, N ), otherwise LDA must be at least max( 1, K ).
+ *
+ * @param[in] B
+ * B is a LDB-by-kb matrix, where kb is K when trans = CblasNoTrans,
+ * and is N otherwise.
+ *
+ * @param[in] LDB
+ * The leading dimension of the array B. LDB must be at least
+ * max( 1, N ), otherwise LDB must be at least max( 1, K ).
+ *
+ * @param[in] beta
+ * beta specifies the scalar beta.
+ *
+ * @param[in,out] C
+ * C is a LDC-by-N matrix.
+ * On exit, the array uplo part of the matrix is overwritten
+ * by the uplo part of the updated matrix.
+ *
+ * @param[in] LDC
+ * The leading dimension of the array C. LDC >= max( 1, N ).
+ *
+ *******************************************************************************
+ *
+ * @sa CHAMELEON_cblas_zsyr2k
+ * @sa CHAMELEON_cblas_csyr2k
+ * @sa CHAMELEON_cblas_dsyr2k
+ * @sa CHAMELEON_cblas_ssyr2k
+ *
+ */
+void CHAMELEON_cblas_zsyr2k( const CBLAS_ORDER order, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans,
+ const int N, const int K,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const CHAMELEON_Complex64_t *B, const int ldb,
+ const void *beta, CHAMELEON_Complex64_t *C, const int ldc )
+{
+ if (order != CblasColMajor){
+ fprintf(stderr, "CHAMELEON ERROR: %s(): %s\n", "CHAMELEON_cblas_zsyr2k", "illegal value of order");
+ }
+
+#if defined(PRECISION_z) || defined(PRECISION_c)
+ CHAMELEON_Complex64_t alphac = *(CHAMELEON_Complex64_t *)alpha;
+ CHAMELEON_Complex64_t betac = *(CHAMELEON_Complex64_t *)beta;
+#else
+ CHAMELEON_Complex64_t alphac = alpha;
+ CHAMELEON_Complex64_t betac = beta;
+#endif
+
+ CHAMELEON_zsyr2k( (cham_uplo_t)uplo, (cham_trans_t)trans, N, K,
+ alphac, (CHAMELEON_Complex64_t *)A, lda,
+ (CHAMELEON_Complex64_t *)B, ldb,
+ betac, (CHAMELEON_Complex64_t *)C, ldc );
+}
diff --git a/lapack_api/src/lapack_zsyrk.c b/lapack_api/src/lapack_zsyrk.c
new file mode 100644
index 0000000000000000000000000000000000000000..374cc319351edfa27ead0732714ed6b79aae63a9
--- /dev/null
+++ b/lapack_api/src/lapack_zsyrk.c
@@ -0,0 +1,128 @@
+/**
+ *
+ * @file lapack_zsyrk.c
+ *
+ * @copyright 2022 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ * Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief Chameleon blas and cblas api for syrk
+ *
+ * @version 1.2.0
+ * @author Mathieu Faverge
+ * @author Florent Pruvost
+ * @date 2022-08-19
+ * @precisions normal z -> s d c
+ *
+ */
+
+#include "chameleon_lapack.h"
+#include "lapack_api_common.h"
+
+/* Fortran BLAS interface */
+
+#define CHAMELEON_blas_zsyrk CHAMELEON_GLOBAL( chameleon_blas_zsyrk, CHAMELEON_BLAS_Zsyrk )
+void CHAMELEON_blas_zsyrk ( const char* uplo, const char* trans,
+ const int* n, const int* k,
+ const CHAMELEON_Complex64_t* alpha, const CHAMELEON_Complex64_t* a, const int* lda,
+ const CHAMELEON_Complex64_t* beta, CHAMELEON_Complex64_t* c, const int* ldc )
+{
+ CHAMELEON_cblas_zsyrk( CblasColMajor,
+ chameleon_blastocblas_uplo(uplo),
+ chameleon_blastocblas_trans(trans),
+ *n, *k,
+ CBLAS_SADDR(*alpha), a, *lda,
+ CBLAS_SADDR(*beta), c, *ldc );
+}
+
+/* C CBLAS interface */
+
+/**
+ ********************************************************************************
+ *
+ * @ingroup CHAMELEON_LAPACK_API
+ *
+ * CHAMELEON_cblas_zsyrk - Performs one of the symmetric rank k operations
+ *
+ * \f[ C = \alpha [ A \times A' ] + \beta C \f]
+ * or
+ * \f[ C = \alpha [ A' \times A ] + \beta C \f]
+ *
+ * where alpha and beta are real scalars, C is an n-by-n symmetric
+ * matrix and A is an n-by-k matrix in the first case and a k-by-n
+ * matrix in the second case.
+ *
+ *******************************************************************************
+ *
+ * @param[in] order
+ * Specifies whether the matrices are row or column major, it must be
+ * set to CblasColMajor, the order supported in Chameleon.
+ *
+ * @param[in] uplo
+ * = CblasUpper: Upper triangle of C is stored;
+ * = CblasLower: Lower triangle of C is stored.
+ *
+ * @param[in] trans
+ * Specifies the operation to be performed as follows:
+ * = CblasNoTrans: \f[ C = \alpha [ A \times A' ] + \beta C \f]
+ * = CblasTrans: \f[ C = \alpha [ A' \times A ] + \beta C \f]
+ *
+ * @param[in] N
+ * N specifies the order of the matrix C. N must be at least zero.
+ *
+ * @param[in] K
+ * K specifies the number of columns of the matrix A.
+ *
+ * @param[in] alpha
+ * alpha specifies the scalar alpha.
+ *
+ * @param[in] A
+ * A is a LDA-by-ka matrix, where ka is K when trans = CblasNoTrans,
+ * and is N otherwise.
+ *
+ * @param[in] LDA
+ * The leading dimension of the array A. LDA must be at least
+ * max( 1, N ) if trans == CblasNoTrans, otherwise LDA must
+ * be at least max( 1, K ).
+ *
+ * @param[in] beta
+ * beta specifies the scalar beta
+ *
+ * @param[in,out] C
+ * C is a LDC-by-N matrix.
+ * On exit, the array uplo part of the matrix is overwritten
+ * by the uplo part of the updated matrix.
+ *
+ * @param[in] LDC
+ * The leading dimension of the array C. LDC >= max( 1, N ).
+ *
+ *******************************************************************************
+ *
+ * @sa CHAMELEON_cblas_zsyrk
+ * @sa CHAMELEON_cblas_csyrk
+ * @sa CHAMELEON_cblas_dsyrk
+ * @sa CHAMELEON_cblas_ssyrk
+ *
+ */
+void CHAMELEON_cblas_zsyrk( const CBLAS_ORDER order, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans,
+ const int N, const int K,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const void *beta, CHAMELEON_Complex64_t *C, const int ldc )
+{
+ if (order != CblasColMajor){
+ fprintf(stderr, "CHAMELEON ERROR: %s(): %s\n", "CHAMELEON_cblas_zsyrk", "illegal value of order");
+ }
+
+#if defined(PRECISION_z) || defined(PRECISION_c)
+ CHAMELEON_Complex64_t alphac = *(CHAMELEON_Complex64_t *)alpha;
+ CHAMELEON_Complex64_t betac = *(CHAMELEON_Complex64_t *)beta;
+#else
+ CHAMELEON_Complex64_t alphac = alpha;
+ CHAMELEON_Complex64_t betac = beta;
+#endif
+
+ CHAMELEON_zsyrk( (cham_uplo_t)uplo, (cham_trans_t)trans, N, K,
+ alphac, (CHAMELEON_Complex64_t *)A, lda,
+ betac, (CHAMELEON_Complex64_t *)C, ldc );
+}
diff --git a/lapack_api/src/lapack_ztrmm.c b/lapack_api/src/lapack_ztrmm.c
new file mode 100644
index 0000000000000000000000000000000000000000..2811813d11cff49a3a0637ae62216a4e2a04590f
--- /dev/null
+++ b/lapack_api/src/lapack_ztrmm.c
@@ -0,0 +1,136 @@
+/**
+ *
+ * @file lapack_ztrmm.c
+ *
+ * @copyright 2022 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ * Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief Chameleon blas and cblas api for trmm
+ *
+ * @version 1.2.0
+ * @author Mathieu Faverge
+ * @author Florent Pruvost
+ * @date 2022-08-18
+ * @precisions normal z -> s d c
+ *
+ */
+
+#include "chameleon_lapack.h"
+#include "lapack_api_common.h"
+
+/* Fortran BLAS interface */
+
+#define CHAMELEON_blas_ztrmm CHAMELEON_GLOBAL( chameleon_blas_ztrmm, CHAMELEON_BLAS_Ztrmm )
+void CHAMELEON_blas_ztrmm ( const char* side, const char* uplo,
+ const char* trans, const char* diag,
+ const int* m, const int* n,
+ const CHAMELEON_Complex64_t* alpha, const CHAMELEON_Complex64_t* a, const int* lda,
+ const CHAMELEON_Complex64_t* b, const int* ldb )
+{
+ CHAMELEON_cblas_ztrmm( CblasColMajor,
+ chameleon_blastocblas_side(side),
+ chameleon_blastocblas_uplo(uplo),
+ chameleon_blastocblas_side(trans),
+ chameleon_blastocblas_diag(diag),
+ *m, *n,
+ CBLAS_SADDR(*alpha), a, *lda,
+ b, *ldb );
+}
+
+/* C CBLAS interface */
+
+/**
+ ********************************************************************************
+ *
+ * @ingroup CHAMELEON_LAPACK_API
+ *
+ * CHAMELEON_cblas_ztrmm - Computes B = alpha*op( A )*B or B = alpha*B*op( A ).
+ *
+ *******************************************************************************
+ *
+ * @param[in] order
+ * Specifies whether the matrices are row or column major, it must be
+ * set to CblasColMajor, the order supported in Chameleon.
+ *
+ * @param[in] side
+ * Specifies whether A appears on the left or on the right of X:
+ * = CblasLeft: A*X = B
+ * = CblasRight: X*A = B
+ *
+ * @param[in] uplo
+ * Specifies whether the matrix A is upper triangular or lower triangular:
+ * = CblasUpper: Upper triangle of A is stored;
+ * = CblasLower: Lower triangle of A is stored.
+ *
+ * @param[in] trans
+ * Specifies whether the matrix A is transposed, not transposed or conjugate transposed:
+ * = CblasNoTrans: A is transposed;
+ * = CblasTrans: A is not transposed;
+ * = CblasConjTrans: A is conjugate transposed.
+ *
+ * @param[in] diag
+ * Specifies whether or not A is unit triangular:
+ * = CblasNonUnit: A is non unit;
+ * = CblasUnit: A us unit.
+ *
+ * @param[in] N
+ * The order of the matrix A. N >= 0.
+ *
+ * @param[in] NRHS
+ * The number of right hand sides, i.e., the number of columns of the matrix B if side = CblasLeft or
+ * the number of rows of the matrix B if side = CblasRight. NRHS >= 0.
+ *
+ * @param[in] alpha
+ * alpha specifies the scalar alpha.
+ *
+ * @param[in] A
+ * The triangular matrix A. If uplo = CblasUpper, the leading N-by-N upper triangular
+ * part of the array A contains the upper triangular matrix, and the strictly lower
+ * triangular part of A is not referenced. If uplo = CblasLower, the leading N-by-N
+ * lower triangular part of the array A contains the lower triangular matrix, and the
+ * strictly upper triangular part of A is not referenced. If diag = CblasUnit, the
+ * diagonal elements of A are also not referenced and are assumed to be 1.
+ *
+ * @param[in] LDA
+ * The leading dimension of the array A. LDA >= max(1,N).
+ *
+ * @param[in,out] B
+ * On entry, the N-by-NRHS right hand side matrix B.
+ * On exit, if return value = 0, the N-by-NRHS solution matrix X if side = CblasLeft
+ * or the NRHS-by-N matrix X if side = CblasRight.
+ *
+ * @param[in] LDB
+ * The leading dimension of the array B. LDB >= max(1,N).
+ *
+ *******************************************************************************
+ *
+ * @sa CHAMELEON_cblas_ztrmm
+ * @sa CHAMELEON_cblas_ctrmm
+ * @sa CHAMELEON_cblas_dtrmm
+ * @sa CHAMELEON_cblas_strmm
+ *
+ */
+void CHAMELEON_cblas_ztrmm( const CBLAS_ORDER order, const CBLAS_SIDE side, const CBLAS_UPLO uplo,
+ const CBLAS_TRANSPOSE trans, const CBLAS_DIAG diag,
+ const int M, const int N,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const CHAMELEON_Complex64_t *B, const int ldb )
+{
+ if (order != CblasColMajor){
+ fprintf(stderr, "CHAMELEON ERROR: %s(): %s\n", "CHAMELEON_cblas_ztrmm", "illegal value of order");
+ }
+
+#if defined(PRECISION_z) || defined(PRECISION_c)
+ CHAMELEON_Complex64_t alphac = *(CHAMELEON_Complex64_t *)alpha;
+#else
+ CHAMELEON_Complex64_t alphac = alpha;
+#endif
+
+ CHAMELEON_ztrmm( (cham_side_t)side, (cham_uplo_t)uplo,
+ (cham_trans_t)trans, (cham_diag_t)diag,
+ M, N,
+ alphac, (CHAMELEON_Complex64_t *)A, lda,
+ (CHAMELEON_Complex64_t *)B, ldb );
+}
diff --git a/lapack_api/src/lapack_ztrsm.c b/lapack_api/src/lapack_ztrsm.c
new file mode 100644
index 0000000000000000000000000000000000000000..30aa75eaa8fb217cd36b3cf73ba0b297551bb653
--- /dev/null
+++ b/lapack_api/src/lapack_ztrsm.c
@@ -0,0 +1,156 @@
+/**
+ *
+ * @file lapack_ztrsm.c
+ *
+ * @copyright 2022 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ * Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief Chameleon blas and cblas api for trsm
+ *
+ * @version 1.2.0
+ * @author Mathieu Faverge
+ * @author Florent Pruvost
+ * @date 2022-08-19
+ * @precisions normal z -> s d c
+ *
+ */
+
+#include "chameleon_lapack.h"
+#include "lapack_api_common.h"
+
+/* Fortran BLAS interface */
+
+#define CHAMELEON_blas_ztrsm CHAMELEON_GLOBAL( chameleon_blas_ztrsm, CHAMELEON_BLAS_Ztrsm )
+void CHAMELEON_blas_ztrsm ( const char* side, const char* uplo,
+ const char* trans, const char* diag,
+ const int* m, const int* n,
+ const CHAMELEON_Complex64_t* alpha, const CHAMELEON_Complex64_t* a, const int* lda,
+ const CHAMELEON_Complex64_t* b, const int* ldb )
+{
+ CHAMELEON_cblas_ztrsm( CblasColMajor,
+ chameleon_blastocblas_side(side),
+ chameleon_blastocblas_uplo(uplo),
+ chameleon_blastocblas_side(trans),
+ chameleon_blastocblas_diag(diag),
+ *m, *n,
+ CBLAS_SADDR(*alpha), a, *lda,
+ b, *ldb );
+}
+
+/* C CBLAS interface */
+
+/**
+ ********************************************************************************
+ *
+ * @ingroup CHAMELEON_LAPACK_API
+ *
+ * CHAMELEON_cblas_ztrsm - Solves one of the matrix equations
+ * op( A )*X = alpha*B, or X*op( A ) = alpha*B,
+ *
+ * where alpha is a scalar, X and B are m by n matrices, A is a unit, or
+ * non-unit, upper or lower triangular matrix and op( A ) is one of
+ *
+ * op( A ) = A or op( A ) = A**T or op( A ) = A**H.
+ *
+ * The matrix X is overwritten on B.
+ *
+ *******************************************************************************
+ *
+ * @param[in] order
+ * Specifies whether the matrices are row or column major, it must be
+ * set to CblasColMajor, the order supported in Chameleon.
+ *
+ * @param[in] side
+ * Specifies whether op(A) appears on the left or on the right of X:
+ * = CblasLeft: op(A) * X = B
+ * = CblasRight: X * op(A) = B
+ *
+ * @param[in] uplo
+ * Specifies whether the matrix A is upper triangular or lower triangular:
+ * = CblasUpper: A is an upper triangular matrix.
+ * = CblasLower: A is a lower triangular matrix.
+ *
+ * @param[in] trans
+ * Specifies the form of op( A ) to be used in the matrix
+ * multiplication as follows:
+ * = CblasNoTrans: op( A ) = A.
+ * = CblasTrans: op( A ) = A**T.
+ * = CblasConjTrans: op( A ) = A**H.
+ *
+ * @param[in] diag
+ * Specifies whether or not A is unit triangular:
+ * = CblasNonUnit: A is assumed to be unit triangular.
+ * = CblasUnit: A is not assumed to be unit triangular.
+ *
+ * @param[in] M
+ * M specifies the number of rows of B. M must be at least zero.
+ *
+ * @param[in] N
+ * N specifies the number of columns of B. N must be at least zero.
+ *
+ * @param[in] alpha
+ * alpha specifies the scalar alpha. When alpha is zero then A is not
+ * referenced and B need not be set before entry.
+ *
+ * @param[in] A
+ * The triangular matrix A of dimension lda-by-k,
+ * where k is M when side = CblasLeft
+ * and k is N when side = CblasRight
+ * Before entry with uplo = CblasUpper, the leading k-by-k upper
+ * triangular part of the array A must contain the upper triangular
+ * matrix and the strictly lower triangular part of A is not
+ * referenced.
+ * Before entry with uplo = CblasLower, the leading k-by-k lower
+ * triangular part of the array A must contain the lower triangular
+ * matrix and the strictly upper triangular part of A is not
+ * referenced.
+ * Note that when diag = CblasUnit, the diagonal elements of A are not
+ * referenced either, but are assumed to be unity.
+ *
+ * @param[in] LDA
+ * LDA specifies the first dimension of A. When side = CblasLeft then
+ * LDA must be at least max( 1, M ), when side = CblasRight then LDA
+ * must be at least max( 1, N ).
+ *
+ * @param[in,out] B
+ * The matrix B of dimension LDB-by-N.
+ * Before entry, the leading m by n part of the array B must contain
+ * the right-hand side matrix B, and on exit is overwritten by the
+ * solution matrix X.
+ *
+ * @param[in] LDB
+ * LDB specifies the first dimension of B. LDB must be at least
+ * max( 1, M ).
+ *
+ *******************************************************************************
+ *
+ * @sa CHAMELEON_cblas_ztrsm
+ * @sa CHAMELEON_cblas_ctrsm
+ * @sa CHAMELEON_cblas_dtrsm
+ * @sa CHAMELEON_cblas_strsm
+ *
+ */
+void CHAMELEON_cblas_ztrsm( const CBLAS_ORDER order, const CBLAS_SIDE side, const CBLAS_UPLO uplo,
+ const CBLAS_TRANSPOSE trans, const CBLAS_DIAG diag,
+ const int M, const int N,
+ const void *alpha, const CHAMELEON_Complex64_t *A, const int lda,
+ const CHAMELEON_Complex64_t *B, const int ldb )
+{
+ if (order != CblasColMajor){
+ fprintf(stderr, "CHAMELEON ERROR: %s(): %s\n", "CHAMELEON_cblas_ztrsm", "illegal value of order");
+ }
+
+#if defined(PRECISION_z) || defined(PRECISION_c)
+ CHAMELEON_Complex64_t alphac = *(CHAMELEON_Complex64_t *)alpha;
+#else
+ CHAMELEON_Complex64_t alphac = alpha;
+#endif
+
+ CHAMELEON_ztrsm( (cham_side_t)side, (cham_uplo_t)uplo,
+ (cham_trans_t)trans, (cham_diag_t)diag,
+ M, N,
+ alphac, (CHAMELEON_Complex64_t *)A, lda,
+ (CHAMELEON_Complex64_t *)B, ldb );
+}
diff --git a/testing/testing_zhemm.c b/testing/testing_zhemm.c
index 6b1c25699cea21661747ce437c814675422b79f7..f653fa17afe17119ced290d3c0dd992c5e3c46f6 100644
--- a/testing/testing_zhemm.c
+++ b/testing/testing_zhemm.c
@@ -127,6 +127,7 @@ testing_zhemm_std( run_arg_list_t *args, int check )
int hres = 0;
/* Read arguments */
+ int api = parameters_getvalue_int( "api" );
int nb = run_arg_get_int( args, "nb", 320 );
cham_side_t side = run_arg_get_side( args, "side", ChamLeft );
cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
@@ -173,7 +174,21 @@ testing_zhemm_std( run_arg_list_t *args, int check )
testing_stop( &test_data, flops_zhemm( side, M, N ) );
#else
testing_start( &test_data );
- hres = CHAMELEON_zhemm( side, uplo, M, N, alpha, A, LDA, B, LDB, beta, C, LDC );
+ switch ( api ) {
+ case 1:
+ hres = CHAMELEON_zhemm( side, uplo, M, N, alpha, A, LDA, B, LDB, beta, C, LDC );
+ break;
+ case 2:
+ CHAMELEON_cblas_zhemm( CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo, M, N,
+ CBLAS_SADDR(alpha), A, LDA, B, LDB, CBLAS_SADDR(beta), C, LDC );
+ break;
+ default:
+ if ( CHAMELEON_Comm_rank() == 0 ) {
+ fprintf( stderr,
+ "SKIPPED: This function can only be used with the option --api 1 or --api 2.\n" );
+ }
+ return -1;
+ }
test_data.hres = hres;
testing_stop( &test_data, flops_zhemm( side, M, N ) );
diff --git a/testing/testing_zher2k.c b/testing/testing_zher2k.c
index 52f9b7e850aa180ddd6a0663d6d093293d0f4953..877dc5e2a10cf9556c3692702c9a1bcb0e6c4845 100644
--- a/testing/testing_zher2k.c
+++ b/testing/testing_zher2k.c
@@ -129,6 +129,7 @@ testing_zher2k_std( run_arg_list_t *args, int check )
int hres = 0;
/* Read arguments */
+ int api = parameters_getvalue_int( "api" );
int nb = run_arg_get_int( args, "nb", 320 );
cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
@@ -186,7 +187,21 @@ testing_zher2k_std( run_arg_list_t *args, int check )
testing_stop( &test_data, flops_zher2k( K, N ) );
#else
testing_start( &test_data );
- hres = CHAMELEON_zher2k( uplo, trans, N, K, alpha, A, LDA, B, LDB, beta, C, LDC );
+ switch ( api ) {
+ case 1:
+ hres = CHAMELEON_zher2k( uplo, trans, N, K, alpha, A, LDA, B, LDB, beta, C, LDC );
+ break;
+ case 2:
+ CHAMELEON_cblas_zher2k( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans, N, K,
+ CBLAS_SADDR(alpha), A, LDA, B, LDB, beta, C, LDC );
+ break;
+ default:
+ if ( CHAMELEON_Comm_rank() == 0 ) {
+ fprintf( stderr,
+ "SKIPPED: This function can only be used with the option --api 1 or --api 2.\n" );
+ }
+ return -1;
+ }
test_data.hres = hres;
testing_stop( &test_data, flops_zher2k( K, N ) );
diff --git a/testing/testing_zherk.c b/testing/testing_zherk.c
index 6dc56c2de270d11b738423131f2c18c046311107..d17ccc4265d1cff5da6d5069a19850a793ef9cc4 100644
--- a/testing/testing_zherk.c
+++ b/testing/testing_zherk.c
@@ -122,6 +122,7 @@ testing_zherk_std( run_arg_list_t *args, int check )
int hres = 0;
/* Read arguments */
+ int api = parameters_getvalue_int( "api" );
int nb = run_arg_get_int( args, "nb", 320 );
cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
@@ -172,7 +173,21 @@ testing_zherk_std( run_arg_list_t *args, int check )
testing_stop( &test_data, flops_zherk( N, K ) );
#else
testing_start( &test_data );
- hres = CHAMELEON_zherk( uplo, trans, N, K, alpha, A, LDA, beta, C, LDC );
+ switch ( api ) {
+ case 1:
+ hres = CHAMELEON_zherk( uplo, trans, N, K, alpha, A, LDA, beta, C, LDC );
+ break;
+ case 2:
+ CHAMELEON_cblas_zherk( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans, N, K,
+ alpha, A, LDA, beta, C, LDC );
+ break;
+ default:
+ if ( CHAMELEON_Comm_rank() == 0 ) {
+ fprintf( stderr,
+ "SKIPPED: This function can only be used with the option --api 1 or --api 2.\n" );
+ }
+ return -1;
+ }
test_data.hres = hres;
testing_stop( &test_data, flops_zherk( N, K ) );
diff --git a/testing/testing_zlauum.c b/testing/testing_zlauum.c
index 71859dbcd40f5dc79eb7bcf3b60d5c5ba3a653d9..8150747b59c624275a798facd30b6a5392b20d1d 100644
--- a/testing/testing_zlauum.c
+++ b/testing/testing_zlauum.c
@@ -21,6 +21,7 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#include <coreblas.h>
static cham_fixdbl_t
flops_zlauum( int N )
@@ -91,6 +92,7 @@ testing_zlauum_std( run_arg_list_t *args, int check )
int hres = 0;
/* Read arguments */
+ int api = parameters_getvalue_int( "api" );
int nb = run_arg_get_int( args, "nb", 320 );
cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
int N = run_arg_get_int( args, "N", 1000 );
@@ -110,7 +112,20 @@ testing_zlauum_std( run_arg_list_t *args, int check )
/* Calculates the matrix product */
testing_start( &test_data );
- hres = CHAMELEON_zlauum( uplo, N, A, LDA );
+ switch ( api ) {
+ case 1:
+ hres = CHAMELEON_zlauum( uplo, N, A, LDA );
+ break;
+ case 2:
+ CHAMELEON_lapacke_zlauum( CblasColMajor, chameleon_lapack_const(uplo), N, A, LDA );
+ break;
+ default:
+ if ( CHAMELEON_Comm_rank() == 0 ) {
+ fprintf( stderr,
+ "SKIPPED: This function can only be used with the option --api 1 or --api 2.\n" );
+ }
+ return -1;
+ }
test_data.hres = hres;
testing_stop( &test_data, flops_zlauum( N ) );
diff --git a/testing/testing_zsyr2k.c b/testing/testing_zsyr2k.c
index 44437ec6680937199b54ade9b8a4494a91627074..a1b790e320680e8a30fba89cf13f42c6cf7f1d8b 100644
--- a/testing/testing_zsyr2k.c
+++ b/testing/testing_zsyr2k.c
@@ -129,6 +129,7 @@ testing_zsyr2k_std( run_arg_list_t *args, int check )
int hres = 0;
/* Read arguments */
+ int api = parameters_getvalue_int( "api" );
int nb = run_arg_get_int( args, "nb", 320 );
cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
@@ -186,7 +187,21 @@ testing_zsyr2k_std( run_arg_list_t *args, int check )
testing_stop( &test_data, flops_zher2k( N, K ) );
#else
testing_start( &test_data );
- hres = CHAMELEON_zsyr2k( uplo, trans, N, K, alpha, A, LDA, B, LDB, beta, C, LDC );
+ switch ( api ) {
+ case 1:
+ hres = CHAMELEON_zsyr2k( uplo, trans, N, K, alpha, A, LDA, B, LDB, beta, C, LDC );
+ break;
+ case 2:
+ CHAMELEON_cblas_zsyr2k( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans, N, K,
+ CBLAS_SADDR(alpha), A, LDA, B, LDB, CBLAS_SADDR(beta), C, LDC );
+ break;
+ default:
+ if ( CHAMELEON_Comm_rank() == 0 ) {
+ fprintf( stderr,
+ "SKIPPED: This function can only be used with the option --api 1 or --api 2.\n" );
+ }
+ return -1;
+ }
test_data.hres = hres;
testing_stop( &test_data, flops_zher2k( N, K ) );
diff --git a/testing/testing_zsyrk.c b/testing/testing_zsyrk.c
index 9000c452dfa1f5db90499985673d6739258c45a7..09269ec267ab3f949b2df98d95c0650143b0471c 100644
--- a/testing/testing_zsyrk.c
+++ b/testing/testing_zsyrk.c
@@ -122,6 +122,7 @@ testing_zsyrk_std( run_arg_list_t *args, int check )
int hres = 0;
/* Read arguments */
+ int api = parameters_getvalue_int( "api" );
int nb = run_arg_get_int( args, "nb", 320 );
cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
@@ -171,7 +172,21 @@ testing_zsyrk_std( run_arg_list_t *args, int check )
testing_stop( &test_data, flops_zsyrk( K, N ) );
#else
testing_start( &test_data );
- hres = CHAMELEON_zsyrk( uplo, trans, N, K, alpha, A, LDA, beta, C, LDC );
+ switch ( api ) {
+ case 1:
+ hres = CHAMELEON_zsyrk( uplo, trans, N, K, alpha, A, LDA, beta, C, LDC );
+ break;
+ case 2:
+ CHAMELEON_cblas_zsyrk( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans, N, K,
+ CBLAS_SADDR(alpha), A, LDA, CBLAS_SADDR(beta), C, LDC );
+ break;
+ default:
+ if ( CHAMELEON_Comm_rank() == 0 ) {
+ fprintf( stderr,
+ "SKIPPED: This function can only be used with the option --api 1 or --api 2.\n" );
+ }
+ return -1;
+ }
test_data.hres = hres;
testing_stop( &test_data, flops_zsyrk( K, N ) );
diff --git a/testing/testing_ztrmm.c b/testing/testing_ztrmm.c
index 1a38de09bd674e823b7b7c658fa42625e4bd8009..b9b0a5d48f716c392f9070895b10b6618d4b6506 100644
--- a/testing/testing_ztrmm.c
+++ b/testing/testing_ztrmm.c
@@ -117,6 +117,7 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
int hres = 0;
/* Read arguments */
+ int api = parameters_getvalue_int( "api" );
int nb = run_arg_get_int( args, "nb", 320 );
cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
cham_side_t side = run_arg_get_side( args, "side", ChamLeft );
@@ -157,7 +158,22 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
testing_stop( &test_data, flops_ztrmm( side, N, M ) );
#else
testing_start( &test_data );
- hres = CHAMELEON_ztrmm( side, uplo, trans, diag, M, N, alpha, A, LDA, B, LDB );
+ switch ( api ) {
+ case 1:
+ hres = CHAMELEON_ztrmm( side, uplo, trans, diag, M, N, alpha, A, LDA, B, LDB );
+ break;
+ case 2:
+ CHAMELEON_cblas_ztrmm( CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
+ (CBLAS_TRANSPOSE)trans, (CBLAS_DIAG)diag, M, N,
+ CBLAS_SADDR(alpha), A, LDA, B, LDB );
+ break;
+ default:
+ if ( CHAMELEON_Comm_rank() == 0 ) {
+ fprintf( stderr,
+ "SKIPPED: This function can only be used with the option --api 1 or --api 2.\n" );
+ }
+ return -1;
+ }
test_data.hres = hres;
testing_stop( &test_data, flops_ztrmm( side, N, M ) );
diff --git a/testing/testing_ztrsm.c b/testing/testing_ztrsm.c
index 3bff1b5a4c8c4f5638f65ba585028e2b376ca26b..868e1640196310bf6157e42ee9e50a17a0acb9ed 100644
--- a/testing/testing_ztrsm.c
+++ b/testing/testing_ztrsm.c
@@ -111,6 +111,7 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
int hres = 0;
/* Read arguments */
+ int api = parameters_getvalue_int( "api" );
int nb = run_arg_get_int( args, "nb", 320 );
cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
cham_side_t side = run_arg_get_side( args, "side", ChamLeft );
@@ -149,7 +150,22 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
testing_stop( &test_data, flops_ztrsm( side, M, N ) );
#else
testing_start( &test_data );
- hres = CHAMELEON_ztrsm( side, uplo, trans, diag, M, N, alpha, A, LDA, B, LDB );
+ switch ( api ) {
+ case 1:
+ hres = CHAMELEON_ztrsm( side, uplo, trans, diag, M, N, alpha, A, LDA, B, LDB );
+ break;
+ case 2:
+ CHAMELEON_cblas_ztrsm( CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
+ (CBLAS_TRANSPOSE)trans, (CBLAS_DIAG)diag, M, N,
+ CBLAS_SADDR(alpha), A, LDA, B, LDB );
+ break;
+ default:
+ if ( CHAMELEON_Comm_rank() == 0 ) {
+ fprintf( stderr,
+ "SKIPPED: This function can only be used with the option --api 1 or --api 2.\n" );
+ }
+ return -1;
+ }
test_data.hres = hres;
testing_stop( &test_data, flops_ztrsm( side, M, N ) );