diff --git a/spm.c b/spm.c
index 8e4db76a9a6997c888df5e71e4c83c70339f2c25..9a121ceef8f6de3d505ab3522d5d54d5373cf312 100644
--- a/spm.c
+++ b/spm.c
@@ -466,11 +466,11 @@ spm2Dense( const pastix_spm_t *spm )
********************************************************************************
*
* @return
- * \retval the norm described above. Note that for simplicity, even if
+ * \retval norm The norm described above. Note that for simplicity, even if
* the norm of single real or single complex matrix is computed with
* single precision, the returned norm is stored in double precision
* number.
- * \retval -1., if the floating point of the sparse matrix is
+ * \retval -1 If the floating point of the sparse matrix is
* undefined.
*
*******************************************************************************/
diff --git a/spm.h b/spm.h
index 44b143fe3982ed3a8b3248bf02a01cbe1c01c614..72bf768f204842e682c2b7aee801250b2c18d42b 100644
--- a/spm.h
+++ b/spm.h
@@ -18,28 +18,28 @@
/**
* @ingroup pastix_spm
*
- * @brief The list of matrix driver reader and generators
+ * @brief The list of matrix driver readers and generators
*
*/
typedef enum pastix_driver_e {
- PastixDriverRSA, /* ok */
- PastixDriverCCC,//
- PastixDriverRCC,//
- PastixDriverOlaf,//
- PastixDriverPeer,//
- PastixDriverHB, /* ok */
- PastixDriverIJV, /* ok */
- PastixDriverMM, /* ok */
- PastixDriverDMM, /* ok */
- PastixDriverPetscS, /* ok */
- PastixDriverPetscU, /* ok */
- PastixDriverPetscH, /* ok */
- PastixDriverCSCD,//
- PastixDriverLaplacian, /* ok */
- PastixDriverXLaplacian, /* ok */
- PastixDriverBRGM,//
- PastixDriverBRGMD,//
- PastixDriverGraph
+ PastixDriverRSA, /**< RSA driver */
+ PastixDriverHB, /**< Harwell Boeing driver */
+ PastixDriverIJV, /**< IJV Coordinate driver */
+ PastixDriverMM, /**< Matrix Market driver */
+ PastixDriverLaplacian, /**< 3, 5, or 7 points Lapalacian stencil generator */
+ PastixDriverXLaplacian, /**< 15-points Laplacian stencil generator */
+ PastixDriverGraph, /**< Scotch Graph driver */
+ /* PastixDriverDMM, /\**< Distributed Matrix Market driver *\/ */
+ /* PastixDriverCSCD, /\**< CSC distributed driver *\/ */
+ /* PastixDriverPetscS, /\**< Petsc Symmetric driver *\/ */
+ /* PastixDriverPetscU, /\**< Pestc Unssymmetric driver *\/ */
+ /* PastixDriverPetscH, /\**< Pestc Hermitian driver *\/ */
+ /* PastixDriverCCC, /\**< Not supported yet *\/ */
+ /* PastixDriverRCC, /\**< Not supported yet *\/ */
+ /* PastixDriverOlaf, /\**< Not supported yet *\/ */
+ /* PastixDriverPeer, /\**< Not supported yet *\/ */
+ /* PastixDriverBRGM, /\**< Not supported yet *\/ */
+ /* PastixDriverBRGMD, /\**< Not supported yet *\/ */
} pastix_driver_t;
/**
@@ -55,7 +55,7 @@ typedef enum pastix_driver_e {
* It is also possible to describe a matrix with constant or varaibel degrees of freedom.
*
*/
-struct pastix_spm_s {
+typedef struct pastix_spm_s {
int mtxtype; /**< Matrix structure: PastixGeneral, PastixSymmetric
or PastixHermitian. */
pastix_coeftype_t flttype; /**< avals datatype: PastixPattern, PastixFloat, PastixDouble,
@@ -83,71 +83,66 @@ struct pastix_spm_s {
pastix_int_t *rowptr; /**< List of edges for each vertex [+baseval] */
pastix_int_t *loc2glob;/**< Corresponding numbering from local to global [+baseval] */
void *values; /**< Values stored in the matrix */
-};
+} pastix_spm_t;
/**
- * Integer arrays subroutines
+ * SPM subroutines
*/
-pastix_int_t *spmIntConvert( pastix_int_t n, int *input );
+void spmInit( pastix_spm_t *spm );
+void spmExit( pastix_spm_t *spm );
+pastix_spm_t *spmCopy( const pastix_spm_t *spm );
+void spmBase( pastix_spm_t *spm, int baseval );
+void spmUpdateComputedFields( pastix_spm_t *spm );
+int spmConvert( int ofmttype, pastix_spm_t *ospm );
+void * spm2Dense( const pastix_spm_t *spm );
+pastix_int_t spmFindBase( const pastix_spm_t *spm );
+double spmNorm( int ntype, const pastix_spm_t *spm );
+int spmMatVec(const pastix_trans_t trans, const void *alpha, const pastix_spm_t *spm, const void *x, const void *beta, void *y );
+void spmScal( const pastix_complex64_t alpha, pastix_spm_t* spm );
+
+int spmSort( pastix_spm_t *spm );
+pastix_int_t spmMergeDuplicate( pastix_spm_t *spm );
+pastix_int_t spmSymmetrize( pastix_spm_t *spm );
+
+pastix_spm_t *spmCheckAndCorrect( pastix_spm_t *spm );
/**
- *******************************************************************************
- *
- * @ingroup pastix_spm
- *
- * @brief Sorts in ascending order array of element composed of one single
- * pastix_int_t with a single key value.
- *
- *******************************************************************************
- *
- * @param[in,out] pbase TODO
- *
- *
- * @param[in] n
- * The number of elements in the array.
- *
- *******************************************************************************
+ * SPM IO subroutines
*/
-void spmIntSort1Asc1(void * const pbase, const pastix_int_t n);
+int spmLoad( pastix_spm_t *spm, FILE *infile );
+int spmSave( pastix_spm_t *spm, FILE *outfile );
/**
- *******************************************************************************
- *
- * @ingroup pastix_spm
- *
- * @brief Sorts in ascending order array of element composed of two
- * pastix_int_t by ascending order. The first value is used as key.
- *
- *******************************************************************************
- *
- * @param[in,out] pbase TODO
- *
- *
- * @param[in] n
- * The number of elements in the array.
- *
- *******************************************************************************
+ * SPM subroutines to check factorization/solve
*/
-void spmIntSort2Asc1(void * const pbase, const pastix_int_t n);
+int spmGenRHS( int type, int nrhs, const pastix_spm_t *spm, void *x, int ldx, void *b, int ldb );
+int spmCheckAxb( int nrhs, const pastix_spm_t *spm, void *x0, int ldx0, void *b, int ldb, const void *x, int ldx );
/**
- *******************************************************************************
- *
- * @ingroup pastix_spm
- *
- * @brief Sorts in ascending order array of element composed of two
- * pastix_int_t by ascending order. Both values are used as key.
- *
- *******************************************************************************
- *
- * @param[in,out] pbase TODO
- *
- *
- * @param[in] n
- * The number of elements in the array.
- *
- *******************************************************************************
+ * SPM print output
*/
+void spmPrint( FILE *f, const pastix_spm_t *spm );
+
+/**
+ * SPM multi-dof subroutines
+ */
+pastix_spm_t *spmExpand(const pastix_spm_t* spm);
+pastix_spm_t *spmDofExtend( const int type, const int dof, const pastix_spm_t *spm );
+
+/**
+ * SPM read driver access
+ */
+int spmReadDriver( pastix_driver_t driver,
+ char *filename,
+ pastix_spm_t *spm,
+ MPI_Comm pastix_comm );
+
+/**
+ * SPM subroutines to manipulate integers arrays
+ */
+pastix_int_t *spmIntConvert( pastix_int_t n, int *input );
+void spmIntSort1Asc1(void * const pbase, const pastix_int_t n);
+void spmIntSort2Asc1(void * const pbase, const pastix_int_t n);
void spmIntSort2Asc2(void * const pbase, const pastix_int_t n);
/**
@@ -160,121 +155,28 @@ void spmIntSort2Asc2(void * const pbase, const pastix_int_t n);
*******************************************************************************
* @param[in] f Pointer to the file
*
- * @param[in] i TODO
+ * @param[in] i Row index of the element
*
- * @param[in] j TODO
+ * @param[in] j Column index of the element
*
- * @param[in] A TODO
+ * @param[in] A Value of the element A|i,j]
*******************************************************************************
+ * @{
*/
static inline void z_spmPrintElt( FILE *f, pastix_int_t i, pastix_int_t j, pastix_complex64_t A ){
fprintf( f, "%ld %ld %e %e\n", (long)i, (long)j, creal(A), cimag(A) );
}
-
-/**
- *******************************************************************************
- *
- * @ingroup pastix_spm_dev
- *
- * @brief Subroutines to print elements of spm structures
- *
- *******************************************************************************
- * @param[in] f Pointer to the file
- *
- * @param[in] i TODO
- *
- * @param[in] j TODO
- *
- * @param[in] A TODO
- *******************************************************************************
- */
static inline void c_spmPrintElt( FILE *f, pastix_int_t i, pastix_int_t j, pastix_complex32_t A ){
fprintf( f, "%ld %ld %e %e\n", (long)i, (long)j, crealf(A), cimagf(A) );
}
-
-/**
- *******************************************************************************
- *
- * @ingroup pastix_spm_dev
- *
- * @brief Subroutines to print elements of spm structures
- *
- *******************************************************************************
- * @param[in] f Pointer to the file
- *
- * @param[in] i TODO
- *
- * @param[in] j TODO
- *
- * @param[in] A TODO
- *******************************************************************************
- */
static inline void d_spmPrintElt( FILE *f, pastix_int_t i, pastix_int_t j, double A ){
fprintf( f, "%ld %ld %e\n", (long)i, (long)j, A );
}
-
-/**
- *******************************************************************************
- *
- * @ingroup pastix_spm_dev
- *
- * @brief Subroutines to print elements of spm structures
- *
- *******************************************************************************
- * @param[in] f Pointer to the file
- *
- * @param[in] i TODO
- *
- * @param[in] j TODO
- *
- * @param[in] A TODO
- *******************************************************************************
- */
static inline void s_spmPrintElt( FILE *f, pastix_int_t i, pastix_int_t j, float A ){
fprintf( f, "%ld %ld %e\n", (long)i, (long)j, A );
}
-
-/**
- * SPM subroutines
- */
-int spmLoad( pastix_spm_t *spm, FILE *infile );
-int spmSave( pastix_spm_t *spm, FILE *outfile );
-
-void spmPrint( FILE *f, const pastix_spm_t *spm );
-
-int spmGenRHS(int type, int nrhs, const pastix_spm_t *spm, void *x, int ldx, void *b, int ldb );
-int spmCheckAxb( int nrhs, const pastix_spm_t *spm, void *x0, int ldx0, void *b, int ldb, const void *x, int ldx );
-
-void spmInit( pastix_spm_t *spm );
-void spmExit( pastix_spm_t *spm );
-pastix_spm_t *spmCopy( const pastix_spm_t *spm );
-void spmBase( pastix_spm_t *spm, int baseval );
-void spmUpdateComputedFields( pastix_spm_t *spm );
-int spmConvert( int ofmttype, pastix_spm_t *ospm );
-void * spm2Dense( const pastix_spm_t *spm );
-pastix_int_t spmFindBase( const pastix_spm_t *spm );
-double spmNorm( int ntype, const pastix_spm_t *spm );
-int spmMatVec(const pastix_trans_t trans, const void *alpha, const pastix_spm_t *spm, const void *x, const void *beta, void *y );
-void spmScal( const pastix_complex64_t alpha, pastix_spm_t* spm );
-
-int spmSort( pastix_spm_t *spm );
-pastix_int_t spmMergeDuplicate( pastix_spm_t *spm );
-pastix_int_t spmSymmetrize( pastix_spm_t *spm );
-
-pastix_spm_t *spmCheckAndCorrect( pastix_spm_t *spm );
-
/**
- * SPM multi-dof subroutines
- */
-pastix_spm_t *spmExpand(const pastix_spm_t* spm);
-pastix_spm_t *spmDofExtend( const int type, const int dof, const pastix_spm_t *spm );
-
-/**
- * SPM read driver access
+ * @}
*/
-int spmReadDriver( pastix_driver_t driver,
- char *filename,
- pastix_spm_t *spm,
- MPI_Comm pastix_comm );
#endif /* _SPM_H_ */
diff --git a/spm_integers.c b/spm_integers.c
index 455484e33250c73177e33585e10e7667c84fdf5d..3486c60e01f0d9496980044dd0e6e91d9bf2a82a 100644
--- a/spm_integers.c
+++ b/spm_integers.c
@@ -67,15 +67,24 @@ spmIntConvert( pastix_int_t n, int *input )
/**
*******************************************************************************
*
+ * @fn void spmIntSort1Asc1(void * const pbase, const pastix_int_t n);
* @ingroup pastix_spm_dev
*
- * @brief Sorts in ascending order array of element composed of one single
+ * Sorts in ascending order array of element composed of one single
* pastix_int_t with a single key value.
*
*******************************************************************************
+ *
+ * @param[in,out] pbase
+ * Pointer to the array of integers to sort.
+ *
+ * @param[in] n
+ * The number of elements in the array.
+ *
+ *******************************************************************************
*/
-#define INTSORTNAME spmIntSort1Asc1
#ifndef DOXYGEN_SHOULD_SKIP_THIS
+#define INTSORTNAME spmIntSort1Asc1
#define INTSORTSIZE (sizeof (pastix_int_t))
#define INTSORTSWAP(p,q) do { \
pastix_int_t t; \
@@ -94,15 +103,24 @@ spmIntConvert( pastix_int_t n, int *input )
/**
*******************************************************************************
*
+ * @fn void spmIntSort2Asc1(void * const pbase, const pastix_int_t n);
* @ingroup pastix_spm_dev
*
- * @brief Sorts in ascending order array of element composed of two
+ * Sorts in ascending order array of element composed of two
* pastix_int_t by ascending order. The first value is used as key.
*
*******************************************************************************
+ *
+ * @param[in,out] pbase
+ * Pointer to the array of couple of integers to sort.
+ *
+ * @param[in] n
+ * The number of elements in the array.
+ *
+ *******************************************************************************
*/
-#define INTSORTNAME spmIntSort2Asc1
#ifndef DOXYGEN_SHOULD_SKIP_THIS
+#define INTSORTNAME spmIntSort2Asc1
#define INTSORTSIZE (2 * sizeof (pastix_int_t))
#define INTSORTSWAP(p,q) do { \
pastix_int_t t, u; \
@@ -124,15 +142,27 @@ spmIntConvert( pastix_int_t n, int *input )
/**
*******************************************************************************
*
+ * @fn void spmIntSort3Asc1(void * const pbase, const pastix_int_t n);
* @ingroup pastix_spm_dev
*
* @brief Sorts in ascending order array of element composed of three
* pastix_int_t by ascending order. The first value is used as key.
*
*******************************************************************************
+ *
+ * @param[in,out] pbase
+ * Pointer to the array of triplet of integers to sort.
+ *
+ * @param[in] n
+ * The number of elements in the array.
+ *
+ *******************************************************************************
*/
-#define INTSORTNAME spmInt_intSort3Asc1
+/* Declare here for now, because unused */
+void spmIntSort3Asc1(void *const pbase, const pastix_int_t n);
+
#ifndef DOXYGEN_SHOULD_SKIP_THIS
+#define INTSORTNAME spmIntSort3Asc1
#define INTSORTSIZE (3 * sizeof (pastix_int_t))
#define INTSORTSWAP(p,q) do { \
pastix_int_t t, u, v; \
@@ -157,15 +187,23 @@ spmIntConvert( pastix_int_t n, int *input )
/**
*******************************************************************************
*
+ * @fn void spmIntSort2Asc2(void * const pbase, const pastix_int_t n);
* @ingroup pastix_spm_dev
- *
* @brief Sorts in ascending order array of element composed of two
* pastix_int_t by ascending order. Both values are used as key.
*
*******************************************************************************
+ *
+ * @param[in,out] pbase
+ * Pointer to the array of couple of integers to sort.
+ *
+ * @param[in] n
+ * The number of elements in the array.
+ *
+ *******************************************************************************
*/
-#define INTSORTNAME spmIntSort2Asc2
#ifndef DOXYGEN_SHOULD_SKIP_THIS
+#define INTSORTNAME spmIntSort2Asc2
#define INTSORTSIZE (2 * sizeof (pastix_int_t))
#define INTSORTSWAP(p,q) do { \
pastix_int_t t, u; \
@@ -187,6 +225,7 @@ spmIntConvert( pastix_int_t n, int *input )
/**
*******************************************************************************
*
+ * @fn void spmIntMSortIntAsc(void ** const pbase, const pastix_int_t n);
* @ingroup pastix_spm_dev
*
* @brief Sort 2 arrays simultaneously, the first array is an array of
@@ -194,9 +233,20 @@ spmIntConvert( pastix_int_t n, int *input )
* other array of pastix_int_t used as secondary key.
*
*******************************************************************************
+ *
+ * @param[in,out] pbase
+ * Array of pointers to the arrays of integers to sort.
+ *
+ * @param[in] n
+ * The number of elements in the array.
+ *
+ *******************************************************************************
*/
-#define INTSORTNAME spmIntMSortIntAsc
+/* Declare here for now, because unused */
+void spmIntMSortIntAsc(void ** const pbase, const pastix_int_t n);
+
#ifndef DOXYGEN_SHOULD_SKIP_THIS
+#define INTSORTNAME spmIntMSortIntAsc
#define INTSORTSIZE(x) (sizeof (pastix_int_t))
#define INTSORTNTAB 2
#define INTSORTSWAP(p,q) do { \
@@ -208,7 +258,7 @@ spmIntConvert( pastix_int_t n, int *input )
t = *((pastix_int_t *) (p)); \
*((pastix_int_t *) (p)) = *((pastix_int_t *) (q)); \
*((pastix_int_t *) (q)) = t; \
- /* swap on secont integer array */ \
+ /* swap on second integer array */ \
t = int2ptr[disp_p]; \
int2ptr[disp_p] = int2ptr[disp_q]; \
int2ptr[disp_q] = t; \
@@ -228,16 +278,27 @@ spmIntConvert( pastix_int_t n, int *input )
/**
*******************************************************************************
*
+ * @fn void spmIntMSortSmallIntAsc(void **const pbase, const pastix_int_t n);
* @ingroup pastix_spm_dev
- *
* @brief Sort 2 arrays simultaneously, the first array is an array of
* pastix_int_t and used as primary key for sorting. The second array is an
* other array of pastix_int_t used as secondary key.
*
*******************************************************************************
+ *
+ * @param[in,out] pbase
+ * Array of pointers to the arrays of integers to sort.
+ *
+ * @param[in] n
+ * The number of elements in the array.
+ *
+ *******************************************************************************
*/
-#define INTSORTNAME spmIntMSortSmallIntAsc
+/* Declare here for now, because unused */
+void spmIntMSortSmallIntAsc(void ** const pbase, const pastix_int_t n);
+
#ifndef DOXYGEN_SHOULD_SKIP_THIS
+#define INTSORTNAME spmIntMSortSmallIntAsc
#define INTSORTSIZE(x) (sizeof (int))
#define INTSORTNTAB 2
#define INTSORTSWAP(p,q) do { \
diff --git a/spm_read_driver.c b/spm_read_driver.c
index 8c4600e6f6d2d717f50f73e47774b7886a42723d..1de44c1f4afab9ec78390a2ea81bbe0ddc4a6856 100644
--- a/spm_read_driver.c
+++ b/spm_read_driver.c
@@ -1,7 +1,9 @@
/**
- * @file drivers.c
+ * @file spm_read_driver.c
*
- * $COPYRIGHTS$
+ * PaStiX spm routines
+ * PaStiX is a software package provided by Inria Bordeaux - Sud-Ouest,
+ * LaBRI, University of Bordeaux 1 and IPB.
*
* @version 1.0.0
* @author Mathieu Faverge
@@ -39,6 +41,7 @@
* = PastixDriverMM
* = PastixDriverLaplacian
* = PastixDriverXLaplacian
+ * = PastixDriverGraph
*
* @param[in] filename
* The name of the file that stores the matrix (see driver)
@@ -75,19 +78,12 @@ spmReadDriver( pastix_driver_t driver,
MPI_Comm_rank( comm, &mpirank );
}
- if ( (mpirank == 0) ||
- (driver == PastixDriverLaplacian) ||
- (driver == PastixDriverCSCD) ||
- (driver == PastixDriverBRGMD) ||
- (driver == PastixDriverDMM) )
+ if ( mpirank == 0 )
{
switch(driver)
{
- case PastixDriverCCC:
- case PastixDriverRCC:
- case PastixDriverOlaf:
- case PastixDriverPeer:
- fprintf(stderr, "driver: Driver not implemented\n");
+ case PastixDriverRSA:
+ readRSA( filename, spm );
break;
case PastixDriverHB:
@@ -106,25 +102,6 @@ spmReadDriver( pastix_driver_t driver,
readMM( filename, spm );
break;
- case PastixDriverDMM:
- printf("driver: DistributedMatrixMarket file: %s\n", filename);
- //readMMD( filename, spm );
- break;
-
- case PastixDriverPetscS:
- case PastixDriverPetscU:
- case PastixDriverPetscH:
- printf("driver: PETSc file: %s\n", filename);
- //readPETSC( filename, spm );
- if (driver == PastixDriverPetscS) spm->mtxtype = PastixSymmetric;
- if (driver == PastixDriverPetscH) spm->mtxtype = PastixHermitian;
- break;
-
- case PastixDriverCSCD:
- printf("driver CSCd file: %s\n", filename);
- //readCSCD( filename, spm, rhs, comm );
- break;
-
case PastixDriverLaplacian:
if (mpirank == 0)
printf("driver Laplacian: %s\n", filename);
@@ -168,126 +145,11 @@ spmReadDriver( pastix_driver_t driver,
#endif
break;
- case PastixDriverRSA:
default:
- readRSA( filename, spm );
+ fprintf(stderr, "driver: Driver not implemented\n");
}
}
- /* #ifndef TYPE_COMPLEX */
- /* if (*type) */
- /* if ((*type)[1] == 'H') */
- /* (*type)[1] = 'S'; */
- /* #endif */
-
- /* /\* read RHS file *\/ */
- /* if (mpirank == 0) */
- /* { */
- /* FILE *file; */
- /* char filename2[256]; */
- /* pastix_int_t i; */
- /* double re; */
-
- /* sprintf(filename2,"%s.rhs",filename); */
- /* fprintf(stderr,"open RHS file : %s\n",filename2); */
- /* file = fopen(filename2,"r"); */
- /* if (file==NULL) */
- /* { */
- /* fprintf(stderr,"cannot load %s\n", filename2); */
- /* } */
- /* else */
- /* { */
- /* *rhs = (pastix_complex64_t *) malloc((*ncol)*sizeof(pastix_complex64_t)); */
- /* for (i = 0; i < *ncol; i++) */
- /* { */
- /* (*rhs)[i] = 0.0; */
- /* if (1 != fscanf(file,"%lg\n", &re)) */
- /* { */
- /* fprintf(stderr, "ERROR: reading rhs(%ld)\n", (long int)i); */
- /* exit(1); */
- /* } */
- /* (*rhs)[i] = (pastix_complex64_t)re; */
- /* } */
- /* fclose(file); */
- /* } */
- /* } */
-
- /* if (*rhs == NULL && ( mpirank == 0 || */
- /* driver_type == LAPLACIAN) && */
- /* driver_type != CSCD && driver_type != FDUP_DIST && driver_type != MMD) */
- /* { */
- /* *rhs = (pastix_complex64_t *) malloc((*ncol)*sizeof(pastix_complex64_t)); */
- /* pastix_int_t i,j; */
- /* for (i = 0; i < *ncol; i++) */
- /* (*rhs)[i] = 0.0; */
-
- /* #ifdef TYPE_COMPLEX */
- /* fprintf(stdout, "Setting right-hand-side member such as X[i] = i + i*I\n"); */
- /* #else */
- /* fprintf(stdout, "Setting right-hand-side member such as X[i] = i\n"); */
- /* #endif */
- /* for (i = 0; i < *ncol; i++) */
- /* { */
- /* for (j = (*colptr)[i] -1; j < (*colptr)[i+1]-1; j++) */
- /* { */
- /* #ifdef TYPE_COMPLEX */
- /* (*rhs)[(*rows)[j]-1] += (i+1 + I*(i+1))*(*values)[j]; */
- /* #else */
- /* (*rhs)[(*rows)[j]-1] += (i+1)*(*values)[j]; */
- /* #endif */
- /* if (MTX_ISSYM((*type)) && i != (*rows)[j]-1) */
- /* { */
- /* #ifdef TYPE_COMPLEX */
- /* (*rhs)[i] += ((*rows)[j] + (*rows)[j] * I)*(*values)[j]; */
- /* #else */
- /* (*rhs)[i] += ((*rows)[j])*(*values)[j]; */
- /* #endif */
- /* } */
- /* } */
- /* } */
- /* } */
- /* if (driver_type == CSCD || driver_type == FDUP_DIST || driver_type == MMD) */
- /* { */
- /* pastix_int_t i,j; */
- /* pastix_int_t N; */
- /* pastix_int_t send[2], recv[2]; */
- /* int comm_size; */
- /* MPI_Comm_size(comm,&comm_size); */
- /* send[0] = *ncol; */
- /* send[1] = 0; */
- /* if (*ncol != 0 && *rhs == NULL) */
- /* send[1] = 1; */
- /* MPI_Allreduce(send, recv, 2, PASTIX_MPI_INT, MPI_SUM, comm); */
- /* N = recv[0]; */
- /* if (recv[1] > 0) */
- /* { */
- /* pastix_complex64_t *RHS; */
- /* pastix_complex64_t *RHS_recv; */
- /* RHS = (pastix_complex64_t *) malloc((N)*sizeof(pastix_complex64_t)); */
-
- /* for (i = 0; i < N; i++) */
- /* (RHS)[i] = 0.0; */
- /* if (mpirank == 0) */
- /* fprintf(stdout, "Setting RHS such as X[i] = i\n"); */
- /* for (i = 0; i < *ncol; i++) */
- /* { */
- /* for (j = (*colptr)[i] -1; j < (*colptr)[i+1]-1; j++) */
- /* { */
- /* (RHS)[(*rows)[j]-1] += ((*loc2glob)[i])*(*values)[j]; */
- /* if (MTX_ISSYM((*type)) && i != (*rows)[j]-1) */
- /* (RHS)[(*loc2glob)[i]-1] += ((*rows)[j])*(*values)[j]; */
- /* } */
- /* } */
- /* RHS_recv = (pastix_complex64_t *) malloc((N)*sizeof(pastix_complex64_t)); */
- /* MPI_Allreduce(RHS, RHS_recv, N, PASTIX_MPI_FLOAT, MPI_SUM, comm); */
- /* free(RHS); */
- /* *rhs = (pastix_complex64_t *) malloc((*ncol)*sizeof(pastix_complex64_t)); */
-
- /* for (i = 0; i < *ncol; i++) */
- /* (*rhs)[i] = RHS_recv[(*loc2glob)[i]-1]; */
- /* } */
- /* } */
-
if ( mpiinit )
{
pastix_int_t nnz;
@@ -309,15 +171,11 @@ spmReadDriver( pastix_driver_t driver,
spm->values = (void *) malloc(nnz * pastix_size_of( spm->flttype ));
spm->loc2glob = NULL;
spm->loc2glob = NULL;
- /* spm->rhs = (void *) malloc((*ncol)*sizeof(pastix_complex64_t)); */
- /* spm->type = (char *) malloc(4*sizeof(char)); */
}
MPI_Bcast( spm->colptr, spm->gN+1, PASTIX_MPI_INT, 0, comm );
MPI_Bcast( spm->rowptr, nnz, PASTIX_MPI_INT, 0, comm );
MPI_Bcast( spm->values, nnz * pastix_size_of( spm->flttype ), MPI_CHAR, 0, comm );
- /* MPI_Bcast(*rhs, *ncol, PASTIX_MPI_FLOAT, 0, comm); */
- /* MPI_Bcast(*type, 4, MPI_CHAR, 0, comm); */
}
spmUpdateComputedFields( spm );
diff --git a/z_spm.h b/z_spm.h
index 9211caf5cf65f9ab21259bcc0a3d40b2622fc214..163325e4507ecb76c5b4a6034513ccc3df00e9ac 100644
--- a/z_spm.h
+++ b/z_spm.h
@@ -21,7 +21,7 @@
/**
* Integer routines
*/
-int z_spmIntSortAsc(void ** const pbase, const pastix_int_t n);
+void z_spmIntSortAsc(void ** const pbase, const pastix_int_t n);
/**
* Conversion routines
diff --git a/z_spm_integer.c b/z_spm_integer.c
index e56c23d5cc5c14efc8950e6a091d70ccefcdd0a0..aa82fc28690ea1a1839f048f6b2ae68b57b5fdc7 100644
--- a/z_spm_integer.c
+++ b/z_spm_integer.c
@@ -1,6 +1,6 @@
/**
*
- * @file z_spm_integers.c
+ * @file z_spm_integer.c
*
* PaStiX spm routines
* PaStiX is a software package provided by Inria Bordeaux - Sud-Ouest,
@@ -24,14 +24,24 @@
/**
*******************************************************************************
*
+ * @fn void z_spmIntSortAsc(void ** const pbase, const pastix_int_t n)
* @ingroup pastix_spm_dev
- *
* @brief Sort 2 arrays simultaneously, the first array is an array of
* pastix_int_t and used as key for sorting. The second array is an array of
* pastix_complex64_t.
*
*******************************************************************************
+ *
+ * @param[in,out] pbase
+ * Couple of pointers to an array of integers and to an array of
+ * pastix_complex64_t to sort.
+ *
+ * @param[in] n
+ * The number of elements in the array.
+ *
+ *******************************************************************************
*/
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
static size_t intsortsize[2] = { sizeof(pastix_int_t), sizeof(pastix_complex64_t) };
#define INTSORTNAME z_spmIntSortAsc
#define INTSORTSIZE(x) (intsortsize[x])
@@ -58,4 +68,5 @@ static size_t intsortsize[2] = { sizeof(pastix_int_t), sizeof(pastix_complex64_t
#undef INTSORTSWAP
#undef INTSORTCMP
#undef INTSORTNTAB
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */