int CPLEXDelConstraint(LinEquation* InEquation) {
int Status = 0;
int rowIndex = InEquation->Index;
int* indexPtr;
string ConstraintName = GetConstraintName(InEquation);
Status = CPXgetrowindex(CPLEXenv, CPLEXModel, ConstraintName.data(), indexPtr);
if (Status) {
FErrorFile() << "Failed to get constraint index for deletion." << endl;
FlushErrorFile();
return FAIL;
}
Status = CPXdelrows(CPLEXenv, CPLEXModel, rowIndex, rowIndex);
if (Status) {
FErrorFile() << "Failed to delete constraint " << ConstraintName << endl;
FlushErrorFile();
return FAIL;
} else {
return SUCCESS;
}
}
void CplexSolver::applyBranchingRule(DecisionList const & decisions, RowBuffer & rowBuffer, RowBuffer & decisionBuffer) {
if (rowBuffer.size() != CPXgetnumrows(_env, _prob))
CPXdelrows(_env, _prob, rowBuffer.size(), CPXgetnumrows(_env, _prob) - 1);
decisionBuffer.clear();
if (!decisions.empty()) {
for (Decision const & decision : decisions) {
if (decision.cannot()) {
// r+b <= 1
decisionBuffer.add(1, 'L', decision.name());
decisionBuffer.add(decision.noeud1(), +1);
decisionBuffer.add(decision.noeud2(), +1);
} else {
// r = b
decisionBuffer.add(0, 'E', decision.name());
decisionBuffer.add(decision.noeud1(), +1);
decisionBuffer.add(decision.noeud2(), -1);
}
}
decisionBuffer.add(_env, _prob);
}
}
void CplexSolver::delRows(int first, int last) {
CPXdelrows(_env, _prob, first, last);
}
void mexFunction(
int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[]
)
{
int display=0, from=0, to=0;
long *lpenv=NULL, *p_lp=NULL;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status ;
if (nrhs > 5 || nrhs < 1) {
mexErrMsgTxt("Usage: [how] "
"= lp_delrows(lpenv,p_lp,from,to,disp)");
return;
}
switch (nrhs) {
case 5:
if (mxGetM(prhs[4]) != 0 || mxGetN(prhs[4]) != 0) {
if (!mxIsNumeric(prhs[4]) || mxIsComplex(prhs[4])
|| mxIsSparse(prhs[4])
|| !(mxGetM(prhs[4])==1 && mxGetN(prhs[4])==1)) {
mexErrMsgTxt("5th argument (display) must be "
"an integer scalar.");
return;
}
display = *mxGetPr(prhs[4]);
}
case 4:
if (mxGetM(prhs[3]) != 0 || mxGetN(prhs[3]) != 0) {
if (!mxIsNumeric(prhs[3]) || mxIsComplex(prhs[3])
|| mxIsSparse(prhs[3])
|| !(mxGetM(prhs[3])==1 && mxGetN(prhs[3])==1)) {
mexErrMsgTxt("4th argument (display) must be "
"an integer scalar.");
return;
}
to = *mxGetPr(prhs[3]);
}
case 3:
if (mxGetM(prhs[2]) != 0 || mxGetN(prhs[2]) != 0) {
if (!mxIsNumeric(prhs[2]) || mxIsComplex(prhs[2])
|| mxIsSparse(prhs[2])
|| !(mxGetM(prhs[2])==1 && mxGetN(prhs[2])==1)) {
mexErrMsgTxt("3rd argument (display) must be "
"an integer scalar.");
return;
}
from = *mxGetPr(prhs[2]);
}
case 2:
if (mxGetM(prhs[1]) != 0 || mxGetN(prhs[1]) != 0) {
if (!mxIsNumeric(prhs[1]) || mxIsComplex(prhs[1])
|| mxIsSparse(prhs[1])
|| !mxIsDouble(prhs[1])
|| mxGetN(prhs[1])!=1 ) {
mexErrMsgTxt("2nd argument (p_lp) must be "
"a column vector.");
return;
}
if (1 != mxGetM(prhs[1])) {
mexErrMsgTxt("Dimension error (arg 2).");
return;
}
p_lp = (long*) mxGetPr(prhs[1]);
}
case 1:
if (mxGetM(prhs[0]) != 0 || mxGetN(prhs[0]) != 0) {
if (!mxIsNumeric(prhs[0]) || mxIsComplex(prhs[0])
|| mxIsSparse(prhs[0])
|| !mxIsDouble(prhs[0])
|| mxGetN(prhs[0])!=1 ) {
mexErrMsgTxt("1st argument (lpenv) must be "
"a column vector.");
return;
}
if (1 != mxGetM(prhs[0])) {
mexErrMsgTxt("Dimension error (arg 1).");
return;
}
lpenv = (long*) mxGetPr(prhs[0]);
}
}
if (nlhs > 1 || nlhs < 1) {
mexErrMsgTxt("Usage: [how] "
"= lp_delrows(lpenv,p_lp,from,to,disp)");
return;
}
if (display>3) fprintf(STD_OUT, "(from=%i, to=%i) \n", from, to) ;
if (display>2) fprintf(STD_OUT, "argument processing finished\n") ;
/* Initialize the CPLEX environment */
env = (CPXENVptr) lpenv[0] ;
lp=(CPXLPptr)p_lp[0] ;
if (display>2)
fprintf(STD_OUT, "calling CPXdelrows\n") ;
status = CPXdelrows(env, lp, (int)from, (int)to);
if ( status ) {
fprintf (STD_OUT, "CPXdelrows failed.\n");
goto TERMINATE;
}
TERMINATE:
if (status) {
char errmsg[1024];
CPXgeterrorstring (env, status, errmsg);
fprintf (STD_OUT, "%s", errmsg);
if (nlhs >= 1)
plhs[0] = mxCreateString(errmsg) ;
} else
if (nlhs >= 1)
plhs[0] = mxCreateString("OK") ;
;
return ;
}
void
DDSIP_DetEqu ()
{
CPXLPptr det_equ;
int status, scen, i, j, k;
char probname[] = "sipout/det_equ.lp.gz";
double *obj_coef;
double *scaled_obj_coef;
char *sense;
char **scen_spec_rowname;
char **scen_spec_colname;
char **rowname, *rownamestore;
char **colname, *colnamestore;
int rowstorespace, rowsurplus_p;
int colstorespace, colsurplus_p;
char *string1, *string2;
double coef;
double *lb, *lb_sorted;
double *ub, *ub_sorted;
char *vartype, *vartype_sorted;
int *colindex_sorted, *colindex_revers, *matcol_sorted;
double *value;
double *det_equ_rhs = NULL;
double *non_stoc_rhs = NULL;
if (DDSIP_param->seccon)
det_equ_rhs = (double *) DDSIP_Alloc(sizeof(double),DDSIP_param->seccon,"det_equ_rhs(DetEqu)");
else
{
fprintf (stderr,"XXX ERROR: no second stage contraints, got DDSIP_param->seccon=%d.\n",DDSIP_param->seccon);
exit (1);
}
if (DDSIP_param->seccon - DDSIP_param->stocrhs>0)
non_stoc_rhs = (double *) DDSIP_Alloc(sizeof(double),DDSIP_param->seccon - DDSIP_param->stocrhs,"non_stoc_rhs(DetEqu)");
fprintf (stderr,
"\nBuilding deterministic equivalent. This may take some time.\nWorks only for expectation-based model so far.\n");
if (!(sense = (char *) calloc (DDSIP_param->seccon, sizeof (char))))
{
fprintf (stderr, "Not enough memory for building deterministic equivalent\n");
return;
}
if (!(obj_coef = (double *) calloc (DDSIP_param->firstvar + DDSIP_param->secvar, sizeof (double))) ||
!(scaled_obj_coef = (double *) calloc (DDSIP_bb->secvar, sizeof (double))))
{
fprintf (stderr, "Not enough memory for building deterministic equivalent\n");
return;
}
det_equ = CPXcloneprob (DDSIP_env, DDSIP_lp, &status);
CPXchgprobname (DDSIP_env, det_equ, probname);
if (!(rowname = (char **) calloc (DDSIP_param->seccon, sizeof (char *)))
|| !(scen_spec_rowname = (char **) calloc (DDSIP_param->seccon, sizeof (char *)))
|| !(rownamestore = (char *) calloc (DDSIP_param->seccon * 255, sizeof (char))))
{
fprintf (stderr, "Not enough memory for building deterministic equivalent\n");
return;
}
rowstorespace = DDSIP_param->seccon * 255;
status = CPXgetrowname (DDSIP_env, DDSIP_lp, rowname, rownamestore,
rowstorespace, &rowsurplus_p, DDSIP_param->firstcon, DDSIP_param->firstcon + DDSIP_param->seccon - 1);
if (!(colname = (char **) calloc (DDSIP_param->firstvar + DDSIP_param->secvar, sizeof (char *)))
|| !(scen_spec_colname = (char **) calloc (DDSIP_param->secvar, sizeof (char *)))
|| !(colnamestore = (char *) calloc (DDSIP_param->secvar * 255, sizeof (char))))
{
fprintf (stderr, "Not enough memory for building deterministic equivalent\n");
return;
}
colstorespace = (DDSIP_param->firstvar + DDSIP_param->secvar) * 255;
status = CPXgetcolname (DDSIP_env, DDSIP_lp, colname, colnamestore,
colstorespace, &colsurplus_p, 0, DDSIP_param->firstvar + DDSIP_param->secvar - 1);
/*____________________________________________________________________________________*/
status = CPXgetsense (DDSIP_env, DDSIP_lp, sense, DDSIP_param->firstcon, DDSIP_param->firstcon + DDSIP_param->seccon - 1);
/*____________________________________________________________________________________*/
status = CPXgetrhs (DDSIP_env, DDSIP_lp, non_stoc_rhs, DDSIP_param->firstcon + DDSIP_param->stocrhs, DDSIP_param->firstcon + DDSIP_param->seccon - 1);
/*____________________________________________________________________________________*/
status = CPXgetobj (DDSIP_env, DDSIP_lp, obj_coef, 0, DDSIP_param->firstvar + DDSIP_param->secvar - 1);
/*____________________________________________________________________________________*/
//copy rownames scenario many times, append scenario index
//and enter sense and rhs
for (scen = 0; scen < DDSIP_param->scenarios; scen++)
{
for (j = 0; j < DDSIP_param->seccon; j++)
{
if (!(string2 = (char *) calloc (1, 255 * sizeof (char))))
{
fprintf (stderr, "Not enough memory for building deterministic equivalent\n");
return;
}
string1 = rowname[j];
sprintf (string2, "%sSC%.3d", string1, scen);
scen_spec_rowname[j] = string2;
if (j < DDSIP_param->stocrhs)
det_equ_rhs[j] = DDSIP_data->rhs[DDSIP_param->stocrhs * scen + j];
else
det_equ_rhs[j] = non_stoc_rhs[j - DDSIP_param->stocrhs];
}
status = CPXnewrows (DDSIP_env, det_equ, DDSIP_param->seccon, det_equ_rhs, sense, NULL, scen_spec_rowname);
for (j = 0; j < DDSIP_param->seccon; j++)
DDSIP_Free ((void **) &(scen_spec_rowname[j]));
}
//copy colnames scenario many times, append scenario index
//and enter into constraint matrix
if (!(lb = (double *) calloc (DDSIP_param->firstvar + DDSIP_param->secvar, sizeof (double)))
|| !(lb_sorted = (double *) calloc (DDSIP_param->secvar, sizeof (double)))
|| !(ub = (double *) calloc (DDSIP_param->firstvar + DDSIP_param->secvar, sizeof (double)))
|| !(ub_sorted = (double *) calloc (DDSIP_param->secvar, sizeof (double)))
|| !(vartype = (char *) calloc (DDSIP_param->firstvar + DDSIP_param->secvar, sizeof (char)))
|| !(vartype_sorted = (char *) calloc (DDSIP_param->secvar, sizeof (double)))
|| !(colindex_revers = (int *) calloc (DDSIP_param->firstvar + DDSIP_param->secvar, sizeof (int)))
|| !(colindex_sorted = (int *) calloc (DDSIP_param->firstvar + DDSIP_param->secvar, sizeof (int))))
{
fprintf (stderr, "Not enough memory for building deterministic equivalent\n");
return;
}
status = CPXgetlb (DDSIP_env, det_equ, lb, 0, DDSIP_param->firstvar + DDSIP_param->secvar - 1);
status = CPXgetub (DDSIP_env, det_equ, ub, 0, DDSIP_param->firstvar + DDSIP_param->secvar - 1);
status = CPXgetctype (DDSIP_env, det_equ, vartype, 0, DDSIP_param->firstvar + DDSIP_param->secvar - 1);
for (j = 0; j < DDSIP_param->secvar; j++)
{
vartype_sorted[j] = vartype[DDSIP_bb->secondindex[j]];
lb_sorted[j] = lb[DDSIP_bb->secondindex[j]];
ub_sorted[j] = ub[DDSIP_bb->secondindex[j]];
}
for (scen = 0; scen < DDSIP_param->scenarios; scen++)
{
for (j = 0; j < DDSIP_param->secvar; j++)
{
if (!(string2 = (char *) calloc (1, 255 * sizeof (char))))
{
fprintf (stderr, "Not enough memory for building deterministic equivalent\n");
return;
}
string1 = colname[DDSIP_bb->secondindex[j]];
sprintf (string2, "%sSC%.3d", string1, scen);
scen_spec_colname[j] = string2;
scaled_obj_coef[j] = DDSIP_data->prob[scen] * obj_coef[DDSIP_bb->secondindex[j]];
}
status =
CPXnewcols (DDSIP_env, det_equ, DDSIP_param->secvar, scaled_obj_coef,
lb_sorted, ub_sorted, vartype_sorted, scen_spec_colname);
for (j = 0; j < DDSIP_param->secvar; j++)
DDSIP_Free ((void **) &(scen_spec_colname[j]));
}
/////////////////////////////////////////////////
for (j = 0; j < DDSIP_param->firstvar; j++)
{
colindex_sorted[j] = DDSIP_bb->firstindex[j];
}
for (j = 0; j < DDSIP_param->secvar; j++)
{
colindex_sorted[DDSIP_param->firstvar + j] = DDSIP_bb->secondindex[j];
}
for (j = 0; j < DDSIP_param->firstvar + DDSIP_param->secvar; j++)
{
colindex_revers[colindex_sorted[j]] = j;
}
k = DDSIP_param->seccon / 60;
printf ("\n0%% 100%%\n");
for (i = 0; i < DDSIP_param->seccon; i++)
{
for (j = 0; j < DDSIP_param->firstvar; j++)
{
if ((status = CPXgetcoef (DDSIP_env, det_equ, DDSIP_param->firstcon + i, colindex_sorted[j], &coef)))
{
fprintf (stderr, " Build det. equivalent: Error retrieving coefficient of first-stage Variable %d.\n", j);
exit (1);
}
if (coef)
{
for (scen = 0; scen < DDSIP_param->scenarios; scen++)
{
status =
CPXchgcoef (DDSIP_env, det_equ, DDSIP_param->firstcon + DDSIP_bb->seccon + scen * DDSIP_param->seccon + i, colindex_sorted[j], coef);
if (status)
{
fprintf (stderr, " Build det. equivalent: Error setting coefficient of first-stage Variable %d.\n", j);
exit (1);
}
}
}
}
for (j = DDSIP_param->firstvar; j < DDSIP_param->firstvar + DDSIP_param->secvar; j++)
{
if ((status = CPXgetcoef (DDSIP_env, det_equ, DDSIP_param->firstcon + i, colindex_sorted[j], &coef)))
{
fprintf (stderr,
" Build det. equivalent: Error retrieving coefficient of second-stage Variable %d.\n",
j - DDSIP_param->firstvar);
exit (1);
}
if (coef)
{
for (scen = 0; scen < DDSIP_param->scenarios; scen++)
{
status =
CPXchgcoef (DDSIP_env, det_equ,
DDSIP_param->firstcon + DDSIP_bb->seccon + scen * DDSIP_param->seccon + i, (scen + 1) * DDSIP_param->secvar + j, coef);
}
if (status)
{
fprintf (stderr,
" Build det. equivalent: Error setting coefficient of second-stage Variable %d.\n",
j - DDSIP_param->firstvar);
exit (1);
}
}
}
if (!k)
{
for (j = 0; j <= 60 / DDSIP_param->seccon; j++)
printf ("#");
}
else if (i % k == k - 1)
printf ("#");
}
printf ("\n\n");
///////delete original second stage rows & cols ////////////////////////////////////////////
status = CPXdelrows (DDSIP_env, det_equ, DDSIP_param->firstcon, DDSIP_param->firstcon + DDSIP_bb->seccon - 1);
j = 0;
for (i = 0; i < DDSIP_param->secvar; i++)
{
status = CPXdelcols (DDSIP_env, det_equ, DDSIP_bb->secondindex[i] - j, DDSIP_bb->secondindex[i] - j);
j++;
}
///////enter stochastic matrix entries//////////////////////////////////////////////////////
if (DDSIP_param->stocmat)
{
if (!(value = (double *) calloc (DDSIP_param->stocmat, sizeof (double)))
|| !(matcol_sorted = (int *) calloc (DDSIP_param->stocmat, sizeof (int))))
{
fprintf (stderr, "Not enough memory for building deterministic equivalent\n");
return;
}
for (j = 0; j < DDSIP_param->stocmat; j++)
{
matcol_sorted[j] = colindex_revers[DDSIP_data->matcol[j]];
}
for (scen = 0; scen < DDSIP_param->scenarios; scen++)
{
for (j = 0; j < DDSIP_param->stocmat; j++)
{
value[j] = DDSIP_data->matval[scen * DDSIP_param->stocmat + j];
}
status = CPXchgcoeflist (DDSIP_env, det_equ, DDSIP_param->stocmat, DDSIP_data->matrow, matcol_sorted, value);
if (status)
{
char errmsg[1024];
CPXgeterrorstring (DDSIP_env, status, errmsg);
fprintf (stderr, "in DetEqu: %s\n", errmsg);
}
for (j = 0; j < DDSIP_param->stocmat; j++)
{
DDSIP_data->matrow[j] += DDSIP_param->seccon;
if (matcol_sorted[j] >= DDSIP_param->firstvar)
matcol_sorted[j] += DDSIP_param->secvar;
}
}
DDSIP_Free ((void **) &(value));
DDSIP_Free ((void **) &(matcol_sorted));
//set matrow to the old values
for (j = 0; j < DDSIP_param->stocmat; j++)
{
DDSIP_data->matrow[j] -= DDSIP_param->scenarios * DDSIP_param->seccon;
}
}
///////enter stochastic cost coefficients //////////////////////////////////////////////////
if (DDSIP_param->stoccost)
{
if (!(value = (double *) calloc (DDSIP_param->stoccost, sizeof (double)))
|| !(matcol_sorted = (int *) calloc (DDSIP_param->stoccost, sizeof (int))))
{
fprintf (stderr, "Not enough memory for building deterministic equivalent\n");
return;
}
for (j = 0; j < DDSIP_param->stoccost; j++)
{
value[j] = 0.0;
matcol_sorted[j] = colindex_revers[DDSIP_data->costind[j]];
}
for (scen = 0; scen < DDSIP_param->scenarios; scen++)
{
for (j = 0; j < DDSIP_param->stoccost; j++)
{
if (matcol_sorted[j] >= DDSIP_param->firstvar)
value[j] = DDSIP_data->prob[scen] * DDSIP_data->cost[scen * DDSIP_param->stoccost + j];
else
value[j] += DDSIP_data->prob[scen] * DDSIP_data->cost[scen * DDSIP_param->stoccost + j];
}
status = CPXchgobj (DDSIP_env, det_equ, DDSIP_param->stoccost, matcol_sorted, value);
if (status)
{
char errmsg[1024];
CPXgeterrorstring (DDSIP_env, status, errmsg);
fprintf (stderr, "in DetEqu: %s\n", errmsg);
}
for (j = 0; j < DDSIP_param->stoccost; j++)
{
if (matcol_sorted[j] >= DDSIP_param->firstvar)
matcol_sorted[j] += DDSIP_param->secvar;
}
}
DDSIP_Free ((void **) &(value));
DDSIP_Free ((void **) &(matcol_sorted));
}
////////////////////////////////////////////////////////////////////////////////////////////
status = CPXwriteprob (DDSIP_env, det_equ, probname, NULL);
if (status)
fprintf (DDSIP_outfile, " *** Deterministic equivalent not written successfully, status = %d\n", status);
else
fprintf (DDSIP_outfile, " *** Deterministic equivalent written successfully\n");
status = CPXfreeprob (DDSIP_env, &det_equ);
DDSIP_Free ((void **) &(sense));
DDSIP_Free ((void **) &(vartype));
DDSIP_Free ((void **) &(rowname));
DDSIP_Free ((void **) &(rownamestore));
DDSIP_Free ((void **) &(colname));
DDSIP_Free ((void **) &(colnamestore));
DDSIP_Free ((void **) &(det_equ_rhs));
DDSIP_Free ((void **) &(non_stoc_rhs));
DDSIP_Free ((void **) &(lb));
DDSIP_Free ((void **) &(ub));
DDSIP_Free ((void **) &(vartype_sorted));
DDSIP_Free ((void **) &(lb_sorted));
DDSIP_Free ((void **) &(ub_sorted));
DDSIP_Free ((void **) &(obj_coef));
DDSIP_Free ((void **) &(scaled_obj_coef));
DDSIP_Free ((void **) &(colindex_sorted));
DDSIP_Free ((void **) &(colindex_revers));
DDSIP_Free ((void **) &(scen_spec_rowname));
DDSIP_Free ((void **) &(scen_spec_colname));
return;
}
