int main(void)
{
printf("========= Starts SBM tests 1 for SBM ========= \n");
SparseBlockStructuredMatrix M;
FILE *file = fopen("data/SBM1.dat", "r");
newFromFileSBM(&M, file);
fclose(file);
/*alloc enough memory */
int res = test_SBMRowToDense(&M);
if (res)
{
printf("========= Failed SBM tests 1 for SBM ========= \n");
return 1;
}
SBMfree(&M, NUMERICS_SBM_FREE_BLOCK);
SparseBlockStructuredMatrix M2;
file = fopen("data/SBM2.dat", "r");
newFromFileSBM(&M2, file);
fclose(file);
res = test_SBMRowToDense(&M2);
if (res)
{
printf("========= Failed SBM tests 1 for SBM ========= \n");
return 1;
}
SBMfree(&M2, NUMERICS_SBM_FREE_BLOCK);
printf("\n========= Succeeded SBM tests 1 for SBM ========= \n");
return 0;
}
int test_RowPermutationSBM(SparseBlockStructuredMatrix *M)
{
SparseBlockStructuredMatrix MRes;
unsigned int nbRow = M->blocknumber0;
unsigned int * rowBlockIndex = (unsigned int*) malloc(nbRow * sizeof(unsigned int));
unsigned int * mark = (unsigned int*) malloc(nbRow * sizeof(unsigned int));
for (unsigned int i = 0; i < nbRow; i++)
{
mark[i] = 0;
}
for (unsigned int i = 0; i < nbRow; i++)
{
int candidate = rand() % nbRow;
while (mark[candidate])
candidate = rand() % nbRow;
rowBlockIndex[i] = candidate;
mark[candidate] = 1;
}
RowPermutationSBM(rowBlockIndex, M, &MRes);
double * denseMRes = (double*) malloc(M->blocksize0[M->blocknumber0 - 1] * M->blocksize1[M->blocknumber1 - 1] * sizeof(double));
SBMtoDense(&MRes, denseMRes);
double * denseM = (double*) malloc(M->blocksize0[M->blocknumber0 - 1] * M->blocksize1[M->blocknumber1 - 1] * sizeof(double));
unsigned int curRow = 0;
unsigned int nbRowInM = M->blocksize0[M->blocknumber0 - 1];
for (unsigned int i = 0; i < nbRow; i++)
{
unsigned int rowInM = rowBlockIndex[i];
unsigned int nbRow = 0;
if (rowInM)
nbRow = M->blocksize0[rowInM] - M->blocksize0[rowInM - 1];
else
nbRow = M->blocksize0[rowInM];
SBMRowToDense(M, rowInM, denseM, curRow, nbRowInM);
curRow += nbRow;
}
for (unsigned int n = 0; n < M->blocksize0[M->blocknumber0 - 1]*M->blocksize1[M->blocknumber1 - 1]; n++)
if (fabs(denseMRes[n] - denseM[n]) > 10e-12)
{
free(denseM);
free(denseMRes);
free(rowBlockIndex);
free(mark);
SBMfree(&MRes, 0);
return 1;
}
free(denseM);
free(denseMRes);
free(rowBlockIndex);
free(mark);
SBMfree(&MRes, 0);
return 0;
}
int main(void)
{
int res;
printf("========= Starts SBM tests 4 for SBM ========= \n");
SparseBlockStructuredMatrix M;
FILE *file = fopen("data/SBM2.dat", "r");
newFromFileSBM(&M, file);
printSBM(&M);
fclose(file);
/*alloc enough memory */
CSparseMatrix sparseMat;
res = SBMtoSparseInitMemory(&M, &sparseMat);
if (res)
{
printf("========= Failed SBM tests 4 for SBM ========= \n");
return 1;
}
res = SBMtoSparse(&M, &sparseMat);
if (res)
{
printf("========= Failed SBM tests 4 for SBM ========= \n");
return 1;
}
cs_print(&sparseMat, 1);
cs_spfree_on_stack(&sparseMat);
int n = M.blocksize0[M.blocknumber0 - 1];
int m = M.blocksize1[M.blocknumber1 - 1];
double * denseMat = (double *)malloc(n * m * sizeof(double));
SBMtoDense(&M, denseMat);
if (res)
{
printf("========= Failed SBM tests 4 for SBM ========= \n");
return 1;
}
printf("[");
for (int i = 0; i < n * m; i++)
{
printf("%lf ", denseMat[i]);
if ((i + 1) % m == 0)
printf("\n");
}
printf("]");
printf("\n (warning: column-major) \n");
free(denseMat);
printf("NUMERICS_SBM_FREE_BLOCK value %d", NUMERICS_SBM_FREE_BLOCK);
SBMfree(&M, NUMERICS_SBM_FREE_BLOCK);
printf("\n========= Succed SBM tests 4 for SBM ========= \n");
return 0;
}
int test_ColPermutationSBM(SparseBlockStructuredMatrix *M)
{
SparseBlockStructuredMatrix MRes;
int nbCol = M->blocknumber1;
unsigned int * colBlockIndex = (unsigned int*) malloc(nbCol * sizeof(unsigned int));
int * mark = (int*) malloc(nbCol * sizeof(int));
for (int i = 0; i < nbCol; i++)
mark[i] = 0;
for (int i = 0; i < nbCol; i++)
{
int candidate = rand() % nbCol;
while (mark[candidate])
candidate = rand() % nbCol;
colBlockIndex[i] = candidate;
mark[candidate] = 1;
}
ColPermutationSBM(colBlockIndex, M, &MRes);
free(colBlockIndex);
free(mark);
SBMfree(&MRes, 0);
return 0;
}
/*mem loc done */
void buildReducedGMP(GenericMechanicalProblem* pInProblem, double * Me, double * Mi, double * Qe, double * Qi, int * Me_Size, int* Mi_Size)
{
assert(pInProblem->M->storageType);
//#ifdef TYTYFCRR
SparseBlockStructuredMatrix* m = pInProblem->M->matrix1;
#ifdef GMP_DEBUG_REDUCED
FILE * titi = fopen("buildReducedGMP_input.txt", "w");
printInFileSBMForScilab(m, titi);
fclose(titi);
#endif
int curSize = 0;
// int *newIndexOfBlockI;
// int NbCol=pInProblem->size;
int nbBlockCol = m->blocknumber1;
unsigned int * newIndexOfCol = (unsigned int*) malloc(nbBlockCol * sizeof(unsigned int));
/*Me building*/
int MeRow = 0;
int MiRow = 0;
/**size of Me */
listNumericsProblem * curProblem = 0;
int nbBlockRowE = 0;
int nbBlockRowI = 0;
int numBlockRow = 0;
curProblem = pInProblem->firstListElem;
while (curProblem)
{
if (numBlockRow)
curSize = m->blocksize0[numBlockRow] - m->blocksize0[numBlockRow - 1];
else
curSize = m->blocksize0[numBlockRow];
if (curProblem->type == SICONOS_NUMERICS_PROBLEM_EQUALITY)
{
nbBlockRowE++;
MeRow += curSize;
}
else
{
nbBlockRowI++;
MiRow += curSize;
}
curProblem = curProblem->nextProblem;
numBlockRow++;
}
numBlockRow = 0;
int numRowE = 0;
int numRowI = 0;
int numRow = 0;
curProblem = pInProblem->firstListElem;
while (curProblem)
{
if (curProblem->type == SICONOS_NUMERICS_PROBLEM_EQUALITY)
{
newIndexOfCol[numRow] = numRowE;
numRowE++;
}
else
{
newIndexOfCol[numRow] = numRowI + nbBlockRowE;
numRowI++;
}
numRow++;
curProblem = curProblem->nextProblem;
}
#ifdef GMP_DEBUG_REDUCED
printf("buildReducedGMP nb of block of eq=%i. nb of iq=%i\n", numRowE, numRowI);
#endif
/*building of the permutation matrices*/
SparseBlockStructuredMatrix Maux;
ColPermutationSBM(newIndexOfCol, m, &Maux);
SparseBlockStructuredMatrix Morder;
RowPermutationSBM(newIndexOfCol, &Maux, &Morder);
SBMfree(&Maux, 0);
/*
get the permutation indices of col (and row).
*/
curProblem = pInProblem->firstListElem;
/**mem alloc for Me and Mi*/
//int nbCol=MeRow+MiRow;
*Me_Size = MeRow;
*Mi_Size = MiRow;
/* Me=(double *) malloc(MeRow*nbCol*sizeof(double));
Qe=(double *) malloc(MeRow*sizeof(double));
Mi=(double *) malloc(MiRow*nbCol*sizeof(double));
Qi=(double *) malloc(MiRow*sizeof(double));*/
/** copi in Me*/
int curPos = 0;
for (int numBlockRow = 0; numBlockRow < nbBlockRowE; numBlockRow++)
{
SBMRowToDense(&Morder, numBlockRow, Me, curPos, MeRow);
curPos = Morder.blocksize1[numBlockRow];
}
curPos = 0;
int firtMiLine = 0;
if (nbBlockRowI > 0)
firtMiLine = Morder.blocksize1[nbBlockRowE];
for (int numBlockRow = nbBlockRowE; numBlockRow < nbBlockRowE + nbBlockRowI; numBlockRow++)
{
curPos = Morder.blocksize1[numBlockRow] - firtMiLine;
SBMRowToDense(&Morder, numBlockRow, Mi, curPos, MiRow);
}
SBMfree(&Morder, 0);
curProblem = pInProblem->firstListElem;
int curBlock = 0;
int curPosIq = 0;
int curPosEq = 0;
double *curQ = pInProblem->q;
double *curQe = Qe;
double *curQi = Qi;
curBlock = 0;
while (curProblem)
{
if (curBlock)
{
curSize = m->blocksize0[curBlock] - m->blocksize0[curBlock - 1];
}
else
{
curSize = m->blocksize0[curBlock];
}
switch (curProblem->type)
{
case SICONOS_NUMERICS_PROBLEM_EQUALITY:
{
/** copy the current line block in Me*/
memcpy(curQe, curQ, curSize * sizeof(double));
curPosEq += curSize;
curQe += curSize;
break;
}
case SICONOS_NUMERICS_PROBLEM_LCP:
case SICONOS_NUMERICS_PROBLEM_FC3D:
{
memcpy(curQi, curQ, curSize * sizeof(double));
curPosIq += curSize;
curQi += curSize;
break;
}
default:
printf("GMPReduced buildReducedGMP: problemType unknown: %d . \n", curProblem->type);
}
curProblem = curProblem->nextProblem;
curQ += curSize;
curBlock++;
}
#ifdef GMP_DEBUG_REDUCED
int nbCol = MeRow + MiRow;
printf("\\The Me matrix is:\n");
printf("Me=[ \n");
for (int i = 0; i < MeRow; i++)
{
printf("[");
for (int j = 0; j < nbCol; j++)
{
printf("%e\t ", Me[i + j * MeRow]);
}
printf("];\n");
}
printf("];\n");
printf("Qe= [ \n");
for (int i = 0; i < MeRow; i++)
printf("%e\t ", Qe[i]);
printf("];\n");
printf("\\The Mi matrix is:\n");
printf("Mi=[ \n");
for (int i = 0; i < MiRow; i++)
{
printf("[");
for (int j = 0; j < nbCol; j++)
{
printf("%e\t ", Mi[i + j * MiRow]);
}
printf("];\n");
}
printf("];\n");
printf("Qi= [ \n");
for (int i = 0; i < MiRow; i++)
printf("%e\t ", Qi[i]);
printf("];\n");
#endif
free(newIndexOfCol);
//#endif
}