diff --git a/spm.c b/spm.c
index 9a121ceef8f6de3d505ab3522d5d54d5373cf312..d4a066f4d3986d0f001dc8e20b93f57cf407838d 100644
--- a/spm.c
+++ b/spm.c
@@ -6,7 +6,7 @@
* PaStiX is a software package provided by Inria Bordeaux - Sud-Ouest,
* LaBRI, University of Bordeaux 1 and IPB.
*
- * @version 5.1.0
+ * @version 6.0.0
* @author Xavier Lacoste
* @author Pierre Ramet
* @author Mathieu Faverge
@@ -76,11 +76,11 @@ static int (*conversionTable[3][3][6])(pastix_spm_t*) = {
*
* @ingroup pastix_spm
*
- * @brief Init the spm structure given as parameter
+ * @brief Init the spm structure.
*
*******************************************************************************
*
- * @param[in,out] spm
+ * @param[inout] spm
* The sparse matrix to init.
*
*******************************************************************************/
@@ -116,19 +116,19 @@ spmInit( pastix_spm_t *spm )
*
* @ingroup pastix_spm
*
- * @brief Update all the computed fields based on the static values stored
+ * @brief Update all the computed fields based on the static values stored.
*
*******************************************************************************
*
- * @param[in,out] spm
- * The sparse matrix to init.
+ * @param[inout] spm
+ * The sparse matrix to update.
*
*******************************************************************************/
void
spmUpdateComputedFields( pastix_spm_t *spm )
{
- /**
+ /*
* Compute the local expended field for multi-dofs
*/
if ( spm->dof > 0 ) {
@@ -192,11 +192,11 @@ spmUpdateComputedFields( pastix_spm_t *spm )
*
* @ingroup pastix_spm
*
- * @brief Free the spm structure
+ * @brief Free the spm structure.
*
*******************************************************************************
*
- * @param[in,out] spm
+ * @param[inout] spm
* The sparse matrix to free.
*
*******************************************************************************/
@@ -220,14 +220,13 @@ spmExit( pastix_spm_t *spm )
*
* @ingroup pastix_spm
*
- * @brief Rebase the spm
+ * @brief Rebase the arrays of the spm to the given value.
*
- * Rebase the arrays of the spm to the given value. If the value is equal to the
- * original base, then nothing is performed.
+ * If the value is equal to the original base, then nothing is performed.
*
*******************************************************************************
*
- * @param[in,out] spm
+ * @param[inout] spm
* The sparse matrix to rebase.
*
* @param[in] baseval
@@ -356,24 +355,23 @@ spmFindBase( const pastix_spm_t *spm )
*
* @ingroup pastix_spm
*
- * @brief Convert the storage format of the spm to ofmttype.
+ * @brief Convert the storage format of the spm.
*
- * Convert the storage format of the given sparse matrix from any of the
- * following format: PastixCSC, PastixCSR, or PastixIJV to one of these.
- *
- *******************************************************************************
+ *******************************************************************************
*
* @param[in] ofmttype
- * The output format of the sparse matrix. It might be PastixCSC,
- * PastixCSR, or PastixIJV.
+ * The output format of the sparse matrix. It must be:
+ * - PastixCSC
+ * - PastixCSR
+ * - PastixIJV
*
- * @param[in,out] spm
+ * @param[inout] spm
* The sparse matrix structure to convert.
*
********************************************************************************
*
* @return
- * \retval PASTIX_SUCCESS if the conversion happened successfuly
+ * \retval PASTIX_SUCCESS if the conversion happened successfully.
* \retval PASTIX_ERR_BADPARAMETER if one the parameter is incorrect.
*
*******************************************************************************/
@@ -397,12 +395,13 @@ spmConvert( int ofmttype, pastix_spm_t *spm )
*
* @ingroup pastix_spm
*
- * @brief Convert the spm matrix into a dense matrix for test purpose. DO NOT
- * USE with large matrices.
+ * @brief Convert the spm matrix into a dense matrix for test purpose.
+ *
+ * DO NOT USE with large matrices.
*
*******************************************************************************
*
- * @param[in,out] spm
+ * @param[inout] spm
* The sparse matrix structure to convert.
*
********************************************************************************
@@ -455,23 +454,20 @@ spm2Dense( const pastix_spm_t *spm )
*******************************************************************************
*
* @param[in] ntype
- * = PastixMaxNorm: Max norm
- * = PastixOneNorm: One norm
- * = PastixInfNorm: Infinity norm
- * = PastixFrobeniusNorm: Frobenius norm
+ * - PastixMaxNorm
+ * - PastixOneNorm
+ * - PastixInfNorm
+ * - PastixFrobeniusNorm
*
* @param[in] spm
* The sparse matrix structure.
*
********************************************************************************
*
- * @return
- * \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
- * undefined.
+ * @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.
+ * @retval -1 If the floating point of the sparse matrix is undefined.
*
*******************************************************************************/
double
@@ -519,26 +515,23 @@ spmNorm( int ntype,
*
* @ingroup pastix_spm
*
- * @brief Sort the subarray of edges of each vertex in a CSC or CSR spm
+ * @brief Sort the subarray of edges of each vertex in a CSC or CSR format.
*
- * This routine sorts the subarray of edges of each vertex in a
- * centralized spm stored in CSC or CSR format. Nothing is performed if IJV
- * format is used.
+ * Nothing is performed if IJV format is used.
*
* WARNING: This function should NOT be called if dof is greater than 1.
*
*******************************************************************************
*
- * @param[in,out] spm
+ * @param[inout] spm
* On entry, the pointer to the sparse matrix structure.
* On exit, the same sparse matrix with subarrays of edges sorted by
* ascending order.
*
********************************************************************************
*
- * @return
- * \retval PASTIX_SUCCESS if the sort was called
- * \retval PASTIX_ERR_BADPARAMETER, if the given spm was incorrect.
+ * @retval PASTIX_SUCCESS if the sort was called
+ * @retval PASTIX_ERR_BADPARAMETER if the given spm was incorrect.
*
*******************************************************************************/
int
@@ -575,26 +568,23 @@ spmSort( pastix_spm_t *spm )
*
* @ingroup pastix_spm
*
- * @brief Merge mulitple entries in a spm by summing them.
+ * @brief Merge multiple entries in a spm by summing their values together.
*
- * This routine merge the multiple entries in a sparse
- * matrix by suming their values together. The sparse matrix needs to be sorted
- * first (see spmSort()).
+ * The sparse matrix needs to be sorted first (see spmSort()).
*
* WARNING: Not implemented for CSR and IJV format.
*
*******************************************************************************
*
- * @param[in,out] spm
+ * @param[inout] spm
* On entry, the pointer to the sparse matrix structure.
* On exit, the reduced sparse matrix of multiple entries were present
* in it. The multiple values for a same vertex are sum up together.
*
********************************************************************************
*
- * @return
- * \retval If >=0, the number of vertices that were merged
- * \retval PASTIX_ERR_BADPARAMETER, if the given spm was incorrect.
+ * @retval >=0 the number of vertices that were merged,
+ * @retval PASTIX_ERR_BADPARAMETER if the given spm was incorrect.
*
*******************************************************************************/
pastix_int_t
@@ -630,26 +620,23 @@ spmMergeDuplicate( pastix_spm_t *spm )
*
* @ingroup pastix_spm
*
- * @brief Symmetrize the pattern of the spm
- *
- * Symmetrize the pattern of the input spm by edges when A(i,j) exists, but
- * A(j,i) does not. When values are associated to the edge, zeroes are added to
- * the values array.
+ * @brief Symmetrize the pattern of the spm.
*
- * WARNING: Not implemented for CSR and IJV format.
+ * This routine corrects the sparse matrix structure if it's pattern is not
+ * symmetric. It returns the new symmetric pattern with zeroes on the new
+ * entries.
*
*******************************************************************************
*
- * @param[in,out] spm
+ * @param[inout] spm
* On entry, the pointer to the sparse matrix structure.
- * On exit, the reduced sparse matrix of multiple entries were present
- * in it. The multiple values for a same vertex are sum up together.
+ * On exit, the same sparse matrix with extra entries that makes it
+ * pattern symmetric.
*
********************************************************************************
*
- * @return
- * \retval If >=0, the number of vertices that were merged
- * \retval PASTIX_ERR_BADPARAMETER, if the given spm was incorrect.
+ * @retval >=0 the number of entries added to the matrix,
+ * @retval PASTIX_ERR_BADPARAMETER if the given spm was incorrect.
*
*******************************************************************************/
pastix_int_t
@@ -690,28 +677,21 @@ spmSymmetrize( pastix_spm_t *spm )
* This routine initializes the sparse matrix to fit the PaStiX requirements. If
* needed, the format is changed to CSC, the duplicated vertices are merged
* together by summing their values; the graph is made symmetric for matrices
- * with unsymmetric pattern, new values are set to 0.; Only the lower part is
- * kept for the symmetric matrices.
+ * with unsymmetric pattern, new values are set to 0. Only the lower part is
+ * kept for symmetric matrices.
*
- * On exit, if no changes have been made, the initial sparse matrix is returned,
- * otherwise a copy of the sparse matrix structured fixed to meet the PaStiX
- * requirements is returned.
+ *******************************************************************************
*
- *******************************************************************************
- *
- * @param[in,out] spm
+ * @param[inout] spm
* The pointer to the sparse matrix structure to check, and correct.
* On exit, the subarrays related to each column might have been sorted
* by ascending order.
*
*******************************************************************************
*
- * @return
- * \retval If no modifications were made to the initial matrix
- * structure, the one given as parameter is returned
- * \retval Otherwise, the news sparse matrix structure is returned. It
- * must be destroyed with spmExit() and a free of the returned
- * pointer.
+ * @return if no changes have been made, the initial sparse matrix is returned,
+ * otherwise a copy of the sparse matrix, fixed to meet the PaStiX requirements,
+ * is returned.
*
*******************************************************************************/
pastix_spm_t *
@@ -740,7 +720,7 @@ spmCheckAndCorrect( pastix_spm_t *spm )
fprintf(stderr, "spmCheckAndCorrect: %ld entries have been merged\n", (long)count );
}
- /**
+ /*
* If the matrix is symmetric or hermitian, we keep only the upper or lower
* part, otherwise, we symmetrize the graph to get A+A^t, new values are set
* to 0.
@@ -755,7 +735,7 @@ spmCheckAndCorrect( pastix_spm_t *spm )
//spmToLower( newspm );
}
- /**
+ /*
* Check if we return the new one, or the original one because no changes
* have been made
*/
@@ -776,7 +756,7 @@ spmCheckAndCorrect( pastix_spm_t *spm )
*
* @ingroup pastix_spm
*
- * @brief Create a copy of the spm
+ * @brief Create a copy of the spm.
*
* Duplicate the spm data structure given as parameter. All new arrays are
* allocated and copied from the original matrix. Both matrices need to be
@@ -856,10 +836,10 @@ spmCopy( const pastix_spm_t *spm )
*******************************************************************************
*
* @param[in] f
- * File to print the spm matrix
+ * File to print the spm matrix.
*
* @param[in] spm
- * The sparse matrix to copy.
+ * The sparse matrix to print.
*
*******************************************************************************/
void
@@ -890,7 +870,7 @@ spmPrint(FILE *f, const pastix_spm_t* spm)
*
* @ingroup pastix_spm
*
- * @brief Expand a multi-dof spm matrix into an spm with constant dof to 1.
+ * @brief Expand a multi-dof spm matrix into an spm with constant dof set to 1.
*
* Duplicate the spm data structure given as parameter. All new arrays are
* allocated and copied from the original matrix. Both matrices need to be
@@ -935,9 +915,7 @@ spmExpand(const pastix_spm_t* spm)
*
* @ingroup pastix_spm
*
- * @brief Compute a matrix-vector product
- *
- * Compute the matrix vector product:
+ * @brief Compute a matrix-vector product.
*
* y = alpha * op(A) * x + beta * y, where op(A) is one of
*
@@ -948,11 +926,10 @@ spmExpand(const pastix_spm_t* spm)
*******************************************************************************
*
* @param[in] trans
- * Specifies whether the matrix spm is transposed, not transposed or
- * conjugate transposed:
- * = PastixNoTrans: A is not transposed;
- * = PastixTrans: A is transposed;
- * = PastixConjTrans: A is conjugate transposed.
+ * Specifies whether the matrix spm is transposed, not transposed or conjugate transposed:
+ * - PastixTrans
+ * - PastixNoTrans
+ * - PastixConjTrans
*
* @param[in] alpha
* alpha specifies the scalar alpha.
@@ -966,14 +943,13 @@ spmExpand(const pastix_spm_t* spm)
* @param[in] beta
* beta specifies the scalar beta.
*
- * @param[in,out] y
+ * @param[inout] y
* The vector y.
*
*******************************************************************************
*
- * @return
- * \retval PASTIX_SUCCESS if the y vector has been computed succesfully,
- * \retval PASTIX_ERR_BADPARAMETER otherwise.
+ * @retval PASTIX_SUCCESS if the y vector has been computed successfully,
+ * @retval PASTIX_ERR_BADPARAMETER otherwise.
*
*******************************************************************************/
int
@@ -1021,11 +997,9 @@ spmMatVec(const pastix_trans_t trans,
*
* @ingroup pastix_spm
*
- * @brief Generate right hand sides.
+ * @brief Generate right hand side vectors associated to a given matrix.
*
- * Generate nrhs right hand side vectors associated to a given matrix to test a
- * problem with a solver. The vectors can be initialized randomly, or to get a
- * specific solution.
+ * The vectors can be initialized randomly or to get a specific solution.
*
*******************************************************************************
*
@@ -1052,7 +1026,7 @@ spmMatVec(const pastix_trans_t trans,
* Defines the leading dimension of x when multiple right hand sides
* are available. ldx >= spm->n.
*
- * @param[in,out] b
+ * @param[inout] b
* b must be an allocated matrix of size at least ldb * nrhs.
* On exit, b is initialized as defined by the type parameter.
*
@@ -1062,9 +1036,8 @@ spmMatVec(const pastix_trans_t trans,
*
*******************************************************************************
*
- * @return
- * \retval PASTIX_SUCCESS if the b vector has been computed succesfully,
- * \retval PASTIX_ERR_BADPARAMETER otherwise.
+ * @retval PASTIX_SUCCESS if the b vector has been computed successfully,
+ * @retval PASTIX_ERR_BADPARAMETER otherwise.
*
*******************************************************************************/
int
@@ -1094,9 +1067,7 @@ spmGenRHS( int type, int nrhs,
*
* @ingroup pastix_spm
*
- * @brief Check backward and forward errors
- *
- * Check the backward error, and the forward error if x0 is provided.
+ * @brief Check the backward error, and the forward error if x0 is provided.
*
*******************************************************************************
*
@@ -1104,18 +1075,18 @@ spmGenRHS( int type, int nrhs,
* Defines the number of right hand side that must be generated.
*
* @param[in] spm
- * The sparse matrix uses to generate the right hand side, and the
+ * The sparse matrix used to generate the right hand side, and the
* solution of the full problem.
*
- * @param[in,out] x0
+ * @param[inout] x0
* If x0 != NULL, the forward error is computed.
- * On exit, x0 stores (x0-x)
+ * On exit, x0 stores x0-x
*
* @param[in] ldx0
* Defines the leading dimension of x0 when multiple right hand sides
* are available. ldx0 >= spm->n.
*
- * @param[in,out] b
+ * @param[inout] b
* b is a matrix of size at least ldb * nrhs.
* On exit, b stores Ax-b.
*
@@ -1132,9 +1103,8 @@ spmGenRHS( int type, int nrhs,
*
*******************************************************************************
*
- * @return
- * \retval PASTIX_SUCCESS if the b vector has been computed succesfully,
- * \retval PASTIX_ERR_BADPARAMETER otherwise.
+ * @retval PASTIX_SUCCESS if the b vector has been computed successfully,
+ * @retval PASTIX_ERR_BADPARAMETER otherwise.
*
*******************************************************************************/
int
@@ -1164,14 +1134,16 @@ spmCheckAxb( int nrhs,
*
* @ingroup pastix_spm
*
- * @brief Scal the spm: A = alpha * A
+ * @brief Scale the spm.
+ *
+ * A = alpha * A
*
*******************************************************************************
*
* @param[in] alpha
* The scaling parameter.
*
- * @param[in,out] spm
+ * @param[inout] spm
* The sparse matrix to scal.
*
*******************************************************************************/
diff --git a/spm.h b/spm.h
index b636c53458df70d735cd91f7a699ff179597a171..b9aec784311d8c883c0a5ab336c3c809149ed0a7 100644
--- a/spm.h
+++ b/spm.h
@@ -5,7 +5,7 @@
* PaStiX sparse matrix routines to handle different format of sparse matrices.
* $COPYRIGHTS$
*
- * @version 5.1.0
+ * @version 6.0.0
* @author Xavier Lacoste
* @author Pierre Ramet
* @author Mathieu Faverge
@@ -93,64 +93,85 @@ typedef struct pastix_spm_s {
} pastix_spm_t;
/**
- * SPM subroutines
+ * @name SPM basic subroutines
+ * @{
*/
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 );
+int spmConvert( int ofmttype, pastix_spm_t *ospm );
+void spmUpdateComputedFields( pastix_spm_t *spm );
+
+/**
+ * @}
+ * @name SPM BLAS subroutines
+ * @{
+ */
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 );
+/**
+ * @}
+ * @name SPM subroutines to check format
+ * @{
+ */
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 IO subroutines
- */
-int spmLoad( pastix_spm_t *spm, FILE *infile );
-int spmSave( pastix_spm_t *spm, FILE *outfile );
-
-/**
- * SPM subroutines to check factorization/solve
+ * @}
+ * @name SPM subroutines to check factorization/solve
+ * @{
*/
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 );
/**
- * SPM print output
+ * @}
+ * @name SPM subroutines to manipulate integers arrays
+ * @{
*/
-void spmPrint( FILE *f, const pastix_spm_t *spm );
+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);
/**
- * SPM multi-dof subroutines
+ * @}
+ * @name SPM IO 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 );
+int spmLoad( pastix_spm_t *spm, FILE *infile );
+int spmSave( pastix_spm_t *spm, FILE *outfile );
/**
- * SPM read driver access
+ * @}
+ * @name SPM driver
+ * @{
*/
int spmReadDriver( pastix_driver_t driver,
char *filename,
pastix_spm_t *spm,
MPI_Comm pastix_comm );
+/**
+ * @}
+ * @name SPM debug subroutines
+ * @{
+ */
+void * spm2Dense( const pastix_spm_t *spm );
+void spmPrint( FILE *f, const pastix_spm_t *spm );
+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 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);
+
/**
* @}
*/
diff --git a/spm_dofs.c b/spm_dofs.c
index 4febd9ba181065b1760efdcfb813478f59fdfbdd..facbe5fc35d5d505e4c6c5f5b169d4fb181445c2 100644
--- a/spm_dofs.c
+++ b/spm_dofs.c
@@ -6,7 +6,7 @@
* PaStiX is a software package provided by Inria Bordeaux - Sud-Ouest,
* LaBRI, University of Bordeaux 1 and IPB.
*
- * @version 5.1.0
+ * @version 6.0.0
* @author Mathieu Faverge
* @author Theophile Terraz
* @author Alban Bellot
@@ -27,21 +27,24 @@
*
* @ingroup pastix_spm
*
- * @brief SPM multi-dof subroutines
- *
- * TODO
+ * @brief Generate a random multidof spm from a given spm (with dof=1).
*
*******************************************************************************
*
- * @param[in] type TODO
+ * @param[in] type
+ * Defines how to generate dofs.
+ * - 0: Generate a constant dof vector,
+ * - else: Generate a variable dof vector.
*
- * @param[in] dof TODO
+ * @param[in] dof
+ * The maximum value for dofs.
*
- * @param[in] spm TODO
+ * @param[in] spm
+ * The sparse matrix used to generate the new multidof spm.
*
********************************************************************************
*
- * @return TODO
+ * @return the new multidof spm.
*
*******************************************************************************/
pastix_spm_t *
@@ -62,7 +65,7 @@ spmDofExtend( const int type,
newspm = spmCopy( spm );
- /**
+ /*
* Generate constant dof
*/
if (type == 0) {
@@ -78,7 +81,7 @@ spmDofExtend( const int type,
newspm->dofs = malloc( (spm->n+1) * sizeof(pastix_int_t) );
dofptr = newspm->dofs;
- /**
+ /*
* Initialize the dofs array where the degree of freedom of vertex i is
* dof[i+1] - dof[i]
*/
diff --git a/spm_integers.c b/spm_integers.c
index 3486c60e01f0d9496980044dd0e6e91d9bf2a82a..2029da67154482f31152da0539b9381e9211c2ad 100644
--- a/spm_integers.c
+++ b/spm_integers.c
@@ -6,7 +6,7 @@
* PaStiX is a software package provided by Inria Bordeaux - Sud-Ouest,
* LaBRI, University of Bordeaux 1 and IPB.
*
- * @version 5.1.0
+ * @version 6.0.0
* @author Francois Pellegrini
* @author Xavier Lacoste
* @author Pierre Ramet
@@ -25,8 +25,7 @@
*
* @ingroup pastix_spm
*
- * @brief Convert integer array to the pastix_int_t format if it is not already
- * the case.
+ * @brief Convert integer array to pastix_int_t format.
*
*******************************************************************************
*
@@ -34,13 +33,13 @@
* The number of elements in the array.
*
* @param[in,out] input
- * The input array. If the type size is not the same, the array is
+ * The input array. If the types are not the same, the array is
* freed on exit.
*
*******************************************************************************
*
- * @return The pointer to the new allocated array if size has changed, or to
- * input if sizes are identical.
+ * @return The pointer to the new allocated array if the type has changed,
+ * or the original array if the types are identical.
*
*******************************************************************************/
pastix_int_t *
diff --git a/spm_io.c b/spm_io.c
index 89b7fd474d5e3ef7885b33527fca69e526d0f4b8..76678ba001a92d7179ee583e5ddd40bc532dcd31 100644
--- a/spm_io.c
+++ b/spm_io.c
@@ -6,7 +6,7 @@
* PaStiX is a software package provided by Inria Bordeaux - Sud-Ouest,
* LaBRI, University of Bordeaux 1 and IPB.
*
- * @version 5.1.0
+ * @version 6.0.0
* @author Xavier Lacoste
* @author Pierre Ramet
* @author Mathieu Faverge
@@ -36,9 +36,8 @@
*
********************************************************************************
*
- * @return
- * \retval PASTIX_SUCCESS if the read happened successfuly.
- * \retval PASTIX_ERR_FILE if the input format is incorrect.
+ * @retval PASTIX_SUCCESS if the read happened successfully,
+ * @retval PASTIX_ERR_FILE if the input format is incorrect.
*
*******************************************************************************/
static inline int
@@ -118,9 +117,8 @@ readArrayOfInteger( FILE *stream,
*
********************************************************************************
*
- * @return
- * \retval PASTIX_SUCCESS if the read happened successfuly.
- * \retval PASTIX_ERR_FILE if the input format is incorrect.
+ * @retval PASTIX_SUCCESS if the read happened successfully,
+ * @retval PASTIX_ERR_FILE if the input format is incorrect.
*
*******************************************************************************/
static inline int
@@ -205,9 +203,8 @@ readArrayOfComplex64( FILE *stream,
*
********************************************************************************
*
- * @return
- * \retval PASTIX_SUCCESS if the read happened successfuly.
- * \retval PASTIX_ERR_FILE if the input format is incorrect.
+ * @retval PASTIX_SUCCESS if the read happened successfully,
+ * @retval PASTIX_ERR_FILE if the input format is incorrect.
*
*******************************************************************************/
static inline int
@@ -292,9 +289,8 @@ readArrayOfComplex32( FILE *stream,
*
********************************************************************************
*
- * @return
- * \retval PASTIX_SUCCESS if the read happened successfuly.
- * \retval PASTIX_ERR_FILE if the input format is incorrect.
+ * @retval PASTIX_SUCCESS if the read happened successfully,
+ * @retval PASTIX_ERR_FILE if the input format is incorrect.
*
*******************************************************************************/
static inline int
@@ -377,9 +373,8 @@ readArrayOfDouble( FILE *stream,
*
********************************************************************************
*
- * @return
- * \retval PASTIX_SUCCESS if the read happened successfuly.
- * \retval PASTIX_ERR_FILE if the input format is incorrect.
+ * @retval PASTIX_SUCCESS if the read happened successfully,
+ * @retval PASTIX_ERR_FILE if the input format is incorrect.
*
*******************************************************************************/
static inline int
@@ -445,25 +440,22 @@ readArrayOfFloat( FILE *stream,
*
* @ingroup pastix_spm
*
- * @brief Load the spm structure from a file (internal format)
+ * @brief Load the spm structure from a file (internal format).
*
- * Load the spm data structure from a file store in an internal format. For now
- * this function only load a simple csc matrix.
*
*******************************************************************************
*
* @param[in,out] spm
* On entry, an allocated spm data structure.
- * On exit, the spm filled with the information read in the file
+ * On exit, the spm filled with the information read in the file.
*
* @param[in] infile
* The opened file in which the spm is stored.
*
*******************************************************************************
*
- * @return
- * \retval PASTIX_SUCCESS if the load happened successfuly.
- * \retval PASTIX_ERR_FILE if the input format is incorrect.
+ * @retval PASTIX_SUCCESS if the load happened successfully,
+ * @retval PASTIX_ERR_FILE if the input format is incorrect.
*
*******************************************************************************/
int
@@ -474,7 +466,7 @@ spmLoad( pastix_spm_t *spm,
char line[256], *test;
int rc = PASTIX_SUCCESS;
- /**
+ /*
* Skip comments
*/
do {
@@ -485,7 +477,7 @@ spmLoad( pastix_spm_t *spm,
}
while( line[0] == '#' );
- /**
+ /*
* Read header
*/
{
@@ -533,7 +525,7 @@ spmLoad( pastix_spm_t *spm,
break;
}
- /**
+ /*
* Read colptr
*/
spm->colptr = malloc( colsize * sizeof(pastix_int_t) );
@@ -542,7 +534,7 @@ spmLoad( pastix_spm_t *spm,
return rc;
}
- /**
+ /*
* Read rowptr
*/
spm->rowptr = malloc( rowsize * sizeof(pastix_int_t) );
@@ -551,7 +543,7 @@ spmLoad( pastix_spm_t *spm,
return rc;
}
- /**
+ /*
* Read dofs
*/
if ( spm->dof > 0 ) {
@@ -565,7 +557,7 @@ spmLoad( pastix_spm_t *spm,
}
}
- /**
+ /*
* Read dofs
*/
if ( spm->gN == spm->n ) {
@@ -579,7 +571,7 @@ spmLoad( pastix_spm_t *spm,
}
}
- /**
+ /*
* Read values
*/
if (spm->flttype == PastixPattern ) {
@@ -629,7 +621,7 @@ spmLoad( pastix_spm_t *spm,
*
*******************************************************************************
*
- * @return PASTIX_SUCCESS if the write happened successfuly.
+ * @return PASTIX_SUCCESS if the write happened successfully.
*
*******************************************************************************/
static inline int
@@ -670,7 +662,7 @@ writeArrayOfComplex64( FILE *outfile,
*
*******************************************************************************
*
- * @return PASTIX_SUCCESS if the write happened successfuly.
+ * @return PASTIX_SUCCESS if the write happened successfully.
*
*******************************************************************************/
static inline int
@@ -711,7 +703,7 @@ writeArrayOfComplex32( FILE *outfile,
*
*******************************************************************************
*
- * @return PASTIX_SUCCESS if the write happened successfuly.
+ * @return PASTIX_SUCCESS if the write happened successfully.
*
*******************************************************************************/
static inline int
@@ -752,7 +744,7 @@ writeArrayOfDouble( FILE *outfile,
*
*******************************************************************************
*
- * @return PASTIX_SUCCESS if the write happened successfuly.
+ * @return PASTIX_SUCCESS if the write happened successfully.
*
*
*******************************************************************************/
@@ -779,10 +771,8 @@ writeArrayOfFloat( FILE *outfile,
*
* @ingroup pastix_spm
*
- * @brief Save the spm structure into a file (internal format)
+ * @brief Save the spm structure into a file (internal format).
*
- * Save the spm data structure into a file and stored in an internal format. For
- * now this function only save a simple csc matrix.
*
*******************************************************************************
*
@@ -794,7 +784,7 @@ writeArrayOfFloat( FILE *outfile,
*
********************************************************************************
*
- * @return PASTIX_SUCCESS if the save happened successfuly
+ * @return PASTIX_SUCCESS if the save happened successfully.
*
*******************************************************************************/
int
@@ -803,7 +793,7 @@ spmSave( pastix_spm_t *spm,
{
pastix_int_t i, colsize, rowsize;
- /**
+ /*
* Write header
*/
fprintf( outfile,
@@ -831,7 +821,7 @@ spmSave( pastix_spm_t *spm,
rowsize = 0;
}
- /**
+ /*
* Write colptr
*/
for (i=0; i<colsize; i++)
@@ -841,7 +831,7 @@ spmSave( pastix_spm_t *spm,
}
if ((i-1)%4 !=3) fprintf(outfile, "\n");
- /**
+ /*
* Write rowptr
*/
for (i=0; i<rowsize; i++)
@@ -851,7 +841,7 @@ spmSave( pastix_spm_t *spm,
}
if ((i-1)%4 !=3) fprintf(outfile, "\n");
- /**
+ /*
* Write dofs
*/
if ( spm->dof <= 0 ) {
@@ -863,7 +853,7 @@ spmSave( pastix_spm_t *spm,
if ((i-1)%4 !=3) fprintf(outfile, "\n");
}
- /**
+ /*
* Write loc2glob
*/
if ( spm->n != spm->gN ) {
@@ -875,7 +865,7 @@ spmSave( pastix_spm_t *spm,
if ((i-1)%4 !=3) fprintf(outfile, "\n");
}
- /**
+ /*
* Write values
*/
switch( spm->flttype ) {
diff --git a/spm_read_driver.c b/spm_read_driver.c
index 1de44c1f4afab9ec78390a2ea81bbe0ddc4a6856..8fb6382be28e2cd0fa80a334eced10500d3c7ef0 100644
--- a/spm_read_driver.c
+++ b/spm_read_driver.c
@@ -25,7 +25,7 @@
*
* @ingroup pastix_spm
*
- * @brief Import a matrix file into a spm structure
+ * @brief Import a matrix file into a spm structure.
*
* This function read or generate a sparse matrix from a file to store it into a
* spm structure. The different formats accepted by this driver are described by
@@ -34,17 +34,17 @@
*******************************************************************************
*
* @param[in] driver
- * This defines the driver to use to create the spm structure.
- * = PastixDriverRSA
- * = PastixDriverHB
- * = PastixDriverIJV
- * = PastixDriverMM
- * = PastixDriverLaplacian
- * = PastixDriverXLaplacian
- * = PastixDriverGraph
+ * This defines the driver to use to create the spm structure:
+ * - PastixDriverRSA
+ * - PastixDriverHB
+ * - PastixDriverIJV
+ * - PastixDriverMM
+ * - PastixDriverLaplacian
+ * - PastixDriverXLaplacian
+ * - PastixDriverGraph
*
* @param[in] filename
- * The name of the file that stores the matrix (see driver)
+ * The name of the file that stores the matrix (see driver).
*
* @param[in,out] spm
* On entry, an allocated sparse matrix structure.
@@ -57,9 +57,8 @@
*
********************************************************************************
*
- * @return
- * \retval PASTIX_SUCCESS if the file reading happened successfuly
- * \retval PASTIX_ERR_BADPARAMETER if one the parameter is incorrect.
+ * @retval PASTIX_SUCCESS if the file reading happened successfully,
+ * @retval PASTIX_ERR_BADPARAMETER if one the parameter is incorrect.
*
*******************************************************************************/
int
diff --git a/z_spm.c b/z_spm.c
index 4560b5512345ad7de2eb93de638c59048b078be7..a7cb855a42dfb3b9e94fb7b9287195158a958d85 100644
--- a/z_spm.c
+++ b/z_spm.c
@@ -191,20 +191,20 @@ z_spmMergeDuplicate( pastix_spm_t *spm )
* @brief This routine corrects the sparse matrix structure if it's
* pattern is not symmetric.
*
- * It returns the new symmetric pattern with zeores on
+ * It returns the new symmetric pattern with zeroes on
* the new entries.
*
*******************************************************************************
*
* @param[in,out] spm
* On entry, the pointer to the sparse matrix structure.
- * On exit, the same sparse matrix with extra entires that makes it
+ * On exit, the same sparse matrix with extra entries that makes it
* pattern symmetric.
*
*******************************************************************************
*
* @return
- * \retval Returns the number of elements added to the matrix.
+ * \retval Returns the number of entries added to the matrix.
*
*******************************************************************************/
pastix_int_t