diff --git a/compute/zgeadd.c b/compute/zgeadd.c
index ecf975a90088793b1f6455d4c7197c390f202d7e..fc18ca2d37eaf83c3992d39697554c626c7da66e 100644
--- a/compute/zgeadd.c
+++ b/compute/zgeadd.c
@@ -164,10 +164,10 @@ int MORSE_zgeadd(MORSE_enum trans, int M, int N,
trans, alpha, &descA, beta, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap( descB, B, NB, NB, LDB, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap( descB, B, NB, NB, LDB, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgelqf.c b/compute/zgelqf.c
index 100a0e1300c3fc329641384374bcdeb35a31e5a7..191ae7a0fed19fa4c948e08e605e21ffacca060f 100644
--- a/compute/zgelqf.c
+++ b/compute/zgelqf.c
@@ -76,8 +76,8 @@
*
******************************************************************************/
int MORSE_zgelqf(int M, int N,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descT)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descT)
{
int NB;
int status;
@@ -130,9 +130,9 @@ int MORSE_zgelqf(int M, int N,
MORSE_zgelqf_Tile_Async(&descA, descT, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -230,7 +230,7 @@ int MORSE_zgelqf_Tile(MORSE_desc_t *A, MORSE_desc_t *T)
*
******************************************************************************/
int MORSE_zgelqf_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
MORSE_desc_t D, *Dptr = NULL;
@@ -269,10 +269,10 @@ int MORSE_zgelqf_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(M, N) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(M, N) == 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
int m = chameleon_min(A->mt, A->nt) * A->mb;
diff --git a/compute/zgelqf_param.c b/compute/zgelqf_param.c
index 22d8dacdda0bbf8f64edc477821ea9bb4e10f61c..270dba3ba3c37c66cc376092931076dacfcc1991 100644
--- a/compute/zgelqf_param.c
+++ b/compute/zgelqf_param.c
@@ -127,9 +127,9 @@ int MORSE_zgelqf_param(const libhqr_tree_t *qrtree, int M, int N,
MORSE_zgelqf_param_Tile_Async(qrtree, &descA, descTS, descTT, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -270,10 +270,10 @@ int MORSE_zgelqf_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_desc_t *A,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(M, N) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(M, N) == 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
int m = chameleon_min(A->mt, A->nt) * A->mb;
diff --git a/compute/zgelqs.c b/compute/zgelqs.c
index b9f5013789ed5d171d19b20a5610b66e40c87282..124188a514898423ca06e1cc6fac403ea2787cd4 100644
--- a/compute/zgelqs.c
+++ b/compute/zgelqs.c
@@ -82,9 +82,9 @@
*
******************************************************************************/
int MORSE_zgelqs(int M, int N, int NRHS,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descT,
- MORSE_Complex64_t *B, int LDB)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descT,
+ MORSE_Complex64_t *B, int LDB)
{
int NB;
int status;
@@ -147,8 +147,8 @@ int MORSE_zgelqs(int M, int N, int NRHS,
MORSE_zgelqs_Tile_Async(&descA, descT, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
morse_sequence_wait(morse, sequence);
morse_desc_mat_free(&descA);
morse_desc_mat_free(&descB);
@@ -251,7 +251,7 @@ int MORSE_zgelqs_Tile(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *B)
*
******************************************************************************/
int MORSE_zgelqs_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *B,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_desc_t *subB;
MORSE_desc_t *subA;
@@ -296,11 +296,11 @@ int MORSE_zgelqs_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *B,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(M, chameleon_min(N, NRHS)) == 0) {
- return MORSE_SUCCESS;
- }
-*/
+ /*
+ if (chameleon_min(M, chameleon_min(N, NRHS)) == 0) {
+ return MORSE_SUCCESS;
+ }
+ */
/* subB = morse_desc_submatrix(B, A->m, 0, A->n-A->m, B->n);
morse_pzlaset( MorseUpperLower, 0., 0., subB, sequence, request );
free(subB); */
diff --git a/compute/zgelqs_param.c b/compute/zgelqs_param.c
index b6faae1ba51f504a29b3aec5e181714340396278..0a03c9cbf715b9c022d3c71e57068cecaa0030ce 100644
--- a/compute/zgelqs_param.c
+++ b/compute/zgelqs_param.c
@@ -149,8 +149,8 @@ int MORSE_zgelqs_param(const libhqr_tree_t *qrtree, int M, int N, int NRHS,
MORSE_zgelqs_param_Tile_Async(qrtree, &descA, descTS, descTT, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
morse_sequence_wait(morse, sequence);
morse_desc_mat_free(&descA);
morse_desc_mat_free(&descB);
@@ -305,14 +305,14 @@ int MORSE_zgelqs_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_desc_t *A,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(M, chameleon_min(N, NRHS)) == 0) {
- return MORSE_SUCCESS;
- }
-*/
+ /*
+ if (chameleon_min(M, chameleon_min(N, NRHS)) == 0) {
+ return MORSE_SUCCESS;
+ }
+ */
/* subB = morse_desc_submatrix(B, A->m, 0, A->n-A->m, B->n);
- morse_pzlaset( MorseUpperLower, 0., 0., subB, sequence, request);
- free(subB); */
+ morse_pzlaset( MorseUpperLower, 0., 0., subB, sequence, request);
+ free(subB); */
subB = morse_desc_submatrix(B, 0, 0, A->m, B->n);
subA = morse_desc_submatrix(A, 0, 0, A->m, A->m);
diff --git a/compute/zgels.c b/compute/zgels.c
index c3a7c852c4683105cd4d2a28631c5276213f3ede..33d50af978e5284ea80e2b48b410c79e81ba0f86 100644
--- a/compute/zgels.c
+++ b/compute/zgels.c
@@ -108,9 +108,9 @@
*
******************************************************************************/
int MORSE_zgels(MORSE_enum trans, int M, int N, int NRHS,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descT,
- MORSE_Complex64_t *B, int LDB)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descT,
+ MORSE_Complex64_t *B, int LDB)
{
int i, j;
int NB;
@@ -189,11 +189,11 @@ int MORSE_zgels(MORSE_enum trans, int M, int N, int NRHS,
MORSE_zgels_Tile_Async(MorseNoTrans, &descA, descT, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -255,7 +255,7 @@ int MORSE_zgels(MORSE_enum trans, int M, int N, int NRHS,
*
******************************************************************************/
int MORSE_zgels_Tile(MORSE_enum trans, MORSE_desc_t *A,
- MORSE_desc_t *T, MORSE_desc_t *B)
+ MORSE_desc_t *T, MORSE_desc_t *B)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -358,12 +358,12 @@ int MORSE_zgels_Tile_Async(MORSE_enum trans, MORSE_desc_t *A,
return morse_request_fail(sequence, request, MORSE_ERR_NOT_SUPPORTED);
}
/* Quick return - currently NOT equivalent to LAPACK's:
- if (chameleon_min(M, chameleon_min(N, NRHS)) == 0) {
- for (i = 0; i < chameleon_max(M, N); i++)
- for (j = 0; j < NRHS; j++)
- B[j*LDB+i] = 0.0;
- return MORSE_SUCCESS;
- }
+ if (chameleon_min(M, chameleon_min(N, NRHS)) == 0) {
+ for (i = 0; i < chameleon_max(M, N); i++)
+ for (j = 0; j < NRHS; j++)
+ B[j*LDB+i] = 0.0;
+ return MORSE_SUCCESS;
+ }
*/
if (A->m >= A->n) {
@@ -392,8 +392,8 @@ int MORSE_zgels_Tile_Async(MORSE_enum trans, MORSE_desc_t *A,
}
else {
/* subB = morse_desc_submatrix(B, A->m, 0, A->n-A->m, B->n);
- morse_pzlaset( MorseUpperLower, 0., 0., subB, sequence, request);
- free(subB); */
+ morse_pzlaset( MorseUpperLower, 0., 0., subB, sequence, request);
+ free(subB); */
#if defined(CHAMELEON_COPY_DIAG)
{
int m = chameleon_min(A->mt, A->nt) * A->mb;
diff --git a/compute/zgemm.c b/compute/zgemm.c
index b830977a3164cf5cebdb521fc0a5021cfb476204..00f7a3b1410cecb74abefb945009ba8085481c87 100644
--- a/compute/zgemm.c
+++ b/compute/zgemm.c
@@ -131,9 +131,9 @@
*
******************************************************************************/
int MORSE_zgemm(MORSE_enum transA, MORSE_enum transB, int M, int N, int K,
- MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA,
- MORSE_Complex64_t *B, int LDB,
- MORSE_Complex64_t beta, MORSE_Complex64_t *C, int LDC)
+ MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA,
+ MORSE_Complex64_t *B, int LDB,
+ MORSE_Complex64_t beta, MORSE_Complex64_t *C, int LDC)
{
int NB;
int Am, An, Bm, Bn;
@@ -346,9 +346,9 @@ int MORSE_zgemm_Tile(MORSE_enum transA, MORSE_enum transB,
*
******************************************************************************/
int MORSE_zgemm_Tile_Async(MORSE_enum transA, MORSE_enum transB,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_Complex64_t beta, MORSE_desc_t *C,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
+ MORSE_Complex64_t beta, MORSE_desc_t *C,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
int M, N, K;
diff --git a/compute/zgeqrf.c b/compute/zgeqrf.c
index 8e32eb570210bca1c1280bfe31338ec9181dba1a..00a462be33b40ad29846c534916da75112148edd 100644
--- a/compute/zgeqrf.c
+++ b/compute/zgeqrf.c
@@ -75,8 +75,8 @@
*
******************************************************************************/
int MORSE_zgeqrf(int M, int N,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descT)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descT)
{
int NB;
int status;
@@ -129,9 +129,9 @@ int MORSE_zgeqrf(int M, int N,
MORSE_zgeqrf_Tile_Async(&descA, descT, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -229,7 +229,7 @@ int MORSE_zgeqrf_Tile(MORSE_desc_t *A, MORSE_desc_t *T)
*
******************************************************************************/
int MORSE_zgeqrf_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
MORSE_desc_t D, *Dptr = NULL;
@@ -268,10 +268,10 @@ int MORSE_zgeqrf_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(M, N) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(M, N) == 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
int n = chameleon_min(A->mt, A->nt) * A->nb;
diff --git a/compute/zgeqrf_param.c b/compute/zgeqrf_param.c
index 00fce04afd9517d2f383589b565fed2124dfa6ce..c5db6d1d8ff5daa5e349a23662f06799d1e03f66 100644
--- a/compute/zgeqrf_param.c
+++ b/compute/zgeqrf_param.c
@@ -129,12 +129,12 @@ int MORSE_zgeqrf_param(const libhqr_tree_t *qrtree, int M, int N,
A, NB, NB, LDA, N, M, N, sequence, &request );
/* Call the tile interface */
- MORSE_zgeqrf_param_Tile_Async(qrtree, &descA, descTS, descTT, sequence, &request);
+ MORSE_zgeqrf_param_Tile_Async(qrtree, &descA, descTS, descTT, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -236,7 +236,7 @@ int MORSE_zgeqrf_param_Tile(const libhqr_tree_t *qrtree, MORSE_desc_t *A, MORSE_
*
******************************************************************************/
int MORSE_zgeqrf_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_desc_t *A, MORSE_desc_t *TS, MORSE_desc_t *TT,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
MORSE_desc_t D, *Dptr = NULL;
@@ -279,10 +279,10 @@ int MORSE_zgeqrf_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_desc_t *A,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(M, N) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(M, N) == 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
int n = chameleon_min(A->mt, A->nt) * A->nb;
diff --git a/compute/zgeqrs.c b/compute/zgeqrs.c
index 2c9012db358f86d77424bfd6f57bcd0ade7ed0a6..30d4151466d8137545e36c343b81c8d60bf4af74 100644
--- a/compute/zgeqrs.c
+++ b/compute/zgeqrs.c
@@ -82,9 +82,9 @@
*
*******************************************************************************/
int MORSE_zgeqrs(int M, int N, int NRHS,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descT,
- MORSE_Complex64_t *B, int LDB)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descT,
+ MORSE_Complex64_t *B, int LDB)
{
int NB;
int status;
@@ -147,12 +147,12 @@ int MORSE_zgeqrs(int M, int N, int NRHS,
MORSE_zgeqrs_Tile_Async(&descA, descT, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
-
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -251,7 +251,7 @@ int MORSE_zgeqrs_Tile(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *B)
*
******************************************************************************/
int MORSE_zgeqrs_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *B,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_desc_t *subA;
MORSE_desc_t *subB;
@@ -296,11 +296,11 @@ int MORSE_zgeqrs_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *B,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(M, chameleon_min(N, NRHS)) == 0) {
- return MORSE_SUCCESS;
- }
-*/
+ /*
+ if (chameleon_min(M, chameleon_min(N, NRHS)) == 0) {
+ return MORSE_SUCCESS;
+ }
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
int n = chameleon_min(A->mt, A->nt) * A->nb;
diff --git a/compute/zgeqrs_param.c b/compute/zgeqrs_param.c
index f74ca15829cd7a8f94fc87a3c214b0e64862ae31..bf285e43105c65ad2b3040992a6beff70542eb29 100644
--- a/compute/zgeqrs_param.c
+++ b/compute/zgeqrs_param.c
@@ -142,11 +142,11 @@ int MORSE_zgeqrs_param(const libhqr_tree_t *qrtree, int M, int N, int NRHS,
MORSE_zgeqrs_param_Tile_Async(qrtree, &descA, descTS, descTT, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgesv_incpiv.c b/compute/zgesv_incpiv.c
index f22c79585c122acc86f376485cede82bb82f8158..1c1abc5161efe305d408b137e31ae756fb4226fa 100644
--- a/compute/zgesv_incpiv.c
+++ b/compute/zgesv_incpiv.c
@@ -87,9 +87,9 @@
*
******************************************************************************/
int MORSE_zgesv_incpiv(int N, int NRHS,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descL, int *IPIV,
- MORSE_Complex64_t *B, int LDB)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descL, int *IPIV,
+ MORSE_Complex64_t *B, int LDB)
{
int NB;
int status;
@@ -146,12 +146,12 @@ int MORSE_zgesv_incpiv(int N, int NRHS,
MORSE_zgesv_incpiv_Tile_Async(&descA, descL, IPIV, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
-
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -218,7 +218,7 @@ int MORSE_zgesv_incpiv_Tile(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV, MORSE_d
RUNTIME_desc_flush( A, sequence );
RUNTIME_desc_flush( B, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -255,7 +255,7 @@ int MORSE_zgesv_incpiv_Tile(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV, MORSE_d
*
******************************************************************************/
int MORSE_zgesv_incpiv_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV, MORSE_desc_t *B,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -297,10 +297,10 @@ int MORSE_zgesv_incpiv_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV, M
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(N, NRHS) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(N, NRHS) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pzgetrf_incpiv(A, L, IPIV, sequence, request);
diff --git a/compute/zgesv_nopiv.c b/compute/zgesv_nopiv.c
index 164ee3109672d7fe7b27d71a6c09aa4a9c2422f0..d1fcc7c66bb1e241138b7daade04e001c9b6efcd 100644
--- a/compute/zgesv_nopiv.c
+++ b/compute/zgesv_nopiv.c
@@ -145,12 +145,12 @@ int MORSE_zgesv_nopiv(int N, int NRHS,
MORSE_zgesv_nopiv_Tile_Async(&descA, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
-
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -210,7 +210,7 @@ int MORSE_zgesv_nopiv_Tile(MORSE_desc_t *A, MORSE_desc_t *B)
RUNTIME_desc_flush( A, sequence );
RUNTIME_desc_flush( B, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -285,10 +285,10 @@ int MORSE_zgesv_nopiv_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *B,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(N, NRHS) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(N, NRHS) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pzgetrf_nopiv(A, sequence, request);
diff --git a/compute/zgesvd.c b/compute/zgesvd.c
index d3f1e8b1def929b05bbda2da0f5aeee3b9f31115..d7e7060b9092d2b8f80d01ac5cd1cdd1f9612815 100644
--- a/compute/zgesvd.c
+++ b/compute/zgesvd.c
@@ -148,12 +148,12 @@
*
******************************************************************************/
int MORSE_zgesvd(MORSE_enum jobu, MORSE_enum jobvt,
- int M, int N,
- MORSE_Complex64_t *A, int LDA,
- double *S,
- MORSE_desc_t *descT,
- MORSE_Complex64_t *U, int LDU,
- MORSE_Complex64_t *VT, int LDVT)
+ int M, int N,
+ MORSE_Complex64_t *A, int LDA,
+ double *S,
+ MORSE_desc_t *descT,
+ MORSE_Complex64_t *U, int LDU,
+ MORSE_Complex64_t *VT, int LDVT)
{
int NB;
int status;
diff --git a/compute/zgetrf_incpiv.c b/compute/zgetrf_incpiv.c
index 809df1bc273b65dec182250382ef869fe8e8997a..f12be25c1edfa078e0b431e86bd593e1b9ce6ec5 100644
--- a/compute/zgetrf_incpiv.c
+++ b/compute/zgetrf_incpiv.c
@@ -79,8 +79,8 @@
*
******************************************************************************/
int MORSE_zgetrf_incpiv(int M, int N,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descL, int *IPIV)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descL, int *IPIV)
{
int NB;
int status;
@@ -131,9 +131,9 @@ int MORSE_zgetrf_incpiv(int M, int N,
MORSE_zgetrf_incpiv_Tile_Async(&descA, descL, IPIV, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -234,7 +234,7 @@ int MORSE_zgetrf_incpiv_Tile(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV)
*
******************************************************************************/
int MORSE_zgetrf_incpiv_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -272,10 +272,10 @@ int MORSE_zgetrf_incpiv_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(M, N) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(M, N) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pzgetrf_incpiv(A, L, IPIV, sequence, request);
diff --git a/compute/zgetrf_nopiv.c b/compute/zgetrf_nopiv.c
index 10e9270bf24e059360df192f5c0742b28e10f27d..87f0d117c6efcf82b6cec68a463716784fda85d2 100644
--- a/compute/zgetrf_nopiv.c
+++ b/compute/zgetrf_nopiv.c
@@ -124,9 +124,9 @@ int MORSE_zgetrf_nopiv(int M, int N,
MORSE_zgetrf_nopiv_Tile_Async(&descA, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request );
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request );
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -184,7 +184,7 @@ int MORSE_zgetrf_nopiv_Tile(MORSE_desc_t *A)
MORSE_zgetrf_nopiv_Tile_Async(A, sequence, &request);
RUNTIME_desc_flush( A, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
diff --git a/compute/zgetrs_incpiv.c b/compute/zgetrs_incpiv.c
index 392f3c8aecbf82509ccb5e6384246eee9e5f8f71..8be117d8aa4fb6853caea8d6bda137f5255cd1be 100644
--- a/compute/zgetrs_incpiv.c
+++ b/compute/zgetrs_incpiv.c
@@ -152,10 +152,10 @@ int MORSE_zgetrs_incpiv(MORSE_enum trans, int N, int NRHS,
MORSE_zgetrs_incpiv_Tile_Async(&descA, descL, IPIV, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -221,7 +221,7 @@ int MORSE_zgetrs_incpiv_Tile(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV, MORSE_
RUNTIME_desc_flush( A, sequence );
RUNTIME_desc_flush( B, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -258,7 +258,7 @@ int MORSE_zgetrs_incpiv_Tile(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV, MORSE_
*
******************************************************************************/
int MORSE_zgetrs_incpiv_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV, MORSE_desc_t *B,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -300,10 +300,10 @@ int MORSE_zgetrs_incpiv_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(N, NRHS) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(N, NRHS) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pztrsmpl(A, B, L, IPIV, sequence, request);
morse_pztrsm(MorseLeft, MorseUpper, MorseNoTrans, MorseNonUnit, 1.0, A, B, sequence, request);
diff --git a/compute/zgetrs_nopiv.c b/compute/zgetrs_nopiv.c
index 5f4448f22024cb92a82cc86aa3f998560c93242a..08858c5d6556673906c3c32a6220643173215eb5 100644
--- a/compute/zgetrs_nopiv.c
+++ b/compute/zgetrs_nopiv.c
@@ -146,10 +146,10 @@ int MORSE_zgetrs_nopiv(MORSE_enum trans, int N, int NRHS,
MORSE_zgetrs_nopiv_Tile_Async(&descA, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -284,10 +284,10 @@ int MORSE_zgetrs_nopiv_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *B,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(N, NRHS) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(N, NRHS) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pztrsm(MorseLeft, MorseLower, MorseNoTrans, MorseUnit, (MORSE_Complex64_t)1.0, A, B, sequence, request);
morse_pztrsm(MorseLeft, MorseUpper, MorseNoTrans, MorseNonUnit, (MORSE_Complex64_t)1.0, A, B, sequence, request);
diff --git a/compute/zheevd.c b/compute/zheevd.c
index 5254ea76660203a0c3e3a287c063bf6f804d03ee..9ea48624212c3f8320c921d43cd972ec4c66a1a8 100644
--- a/compute/zheevd.c
+++ b/compute/zheevd.c
@@ -468,11 +468,11 @@ int MORSE_zheevd_Tile_Async(MORSE_enum jobz, MORSE_enum uplo,
if (uplo == MorseLower)
{
#if defined(CHAMELEON_COPY_DIAG)
- {
- int n = chameleon_min(A->mt, A->nt) * A->nb;
- morse_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
- Dptr = &D;
- }
+ {
+ int n = chameleon_min(A->mt, A->nt) * A->nb;
+ morse_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+ Dptr = &D;
+ }
#endif
subA = morse_desc_submatrix(&descA, descA.mb, 0, descA.m -descA.mb, descA.n-descA.nb);
subQ = morse_desc_submatrix(&descQ2, descQ2.mb, 0, descQ2.m-descQ2.mb, descQ2.n );
@@ -492,11 +492,11 @@ int MORSE_zheevd_Tile_Async(MORSE_enum jobz, MORSE_enum uplo,
}
else {
#if defined(CHAMELEON_COPY_DIAG)
- {
- int m = chameleon_min(A->mt, A->nt) * A->mb;
- morse_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
- Dptr = &D;
- }
+ {
+ int m = chameleon_min(A->mt, A->nt) * A->mb;
+ morse_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
+ Dptr = &D;
+ }
#endif
subA = morse_desc_submatrix(&descA, 0, descA.nb, descA.m -descA.mb, descA.n -descA.nb );
subQ = morse_desc_submatrix(&descQ2, descQ2.mb, 0, descQ2.m-descQ2.mb, descQ2.n );
diff --git a/compute/zhemm.c b/compute/zhemm.c
index 5d31cb37921eb7fd5471cbf99a52e8abb30fe466..7cf7374f3857de337f2f399ebfaa3af151192118 100644
--- a/compute/zhemm.c
+++ b/compute/zhemm.c
@@ -107,9 +107,9 @@
*
******************************************************************************/
int MORSE_zhemm(MORSE_enum side, MORSE_enum uplo, int M, int N,
- MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA,
- MORSE_Complex64_t *B, int LDB,
- MORSE_Complex64_t beta, MORSE_Complex64_t *C, int LDC)
+ MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA,
+ MORSE_Complex64_t *B, int LDB,
+ MORSE_Complex64_t beta, MORSE_Complex64_t *C, int LDC)
{
int NB;
int Am;
@@ -186,11 +186,11 @@ int MORSE_zhemm(MORSE_enum side, MORSE_enum uplo, int M, int N,
side, uplo, alpha, &descA, &descB, beta, &descC, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
- morse_desc_mat_free(&descC);
+ morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
+ morse_desc_mat_free(&descC);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -257,8 +257,8 @@ int MORSE_zhemm(MORSE_enum side, MORSE_enum uplo, int M, int N,
*
******************************************************************************/
int MORSE_zhemm_Tile(MORSE_enum side, MORSE_enum uplo,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_Complex64_t beta, MORSE_desc_t *C)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
+ MORSE_Complex64_t beta, MORSE_desc_t *C)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -276,7 +276,7 @@ int MORSE_zhemm_Tile(MORSE_enum side, MORSE_enum uplo,
RUNTIME_desc_flush( B, sequence );
RUNTIME_desc_flush( C, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -311,9 +311,9 @@ int MORSE_zhemm_Tile(MORSE_enum side, MORSE_enum uplo,
*
******************************************************************************/
int MORSE_zhemm_Tile_Async(MORSE_enum side, MORSE_enum uplo,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_Complex64_t beta, MORSE_desc_t *C,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
+ MORSE_Complex64_t beta, MORSE_desc_t *C,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
diff --git a/compute/zher2k.c b/compute/zher2k.c
index 93d3da9e1c09b2aa7c1163f443683a8189ac1b0c..a4c3f059db3dead7e2dad6b8ef0660f04870cfac 100644
--- a/compute/zher2k.c
+++ b/compute/zher2k.c
@@ -83,7 +83,7 @@
* @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.
*
@@ -109,8 +109,8 @@
*
******************************************************************************/
int MORSE_zher2k(MORSE_enum uplo, MORSE_enum trans, int N, int K,
- MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA, MORSE_Complex64_t *B, int LDB,
- double beta, MORSE_Complex64_t *C, int LDC)
+ MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA, MORSE_Complex64_t *B, int LDB,
+ double beta, MORSE_Complex64_t *C, int LDC)
{
int NB;
int Am, An;
@@ -135,7 +135,7 @@ int MORSE_zher2k(MORSE_enum uplo, MORSE_enum trans, int N, int K,
morse_error("MORSE_zher2k", "illegal value of trans");
return -2;
}
- if ( trans == MorseNoTrans ) {
+ if ( trans == MorseNoTrans ) {
Am = N; An = K;
} else {
Am = K; An = N;
@@ -190,11 +190,11 @@ int MORSE_zher2k(MORSE_enum uplo, MORSE_enum trans, int N, int K,
MORSE_zher2k_Tile_Async(uplo, trans, alpha, &descA, &descB, beta, &descC, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
- morse_desc_mat_free(&descC);
+ morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
+ morse_desc_mat_free(&descC);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -256,8 +256,8 @@ int MORSE_zher2k(MORSE_enum uplo, MORSE_enum trans, int N, int K,
*
******************************************************************************/
int MORSE_zher2k_Tile(MORSE_enum uplo, MORSE_enum trans,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
- double beta, MORSE_desc_t *C)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
+ double beta, MORSE_desc_t *C)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -275,7 +275,7 @@ int MORSE_zher2k_Tile(MORSE_enum uplo, MORSE_enum trans,
RUNTIME_desc_flush( B, sequence );
RUNTIME_desc_flush( C, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -310,9 +310,9 @@ int MORSE_zher2k_Tile(MORSE_enum uplo, MORSE_enum trans,
*
******************************************************************************/
int MORSE_zher2k_Tile_Async(MORSE_enum uplo, MORSE_enum trans,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
- double beta, MORSE_desc_t *C,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
+ double beta, MORSE_desc_t *C,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
int N, K;
@@ -392,7 +392,7 @@ int MORSE_zher2k_Tile_Async(MORSE_enum uplo, MORSE_enum trans,
/* Quick return */
if ( N == 0 ||
- ((alpha == (MORSE_Complex64_t)0.0 || K == 0) && beta == (double)1.0))
+ ((alpha == (MORSE_Complex64_t)0.0 || K == 0) && beta == (double)1.0))
return MORSE_SUCCESS;
morse_pzher2k(uplo, trans, alpha, A, B, beta, C, sequence, request);
diff --git a/compute/zherk.c b/compute/zherk.c
index de717dd8c50b9573660598f78a9b57b0797662fd..64b671dc94a76cd966fa7497286c7622b5892dfa 100644
--- a/compute/zherk.c
+++ b/compute/zherk.c
@@ -99,8 +99,8 @@
*
******************************************************************************/
int MORSE_zherk(MORSE_enum uplo, MORSE_enum trans, int N, int K,
- double alpha, MORSE_Complex64_t *A, int LDA,
- double beta, MORSE_Complex64_t *C, int LDC)
+ double alpha, MORSE_Complex64_t *A, int LDA,
+ double beta, MORSE_Complex64_t *C, int LDC)
{
int NB;
int Am, An;
@@ -125,7 +125,7 @@ int MORSE_zherk(MORSE_enum uplo, MORSE_enum trans, int N, int K,
morse_error("MORSE_zherk", "illegal value of trans");
return -2;
}
- if ( trans == MorseNoTrans ) {
+ if ( trans == MorseNoTrans ) {
Am = N; An = K;
} else {
Am = K; An = N;
@@ -174,10 +174,10 @@ int MORSE_zherk(MORSE_enum uplo, MORSE_enum trans, int N, int K,
MORSE_zherk_Tile_Async(uplo, trans, alpha, &descA, beta, &descC, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descC);
+ morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descC);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -235,8 +235,8 @@ int MORSE_zherk(MORSE_enum uplo, MORSE_enum trans, int N, int K,
*
******************************************************************************/
int MORSE_zherk_Tile(MORSE_enum uplo, MORSE_enum trans,
- double alpha, MORSE_desc_t *A,
- double beta, MORSE_desc_t *C)
+ double alpha, MORSE_desc_t *A,
+ double beta, MORSE_desc_t *C)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -253,7 +253,7 @@ int MORSE_zherk_Tile(MORSE_enum uplo, MORSE_enum trans,
RUNTIME_desc_flush( A, sequence );
RUNTIME_desc_flush( C, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -288,9 +288,9 @@ int MORSE_zherk_Tile(MORSE_enum uplo, MORSE_enum trans,
*
******************************************************************************/
int MORSE_zherk_Tile_Async(MORSE_enum uplo, MORSE_enum trans,
- double alpha, MORSE_desc_t *A,
- double beta, MORSE_desc_t *C,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ double alpha, MORSE_desc_t *A,
+ double beta, MORSE_desc_t *C,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
int N, K;
@@ -366,7 +366,7 @@ int MORSE_zherk_Tile_Async(MORSE_enum uplo, MORSE_enum trans,
/* Quick return */
if ( N == 0 ||
- ((alpha == (double)0.0 || K == 0) && beta == (double)1.0))
+ ((alpha == (double)0.0 || K == 0) && beta == (double)1.0))
return MORSE_SUCCESS;
morse_pzherk(uplo, trans, alpha, A, beta, C, sequence, request);
diff --git a/compute/zlacpy.c b/compute/zlacpy.c
index 828f80445530127605fdb91e1904ab14e840ef51..9c749e85e24641849fb11c1e23183ddf7ac75019 100644
--- a/compute/zlacpy.c
+++ b/compute/zlacpy.c
@@ -75,8 +75,8 @@
*
******************************************************************************/
int MORSE_zlacpy(MORSE_enum uplo, int M, int N,
- MORSE_Complex64_t *A, int LDA,
- MORSE_Complex64_t *B, int LDB)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_Complex64_t *B, int LDB)
{
int NB;
int status;
@@ -116,7 +116,7 @@ int MORSE_zlacpy(MORSE_enum uplo, int M, int N,
/* Quick return */
if (chameleon_min(N, M) == 0)
- return (double)0.0;
+ return (double)0.0;
/* Tune NB depending on M, N & NRHS; Set NBNB */
status = morse_tune(MORSE_FUNC_ZGEMM, M, N, 0);
@@ -140,10 +140,10 @@ int MORSE_zlacpy(MORSE_enum uplo, int M, int N,
MORSE_zlacpy_Tile_Async(uplo, &descA, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descB, B, NB, NB, LDB, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
morse_sequence_destroy(morse, sequence);
return MORSE_SUCCESS;
@@ -236,7 +236,7 @@ int MORSE_zlacpy_Tile(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B)
*
******************************************************************************/
int MORSE_zlacpy_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
diff --git a/compute/zlange.c b/compute/zlange.c
index 8c196310e1f55949a83722cd24b8d90f875615e1..3267d74614d0b2ba03ca95517205e47970f5c106 100644
--- a/compute/zlange.c
+++ b/compute/zlange.c
@@ -101,7 +101,7 @@ double MORSE_zlange(MORSE_enum norm, int M, int N,
}
/* Check input arguments */
if ( (norm != MorseMaxNorm) && (norm != MorseOneNorm)
- && (norm != MorseInfNorm) && (norm != MorseFrobeniusNorm) ) {
+ && (norm != MorseInfNorm) && (norm != MorseFrobeniusNorm) ) {
morse_error("MORSE_zlange", "illegal value of norm");
return -1;
}
@@ -120,7 +120,7 @@ double MORSE_zlange(MORSE_enum norm, int M, int N,
/* Quick return */
if (chameleon_min(N, M) == 0)
- return (double)0.0;
+ return (double)0.0;
/* Tune NB depending on M, N & NRHS; Set NBNB */
status = morse_tune(MORSE_FUNC_ZGEMM, M, N, 0);
@@ -142,10 +142,10 @@ double MORSE_zlange(MORSE_enum norm, int M, int N,
MORSE_zlange_Tile_Async(norm, &descA, &value, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
RUNTIME_desc_flush( &descA, sequence );
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
morse_sequence_destroy(morse, sequence);
return value;
diff --git a/compute/zlanhe.c b/compute/zlanhe.c
index 29924659068e93217a8b1010c326956685dd4984..455f74ec975d999dd33d292b4206a62d615f058a 100644
--- a/compute/zlanhe.c
+++ b/compute/zlanhe.c
@@ -101,7 +101,7 @@ double MORSE_zlanhe(MORSE_enum norm, MORSE_enum uplo, int N,
}
/* Check input arguments */
if ( (norm != MorseMaxNorm) && (norm != MorseOneNorm)
- && (norm != MorseInfNorm) && (norm != MorseFrobeniusNorm) ) {
+ && (norm != MorseInfNorm) && (norm != MorseFrobeniusNorm) ) {
morse_error("MORSE_zlanhe", "illegal value of norm");
return -1;
}
@@ -120,7 +120,7 @@ double MORSE_zlanhe(MORSE_enum norm, MORSE_enum uplo, int N,
/* Quick return */
if ( N == 0)
- return (double)0.0;
+ return (double)0.0;
/* Tune NB depending on M, N & NRHS; Set NBNB */
status = morse_tune(MORSE_FUNC_ZGEMM, N, N, 0);
diff --git a/compute/zlansy.c b/compute/zlansy.c
index 3078ce2a90d7ab2a544b6737c39867b189e623ca..9a10fe7897e697d6b4ab6c945462330c50d412f7 100644
--- a/compute/zlansy.c
+++ b/compute/zlansy.c
@@ -101,7 +101,7 @@ double MORSE_zlansy(MORSE_enum norm, MORSE_enum uplo, int N,
}
/* Check input arguments */
if ( (norm != MorseMaxNorm) && (norm != MorseOneNorm)
- && (norm != MorseInfNorm) && (norm != MorseFrobeniusNorm) ) {
+ && (norm != MorseInfNorm) && (norm != MorseFrobeniusNorm) ) {
morse_error("MORSE_zlansy", "illegal value of norm");
return -1;
}
@@ -120,7 +120,7 @@ double MORSE_zlansy(MORSE_enum norm, MORSE_enum uplo, int N,
/* Quick return */
if ( N == 0)
- return (double)0.0;
+ return (double)0.0;
/* Tune NB depending on M, N & NRHS; Set NBNB */
status = morse_tune(MORSE_FUNC_ZGEMM, N, N, 0);
@@ -142,8 +142,8 @@ double MORSE_zlansy(MORSE_enum norm, MORSE_enum uplo, int N,
MORSE_zlansy_Tile_Async(norm, uplo, &descA, &value, sequence, &request);
/* Submit the matrix conversion */
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
morse_sequence_destroy(morse, sequence);
return value;
diff --git a/compute/zlantr.c b/compute/zlantr.c
index 80ac583054523d0a83bef25a2ba5e01c8261aed8..8ae33b76bff1589e88ab8498eb49e2a12ce2be87 100644
--- a/compute/zlantr.c
+++ b/compute/zlantr.c
@@ -96,7 +96,7 @@
*
******************************************************************************/
double MORSE_zlantr(MORSE_enum norm, MORSE_enum uplo, MORSE_enum diag,
- int M, int N, MORSE_Complex64_t *A, int LDA)
+ int M, int N, MORSE_Complex64_t *A, int LDA)
{
int NB;
int status;
@@ -113,7 +113,7 @@ double MORSE_zlantr(MORSE_enum norm, MORSE_enum uplo, MORSE_enum diag,
}
/* Check input arguments */
if ( (norm != MorseMaxNorm) && (norm != MorseOneNorm)
- && (norm != MorseInfNorm) && (norm != MorseFrobeniusNorm) ) {
+ && (norm != MorseInfNorm) && (norm != MorseFrobeniusNorm) ) {
morse_error("MORSE_zlantr", "illegal value of norm");
return -1;
}
@@ -140,7 +140,7 @@ double MORSE_zlantr(MORSE_enum norm, MORSE_enum uplo, MORSE_enum diag,
/* Quick return */
if (chameleon_min(N, M) == 0)
- return (double)0.0;
+ return (double)0.0;
/* Tune NB depending on M, N & NRHS; Set NBNB */
status = morse_tune(MORSE_FUNC_ZGEMM, M, N, 0);
@@ -162,8 +162,8 @@ double MORSE_zlantr(MORSE_enum norm, MORSE_enum uplo, MORSE_enum diag,
MORSE_zlantr_Tile_Async(norm, uplo, diag, &descA, &value, sequence, &request);
/* Submit the matrix conversion */
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
morse_sequence_destroy(morse, sequence);
return value;
diff --git a/compute/zlascal.c b/compute/zlascal.c
index 91315d99493ebae9f0958623f85e807529ba5178..242fb1aeeaabc6d640fd986b58863c0bf30f5688 100644
--- a/compute/zlascal.c
+++ b/compute/zlascal.c
@@ -63,7 +63,7 @@
*
******************************************************************************/
int MORSE_zlascal(MORSE_enum uplo, int M, int N,
- MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA)
+ MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA)
{
int NB;
int status;
@@ -122,9 +122,9 @@ int MORSE_zlascal(MORSE_enum uplo, int M, int N,
uplo, alpha, &descA, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap( descA, A, NB, NB, LDA, N, sequence, &request);
- RUNTIME_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_zooptile2lap( descA, A, NB, NB, LDA, N, sequence, &request);
+ RUNTIME_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -172,7 +172,7 @@ int MORSE_zlascal(MORSE_enum uplo, int M, int N,
*
******************************************************************************/
int MORSE_zlascal_Tile(MORSE_enum uplo,
- MORSE_Complex64_t alpha, MORSE_desc_t *A)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -222,8 +222,8 @@ int MORSE_zlascal_Tile(MORSE_enum uplo,
*
******************************************************************************/
int MORSE_zlascal_Tile_Async(MORSE_enum uplo,
- MORSE_Complex64_t alpha, MORSE_desc_t *A,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
MORSE_desc_t descA;
diff --git a/compute/zlaset.c b/compute/zlaset.c
index 58fee1e2032fb5b5f971ba62afe8eb49c775856a..9f74ff42a193bd7ecb1608942202f6c17b5f50cf 100644
--- a/compute/zlaset.c
+++ b/compute/zlaset.c
@@ -76,8 +76,8 @@
*
******************************************************************************/
int MORSE_zlaset(MORSE_enum uplo, int M, int N,
- MORSE_Complex64_t alpha, MORSE_Complex64_t beta,
- MORSE_Complex64_t *A, int LDA)
+ MORSE_Complex64_t alpha, MORSE_Complex64_t beta,
+ MORSE_Complex64_t *A, int LDA)
{
int NB;
int status;
@@ -113,7 +113,7 @@ int MORSE_zlaset(MORSE_enum uplo, int M, int N,
/* Quick return */
if (chameleon_min(N, M) == 0)
- return (double)0.0;
+ return (double)0.0;
/* Tune NB depending on M, N & NRHS; Set NBNB */
status = morse_tune(MORSE_FUNC_ZGEMM, M, N, 0);
@@ -135,8 +135,8 @@ int MORSE_zlaset(MORSE_enum uplo, int M, int N,
MORSE_zlaset_Tile_Async(uplo, alpha, beta, &descA, sequence, &request);
/* Submit the matrix conversion */
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
morse_sequence_destroy(morse, sequence);
return MORSE_SUCCESS;
@@ -180,8 +180,8 @@ int MORSE_zlaset(MORSE_enum uplo, int M, int N,
*
******************************************************************************/
int MORSE_zlaset_Tile(MORSE_enum uplo,
- MORSE_Complex64_t alpha, MORSE_Complex64_t beta,
- MORSE_desc_t *A)
+ MORSE_Complex64_t alpha, MORSE_Complex64_t beta,
+ MORSE_desc_t *A)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -227,9 +227,9 @@ int MORSE_zlaset_Tile(MORSE_enum uplo,
*
******************************************************************************/
int MORSE_zlaset_Tile_Async(MORSE_enum uplo,
- MORSE_Complex64_t alpha, MORSE_Complex64_t beta,
- MORSE_desc_t *A,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_Complex64_t alpha, MORSE_Complex64_t beta,
+ MORSE_desc_t *A,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
diff --git a/compute/zlauum.c b/compute/zlauum.c
index 851a2adfe60343e5d45092bc57c3cfa1927c6c4a..eb16a1751389a088b1325bd98505b97d2205e24a 100644
--- a/compute/zlauum.c
+++ b/compute/zlauum.c
@@ -78,7 +78,7 @@
*
******************************************************************************/
int MORSE_zlauum(MORSE_enum uplo, int N,
- MORSE_Complex64_t *A, int LDA)
+ MORSE_Complex64_t *A, int LDA)
{
int NB;
int status;
@@ -86,7 +86,7 @@ int MORSE_zlauum(MORSE_enum uplo, int N,
MORSE_sequence_t *sequence = NULL;
MORSE_request_t request = MORSE_REQUEST_INITIALIZER;
MORSE_desc_t descA;
-
+
morse = morse_context_self();
if (morse == NULL) {
morse_fatal_error("MORSE_zlauum", "MORSE not initialized");
@@ -129,9 +129,9 @@ int MORSE_zlauum(MORSE_enum uplo, int N,
MORSE_zlauum_Tile_Async(uplo, &descA, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -195,7 +195,7 @@ int MORSE_zlauum_Tile(MORSE_enum uplo, MORSE_desc_t *A)
MORSE_zlauum_Tile_Async(uplo, A, sequence, &request);
RUNTIME_desc_flush( A, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -233,7 +233,7 @@ int MORSE_zlauum_Tile(MORSE_enum uplo, MORSE_desc_t *A)
*
******************************************************************************/
int MORSE_zlauum_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -271,10 +271,10 @@ int MORSE_zlauum_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A,
return morse_request_fail(sequence, request, -1);
}
/* Quick return */
-/*
- if (chameleon_max(N, 0) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_max(N, 0) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pzlauum(uplo, A, sequence, request);
return MORSE_SUCCESS;
diff --git a/compute/zplgsy.c b/compute/zplgsy.c
index 7c8e8aeda0f5d1e96d384d40b529751a266875c8..d0264a234dc81a3d3880e1a87ed8c0dcf31b5070 100644
--- a/compute/zplgsy.c
+++ b/compute/zplgsy.c
@@ -172,7 +172,7 @@ int MORSE_zplgsy( MORSE_Complex64_t bump, MORSE_enum uplo, int N,
*
******************************************************************************/
int MORSE_zplgsy_Tile( MORSE_Complex64_t bump, MORSE_enum uplo,
- MORSE_desc_t *A,
+ MORSE_desc_t *A,
unsigned long long int seed )
{
MORSE_context_t *morse;
diff --git a/compute/zposv.c b/compute/zposv.c
index f09a6f707dd437cc37e89faf27eeabca567554e2..01b79e4cd3ed3a4c989605ef41bec120fe3b4955 100644
--- a/compute/zposv.c
+++ b/compute/zposv.c
@@ -96,8 +96,8 @@
*
******************************************************************************/
int MORSE_zposv(MORSE_enum uplo, int N, int NRHS,
- MORSE_Complex64_t *A, int LDA,
- MORSE_Complex64_t *B, int LDB)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_Complex64_t *B, int LDB)
{
int NB;
int status;
@@ -159,11 +159,11 @@ int MORSE_zposv(MORSE_enum uplo, int N, int NRHS,
MORSE_zposv_Tile_Async(uplo, &descA, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -217,7 +217,7 @@ int MORSE_zposv(MORSE_enum uplo, int N, int NRHS,
* @sa MORSE_cposv_Tile
* @sa MORSE_dposv_Tile
* @sa MORSE_sposv_Tile
-*
+ *
******************************************************************************/
int MORSE_zposv_Tile(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B)
{
@@ -236,7 +236,7 @@ int MORSE_zposv_Tile(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B)
RUNTIME_desc_flush( A, sequence );
RUNTIME_desc_flush( B, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -272,7 +272,7 @@ int MORSE_zposv_Tile(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B)
*
******************************************************************************/
int MORSE_zposv_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -315,10 +315,10 @@ int MORSE_zposv_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B,
}
/* Quick return - currently NOT equivalent to LAPACK's
* LAPACK does not have such check for DPOSV */
-/*
- if (chameleon_min(N, NRHS) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(N, NRHS) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pzpotrf(uplo, A, sequence, request);
morse_pztrsm(MorseLeft, uplo, uplo == MorseUpper ? MorseConjTrans : MorseNoTrans, MorseNonUnit, 1.0, A, B, sequence, request);
diff --git a/compute/zpotrf.c b/compute/zpotrf.c
index 8468bdb658bae17a52bb66ee2402c8f6e31d6297..776bede31105c335c8eaaf0bab634dede7f034aa 100644
--- a/compute/zpotrf.c
+++ b/compute/zpotrf.c
@@ -84,7 +84,7 @@
*
******************************************************************************/
int MORSE_zpotrf(MORSE_enum uplo, int N,
- MORSE_Complex64_t *A, int LDA)
+ MORSE_Complex64_t *A, int LDA)
{
int NB;
int status;
@@ -248,7 +248,7 @@ int MORSE_zpotrf_Tile(MORSE_enum uplo, MORSE_desc_t *A)
*
******************************************************************************/
int MORSE_zpotrf_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -286,10 +286,10 @@ int MORSE_zpotrf_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A,
return morse_request_fail(sequence, request, -1);
}
/* Quick return */
-/*
- if (chameleon_max(N, 0) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_max(N, 0) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pzpotrf(uplo, A, sequence, request);
return MORSE_SUCCESS;
diff --git a/compute/zpotri.c b/compute/zpotri.c
index 5b5612914a22be661274cffa987a0d934c88efd1..14711dfa30123b71415cf49f95399e522f763672 100644
--- a/compute/zpotri.c
+++ b/compute/zpotri.c
@@ -75,7 +75,7 @@
*
******************************************************************************/
int MORSE_zpotri(MORSE_enum uplo, int N,
- MORSE_Complex64_t *A, int LDA)
+ MORSE_Complex64_t *A, int LDA)
{
int NB;
int status;
@@ -126,9 +126,9 @@ int MORSE_zpotri(MORSE_enum uplo, int N,
MORSE_zpotri_Tile_Async(uplo, &descA, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -195,7 +195,7 @@ int MORSE_zpotri_Tile(MORSE_enum uplo, MORSE_desc_t *A)
MORSE_zpotri_Tile_Async(uplo, A, sequence, &request);
RUNTIME_desc_flush( A, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -233,7 +233,7 @@ int MORSE_zpotri_Tile(MORSE_enum uplo, MORSE_desc_t *A)
*
******************************************************************************/
int MORSE_zpotri_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -271,10 +271,10 @@ int MORSE_zpotri_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A,
return morse_request_fail(sequence, request, -1);
}
/* Quick return */
-/*
- if (chameleon_max(N, 0) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_max(N, 0) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pztrtri(uplo, MorseNonUnit, A, sequence, request);
morse_pzlauum(uplo, A, sequence, request);
diff --git a/compute/zpotrimm.c b/compute/zpotrimm.c
index b92665ca6ab5eb5ea571d3ddbbb00b4d8c0d3980..ed4f3479f6baea21c5af303dafa34a7bfd400042 100644
--- a/compute/zpotrimm.c
+++ b/compute/zpotrimm.c
@@ -140,13 +140,13 @@ int MORSE_zpotrimm(MORSE_enum uplo, int N,
MORSE_zpotrimm_Tile_Async(uplo, &descA, &descB, &descC, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_zooptile2lap(descB, A, NB, NB, LDB, N, sequence, &request);
- morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
- morse_desc_mat_free(&descC);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descB, A, NB, NB, LDB, N, sequence, &request);
+ morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
+ morse_desc_mat_free(&descC);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -251,7 +251,7 @@ int MORSE_zpotrimm_Tile(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B, MORSE
*
******************************************************************************/
int MORSE_zpotrimm_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B, MORSE_desc_t *C,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -313,7 +313,7 @@ int MORSE_zpotrimm_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B,
/*
morse_pztrtri(uplo, MorseNonUnit, A, sequence, request);
morse_pzlauum(uplo, A, sequence, request);
- */
+ */
return MORSE_SUCCESS;
}
diff --git a/compute/zpotrs.c b/compute/zpotrs.c
index 8311a8b7d86e0845a5a0573153bf45d25ff978a3..65f0f37aabe1bb0753560b1023af3ae9791d1e60 100644
--- a/compute/zpotrs.c
+++ b/compute/zpotrs.c
@@ -81,8 +81,8 @@
*
******************************************************************************/
int MORSE_zpotrs(MORSE_enum uplo, int N, int NRHS,
- MORSE_Complex64_t *A, int LDA,
- MORSE_Complex64_t *B, int LDB)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_Complex64_t *B, int LDB)
{
int NB;
int status;
@@ -143,11 +143,11 @@ int MORSE_zpotrs(MORSE_enum uplo, int N, int NRHS,
MORSE_zpotrs_Tile_Async(uplo, &descA, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
-
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -248,7 +248,7 @@ int MORSE_zpotrs_Tile(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B)
*
******************************************************************************/
int MORSE_zpotrs_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -290,10 +290,10 @@ int MORSE_zpotrs_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B,
return morse_request_fail(sequence, request, -1);
}
/* Quick return */
-/*
- if (chameleon_min(N, NRHS) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(N, NRHS) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pztrsm(MorseLeft, uplo, uplo == MorseUpper ? MorseConjTrans : MorseNoTrans, MorseNonUnit, 1.0, A, B, sequence, request);
morse_pztrsm(MorseLeft, uplo, uplo == MorseUpper ? MorseNoTrans : MorseConjTrans, MorseNonUnit, 1.0, A, B, sequence, request);
diff --git a/compute/zsymm.c b/compute/zsymm.c
index 1bfd9b086618dfe1bf438657479e62b1ec94fca5..e88e9242d8e0fac60924bfd13f73b71b0a93cd9d 100644
--- a/compute/zsymm.c
+++ b/compute/zsymm.c
@@ -107,9 +107,9 @@
*
******************************************************************************/
int MORSE_zsymm(MORSE_enum side, MORSE_enum uplo, int M, int N,
- MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA,
- MORSE_Complex64_t *B, int LDB,
- MORSE_Complex64_t beta, MORSE_Complex64_t *C, int LDC)
+ MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA,
+ MORSE_Complex64_t *B, int LDB,
+ MORSE_Complex64_t beta, MORSE_Complex64_t *C, int LDC)
{
int NB;
int Am;
@@ -186,11 +186,11 @@ int MORSE_zsymm(MORSE_enum side, MORSE_enum uplo, int M, int N,
side, uplo, alpha, &descA, &descB, beta, &descC, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
- morse_desc_mat_free(&descC);
+ morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
+ morse_desc_mat_free(&descC);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -257,8 +257,8 @@ int MORSE_zsymm(MORSE_enum side, MORSE_enum uplo, int M, int N,
*
******************************************************************************/
int MORSE_zsymm_Tile(MORSE_enum side, MORSE_enum uplo,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_Complex64_t beta, MORSE_desc_t *C)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
+ MORSE_Complex64_t beta, MORSE_desc_t *C)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -311,9 +311,9 @@ int MORSE_zsymm_Tile(MORSE_enum side, MORSE_enum uplo,
*
******************************************************************************/
int MORSE_zsymm_Tile_Async(MORSE_enum side, MORSE_enum uplo,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_Complex64_t beta, MORSE_desc_t *C,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
+ MORSE_Complex64_t beta, MORSE_desc_t *C,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
diff --git a/compute/zsyr2k.c b/compute/zsyr2k.c
index 835004eeb3591f87b94698878d9bd4179c4b5652..7a31807e8b369bbdf414f8dfa2be1d38b2e5d37a 100644
--- a/compute/zsyr2k.c
+++ b/compute/zsyr2k.c
@@ -83,7 +83,7 @@
* @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.
*
@@ -109,8 +109,8 @@
*
******************************************************************************/
int MORSE_zsyr2k(MORSE_enum uplo, MORSE_enum trans, int N, int K,
- MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA, MORSE_Complex64_t *B, int LDB,
- MORSE_Complex64_t beta, MORSE_Complex64_t *C, int LDC)
+ MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA, MORSE_Complex64_t *B, int LDB,
+ MORSE_Complex64_t beta, MORSE_Complex64_t *C, int LDC)
{
int NB;
int Am, An;
@@ -135,7 +135,7 @@ int MORSE_zsyr2k(MORSE_enum uplo, MORSE_enum trans, int N, int K,
morse_error("MORSE_zsyr2k", "illegal value of trans");
return -2;
}
- if ( trans == MorseNoTrans ) {
+ if ( trans == MorseNoTrans ) {
Am = N; An = K;
} else {
Am = K; An = N;
@@ -190,11 +190,11 @@ int MORSE_zsyr2k(MORSE_enum uplo, MORSE_enum trans, int N, int K,
MORSE_zsyr2k_Tile_Async(uplo, trans, alpha, &descA, &descB, beta, &descC, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
- morse_desc_mat_free(&descC);
+ morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
+ morse_desc_mat_free(&descC);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -256,8 +256,8 @@ int MORSE_zsyr2k(MORSE_enum uplo, MORSE_enum trans, int N, int K,
*
******************************************************************************/
int MORSE_zsyr2k_Tile(MORSE_enum uplo, MORSE_enum trans,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_Complex64_t beta, MORSE_desc_t *C)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
+ MORSE_Complex64_t beta, MORSE_desc_t *C)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -275,7 +275,7 @@ int MORSE_zsyr2k_Tile(MORSE_enum uplo, MORSE_enum trans,
RUNTIME_desc_flush( B, sequence );
RUNTIME_desc_flush( C, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -310,9 +310,9 @@ int MORSE_zsyr2k_Tile(MORSE_enum uplo, MORSE_enum trans,
*
******************************************************************************/
int MORSE_zsyr2k_Tile_Async(MORSE_enum uplo, MORSE_enum trans,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_Complex64_t beta, MORSE_desc_t *C,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
+ MORSE_Complex64_t beta, MORSE_desc_t *C,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
int N, K;
@@ -392,7 +392,7 @@ int MORSE_zsyr2k_Tile_Async(MORSE_enum uplo, MORSE_enum trans,
/* Quick return */
if ( N == 0 ||
- ((alpha == (MORSE_Complex64_t)0.0 || K == 0) && beta == (MORSE_Complex64_t)1.0))
+ ((alpha == (MORSE_Complex64_t)0.0 || K == 0) && beta == (MORSE_Complex64_t)1.0))
return MORSE_SUCCESS;
morse_pzsyr2k(uplo, trans, alpha, A, B, beta, C, sequence, request);
diff --git a/compute/zsyrk.c b/compute/zsyrk.c
index 70cd975642a889c5c39dbed8d57734c459f7b0c2..74e021d18065c204813997683a8e58e9ea8bbbfe 100644
--- a/compute/zsyrk.c
+++ b/compute/zsyrk.c
@@ -99,8 +99,8 @@
*
******************************************************************************/
int MORSE_zsyrk(MORSE_enum uplo, MORSE_enum trans, int N, int K,
- MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA,
- MORSE_Complex64_t beta, MORSE_Complex64_t *C, int LDC)
+ MORSE_Complex64_t alpha, MORSE_Complex64_t *A, int LDA,
+ MORSE_Complex64_t beta, MORSE_Complex64_t *C, int LDC)
{
int NB;
int Am, An;
@@ -125,7 +125,7 @@ int MORSE_zsyrk(MORSE_enum uplo, MORSE_enum trans, int N, int K,
morse_error("MORSE_zsyrk", "illegal value of trans");
return -2;
}
- if ( trans == MorseNoTrans ) {
+ if ( trans == MorseNoTrans ) {
Am = N; An = K;
} else {
Am = K; An = N;
@@ -174,10 +174,10 @@ int MORSE_zsyrk(MORSE_enum uplo, MORSE_enum trans, int N, int K,
MORSE_zsyrk_Tile_Async(uplo, trans, alpha, &descA, beta, &descC, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descC);
+ morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descC);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -235,8 +235,8 @@ int MORSE_zsyrk(MORSE_enum uplo, MORSE_enum trans, int N, int K,
*
******************************************************************************/
int MORSE_zsyrk_Tile(MORSE_enum uplo, MORSE_enum trans,
- MORSE_Complex64_t alpha, MORSE_desc_t *A,
- MORSE_Complex64_t beta, MORSE_desc_t *C)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A,
+ MORSE_Complex64_t beta, MORSE_desc_t *C)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -253,7 +253,7 @@ int MORSE_zsyrk_Tile(MORSE_enum uplo, MORSE_enum trans,
RUNTIME_desc_flush( A, sequence );
RUNTIME_desc_flush( C, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -288,9 +288,9 @@ int MORSE_zsyrk_Tile(MORSE_enum uplo, MORSE_enum trans,
*
******************************************************************************/
int MORSE_zsyrk_Tile_Async(MORSE_enum uplo, MORSE_enum trans,
- MORSE_Complex64_t alpha, MORSE_desc_t *A,
- MORSE_Complex64_t beta, MORSE_desc_t *C,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A,
+ MORSE_Complex64_t beta, MORSE_desc_t *C,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
int N, K;
@@ -366,7 +366,7 @@ int MORSE_zsyrk_Tile_Async(MORSE_enum uplo, MORSE_enum trans,
/* Quick return */
if ( N == 0 ||
- ((alpha == (MORSE_Complex64_t)0.0 || K == 0) && beta == (MORSE_Complex64_t)1.0))
+ ((alpha == (MORSE_Complex64_t)0.0 || K == 0) && beta == (MORSE_Complex64_t)1.0))
return MORSE_SUCCESS;
morse_pzsyrk(uplo, trans, alpha, A, beta, C, sequence, request);
diff --git a/compute/zsysv.c b/compute/zsysv.c
index bdec5fefc01a314f2c2c8d9cf9b7df817f1bb7a8..5c1f04b7ef856e079239ade84cd296d9ad1213eb 100644
--- a/compute/zsysv.c
+++ b/compute/zsysv.c
@@ -156,11 +156,11 @@ int MORSE_zsysv(MORSE_enum uplo, int N, int NRHS,
MORSE_zsysv_Tile_Async(uplo, &descA, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -210,7 +210,7 @@ int MORSE_zsysv(MORSE_enum uplo, int N, int NRHS,
* @sa MORSE_zsysv
* @sa MORSE_zsysv_Tile_Async
* @sa MORSE_csysv_Tile
-*
+ *
******************************************************************************/
int MORSE_zsysv_Tile(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B)
{
@@ -306,10 +306,10 @@ int MORSE_zsysv_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B,
}
/* Quick return - currently NOT equivalent to LAPACK's
* LAPACK does not have such check for Dsysv */
-/*
- if (chameleon_min(N, NRHS) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(N, NRHS) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pzsytrf(uplo, A, sequence, request);
morse_pztrsm(MorseLeft, uplo, uplo == MorseUpper ? MorseTrans : MorseNoTrans, MorseNonUnit, 1.0, A, B, sequence, request);
diff --git a/compute/zsytrf.c b/compute/zsytrf.c
index 424094d871c41b8c1c46209e86d47efc1579f248..17aaecd4cc60a7c6768ce220c48e0dfc2a830730 100644
--- a/compute/zsytrf.c
+++ b/compute/zsytrf.c
@@ -79,7 +79,7 @@
*
******************************************************************************/
int MORSE_zsytrf(MORSE_enum uplo, int N,
- MORSE_Complex64_t *A, int LDA)
+ MORSE_Complex64_t *A, int LDA)
{
int NB;
int status;
@@ -130,9 +130,9 @@ int MORSE_zsytrf(MORSE_enum uplo, int N,
MORSE_zsytrf_Tile_Async(uplo, &descA, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -230,7 +230,7 @@ int MORSE_zsytrf_Tile(MORSE_enum uplo, MORSE_desc_t *A)
*
******************************************************************************/
int MORSE_zsytrf_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -268,10 +268,10 @@ int MORSE_zsytrf_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A,
return morse_request_fail(sequence, request, -1);
}
/* Quick return */
-/*
- if (chameleon_max(N, 0) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_max(N, 0) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pzsytrf(uplo, A, sequence, request);
return MORSE_SUCCESS;
diff --git a/compute/zsytrs.c b/compute/zsytrs.c
index f1d1b42ee0b1f3f5e1d6fd603d049ac6301fd738..dbdd5c27f404dc3a1d027e281d1760523895b3a9 100644
--- a/compute/zsytrs.c
+++ b/compute/zsytrs.c
@@ -142,11 +142,11 @@ int MORSE_zsytrs(MORSE_enum uplo, int N, int NRHS,
MORSE_zsytrs_Tile_Async(uplo, &descA, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
-
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -283,10 +283,10 @@ int MORSE_zsytrs_Tile_Async(MORSE_enum uplo, MORSE_desc_t *A, MORSE_desc_t *B,
return morse_request_fail(sequence, request, -1);
}
/* Quick return */
-/*
- if (chameleon_min(N, NRHS) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(N, NRHS) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pztrsm(MorseLeft, uplo, uplo == MorseUpper ? MorseTrans : MorseNoTrans, MorseNonUnit, 1.0, A, B, sequence, request);
morse_pztrsm(MorseLeft, uplo, uplo == MorseUpper ? MorseNoTrans : MorseTrans, MorseNonUnit, 1.0, A, B, sequence, request);
diff --git a/compute/ztile.c b/compute/ztile.c
index d23d9b6b8de226e338e3e1e8fd010fa7180f3c24..84a18d4b0417f28ab21e651b1e0b2496ec535cf4 100644
--- a/compute/ztile.c
+++ b/compute/ztile.c
@@ -140,7 +140,7 @@ int MORSE_zLapack_to_Tile(MORSE_Complex64_t *Af77, int LDA, MORSE_desc_t *A)
* @sa MORSE_dTile_to_Lapack
* @sa MORSE_sTile_to_Lapack
*
-******************************************************************************/
+ ******************************************************************************/
int MORSE_zTile_to_Lapack(MORSE_desc_t *A, MORSE_Complex64_t *Af77, int LDA)
{
MORSE_context_t *morse;
diff --git a/compute/ztpgqrt.c b/compute/ztpgqrt.c
index d2b174253810464bfcb061b95997e163242da052..99360ccd0d426354e0853ec78e8028c91e6213e0 100644
--- a/compute/ztpgqrt.c
+++ b/compute/ztpgqrt.c
@@ -221,13 +221,13 @@ int MORSE_ztpgqrt( int M, int N, int K, int L,
MORSE_ztpgqrt_Tile_Async(L, &descV1, descT1, &descV2, descT2, &descQ1, &descQ2, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descQ1, Q1, NB, NB, LDQ1, N, sequence, &request);
- morse_zooptile2lap(descQ2, Q2, NB, NB, LDQ2, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descV1);
- morse_desc_mat_free(&descV2);
- morse_desc_mat_free(&descQ1);
- morse_desc_mat_free(&descQ2);
+ morse_zooptile2lap(descQ1, Q1, NB, NB, LDQ1, N, sequence, &request);
+ morse_zooptile2lap(descQ2, Q2, NB, NB, LDQ2, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descV1);
+ morse_desc_mat_free(&descV2);
+ morse_desc_mat_free(&descQ1);
+ morse_desc_mat_free(&descQ2);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -383,7 +383,7 @@ int MORSE_ztpgqrt_Tile_Async( int L,
{
int minMT;
if (V1->m > V1->n) {
- minMT = V1->nt;
+ minMT = V1->nt;
} else {
minMT = V1->mt;
}
diff --git a/compute/ztpqrt.c b/compute/ztpqrt.c
index ed352901ba033f6fefb7f434a30017aba29a1f4e..e1d19769e2fceb2f3e1dd726a97665af9c1e3144 100644
--- a/compute/ztpqrt.c
+++ b/compute/ztpqrt.c
@@ -195,11 +195,11 @@ int MORSE_ztpqrt( int M, int N, int L,
MORSE_ztpqrt_Tile_Async(L, &descA, &descB, descT, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_zooptile2lap(descB, B, NB, NB, LDB, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
diff --git a/compute/ztradd.c b/compute/ztradd.c
index 2aa2175b7327af92bb32a1b6adcb402716e07471..cb088f2bdb43641556cbfc99f0276bba66ea933d 100644
--- a/compute/ztradd.c
+++ b/compute/ztradd.c
@@ -174,10 +174,10 @@ int MORSE_ztradd(MORSE_enum uplo, MORSE_enum trans, int M, int N,
uplo, trans, alpha, &descA, beta, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap( descB, B, NB, NB, LDB, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap( descB, B, NB, NB, LDB, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -239,8 +239,8 @@ int MORSE_ztradd(MORSE_enum uplo, MORSE_enum trans, int M, int N,
*
******************************************************************************/
int MORSE_ztradd_Tile(MORSE_enum uplo, MORSE_enum trans,
- MORSE_Complex64_t alpha, MORSE_desc_t *A,
- MORSE_Complex64_t beta, MORSE_desc_t *B)
+ MORSE_Complex64_t alpha, MORSE_desc_t *A,
+ MORSE_Complex64_t beta, MORSE_desc_t *B)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
diff --git a/compute/ztrmm.c b/compute/ztrmm.c
index e20dad68661b92e1ca42af6284f5a49a6245eb51..6bb0e62b36a25f8c736025f781e9e1f687399336 100644
--- a/compute/ztrmm.c
+++ b/compute/ztrmm.c
@@ -101,10 +101,10 @@
*
******************************************************************************/
int MORSE_ztrmm(MORSE_enum side, MORSE_enum uplo,
- MORSE_enum transA, MORSE_enum diag,
- int N, int NRHS, MORSE_Complex64_t alpha,
- MORSE_Complex64_t *A, int LDA,
- MORSE_Complex64_t *B, int LDB)
+ MORSE_enum transA, MORSE_enum diag,
+ int N, int NRHS, MORSE_Complex64_t alpha,
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_Complex64_t *B, int LDB)
{
int NB, NA;
int status;
@@ -120,9 +120,9 @@ int MORSE_ztrmm(MORSE_enum side, MORSE_enum uplo,
}
if (side == MorseLeft) {
- NA = N;
+ NA = N;
} else {
- NA = NRHS;
+ NA = NRHS;
}
/* Check input arguments */
@@ -188,10 +188,10 @@ int MORSE_ztrmm(MORSE_enum side, MORSE_enum uplo,
side, uplo, transA, diag, alpha, &descA, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -261,8 +261,8 @@ int MORSE_ztrmm(MORSE_enum side, MORSE_enum uplo,
*
******************************************************************************/
int MORSE_ztrmm_Tile(MORSE_enum side, MORSE_enum uplo,
- MORSE_enum transA, MORSE_enum diag,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B)
+ MORSE_enum transA, MORSE_enum diag,
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -314,9 +314,9 @@ int MORSE_ztrmm_Tile(MORSE_enum side, MORSE_enum uplo,
*
******************************************************************************/
int MORSE_ztrmm_Tile_Async(MORSE_enum side, MORSE_enum uplo,
- MORSE_enum transA, MORSE_enum diag,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_enum transA, MORSE_enum diag,
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
diff --git a/compute/ztrsm.c b/compute/ztrsm.c
index 620a8609d0d8af47ce884bba1a0297cbe1206492..fe914cae9865fbdc3c9b782a95731a41efd93ae4 100644
--- a/compute/ztrsm.c
+++ b/compute/ztrsm.c
@@ -102,10 +102,10 @@
*
******************************************************************************/
int MORSE_ztrsm(MORSE_enum side, MORSE_enum uplo,
- MORSE_enum transA, MORSE_enum diag,
- int N, int NRHS, MORSE_Complex64_t alpha,
- MORSE_Complex64_t *A, int LDA,
- MORSE_Complex64_t *B, int LDB)
+ MORSE_enum transA, MORSE_enum diag,
+ int N, int NRHS, MORSE_Complex64_t alpha,
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_Complex64_t *B, int LDB)
{
int NB, NA;
int status;
@@ -121,9 +121,9 @@ int MORSE_ztrsm(MORSE_enum side, MORSE_enum uplo,
}
if (side == MorseLeft) {
- NA = N;
+ NA = N;
} else {
- NA = NRHS;
+ NA = NRHS;
}
/* Check input arguments */
@@ -186,10 +186,10 @@ int MORSE_ztrsm(MORSE_enum side, MORSE_enum uplo,
side, uplo, transA, diag, alpha, &descA, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -259,8 +259,8 @@ int MORSE_ztrsm(MORSE_enum side, MORSE_enum uplo,
*
******************************************************************************/
int MORSE_ztrsm_Tile(MORSE_enum side, MORSE_enum uplo,
- MORSE_enum transA, MORSE_enum diag,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B)
+ MORSE_enum transA, MORSE_enum diag,
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -277,7 +277,7 @@ int MORSE_ztrsm_Tile(MORSE_enum side, MORSE_enum uplo,
RUNTIME_desc_flush( A, sequence );
RUNTIME_desc_flush( B, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -312,9 +312,9 @@ int MORSE_ztrsm_Tile(MORSE_enum side, MORSE_enum uplo,
*
******************************************************************************/
int MORSE_ztrsm_Tile_Async(MORSE_enum side, MORSE_enum uplo,
- MORSE_enum transA, MORSE_enum diag,
- MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_enum transA, MORSE_enum diag,
+ MORSE_Complex64_t alpha, MORSE_desc_t *A, MORSE_desc_t *B,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
diff --git a/compute/ztrsmpl.c b/compute/ztrsmpl.c
index 0fe3372c90e4f104d2590e13da866eb962b4273d..3d2eb39636de66602312a23cd6ac54dcce8161f5 100644
--- a/compute/ztrsmpl.c
+++ b/compute/ztrsmpl.c
@@ -81,9 +81,9 @@
*
******************************************************************************/
int MORSE_ztrsmpl(int N, int NRHS,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descL, int *IPIV,
- MORSE_Complex64_t *B, int LDB)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descL, int *IPIV,
+ MORSE_Complex64_t *B, int LDB)
{
int NB;
int status;
@@ -140,10 +140,10 @@ int MORSE_ztrsmpl(int N, int NRHS,
MORSE_ztrsmpl_Tile_Async(&descA, descL, IPIV, &descB, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descB);
+ morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descB);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -206,7 +206,7 @@ int MORSE_ztrsmpl_Tile(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV, MORSE_desc_t
RUNTIME_desc_flush( A, sequence );
RUNTIME_desc_flush( B, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -243,7 +243,7 @@ int MORSE_ztrsmpl_Tile(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV, MORSE_desc_t
*
******************************************************************************/
int MORSE_ztrsmpl_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV, MORSE_desc_t *B,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -285,10 +285,10 @@ int MORSE_ztrsmpl_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV, MORSE_
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (chameleon_min(N, NRHS) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(N, NRHS) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pztrsmpl(A, B, L, IPIV, sequence, request);
return MORSE_SUCCESS;
diff --git a/compute/ztrtri.c b/compute/ztrtri.c
index d5462b5555e871cf5dd1229f06fc7cae21d4cb59..51099d09753c0efaea3a0eca64ab5903f94eaece 100644
--- a/compute/ztrtri.c
+++ b/compute/ztrtri.c
@@ -83,7 +83,7 @@
*
******************************************************************************/
int MORSE_ztrtri(MORSE_enum uplo, MORSE_enum diag, int N,
- MORSE_Complex64_t *A, int LDA)
+ MORSE_Complex64_t *A, int LDA)
{
int NB;
int status;
@@ -138,9 +138,9 @@ int MORSE_ztrtri(MORSE_enum uplo, MORSE_enum diag, int N,
MORSE_ztrtri_Tile_Async(uplo, diag, &descA, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
+ morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -214,7 +214,7 @@ int MORSE_ztrtri_Tile(MORSE_enum uplo, MORSE_enum diag, MORSE_desc_t *A)
MORSE_ztrtri_Tile_Async(uplo, diag, A, sequence, &request);
RUNTIME_desc_flush( A, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -251,7 +251,7 @@ int MORSE_ztrtri_Tile(MORSE_enum uplo, MORSE_enum diag, MORSE_desc_t *A)
*
******************************************************************************/
int MORSE_ztrtri_Tile_Async(MORSE_enum uplo, MORSE_enum diag, MORSE_desc_t *A,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
@@ -293,10 +293,10 @@ int MORSE_ztrtri_Tile_Async(MORSE_enum uplo, MORSE_enum diag, MORSE_desc_t *A,
return morse_request_fail(sequence, request, -2);
}
/* Quick return */
-/*
- if (chameleon_max(N, 0) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_max(N, 0) == 0)
+ return MORSE_SUCCESS;
+ */
morse_pztrtri(uplo, diag, A, sequence, request);
return MORSE_SUCCESS;
diff --git a/compute/zunglq.c b/compute/zunglq.c
index c3d30f23059e7428fd7befaaf835437b22d8bd75..4b281a3ad249288b68d20bf238c7ec74241148e0 100644
--- a/compute/zunglq.c
+++ b/compute/zunglq.c
@@ -82,9 +82,9 @@
*
******************************************************************************/
int MORSE_zunglq(int M, int N, int K,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descT,
- MORSE_Complex64_t *Q, int LDQ)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descT,
+ MORSE_Complex64_t *Q, int LDQ)
{
int NB;
int status;
@@ -146,10 +146,10 @@ int MORSE_zunglq(int M, int N, int K,
MORSE_zunglq_Tile_Async(&descA, descT, &descQ, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descQ, Q, NB, NB, LDQ, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descQ);
+ morse_zooptile2lap(descQ, Q, NB, NB, LDQ, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descQ);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -243,7 +243,7 @@ int MORSE_zunglq_Tile(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *Q)
*
******************************************************************************/
int MORSE_zunglq_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *Q,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
MORSE_desc_t D, *Dptr = NULL;
@@ -287,10 +287,10 @@ int MORSE_zunglq_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *Q,
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, Q, LDQ ) */
-/*
- if (chameleon_min(M, N) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(M, N) == 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
diff --git a/compute/zunglq_param.c b/compute/zunglq_param.c
index 39a2250deb544f9eac69d4f498b254d5c1055fdf..00cbb5179de2360256f2a14fb1c92c9816abc3b5 100644
--- a/compute/zunglq_param.c
+++ b/compute/zunglq_param.c
@@ -143,10 +143,10 @@ int MORSE_zunglq_param(const libhqr_tree_t *qrtree, int M, int N, int K,
MORSE_zunglq_param_Tile_Async(qrtree, &descA, descTS, descTT, &descQ, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descQ, Q, NB, NB, LDQ, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descQ);
+ morse_zooptile2lap(descQ, Q, NB, NB, LDQ, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descQ);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -288,10 +288,10 @@ int MORSE_zunglq_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_desc_t *A,
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, Q, LDQ ) */
-/*
- if (chameleon_min(M, N) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(M, N) == 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
int m = chameleon_min(A->mt, A->nt) * A->mb;
diff --git a/compute/zungqr.c b/compute/zungqr.c
index d271bb095453fe3232783d8f1ae735ad26eac13f..804daad2473d00b77332d1c69eee17247e549bd5 100644
--- a/compute/zungqr.c
+++ b/compute/zungqr.c
@@ -82,9 +82,9 @@
*
******************************************************************************/
int MORSE_zungqr(int M, int N, int K,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descT,
- MORSE_Complex64_t *Q, int LDQ)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descT,
+ MORSE_Complex64_t *Q, int LDQ)
{
int NB;
int status;
@@ -145,10 +145,10 @@ int MORSE_zungqr(int M, int N, int K,
MORSE_zungqr_Tile_Async(&descA, descT, &descQ, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descQ, Q, NB, NB, LDQ, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descQ);
+ morse_zooptile2lap(descQ, Q, NB, NB, LDQ, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descQ);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -207,7 +207,7 @@ int MORSE_zungqr_Tile(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *Q)
RUNTIME_desc_flush( A, sequence );
RUNTIME_desc_flush( Q, sequence );
morse_sequence_wait(morse, sequence);
-
+
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
@@ -242,7 +242,7 @@ int MORSE_zungqr_Tile(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *Q)
*
******************************************************************************/
int MORSE_zungqr_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *Q,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
MORSE_desc_t D, *Dptr = NULL;
@@ -285,10 +285,10 @@ int MORSE_zungqr_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *Q,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (N <= 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (N <= 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
int n = chameleon_min(A->mt, A->nt) * A->nb;
diff --git a/compute/zungqr_param.c b/compute/zungqr_param.c
index 5b99249ad99c3f644d909250585278c1595dc557..8fbc7d447098048c72233203bb72dd0ddbb6533a 100644
--- a/compute/zungqr_param.c
+++ b/compute/zungqr_param.c
@@ -286,10 +286,10 @@ int MORSE_zungqr_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_desc_t *A,
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return */
-/*
- if (N <= 0)
- return MORSE_SUCCESS;
- */
+ /*
+ if (N <= 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
int n = chameleon_min(A->mt, A->nt) * A->nb;
diff --git a/compute/zunmlq.c b/compute/zunmlq.c
index fb497ddee9261a3aaff306738f3ca3ddf9758669..e0769ff47f5ad2e7beeb95613f69b8a4f7a1f473 100644
--- a/compute/zunmlq.c
+++ b/compute/zunmlq.c
@@ -106,9 +106,9 @@
*
******************************************************************************/
int MORSE_zunmlq(MORSE_enum side, MORSE_enum trans, int M, int N, int K,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descT,
- MORSE_Complex64_t *C, int LDC)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descT,
+ MORSE_Complex64_t *C, int LDC)
{
int NB, An;
int status;
@@ -184,10 +184,10 @@ int MORSE_zunmlq(MORSE_enum side, MORSE_enum trans, int M, int N, int K,
side, trans, &descA, descT, &descC, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descC);
+ morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descC);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -244,7 +244,7 @@ int MORSE_zunmlq(MORSE_enum side, MORSE_enum trans, int M, int N, int K,
*
******************************************************************************/
int MORSE_zunmlq_Tile(MORSE_enum side, MORSE_enum trans,
- MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *C)
+ MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *C)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -296,8 +296,8 @@ int MORSE_zunmlq_Tile(MORSE_enum side, MORSE_enum trans,
*
******************************************************************************/
int MORSE_zunmlq_Tile_Async(MORSE_enum side, MORSE_enum trans,
- MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *C,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *C,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
MORSE_desc_t D, *Dptr = NULL;
@@ -347,10 +347,10 @@ int MORSE_zunmlq_Tile_Async(MORSE_enum side, MORSE_enum trans,
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, C, LDC ) */
-/*
- if (chameleon_min(M, chameleon_min(N, K)) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(M, chameleon_min(N, K)) == 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
int m = chameleon_min(A->mt, A->nt) * A->mb;
diff --git a/compute/zunmlq_param.c b/compute/zunmlq_param.c
index 4492c2eed8edcaec9bd717414d87f07ebad882c8..49ead29a872117e8118a99fd9df3d2a812fe8f2c 100644
--- a/compute/zunmlq_param.c
+++ b/compute/zunmlq_param.c
@@ -183,10 +183,10 @@ int MORSE_zunmlq_param(const libhqr_tree_t *qrtree, MORSE_enum side, MORSE_enum
qrtree, side, trans, &descA, descTS, descTT, &descC, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descC);
+ morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descC);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -350,10 +350,10 @@ int MORSE_zunmlq_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_enum side,
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, C, LDC ) */
-/*
- if (chameleon_min(M, chameleon_min(N, K)) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(M, chameleon_min(N, K)) == 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
diff --git a/compute/zunmqr.c b/compute/zunmqr.c
index b6eb340da4bb4f23aa556e8c45b72d6b227cfa0c..110e901c5b1519263537d6294fd4a8bbe42f4921 100644
--- a/compute/zunmqr.c
+++ b/compute/zunmqr.c
@@ -108,9 +108,9 @@
*
******************************************************************************/
int MORSE_zunmqr(MORSE_enum side, MORSE_enum trans, int M, int N, int K,
- MORSE_Complex64_t *A, int LDA,
- MORSE_desc_t *descT,
- MORSE_Complex64_t *C, int LDC)
+ MORSE_Complex64_t *A, int LDA,
+ MORSE_desc_t *descT,
+ MORSE_Complex64_t *C, int LDC)
{
int NB, Am;
int status;
@@ -187,10 +187,10 @@ int MORSE_zunmqr(MORSE_enum side, MORSE_enum trans, int M, int N, int K,
side, trans, &descA, descT, &descC, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descC);
+ morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descC);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -248,7 +248,7 @@ int MORSE_zunmqr(MORSE_enum side, MORSE_enum trans, int M, int N, int K,
*
******************************************************************************/
int MORSE_zunmqr_Tile(MORSE_enum side, MORSE_enum trans,
- MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *C)
+ MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *C)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
@@ -300,8 +300,8 @@ int MORSE_zunmqr_Tile(MORSE_enum side, MORSE_enum trans,
*
******************************************************************************/
int MORSE_zunmqr_Tile_Async(MORSE_enum side, MORSE_enum trans,
- MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *C,
- MORSE_sequence_t *sequence, MORSE_request_t *request)
+ MORSE_desc_t *A, MORSE_desc_t *T, MORSE_desc_t *C,
+ MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
MORSE_desc_t D, *Dptr = NULL;
@@ -351,10 +351,10 @@ int MORSE_zunmqr_Tile_Async(MORSE_enum side, MORSE_enum trans,
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, C, LDC ) */
-/*
- if (chameleon_min(M, chameleon_min(N, K)) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(M, chameleon_min(N, K)) == 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{
@@ -364,7 +364,7 @@ int MORSE_zunmqr_Tile_Async(MORSE_enum side, MORSE_enum trans,
}
#endif
- if (morse->householder == MORSE_FLAT_HOUSEHOLDER) {
+ if (morse->householder == MORSE_FLAT_HOUSEHOLDER) {
if ( (trans == MorseConjTrans) &&
(side == MorseLeft) ) {
morse_pzunmqr(side, trans, A, C, T, Dptr, sequence, request);
diff --git a/compute/zunmqr_param.c b/compute/zunmqr_param.c
index bd5ab11c8eb60122bf2d9e715c9b0229c2189ee9..67365cf93a7e8591948361d30969ba30d2526acd 100644
--- a/compute/zunmqr_param.c
+++ b/compute/zunmqr_param.c
@@ -184,14 +184,14 @@ int MORSE_zunmqr_param(const libhqr_tree_t *qrtree,
C, NB, NB, LDC, N, M, N, sequence, &request );
/* Call the tile interface */
- MORSE_zunmqr_param_Tile_Async(
- qrtree, side, trans, &descA, descTS, descTT, &descC, sequence, &request);
+ MORSE_zunmqr_param_Tile_Async(
+ qrtree, side, trans, &descA, descTS, descTT, &descC, sequence, &request);
/* Submit the matrix conversion */
- morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
- morse_sequence_wait(morse, sequence);
- morse_desc_mat_free(&descA);
- morse_desc_mat_free(&descC);
+ morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
+ morse_sequence_wait(morse, sequence);
+ morse_desc_mat_free(&descA);
+ morse_desc_mat_free(&descC);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
@@ -357,10 +357,10 @@ int MORSE_zunmqr_param_Tile_Async(const libhqr_tree_t *qrtree,
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, C, LDC ) */
-/*
- if (chameleon_min(M, chameleon_min(N, K)) == 0)
- return MORSE_SUCCESS;
-*/
+ /*
+ if (chameleon_min(M, chameleon_min(N, K)) == 0)
+ return MORSE_SUCCESS;
+ */
#if defined(CHAMELEON_COPY_DIAG)
{