From b94fbc7d4a9aa8e3db108c5dcf940090d88efa23 Mon Sep 17 00:00:00 2001
From: Mathieu Faverge <mathieu.faverge@inria.fr>
Date: Sat, 31 Mar 2018 13:43:45 +0200
Subject: [PATCH] Fix spaces
---
.dir-locals.el | 105 +++++++++
CMakeLists.txt | 2 +-
src/integer_sort.c | 1 -
src/spm.c | 12 +-
src/spm_read_driver.c | 2 +-
src/z_spm.c | 399 +++++++++++++++++------------------
src/z_spm_expand.c | 1 -
src/z_spm_integer.c | 5 +-
src/z_spm_matrixvector.c | 260 +++++++++++------------
tests/CMakeLists.txt | 1 -
tests/get_options.c | 8 +-
tests/spm_convert_tests.c | 8 +-
tests/spm_dof_expand_tests.c | 8 +-
tests/spm_dof_matvec_tests.c | 8 +-
tests/spm_dof_norm_tests.c | 8 +-
tests/spm_matvec_tests.c | 8 +-
tests/spm_norm_tests.c | 8 +-
tests/spm_tests.h | 74 +++----
tests/validate_convert.sh | 1 -
tests/validate_expand.sh | 1 -
20 files changed, 509 insertions(+), 411 deletions(-)
create mode 100644 .dir-locals.el
diff --git a/.dir-locals.el b/.dir-locals.el
new file mode 100644
index 00000000..abafe960
--- /dev/null
+++ b/.dir-locals.el
@@ -0,0 +1,105 @@
+;; C style for Emacs, to assist in following DAGuE coding conventions (originally from PETSc project)
+((nil . ((indent-tabs-mode . nil)
+ (tab-width . 8)
+ (show-trailing-whitespace . t)))
+ (c-mode . ((c-tab-always-indent . t)
+ (c-basic-offset . 4)
+ (c-comment-only-line-offset . 0)
+ (c-hanging-braces-alist . ((substatement-open after)
+ (brace-list-open after)
+ (brace-entry-open)
+ (defun-open after)
+ (class-open after)
+ (inline-open after)
+ (block-open after)
+ (block-close . c-snug-do-while)
+ (statement-case-open after)
+ (substatement after)))
+ (c-hanging-colons-alist . ((member-init-intro before)
+ (inher-intro)
+ (case-label after)
+ (label after)
+ (access-label after)))
+ (c-hanging-semi&comma-criteria . (c-semi&comma-no-newlines-before-nonblanks))
+ (c-cleanup-list . (scope-operator
+ brace-else-brace
+ brace-elseif-brace
+ brace-catch-brace
+ empty-defun-braces
+ list-close-comma
+ defun-close-semi))
+ (c-offsets-alist . ((inexpr-class . +)
+ (inexpr-statement . +)
+ (lambda-intro-cont . +)
+ (inlambda . c-lineup-inexpr-block)
+ (template-args-cont c-lineup-template-args +)
+ (incomposition . +)
+ (inmodule . +)
+ (innamespace . +)
+ (inextern-lang . +)
+ (composition-close . 0)
+ (module-close . 0)
+ (namespace-close . 0)
+ (extern-lang-close . 0)
+ (composition-open . 0)
+ (module-open . 0)
+ (namespace-open . 0)
+ (extern-lang-open . 0)
+ (objc-method-call-cont c-lineup-ObjC-method-call-colons c-lineup-ObjC-method-call +)
+ (objc-method-args-cont . c-lineup-ObjC-method-args)
+ (objc-method-intro .
+ [0])
+ (friend . 0)
+ (cpp-define-intro c-lineup-cpp-define +)
+ (cpp-macro-cont . +)
+ (cpp-macro .
+ [0])
+ (inclass . +)
+ (stream-op . c-lineup-streamop)
+ (arglist-cont-nonempty c-lineup-gcc-asm-reg c-lineup-arglist)
+ (arglist-cont c-lineup-gcc-asm-reg 0)
+ (arglist-intro . +)
+ (catch-clause . 0)
+ (else-clause . 0)
+ (do-while-closure . 0)
+ (label . 2)
+ (access-label . -)
+ (substatement-label . 2)
+ (substatement . +)
+ (statement-case-open . 0)
+ (statement-case-intro . +)
+ (statement-block-intro . +)
+ (statement-cont . +)
+ (statement . 0)
+ (brace-entry-open . 0)
+ (brace-list-entry . 0)
+ (brace-list-intro . +)
+ (brace-list-close . 0)
+ (brace-list-open . 0)
+ (block-close . 0)
+ (inher-cont . c-lineup-multi-inher)
+ (inher-intro . +)
+ (member-init-cont . c-lineup-multi-inher)
+ (member-init-intro . +)
+ (annotation-var-cont . +)
+ (annotation-top-cont . 0)
+ (topmost-intro-cont . c-lineup-topmost-intro-cont)
+ (topmost-intro . 0)
+ (knr-argdecl . 0)
+ (func-decl-cont . +)
+ (inline-close . 0)
+ (inline-open . +)
+ (class-close . 0)
+ (class-open . 0)
+ (defun-block-intro . +)
+ (defun-close . 0)
+ (defun-open . 0)
+ (string . c-lineup-dont-change)
+ (arglist-close . c-lineup-arglist)
+ (substatement-open . 0)
+ (case-label . 0)
+ (block-open . 0)
+ (c . 1)
+ (comment-intro . 0)
+ (knr-argdecl-intro . -)))
+ (fill-column . 80))))
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5cdca963..1ae3465f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -39,7 +39,7 @@ else()
option(SPM_INT64
"Choose between int32 and int64 for integer representation" ON)
endif()
-
+
if ( PASTIX_WITH_FORTRAN )
set( SPM_WITH_FORTRAN ${SPM_WITH_FORTRAN} )
else()
diff --git a/src/integer_sort.c b/src/integer_sort.c
index 838b6065..acf887e8 100644
--- a/src/integer_sort.c
+++ b/src/integer_sort.c
@@ -275,4 +275,3 @@ const spm_int_t total_elems) /*+ Number of entries to sort +*/
}
}
}
-
diff --git a/src/spm.c b/src/spm.c
index c6a1c4f1..b2737556 100644
--- a/src/spm.c
+++ b/src/spm.c
@@ -206,23 +206,23 @@ spmExit( spmatrix_t *spm )
{
if(spm->colptr != NULL) {
free(spm->colptr);
- spm->colptr = NULL;
+ spm->colptr = NULL;
}
if(spm->rowptr != NULL) {
free(spm->rowptr);
- spm->rowptr = NULL;
+ spm->rowptr = NULL;
}
if(spm->loc2glob != NULL) {
free(spm->loc2glob);
- spm->loc2glob = NULL;
+ spm->loc2glob = NULL;
}
if(spm->values != NULL) {
free(spm->values);
- spm->values = NULL;
+ spm->values = NULL;
}
if(spm->dofs != NULL) {
free(spm->dofs);
- spm->dofs = NULL;
+ spm->dofs = NULL;
}
}
@@ -269,7 +269,7 @@ spmBase( spmatrix_t *spm,
baseadj = baseval - spmFindBase( spm );
if (baseadj == 0)
- return;
+ return;
n = spm->n;
nnz = spm->nnz;
diff --git a/src/spm_read_driver.c b/src/spm_read_driver.c
index 421128e3..e9a3a296 100644
--- a/src/spm_read_driver.c
+++ b/src/spm_read_driver.c
@@ -167,7 +167,7 @@ spmReadDriver( spm_driver_t driver,
default:
fprintf(stderr, "spmReadDriver: Driver not implemented\n");
- return SPM_ERR_UNKNOWN;
+ return SPM_ERR_UNKNOWN;
}
}
diff --git a/src/z_spm.c b/src/z_spm.c
index 090e5bdf..2dc33b8a 100644
--- a/src/z_spm.c
+++ b/src/z_spm.c
@@ -50,42 +50,42 @@ z_spmSort( spmatrix_t *spm )
(void)sortptr;
if (spm->dof > 1){
- fprintf(stderr, "z_spmSort: Number of dof (%d) greater than one not supported\n", (int)spm->dof);
- exit(1);
+ fprintf(stderr, "z_spmSort: Number of dof (%d) greater than one not supported\n", (int)spm->dof);
+ exit(1);
}
/* Sort in place each subset */
if ( spm->fmttype == SpmCSC ) {
- for (i=0; i<n; i++, colptr++)
- {
- size = colptr[1] - colptr[0];
+ for (i=0; i<n; i++, colptr++)
+ {
+ size = colptr[1] - colptr[0];
#if defined(PRECISION_p)
- spmIntSort1Asc1( rowptr, size );
+ spmIntSort1Asc1( rowptr, size );
#else
- sortptr[0] = rowptr;
- sortptr[1] = values;
- z_spmIntFltSortAsc( sortptr, size );
+ sortptr[0] = rowptr;
+ sortptr[1] = values;
+ z_spmIntFltSortAsc( sortptr, size );
#endif
- rowptr += size;
- values += size;
- }
+ rowptr += size;
+ values += size;
+ }
}
else if ( spm->fmttype == SpmCSR ) {
- for (i=0; i<n; i++, rowptr++)
- {
- size = rowptr[1] - rowptr[0];
+ for (i=0; i<n; i++, rowptr++)
+ {
+ size = rowptr[1] - rowptr[0];
#if defined(PRECISION_p)
- spmIntSort1Asc1( rowptr, size );
+ spmIntSort1Asc1( rowptr, size );
#else
- sortptr[0] = colptr;
- sortptr[1] = values;
- z_spmIntFltSortAsc( sortptr, size );
+ sortptr[0] = colptr;
+ sortptr[1] = values;
+ z_spmIntFltSortAsc( sortptr, size );
#endif
- colptr += size;
- values += size;
- }
+ colptr += size;
+ values += size;
+ }
}
}
@@ -128,55 +128,55 @@ z_spmMergeDuplicate( spmatrix_t *spm )
spm_int_t merge = 0;
if ( spm->fmttype == SpmCSC ) {
- idx = 0;
- for (i=0; i<n; i++, colptr++)
- {
- size = colptr[1] - colptr[0];
- for (j = 0; j < size;
- j++, oldrow++, oldval+=dof2, newrow++, newval+=dof2, idx++)
- {
- if ( newrow != oldrow ) {
- newrow[0] = oldrow[0];
+ idx = 0;
+ for (i=0; i<n; i++, colptr++)
+ {
+ size = colptr[1] - colptr[0];
+ for (j = 0; j < size;
+ j++, oldrow++, oldval+=dof2, newrow++, newval+=dof2, idx++)
+ {
+ if ( newrow != oldrow ) {
+ newrow[0] = oldrow[0];
#if !defined(PRECISION_p)
- memcpy( newval, oldval, dof2 * sizeof(spm_complex64_t) );
+ memcpy( newval, oldval, dof2 * sizeof(spm_complex64_t) );
#endif
- }
+ }
- while( ((j+1) < size) && (newrow[0] == oldrow[1]) ) {
- j++; oldrow++; oldval+=dof2;
+ while( ((j+1) < size) && (newrow[0] == oldrow[1]) ) {
+ j++; oldrow++; oldval+=dof2;
#if !defined(PRECISION_p)
- /* Merge the two sets of values */
- for (d = 0; d < dof2; d++) {
- newval[d] += oldval[d];
- }
+ /* Merge the two sets of values */
+ for (d = 0; d < dof2; d++) {
+ newval[d] += oldval[d];
+ }
#endif
- merge++;
- }
- }
- assert( ((merge == 0) && ( colptr[1] == idx+baseval)) ||
- ((merge != 0) && ( colptr[1] > idx+baseval)) );
-
- colptr[1] = idx + baseval;
- }
- assert( ((merge == 0) && (spm->nnz == idx)) ||
- ((merge != 0) && (spm->nnz - merge == idx)) );
-
- if (merge > 0) {
- spm->nnz = spm->nnz - merge;
- spm->gnnz = spm->nnz;
-
- newrow = malloc( spm->nnz * sizeof(spm_int_t) );
- memcpy( newrow, spm->rowptr, spm->nnz * sizeof(spm_int_t) );
- free(spm->rowptr);
- spm->rowptr = newrow;
+ merge++;
+ }
+ }
+ assert( ((merge == 0) && ( colptr[1] == idx+baseval)) ||
+ ((merge != 0) && ( colptr[1] > idx+baseval)) );
+
+ colptr[1] = idx + baseval;
+ }
+ assert( ((merge == 0) && (spm->nnz == idx)) ||
+ ((merge != 0) && (spm->nnz - merge == idx)) );
+
+ if (merge > 0) {
+ spm->nnz = spm->nnz - merge;
+ spm->gnnz = spm->nnz;
+
+ newrow = malloc( spm->nnz * sizeof(spm_int_t) );
+ memcpy( newrow, spm->rowptr, spm->nnz * sizeof(spm_int_t) );
+ free(spm->rowptr);
+ spm->rowptr = newrow;
#if !defined(PRECISION_p)
- newval = malloc( spm->nnz * dof2 * sizeof(spm_int_t) );
- memcpy( newval, spm->values, spm->nnz * dof2 * sizeof(spm_complex64_t) );
- free(spm->values);
- spm->values = newval;
+ newval = malloc( spm->nnz * dof2 * sizeof(spm_int_t) );
+ memcpy( newval, spm->values, spm->nnz * dof2 * sizeof(spm_complex64_t) );
+ free(spm->values);
+ spm->values = newval;
#endif
- }
+ }
}
(void)d;
@@ -223,155 +223,154 @@ z_spmSymmetrize( spmatrix_t *spm )
toaddsze = 0;
if ( (spm->fmttype == SpmCSC) || (spm->fmttype == SpmCSR) ) {
- if (spm->fmttype == SpmCSC) {
- oldcol = spm->colptr;
- coltmp = spm->colptr;
- oldrow = spm->rowptr;
- rowtmp = spm->rowptr;
- }
- else {
- oldcol = spm->rowptr;
- coltmp = spm->rowptr;
- oldrow = spm->colptr;
- rowtmp = spm->colptr;
- }
-
- baseval = oldcol[0];
- for (i=0; i<n; i++, coltmp++)
- {
- size = coltmp[1] - coltmp[0];
- for (r=0; r<size; r++, rowtmp++ )
- {
- j = rowtmp[0]-baseval;
- if ( i != j ) {
- /* Look for the element (j, i) */
- spm_int_t frow = oldcol[ j ] - baseval;
- spm_int_t lrow = oldcol[ j+1 ] - baseval;
- int found = 0;
-
- for (k = frow; (k < lrow); k++)
- {
- if (i == (oldrow[k]-baseval))
- {
- found = 1;
- break;
- }
- else if ( i < (oldrow[k]-baseval))
- {
- /* The spm is sorted so we will not find it later */
- break;
- }
- }
-
- if ( !found ) {
- if ( newcol == NULL ) {
- newcol = malloc( (spm->n+1) * sizeof(spm_int_t) );
- for (k=0; k<spm->n; k++) {
- newcol[k] = oldcol[k+1] - oldcol[k];
- }
-
- /* Let's start with a buffer that will contain 5% of extra elements */
- toaddsze = spm_imax( 0.05 * (double)spm->nnz, 1 );
- toaddtab = malloc( 2*toaddsze * sizeof(spm_int_t) );
- }
-
- if (toaddcnt >= toaddsze) {
- toaddsze *= 2;
- toaddtab = (spm_int_t*)realloc( toaddtab, 2*toaddsze*sizeof(spm_int_t) );
- }
-
- /* Newcol stores the number of elements per column */
- newcol[ j ]++;
- /* toaddtab stores the couples (j, i) to be added in the final sparse matrix */
- toaddtab[ toaddcnt * 2 ] = j;
- toaddtab[ toaddcnt * 2 + 1 ] = i;
- toaddcnt++;
- }
- }
- }
- }
-
- if (toaddcnt > 0) {
- spm_int_t newsize, oldsize;
-
- /* Sort the array per column */
- spmIntSort2Asc1(toaddtab, toaddcnt);
-
- spm->nnz = spm->nnz + toaddcnt;
- spm->gnnz = spm->nnz;
-
- newrow = malloc( spm->nnz * sizeof(spm_int_t) );
+ if (spm->fmttype == SpmCSC) {
+ oldcol = spm->colptr;
+ coltmp = spm->colptr;
+ oldrow = spm->rowptr;
+ rowtmp = spm->rowptr;
+ }
+ else {
+ oldcol = spm->rowptr;
+ coltmp = spm->rowptr;
+ oldrow = spm->colptr;
+ rowtmp = spm->colptr;
+ }
+
+ baseval = oldcol[0];
+ for (i=0; i<n; i++, coltmp++)
+ {
+ size = coltmp[1] - coltmp[0];
+ for (r=0; r<size; r++, rowtmp++ )
+ {
+ j = rowtmp[0]-baseval;
+ if ( i != j ) {
+ /* Look for the element (j, i) */
+ spm_int_t frow = oldcol[ j ] - baseval;
+ spm_int_t lrow = oldcol[ j+1 ] - baseval;
+ int found = 0;
+
+ for (k = frow; (k < lrow); k++)
+ {
+ if (i == (oldrow[k]-baseval))
+ {
+ found = 1;
+ break;
+ }
+ else if ( i < (oldrow[k]-baseval))
+ {
+ /* The spm is sorted so we will not find it later */
+ break;
+ }
+ }
+
+ if ( !found ) {
+ if ( newcol == NULL ) {
+ newcol = malloc( (spm->n+1) * sizeof(spm_int_t) );
+ for (k=0; k<spm->n; k++) {
+ newcol[k] = oldcol[k+1] - oldcol[k];
+ }
+
+ /* Let's start with a buffer that will contain 5% of extra elements */
+ toaddsze = spm_imax( 0.05 * (double)spm->nnz, 1 );
+ toaddtab = malloc( 2*toaddsze * sizeof(spm_int_t) );
+ }
+
+ if (toaddcnt >= toaddsze) {
+ toaddsze *= 2;
+ toaddtab = (spm_int_t*)realloc( toaddtab, 2*toaddsze*sizeof(spm_int_t) );
+ }
+
+ /* Newcol stores the number of elements per column */
+ newcol[ j ]++;
+ /* toaddtab stores the couples (j, i) to be added in the final sparse matrix */
+ toaddtab[ toaddcnt * 2 ] = j;
+ toaddtab[ toaddcnt * 2 + 1 ] = i;
+ toaddcnt++;
+ }
+ }
+ }
+ }
+
+ if (toaddcnt > 0) {
+ spm_int_t newsize, oldsize;
+
+ /* Sort the array per column */
+ spmIntSort2Asc1(toaddtab, toaddcnt);
+
+ spm->nnz = spm->nnz + toaddcnt;
+ spm->gnnz = spm->nnz;
+
+ newrow = malloc( spm->nnz * sizeof(spm_int_t) );
#if !defined(PRECISION_p)
- newval = malloc( spm->nnz * dof2 * sizeof(spm_complex64_t) );
+ newval = malloc( spm->nnz * dof2 * sizeof(spm_complex64_t) );
#endif
- coltmp = newcol;
- rowtmp = newrow;
- valtmp = newval;
- oldval = spm->values;
- toaddtmp = toaddtab;
-
- newsize = coltmp[0];
- coltmp[0] = baseval;
- for (i=0; i<n; i++, coltmp++, oldcol++)
- {
- /* Copy the existing elements */
- oldsize = oldcol[1] - oldcol[0];
- memcpy( rowtmp, oldrow, oldsize * sizeof(spm_int_t) );
+ coltmp = newcol;
+ rowtmp = newrow;
+ valtmp = newval;
+ oldval = spm->values;
+ toaddtmp = toaddtab;
+
+ newsize = coltmp[0];
+ coltmp[0] = baseval;
+ for (i=0; i<n; i++, coltmp++, oldcol++)
+ {
+ /* Copy the existing elements */
+ oldsize = oldcol[1] - oldcol[0];
+ memcpy( rowtmp, oldrow, oldsize * sizeof(spm_int_t) );
#if !defined(PRECISION_p)
- memcpy( valtmp, oldval, oldsize * dof2 * sizeof(spm_complex64_t) );
+ memcpy( valtmp, oldval, oldsize * dof2 * sizeof(spm_complex64_t) );
#endif
- oldrow += oldsize;
- rowtmp += oldsize;
- oldval += oldsize * dof2;
- valtmp += oldsize * dof2;
+ oldrow += oldsize;
+ rowtmp += oldsize;
+ oldval += oldsize * dof2;
+ valtmp += oldsize * dof2;
- /* Some elements have been added */
- assert( newsize >= oldsize );
- if ( newsize > oldsize ) {
- int added = 0;
- int tobeadded = newsize - oldsize;
+ /* Some elements have been added */
+ assert( newsize >= oldsize );
+ if ( newsize > oldsize ) {
+ int added = 0;
+ int tobeadded = newsize - oldsize;
- /* At least one element is equal to i */
- assert( toaddtmp[0] == i );
+ /* At least one element is equal to i */
+ assert( toaddtmp[0] == i );
- /* Let's add the new vertices */
- while( (added < tobeadded) && (toaddtmp[0] == i) ) {
- rowtmp[0] = toaddtmp[1] + baseval;
- rowtmp++; toaddtmp+=2; added++;
- }
- assert( added == tobeadded );
+ /* Let's add the new vertices */
+ while( (added < tobeadded) && (toaddtmp[0] == i) ) {
+ rowtmp[0] = toaddtmp[1] + baseval;
+ rowtmp++; toaddtmp+=2; added++;
+ }
+ assert( added == tobeadded );
#if !defined(PRECISION_p)
- /* Add 0.s for the associated values */
- memset( valtmp, 0, added * dof2 * sizeof(spm_complex64_t) );
- valtmp += added * dof2;
+ /* Add 0.s for the associated values */
+ memset( valtmp, 0, added * dof2 * sizeof(spm_complex64_t) );
+ valtmp += added * dof2;
#endif
- }
-
- /* Use oldsize as temporary variable to update the new colptr */
- oldsize = newsize;
- newsize = coltmp[1];
- coltmp[1] = coltmp[0] + oldsize;
- }
-
- assert( coltmp[0]-baseval == spm->nnz );
- free( toaddtab );
- free( spm->colptr );
- free( spm->rowptr );
- free( spm->values );
- if (spm->fmttype == SpmCSC) {
- spm->colptr = newcol;
- spm->rowptr = newrow;
- }
- else {
- spm->colptr = newrow;
- spm->rowptr = newcol;
- }
- spm->values = newval;
- }
+ }
+
+ /* Use oldsize as temporary variable to update the new colptr */
+ oldsize = newsize;
+ newsize = coltmp[1];
+ coltmp[1] = coltmp[0] + oldsize;
+ }
+
+ assert( coltmp[0]-baseval == spm->nnz );
+ free( toaddtab );
+ free( spm->colptr );
+ free( spm->rowptr );
+ free( spm->values );
+ if (spm->fmttype == SpmCSC) {
+ spm->colptr = newcol;
+ spm->rowptr = newrow;
+ }
+ else {
+ spm->colptr = newrow;
+ spm->rowptr = newcol;
+ }
+ spm->values = newval;
+ }
}
return toaddcnt;
}
-
diff --git a/src/z_spm_expand.c b/src/z_spm_expand.c
index 0b3c31ae..879f64c6 100644
--- a/src/z_spm_expand.c
+++ b/src/z_spm_expand.c
@@ -592,4 +592,3 @@ z_spmExpand( const spmatrix_t *spm )
}
return NULL;
}
-
diff --git a/src/z_spm_integer.c b/src/z_spm_integer.c
index e3a863ce..f0ef07bd 100644
--- a/src/z_spm_integer.c
+++ b/src/z_spm_integer.c
@@ -107,7 +107,7 @@ static size_t intsortsize_iif[3] = { sizeof(spm_int_t), sizeof(spm_int_t), sizeo
/* swap on second integer array */ \
t = intptr[disp_p]; \
intptr[disp_p] = intptr[disp_q]; \
- intptr[disp_q] = t; \
+ intptr[disp_q] = t; \
/* swap corresponding values */ \
f = fltptr[disp_p]; \
fltptr[disp_p] = fltptr[disp_q]; \
@@ -117,7 +117,7 @@ static size_t intsortsize_iif[3] = { sizeof(spm_int_t), sizeof(spm_int_t), sizeo
static inline int
intsortcmp_iif( void ** const pbase, spm_int_t *p, spm_int_t *q ) {
spm_int_t *int1ptr = pbase[0];
- spm_int_t *int2ptr = pbase[1];
+ spm_int_t *int2ptr = pbase[1];
return ( ( *p < *q ) || (( *p == *q ) && ( int2ptr[ p - int1ptr ] < int2ptr[ q - int1ptr ] )) );
}
#define INTSORTCMP(p,q) intsortcmp_iif( pbase, (spm_int_t*)p, (spm_int_t*)q )
@@ -128,4 +128,3 @@ intsortcmp_iif( void ** const pbase, spm_int_t *p, spm_int_t *q ) {
#undef INTSORTCMP
#undef INTSORTNTAB
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
diff --git a/src/z_spm_matrixvector.c b/src/z_spm_matrixvector.c
index f0fc6c63..9396cd45 100644
--- a/src/z_spm_matrixvector.c
+++ b/src/z_spm_matrixvector.c
@@ -63,11 +63,11 @@
*******************************************************************************/
int
z_spmGeCSCv(const spm_trans_t trans,
- spm_complex64_t alpha,
- const spmatrix_t *spm,
- const spm_complex64_t *x,
- spm_complex64_t beta,
- spm_complex64_t *y )
+ spm_complex64_t alpha,
+ const spmatrix_t *spm,
+ const spm_complex64_t *x,
+ spm_complex64_t beta,
+ spm_complex64_t *y )
{
const spm_complex64_t *valptr = (spm_complex64_t*)(spm->values);
const spm_complex64_t *xptr = (const spm_complex64_t*)x;
@@ -76,73 +76,73 @@ z_spmGeCSCv(const spm_trans_t trans,
if ( (spm == NULL) || (x == NULL) || (y == NULL ) )
{
- return SPM_ERR_BADPARAMETER;
+ return SPM_ERR_BADPARAMETER;
}
if( spm->mtxtype != SpmGeneral )
{
- return SPM_ERR_BADPARAMETER;
+ return SPM_ERR_BADPARAMETER;
}
baseval = spmFindBase( spm );
/* first, y = beta*y */
if( beta == 0. ) {
- memset( yptr, 0, spm->gN * sizeof(spm_complex64_t) );
+ memset( yptr, 0, spm->gN * sizeof(spm_complex64_t) );
}
else {
- for( i=0; i<spm->gN; i++, yptr++ ) {
- (*yptr) *= beta;
- }
- yptr = y;
+ for( i=0; i<spm->gN; i++, yptr++ ) {
+ (*yptr) *= beta;
+ }
+ yptr = y;
}
if( alpha != 0. ) {
- /**
- * SpmNoTrans
- */
- if( trans == SpmNoTrans )
- {
- for( col=0; col < spm->gN; col++ )
- {
- for( i=spm->colptr[col]; i<spm->colptr[col+1]; i++ )
- {
- row = spm->rowptr[i-baseval]-baseval;
- yptr[row] += alpha * valptr[i-baseval] * xptr[col];
- }
- }
- }
- /**
- * SpmTrans
- */
- else if( trans == SpmTrans )
- {
- for( col=0; col < spm->gN; col++ )
- {
- for( i=spm->colptr[col]; i<spm->colptr[col+1]; i++ )
- {
- row = spm->rowptr[i-baseval]-baseval;
- yptr[col] += alpha * valptr[i-baseval] * xptr[row];
- }
- }
- }
+ /**
+ * SpmNoTrans
+ */
+ if( trans == SpmNoTrans )
+ {
+ for( col=0; col < spm->gN; col++ )
+ {
+ for( i=spm->colptr[col]; i<spm->colptr[col+1]; i++ )
+ {
+ row = spm->rowptr[i-baseval]-baseval;
+ yptr[row] += alpha * valptr[i-baseval] * xptr[col];
+ }
+ }
+ }
+ /**
+ * SpmTrans
+ */
+ else if( trans == SpmTrans )
+ {
+ for( col=0; col < spm->gN; col++ )
+ {
+ for( i=spm->colptr[col]; i<spm->colptr[col+1]; i++ )
+ {
+ row = spm->rowptr[i-baseval]-baseval;
+ yptr[col] += alpha * valptr[i-baseval] * xptr[row];
+ }
+ }
+ }
#if defined(PRECISION_c) || defined(PRECISION_z)
- else if( trans == SpmConjTrans )
- {
- for( col=0; col < spm->gN; col++ )
- {
- for( i=spm->colptr[col]; i<spm->colptr[col+1]; i++ )
- {
- row = spm->rowptr[i-baseval]-baseval;
- yptr[col] += alpha * conj( valptr[i-baseval] ) * xptr[row];
- }
- }
- }
+ else if( trans == SpmConjTrans )
+ {
+ for( col=0; col < spm->gN; col++ )
+ {
+ for( i=spm->colptr[col]; i<spm->colptr[col+1]; i++ )
+ {
+ row = spm->rowptr[i-baseval]-baseval;
+ yptr[col] += alpha * conj( valptr[i-baseval] ) * xptr[row];
+ }
+ }
+ }
#endif
- else
- {
- return SPM_ERR_BADPARAMETER;
- }
+ else
+ {
+ return SPM_ERR_BADPARAMETER;
+ }
}
return SPM_SUCCESS;
@@ -184,10 +184,10 @@ z_spmGeCSCv(const spm_trans_t trans,
*******************************************************************************/
int
z_spmSyCSCv( spm_complex64_t alpha,
- const spmatrix_t *spm,
- const spm_complex64_t *x,
- spm_complex64_t beta,
- spm_complex64_t *y )
+ const spmatrix_t *spm,
+ const spm_complex64_t *x,
+ spm_complex64_t beta,
+ spm_complex64_t *y )
{
const spm_complex64_t *valptr = (spm_complex64_t*)spm->values;
const spm_complex64_t *xptr = x;
@@ -196,40 +196,40 @@ z_spmSyCSCv( spm_complex64_t alpha,
if ( (spm == NULL) || (x == NULL) || (y == NULL ) )
{
- return SPM_ERR_BADPARAMETER;
+ return SPM_ERR_BADPARAMETER;
}
if( spm->mtxtype != SpmSymmetric )
{
- return SPM_ERR_BADPARAMETER;
+ return SPM_ERR_BADPARAMETER;
}
baseval = spmFindBase( spm );
/* First, y = beta*y */
if( beta == 0. ) {
- memset( yptr, 0, spm->gN * sizeof(spm_complex64_t) );
+ memset( yptr, 0, spm->gN * sizeof(spm_complex64_t) );
}
else {
- for( i=0; i<spm->gN; i++, yptr++ ) {
- (*yptr) *= beta;
- }
- yptr = y;
+ for( i=0; i<spm->gN; i++, yptr++ ) {
+ (*yptr) *= beta;
+ }
+ yptr = y;
}
if( alpha != 0. ) {
- for( col=0; col < spm->gN; col++ )
- {
- for( i=spm->colptr[col]; i < spm->colptr[col+1]; i++ )
- {
- row = spm->rowptr[i-baseval]-baseval;
- yptr[row] += alpha * valptr[i-baseval] * xptr[col];
- if( col != row )
- {
- yptr[col] += alpha * valptr[i-baseval] * xptr[row];
- }
- }
- }
+ for( col=0; col < spm->gN; col++ )
+ {
+ for( i=spm->colptr[col]; i < spm->colptr[col+1]; i++ )
+ {
+ row = spm->rowptr[i-baseval]-baseval;
+ yptr[row] += alpha * valptr[i-baseval] * xptr[col];
+ if( col != row )
+ {
+ yptr[col] += alpha * valptr[i-baseval] * xptr[row];
+ }
+ }
+ }
}
return SPM_SUCCESS;
@@ -272,10 +272,10 @@ z_spmSyCSCv( spm_complex64_t alpha,
*******************************************************************************/
int
z_spmHeCSCv( spm_complex64_t alpha,
- const spmatrix_t *spm,
- const spm_complex64_t *x,
- spm_complex64_t beta,
- spm_complex64_t *y )
+ const spmatrix_t *spm,
+ const spm_complex64_t *x,
+ spm_complex64_t beta,
+ spm_complex64_t *y )
{
const spm_complex64_t *valptr = (spm_complex64_t*)spm->values;
const spm_complex64_t *xptr = x;
@@ -284,42 +284,42 @@ z_spmHeCSCv( spm_complex64_t alpha,
if ( (spm == NULL) || (x == NULL) || (y == NULL ) )
{
- return SPM_ERR_BADPARAMETER;
+ return SPM_ERR_BADPARAMETER;
}
if( spm->mtxtype != SpmHermitian )
{
- return SPM_ERR_BADPARAMETER;
+ return SPM_ERR_BADPARAMETER;
}
/* First, y = beta*y */
if( beta == 0. ) {
- memset( yptr, 0, spm->gN * sizeof(spm_complex64_t) );
+ memset( yptr, 0, spm->gN * sizeof(spm_complex64_t) );
}
else {
- for( i=0; i<spm->gN; i++, yptr++ ) {
- (*yptr) *= beta;
- }
- yptr = y;
+ for( i=0; i<spm->gN; i++, yptr++ ) {
+ (*yptr) *= beta;
+ }
+ yptr = y;
}
baseval = spmFindBase( spm );
if( alpha != 0. ) {
- for( col=0; col < spm->gN; col++ )
- {
- for( i=spm->colptr[col]; i < spm->colptr[col+1]; i++ )
- {
- row=spm->rowptr[i-baseval]-baseval;
- if( col != row ) {
- yptr[row] += alpha * valptr[i-baseval] * xptr[col];
- yptr[col] += alpha * conj( valptr[i-baseval] ) * xptr[row];
- }
- else {
- yptr[row] += alpha * creal(valptr[i-baseval]) * xptr[col];
- }
- }
- }
+ for( col=0; col < spm->gN; col++ )
+ {
+ for( i=spm->colptr[col]; i < spm->colptr[col+1]; i++ )
+ {
+ row=spm->rowptr[i-baseval]-baseval;
+ if( col != row ) {
+ yptr[row] += alpha * valptr[i-baseval] * xptr[col];
+ yptr[col] += alpha * conj( valptr[i-baseval] ) * xptr[row];
+ }
+ else {
+ yptr[row] += alpha * creal(valptr[i-baseval]) * xptr[col];
+ }
+ }
+ }
}
return SPM_SUCCESS;
@@ -365,11 +365,11 @@ z_spmHeCSCv( spm_complex64_t alpha,
*******************************************************************************/
int
z_spmCSCMatVec(const spm_trans_t trans,
- const void *alphaptr,
- const spmatrix_t *spm,
- const void *xptr,
- const void *betaptr,
- void *yptr )
+ const void *alphaptr,
+ const spmatrix_t *spm,
+ const void *xptr,
+ const void *betaptr,
+ void *yptr )
{
const spm_complex64_t *x = (const spm_complex64_t*)xptr;
spm_complex64_t *y = (spm_complex64_t*)yptr;
@@ -381,13 +381,13 @@ z_spmCSCMatVec(const spm_trans_t trans,
switch (spm->mtxtype) {
#if defined(PRECISION_z) || defined(PRECISION_c)
case SpmHermitian:
- return z_spmHeCSCv( alpha, spm, x, beta, y );
+ return z_spmHeCSCv( alpha, spm, x, beta, y );
#endif
case SpmSymmetric:
- return z_spmSyCSCv( alpha, spm, x, beta, y );
+ return z_spmSyCSCv( alpha, spm, x, beta, y );
case SpmGeneral:
default:
- return z_spmGeCSCv( trans, alpha, spm, x, beta, y );
+ return z_spmGeCSCv( trans, alpha, spm, x, beta, y );
}
}
@@ -446,14 +446,14 @@ z_spmCSCMatVec(const spm_trans_t trans,
*******************************************************************************/
int
z_spmCSCMatMat(const spm_trans_t trans,
- spm_int_t n,
- const void *alphaptr,
- const spmatrix_t *A,
- const void *Bptr,
- spm_int_t ldb,
- const void *betaptr,
- void *Cptr,
- spm_int_t ldc )
+ spm_int_t n,
+ const void *alphaptr,
+ const spmatrix_t *A,
+ const void *Bptr,
+ spm_int_t ldb,
+ const void *betaptr,
+ void *Cptr,
+ spm_int_t ldc )
{
const spm_complex64_t *B = (const spm_complex64_t*)Bptr;
spm_complex64_t *C = (spm_complex64_t*)Cptr;
@@ -466,21 +466,21 @@ z_spmCSCMatMat(const spm_trans_t trans,
switch (A->mtxtype) {
#if defined(PRECISION_z) || defined(PRECISION_c)
case SpmHermitian:
- for( i=0; i<n; i++ ){
- rc = z_spmHeCSCv( alpha, A, B + i * ldb, beta, C + i *ldc );
- }
- break;
+ for( i=0; i<n; i++ ){
+ rc = z_spmHeCSCv( alpha, A, B + i * ldb, beta, C + i *ldc );
+ }
+ break;
#endif
case SpmSymmetric:
- for( i=0; i<n; i++ ){
- rc = z_spmSyCSCv( alpha, A, B + i * ldb, beta, C + i *ldc );
- }
- break;
+ for( i=0; i<n; i++ ){
+ rc = z_spmSyCSCv( alpha, A, B + i * ldb, beta, C + i *ldc );
+ }
+ break;
case SpmGeneral:
default:
- for( i=0; i<n; i++ ){
- rc = z_spmGeCSCv( trans, alpha, A, B + i * ldb, beta, C + i *ldc );
- }
+ for( i=0; i<n; i++ ){
+ rc = z_spmGeCSCv( trans, alpha, A, B + i * ldb, beta, C + i *ldc );
+ }
}
return rc;
}
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 76e2fc5d..1cd2d88a 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -87,4 +87,3 @@ endforeach()
foreach(example ${SPM_TESTS} ${SPM_DOF_TESTS} )
add_test(test_mm2_${example} ./${example} --mm ${CMAKE_SOURCE_DIR}/tests/matrix/mhd1280b.mtx)
endforeach()
-
diff --git a/tests/get_options.c b/tests/get_options.c
index 6116e34f..8d8a227b 100644
--- a/tests/get_options.c
+++ b/tests/get_options.c
@@ -96,13 +96,13 @@ static struct option long_options[] =
*******************************************************************************/
void
spmGetOptions( int argc, char **argv,
- spm_driver_t *driver, char **filename )
+ spm_driver_t *driver, char **filename )
{
int c;
if (argc == 1) {
spm_usage();
- exit(0);
+ exit(0);
}
*driver = -1;
@@ -164,7 +164,7 @@ spmGetOptions( int argc, char **argv,
case 'h':
spm_usage();
- exit(EXIT_FAILURE);
+ exit(EXIT_FAILURE);
case ':':
fprintf(stderr, "\nOption %c is missing an argument\n\n", c );
@@ -172,7 +172,7 @@ spmGetOptions( int argc, char **argv,
case '?': /* getopt_long already printed an error message. */
spm_usage();
- exit(EXIT_FAILURE);
+ exit(EXIT_FAILURE);
default:
break;
}
diff --git a/tests/spm_convert_tests.c b/tests/spm_convert_tests.c
index bfff58cb..4cf4fd2d 100644
--- a/tests/spm_convert_tests.c
+++ b/tests/spm_convert_tests.c
@@ -115,16 +115,16 @@ int main (int argc, char **argv)
int rc;
spmGetOptions( argc, argv,
- &driver, &filename );
+ &driver, &filename );
rc = spmReadDriver( driver, filename, &spm, 0 );
free(filename);
if ( rc != SPM_SUCCESS ) {
- fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
- return EXIT_FAILURE;
+ fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
+ return EXIT_FAILURE;
}
-
+
printf(" -- SPM Conversion Test --\n");
spmConvert(SpmCSC, &spm);
diff --git a/tests/spm_dof_expand_tests.c b/tests/spm_dof_expand_tests.c
index 40cafbf6..27709525 100644
--- a/tests/spm_dof_expand_tests.c
+++ b/tests/spm_dof_expand_tests.c
@@ -61,16 +61,16 @@ int main (int argc, char **argv)
* Get options from command line
*/
spmGetOptions( argc, argv,
- &driver, &filename );
+ &driver, &filename );
rc = spmReadDriver( driver, filename, &original, 0 );
free(filename);
if ( rc != SPM_SUCCESS ) {
- fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
- return EXIT_FAILURE;
+ fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
+ return EXIT_FAILURE;
}
-
+
spmtype = original.mtxtype;
printf(" -- SPM Dof Expand Test --\n");
diff --git a/tests/spm_dof_matvec_tests.c b/tests/spm_dof_matvec_tests.c
index 275cd055..96db0053 100644
--- a/tests/spm_dof_matvec_tests.c
+++ b/tests/spm_dof_matvec_tests.c
@@ -55,16 +55,16 @@ int main (int argc, char **argv)
* Get options from command line
*/
spmGetOptions( argc, argv,
- &driver, &filename );
+ &driver, &filename );
rc = spmReadDriver( driver, filename, &original, 0 );
free(filename);
if ( rc != SPM_SUCCESS ) {
- fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
- return EXIT_FAILURE;
+ fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
+ return EXIT_FAILURE;
}
-
+
if ( original.flttype == SpmPattern ) {
spmGenFakeValues( &original );
}
diff --git a/tests/spm_dof_norm_tests.c b/tests/spm_dof_norm_tests.c
index 1e75148d..71d24939 100644
--- a/tests/spm_dof_norm_tests.c
+++ b/tests/spm_dof_norm_tests.c
@@ -54,16 +54,16 @@ int main (int argc, char **argv)
* Get options from command line
*/
spmGetOptions( argc, argv,
- &driver, &filename );
+ &driver, &filename );
rc = spmReadDriver( driver, filename, &original, 0 );
free(filename);
if ( rc != SPM_SUCCESS ) {
- fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
- return EXIT_FAILURE;
+ fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
+ return EXIT_FAILURE;
}
-
+
if ( original.flttype == SpmPattern ) {
spmGenFakeValues( &original );
}
diff --git a/tests/spm_matvec_tests.c b/tests/spm_matvec_tests.c
index 1dc61ad3..c605beef 100644
--- a/tests/spm_matvec_tests.c
+++ b/tests/spm_matvec_tests.c
@@ -50,16 +50,16 @@ int main (int argc, char **argv)
int err = 0;
spmGetOptions( argc, argv,
- &driver, &filename );
+ &driver, &filename );
rc = spmReadDriver( driver, filename, &spm, 0 );
free(filename);
if ( rc != SPM_SUCCESS ) {
- fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
- return EXIT_FAILURE;
+ fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
+ return EXIT_FAILURE;
}
-
+
if ( spm.flttype == SpmPattern ) {
spmGenFakeValues( &spm );
}
diff --git a/tests/spm_norm_tests.c b/tests/spm_norm_tests.c
index 35496256..f37d6529 100644
--- a/tests/spm_norm_tests.c
+++ b/tests/spm_norm_tests.c
@@ -53,16 +53,16 @@ int main (int argc, char **argv)
* Get options from command line
*/
spmGetOptions( argc, argv,
- &driver, &filename );
+ &driver, &filename );
rc = spmReadDriver( driver, filename, &spm, 0 );
free(filename);
if ( rc != SPM_SUCCESS ) {
- fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
- return EXIT_FAILURE;
+ fprintf(stderr, "ERROR: Could not read the file, stop the test !!!\n");
+ return EXIT_FAILURE;
}
-
+
if ( spm.flttype == SpmPattern ) {
spmGenFakeValues( &spm );
}
diff --git a/tests/spm_tests.h b/tests/spm_tests.h
index 2be8bee1..758c720c 100644
--- a/tests/spm_tests.h
+++ b/tests/spm_tests.h
@@ -21,55 +21,55 @@
#include <spm.h>
void spmGetOptions( int argc, char **argv,
- spm_driver_t *driver, char **filename );
+ spm_driver_t *driver, char **filename );
void core_zplrnt( int m, int n, spm_complex64_t *A, int lda,
- int gM, int m0, int n0, unsigned long long int seed );
+ int gM, int m0, int n0, unsigned long long int seed );
int core_zgeadd( spm_trans_t trans,
- spm_int_t M,
- spm_int_t N,
- spm_complex64_t alpha,
- const spm_complex64_t *A,
- spm_int_t LDA,
- spm_complex64_t beta,
- spm_complex64_t *B,
- spm_int_t LDB );
+ spm_int_t M,
+ spm_int_t N,
+ spm_complex64_t alpha,
+ const spm_complex64_t *A,
+ spm_int_t LDA,
+ spm_complex64_t beta,
+ spm_complex64_t *B,
+ spm_int_t LDB );
void core_cplrnt( int m, int n, spm_complex32_t *A, int lda,
- int gM, int m0, int n0, unsigned long long int seed );
+ int gM, int m0, int n0, unsigned long long int seed );
int core_cgeadd( spm_trans_t trans,
- spm_int_t M,
- spm_int_t N,
- spm_complex32_t alpha,
- const spm_complex32_t *A,
- spm_int_t LDA,
- spm_complex32_t beta,
- spm_complex32_t *B,
- spm_int_t LDB );
+ spm_int_t M,
+ spm_int_t N,
+ spm_complex32_t alpha,
+ const spm_complex32_t *A,
+ spm_int_t LDA,
+ spm_complex32_t beta,
+ spm_complex32_t *B,
+ spm_int_t LDB );
void core_dplrnt( int m, int n, double *A, int lda,
- int gM, int m0, int n0, unsigned long long int seed );
+ int gM, int m0, int n0, unsigned long long int seed );
int core_dgeadd( spm_trans_t trans,
- spm_int_t M,
- spm_int_t N,
- double alpha,
- const double *A,
- spm_int_t LDA,
- double beta,
- double *B,
- spm_int_t LDB );
+ spm_int_t M,
+ spm_int_t N,
+ double alpha,
+ const double *A,
+ spm_int_t LDA,
+ double beta,
+ double *B,
+ spm_int_t LDB );
void core_splrnt( int m, int n, float *A, int lda,
- int gM, int m0, int n0, unsigned long long int seed );
+ int gM, int m0, int n0, unsigned long long int seed );
int core_sgeadd( spm_trans_t trans,
- spm_int_t M,
- spm_int_t N,
- float alpha,
- const float *A,
- spm_int_t LDA,
- float beta,
- float *B,
- spm_int_t LDB );
+ spm_int_t M,
+ spm_int_t N,
+ float alpha,
+ const float *A,
+ spm_int_t LDA,
+ float beta,
+ float *B,
+ spm_int_t LDB );
void z_spm_print_check( char *filename, const spmatrix_t *spm );
int z_spm_matvec_check( int trans, const spmatrix_t *spm );
diff --git a/tests/validate_convert.sh b/tests/validate_convert.sh
index 7d93557b..45cac3bb 100755
--- a/tests/validate_convert.sh
+++ b/tests/validate_convert.sh
@@ -44,4 +44,3 @@ do
done
fi
done
-
diff --git a/tests/validate_expand.sh b/tests/validate_expand.sh
index f8f0f65e..b00e6141 100755
--- a/tests/validate_expand.sh
+++ b/tests/validate_expand.sh
@@ -81,4 +81,3 @@ do
done
done
done
-
--
GitLab