From 35fe8c539096b82afbc8c03299dd4ce9e33df1cb Mon Sep 17 00:00:00 2001
From: Mathieu Faverge <mathieu.faverge@inria.fr>
Date: Mon, 22 Jan 2018 18:41:22 +0100
Subject: [PATCH] Indent and whitespace cleanup
---
compute/zgeadd.c | 8 ++++----
compute/zgelqf.c | 20 ++++++++++----------
compute/zgelqf_param.c | 14 +++++++-------
compute/zgelqs.c | 22 +++++++++++-----------
compute/zgelqs_param.c | 18 +++++++++---------
compute/zgels.c | 34 +++++++++++++++++-----------------
compute/zgemm.c | 12 ++++++------
compute/zgeqrf.c | 20 ++++++++++----------
compute/zgeqrf_param.c | 18 +++++++++---------
compute/zgeqrs.c | 30 +++++++++++++++---------------
compute/zgeqrs_param.c | 10 +++++-----
compute/zgesv_incpiv.c | 30 +++++++++++++++---------------
compute/zgesv_nopiv.c | 22 +++++++++++-----------
compute/zgesvd.c | 12 ++++++------
compute/zgetrf_incpiv.c | 20 ++++++++++----------
compute/zgetrf_nopiv.c | 8 ++++----
compute/zgetrs_incpiv.c | 20 ++++++++++----------
compute/zgetrs_nopiv.c | 16 ++++++++--------
compute/zheevd.c | 20 ++++++++++----------
compute/zhemm.c | 28 ++++++++++++++--------------
compute/zher2k.c | 32 ++++++++++++++++----------------
compute/zherk.c | 28 ++++++++++++++--------------
compute/zlacpy.c | 16 ++++++++--------
compute/zlange.c | 10 +++++-----
compute/zlanhe.c | 4 ++--
compute/zlansy.c | 8 ++++----
compute/zlantr.c | 10 +++++-----
compute/zlascal.c | 14 +++++++-------
compute/zlaset.c | 20 ++++++++++----------
compute/zlauum.c | 22 +++++++++++-----------
compute/zplgsy.c | 2 +-
compute/zposv.c | 28 ++++++++++++++--------------
compute/zpotrf.c | 12 ++++++------
compute/zpotri.c | 20 ++++++++++----------
compute/zpotrimm.c | 18 +++++++++---------
compute/zpotrs.c | 24 ++++++++++++------------
compute/zsymm.c | 26 +++++++++++++-------------
compute/zsyr2k.c | 32 ++++++++++++++++----------------
compute/zsyrk.c | 28 ++++++++++++++--------------
compute/zsysv.c | 20 ++++++++++----------
compute/zsytrf.c | 18 +++++++++---------
compute/zsytrs.c | 18 +++++++++---------
compute/ztile.c | 2 +-
compute/ztpgqrt.c | 16 ++++++++--------
compute/ztpqrt.c | 10 +++++-----
compute/ztradd.c | 12 ++++++------
compute/ztrmm.c | 30 +++++++++++++++---------------
compute/ztrsm.c | 32 ++++++++++++++++----------------
compute/ztrsmpl.c | 26 +++++++++++++-------------
compute/ztrtri.c | 20 ++++++++++----------
compute/zunglq.c | 24 ++++++++++++------------
compute/zunglq_param.c | 16 ++++++++--------
compute/zungqr.c | 26 +++++++++++++-------------
compute/zungqr_param.c | 8 ++++----
compute/zunmlq.c | 28 ++++++++++++++--------------
compute/zunmlq_param.c | 16 ++++++++--------
compute/zunmqr.c | 30 +++++++++++++++---------------
compute/zunmqr_param.c | 20 ++++++++++----------
58 files changed, 554 insertions(+), 554 deletions(-)
diff --git a/compute/zgeadd.c b/compute/zgeadd.c
index ecf975a90..fc18ca2d3 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 100a0e130..191ae7a0f 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 22d8dacdd..270dba3ba 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 b9f501378..124188a51 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 b6faae1ba..0a03c9cbf 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 c3a7c852c..33d50af97 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 b830977a3..00f7a3b14 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 8e32eb570..00a462be3 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 00fce04af..c5db6d1d8 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 2c9012db3..30d415146 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 f74ca1582..bf285e431 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 f22c79585..1c1abc516 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 164ee3109..d1fcc7c66 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 d3f1e8b1d..d7e7060b9 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 809df1bc2..f12be25c1 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 10e9270bf..87f0d117c 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 392f3c8ae..8be117d8a 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 5f4448f22..08858c5d6 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 5254ea766..9ea486242 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 5d31cb379..7cf7374f3 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 93d3da9e1..a4c3f059d 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 de717dd8c..64b671dc9 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 828f80445..9c749e85e 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 8c196310e..3267d7461 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 299246590..455f74ec9 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 3078ce2a9..9a10fe789 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 80ac58305..8ae33b76b 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 91315d994..242fb1aee 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 58fee1e20..9f74ff42a 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 851a2adfe..eb16a1751 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 7c8e8aeda..d0264a234 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 f09a6f707..01b79e4cd 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 8468bdb65..776bede31 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 5b5612914..14711dfa3 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 b92665ca6..ed4f3479f 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 8311a8b7d..65f0f37aa 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 1bfd9b086..e88e9242d 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 835004eeb..7a31807e8 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 70cd97564..74e021d18 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 bdec5fefc..5c1f04b7e 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 424094d87..17aaecd4c 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 f1d1b42ee..dbdd5c27f 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 d23d9b6b8..84a18d4b0 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 d2b174253..99360ccd0 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 ed352901b..e1d19769e 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 2aa2175b7..cb088f2bd 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 e20dad686..6bb0e62b3 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 620a8609d..fe914cae9 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 0fe3372c9..3d2eb3963 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 d5462b555..51099d097 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 c3d30f230..4b281a3ad 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 39a2250de..00cbb5179 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 d271bb095..804daad24 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 5b99249ad..8fbc7d447 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 fb497ddee..e0769ff47 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 4492c2eed..49ead29a8 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 b6eb340da..110e901c5 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 bd5ab11c8..67365cf93 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)
{
--
GitLab