int main(void)
{
printf("\n Start of test on Default SolverOptions\n");
int info = 0 ;
SolverOptions * options = (SolverOptions *)malloc(sizeof(SolverOptions));
FILE * finput = fopen("./data/lcp_mmc.dat", "r");
LinearComplementarityProblem* problem = (LinearComplementarityProblem *)malloc(sizeof(LinearComplementarityProblem));
info = linearComplementarity_newFromFile(problem, finput);
fclose(finput);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_NSGS_SBM);
assert(options->internalSolvers);
solver_options_set(options->internalSolvers, SICONOS_LCP_LEMKE);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_PGS);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_RPGS);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_QP);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_NSQP);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_CPG);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_PSOR);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_LATIN);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_LATIN_W);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_LEMKE);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_PATH);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_ENUM);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_NEWTONMIN);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_AVI_CAOFERRIS);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_PIVOT);
solver_options_print(options);
solver_options_delete(options);
freeLinearComplementarityProblem(problem);
free(options);
printf("\n End of test on Default SolverOptions\n");
return info;
}
void GMPasMLCP(GenericMechanicalProblem* pInProblem, double *reaction , double *velocity, int* info, SolverOptions* options)
{
/*First, we don't manage FC3D.*/
listNumericsProblem * curProblem = 0;
curProblem = pInProblem->firstListElem;
while (curProblem)
{
switch (curProblem->type)
{
case SICONOS_NUMERICS_PROBLEM_EQUALITY:
case SICONOS_NUMERICS_PROBLEM_LCP:
break;
case SICONOS_NUMERICS_PROBLEM_FC3D:
{
printf("GMPasMLCP Numerics ERROR: GMPasMLCP doesn't deal with FC3D.\n");
*info = 1;
return;
}
default:
printf("GMPasMLCP Numerics : genericMechanicalProblem_GS unknown problem type %d.\n", curProblem->type);
}
curProblem = curProblem->nextProblem;
}
int Me_size;
int Mi_size;
SparseBlockStructuredMatrix* m = pInProblem->M->matrix1;
int nbRow = m->blocksize0[m->blocknumber0 - 1];
int nbCol = m->blocksize1[m->blocknumber1 - 1];
double * reducedProb = (double *)malloc(nbRow * nbCol * sizeof(double));
double * Qreduced = (double *)malloc(nbRow * sizeof(double));
_GMPReducedEquality(pInProblem, reducedProb, Qreduced, &Me_size, &Mi_size);
if (!Me_size)
{
/*it is a lcp.*/
LinearComplementarityProblem aLCP;
SolverOptions aLcpOptions;
NumericsMatrix M;
M.storageType = 0;
M.size0 = Mi_size;
M.size1 = Mi_size;
M.matrix0 = reducedProb;
M.matrix1 = 0;
aLCP.size = Mi_size;
aLCP.q = Qreduced;
aLCP.M = &M;
linearComplementarity_setDefaultSolverOptions(&aLCP, &aLcpOptions, SICONOS_LCP_ENUM);
lcp_enum_init(&aLCP, &aLcpOptions, 1);
*info = linearComplementarity_driver(&aLCP, reaction, velocity, &aLcpOptions, 0);
lcp_enum_reset(&aLCP, &aLcpOptions, 1);
goto END_GMP3;
}
if (!Mi_size)
{
/*it is a linear system.*/
LinearSystemProblem aLS;
NumericsMatrix M;
M.storageType = 0;
M.size0 = Mi_size;
M.size1 = Mi_size;
M.matrix0 = reducedProb;
M.matrix1 = 0;
aLS.size = Me_size;
aLS.q = Qreduced;
aLS.M = &M;
*info = LinearSystem_driver(&aLS, reaction, velocity, 0);
goto END_GMP3;
}
/*it is a MLCP*/
MixedLinearComplementarityProblem aMLCP;
SolverOptions aMlcpOptions;
aMLCP.n = Me_size;
aMLCP.m = Mi_size;
aMLCP.blocksRows = 0;
aMLCP.blocksIsComp = 0;
aMLCP.isStorageType1 = 1;
aMLCP.isStorageType2 = 0;
aMLCP.A = 0;
aMLCP.B = 0;
aMLCP.C = 0;
aMLCP.D = 0;
aMLCP.a = 0;
aMLCP.b = 0;
aMLCP.q = Qreduced;
NumericsMatrix M;
M.storageType = 0;
M.size0 = Mi_size + Me_size;
M.size1 = Mi_size + Me_size;
M.matrix0 = reducedProb;
M.matrix1 = 0;
aMLCP.M = &M;
aMlcpOptions.solverId = SICONOS_MLCP_ENUM;
mixedLinearComplementarity_setDefaultSolverOptions(&aMLCP, &aMlcpOptions);
mlcp_driver_init(&aMLCP, &aMlcpOptions);
aMlcpOptions.dparam[0] = options->dparam[0];
*info = mlcp_driver(&aMLCP, reaction, velocity, &aMlcpOptions, 0);
mlcp_driver_reset(&aMLCP, &aMlcpOptions);
mixedLinearComplementarity_deleteDefaultSolverOptions(&aMLCP, &aMlcpOptions);
END_GMP3:
;
free(reducedProb);
free(Qreduced);
}
int lcp_test_function_SBM(FILE * f, int solverId)
{
int i, info = 0 ;
LinearComplementarityProblem* problem = (LinearComplementarityProblem *)malloc(sizeof(LinearComplementarityProblem));
info = linearComplementarity_newFromFile(problem, f);
FILE * foutput = fopen("./lcp_mmc.verif", "w");
info = linearComplementarity_printInFile(problem, foutput);
NumericsOptions global_options;
setDefaultNumericsOptions(&global_options);
global_options.verboseMode = 1;
SolverOptions * options = (SolverOptions *)malloc(sizeof(SolverOptions));
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_NSGS_SBM);
set_SolverOptions(options->internalSolvers, solverId);
#ifdef HAVE_GAMS_C_API
if (solverId == SICONOS_LCP_GAMS)
{
// no testing for now
deleteSolverOptions(options);
free(options);
freeLinearComplementarityProblem(problem);
fclose(foutput);
return 0;
/* SN_GAMSparams* GP = (SN_GAMSparams*)options->internalSolvers->solverParameters;
assert(GP);
GP->model_dir = GAMS_MODELS_SOURCE_DIR;*/
}
#endif
double * z = (double *)calloc(problem->size, sizeof(double));
double * w = (double *)calloc(problem->size, sizeof(double));
info = linearComplementarity_driver(problem, z , w, options, &global_options);
for (i = 0 ; i < problem->size ; i++)
{
printf("z[%i] = %12.8e\t,w[%i] = %12.8e\n", i, z[i], i, w[i]);
}
if (!info)
{
printf("test succeeded err=%e \n", options->dparam[1]);
}
else
{
printf("test unsuccessful err =%e \n", options->dparam[1]);
}
free(z);
free(w);
// info = linearComplementarity_deleteDefaultSolverOptions(&options,solvername);
deleteSolverOptions(options);
free(options);
freeLinearComplementarityProblem(problem);
fclose(foutput);
return info;
}
