diff --git a/spm.c b/spm.c
index c8cd8df87628289dbfa496ddd57b781725a5bd1e..1f35b85e729b60b87024d2b0ae3a4090cf7dc738 100644
--- a/spm.c
+++ b/spm.c
@@ -303,6 +303,7 @@ spmConvert( int ofmttype, pastix_spm_t *spm )
{
if ( conversionTable[spm->fmttype][ofmttype][spm->flttype] ) {
if ( spm->dof != 1 ) {
+ //pastix_error_print( "spmConvert: Conversion of non unique dof not yet implemented\n");
return PASTIX_ERR_NOTIMPLEMENTED;
}
return conversionTable[spm->fmttype][ofmttype][spm->flttype]( spm );
diff --git a/spm.h b/spm.h
index 37daba94d1ac87327212a0bb6f164911d0f23855..d065d9116fb8f08e47ce94b86a54af622f7ef67b 100644
--- a/spm.h
+++ b/spm.h
@@ -60,7 +60,7 @@ typedef enum pastix_driver_e {
*
*/
struct pastix_spm_s {
- int mtxtype;/**< Matrix structure: PastixGeneral, PastixSymmetric
+ int mtxtype; /**< Matrix structure: PastixGeneral, PastixSymmetric
or PastixHermitian. */
pastix_coeftype_t flttype; /**< avals datatype: PastixPattern, PastixFloat, PastixDouble,
PastixComplex32 or PastixComplex64 */
diff --git a/z_spm_2dense.c b/z_spm_2dense.c
index bbb23463edcca23c75b1434c122a2ae935765c67..03f06c3d21b8043a7b259a0bd1cfc7863883ebe8 100644
--- a/z_spm_2dense.c
+++ b/z_spm_2dense.c
@@ -523,13 +523,7 @@ z_spmDensePrint( FILE *f, pastix_int_t m, pastix_int_t n, pastix_complex64_t *A,
for(i=0; i<m; i++)
{
if ( cabs( A[ j * lda + i ] ) != 0. ) {
-#if defined(PRECISION_z) || defined(PRECISION_c)
- fprintf( f, "%ld %ld (%e, %e)\n",
- i, j, creal(A[lda * j + i]), cimag(A[lda * j + i]) );
-#else
- fprintf( f, "%ld %ld %e\n",
- i, j, A[lda * j + i] );
-#endif
+ z_spmPrintElt( f, i, j, A[lda * j + i] );
}
}
}
diff --git a/z_spm_dof_extend.c b/z_spm_dof_extend.c
index 0808013ed21ef87c3fd48243ec57317b9c200036..7e03fce0d7d8ce73f0c4befe756020cf0b8ba56f 100644
--- a/z_spm_dof_extend.c
+++ b/z_spm_dof_extend.c
@@ -34,6 +34,11 @@ z_spmDofExtend(pastix_spm_t *spm)
switch(spm->fmttype)
{
+ case PastixCSR:
+ /* Swap pointers to call CSC */
+ colptr = spm->rowptr;
+ rowptr = spm->colptr;
+
case PastixCSC:
/**
* Loop on col
@@ -60,32 +65,32 @@ z_spmDofExtend(pastix_spm_t *spm)
}
}
break;
- case PastixCSR:
- /**
- * Loop on row
- */
- for(i=0; i<spm->n; i++, rowptr++)
- {
- dofi = ( spm->dof > 0 ) ? spm->dof : dofs[i+1] - dofs[i];
+ /* case PastixCSR: */
+ /* /\** */
+ /* * Loop on row */
+ /* *\/ */
+ /* for(i=0; i<spm->n; i++, rowptr++) */
+ /* { */
+ /* dofi = ( spm->dof > 0 ) ? spm->dof : dofs[i+1] - dofs[i]; */
- /**
- * Loop on cols
- */
- for(k=rowptr[0]; k<rowptr[1]; k++, colptr++, oldval++)
- {
- j = *colptr - baseval;
- dofj = ( spm->dof > 0 ) ? spm->dof : dofs[j+1] - dofs[j];
+ /* /\** */
+ /* * Loop on cols */
+ /* *\/ */
+ /* for(k=rowptr[0]; k<rowptr[1]; k++, colptr++, oldval++) */
+ /* { */
+ /* j = *colptr - baseval; */
+ /* dofj = ( spm->dof > 0 ) ? spm->dof : dofs[j+1] - dofs[j]; */
- for(jj=0; jj<dofj; jj++)
- {
- for(ii=0; ii<dofi; ii++, newval++)
- {
- *newval = *oldval;
- }
- }
- }
- }
- break;
+ /* for(jj=0; jj<dofj; jj++) */
+ /* { */
+ /* for(ii=0; ii<dofi; ii++, newval++) */
+ /* { */
+ /* *newval = *oldval; */
+ /* } */
+ /* } */
+ /* } */
+ /* } */
+ /* break; */
case PastixIJV:
/**
* Loop on coordinates
diff --git a/z_spm_expand.c b/z_spm_expand.c
index d10ccae515b243d7583e7874d8a96dfbd9fbc92d..41948aca2bda5d185d8e8fabb4c58f1581528743 100644
--- a/z_spm_expand.c
+++ b/z_spm_expand.c
@@ -39,15 +39,22 @@ z_spmCSCExpand(const pastix_spm_t *spm)
memcpy( newspm, spm, sizeof(pastix_spm_t) );
baseval = spmFindBase( spm );
- oldcol = spm->colptr;
- oldrow = spm->rowptr;
+ newspm->n = spm->nexp;
dofs = spm->dofs;
#if !defined(PRECISION_p)
oldval = oldval2 = (pastix_complex64_t*)(spm->values);
#endif
- newspm->n = spm->nexp;
- newspm->colptr = newcol = malloc(sizeof(pastix_int_t)*(spm->nexp+1));
+ if ( spm->fmttype == PastixCSC ) {
+ oldcol = spm->colptr;
+ oldrow = spm->rowptr;
+ newspm->colptr = newcol = malloc(sizeof(pastix_int_t)*(spm->nexp+1));
+ }
+ else {
+ oldcol = spm->rowptr;
+ oldrow = spm->colptr;
+ newspm->rowptr = newcol = malloc(sizeof(pastix_int_t)*(spm->nexp+1));
+ }
/**
* First loop to compute the new colptr
@@ -87,17 +94,26 @@ z_spmCSCExpand(const pastix_spm_t *spm)
((spm->mtxtype != PastixGeneral) && ((newcol[0]-baseval) <= spm->nnzexp)) );
newspm->nnz = newcol[0] - baseval;
- newspm->rowptr = newrow = malloc(sizeof(pastix_int_t)*newspm->nnz);
#if !defined(PRECISION_p)
newspm->values = newval = malloc(sizeof(pastix_complex64_t)*newspm->nnz);
#endif
+ if (spm->fmttype == PastixCSC) {
+ newspm->rowptr = newrow = malloc(sizeof(pastix_int_t)*newspm->nnz);
+ oldcol = spm->colptr;
+ oldrow = spm->rowptr;
+ newcol = newspm->colptr;
+ }
+ else {
+ newspm->colptr = newrow = malloc(sizeof(pastix_int_t)*newspm->nnz);
+ oldcol = spm->rowptr;
+ oldrow = spm->colptr;
+ newcol = newspm->rowptr;
+ }
+
/**
* Second loop to compute the new rowptr and valptr
*/
- oldcol = spm->colptr;
- oldrow = spm->rowptr;
- newcol = newspm->colptr;
for(j=0, col=0; j<spm->n; j++, oldcol++)
{
/**
@@ -233,7 +249,7 @@ z_spmCSRExpand(const pastix_spm_t *spm)
height = newrow[1] - newrow[0];
newrow++;
- /* Add extra rowumns */
+ /* Add extra rownumns */
for(ii=1; ii<dofi; ii++, newrow++)
{
newrow[1] = newrow[0] + height;
@@ -420,22 +436,24 @@ z_spmIJVExpand(const pastix_spm_t *spm)
}
else {
dofi = dofs[i+1] - dofs[i];
- row = dofs[i];
+ row = dofs[i] - baseval;
dofj = dofs[j+1] - dofs[j];
- col = dofs[j];
+ col = dofs[j] - baseval;
}
if ( spm->layout == PastixColMajor ) {
for(jj=0; jj<dofj; jj++, col++)
{
- for(ii=0; ii<dofi; ii++, row++, oldval++)
+ for(ii=0; ii<dofi; ii++, oldval++)
{
if ( (spm->mtxtype == PastixGeneral) ||
(i != j) ||
- ((i == j) && (row >= col)) )
+ ((i == j) && (row + ii >= col)) )
{
+ assert( col < newspm->n );
+ assert( row + ii < newspm->n );
(*newcol) = col + baseval; newcol++;
- (*newrow) = row + baseval; newrow++;
+ (*newrow) = row + ii + baseval; newrow++;
#if !defined(PRECISION_p)
(*newval) = *oldval; newval++;
#endif
@@ -446,13 +464,15 @@ z_spmIJVExpand(const pastix_spm_t *spm)
else {
for(ii=0; ii<dofi; ii++, row++)
{
- for(jj=0; jj<dofj; jj++, col++, oldval++)
+ for(jj=0; jj<dofj; jj++, oldval++)
{
if ( (spm->mtxtype == PastixGeneral) ||
(i != j) ||
- ((i == j) && (row >= col)) )
+ ((i == j) && (row >= col + jj)) )
{
- (*newcol) = col + baseval; newcol++;
+ assert( col + jj < newspm->n );
+ assert( row < newspm->n );
+ (*newcol) = col + jj + baseval; newcol++;
(*newrow) = row + baseval; newrow++;
#if !defined(PRECISION_p)
(*newval) = *oldval; newval++;
@@ -462,6 +482,8 @@ z_spmIJVExpand(const pastix_spm_t *spm)
}
}
}
+ assert( newcol - newspm->colptr == newspm->nnz );
+ assert( newrow - newspm->rowptr == newspm->nnz );
newspm->gN = newspm->n;
newspm->gnnz = newspm->nnz;