58#define SCIP_DEFAULT_TRANSFERCUTS FALSE
59#define SCIP_DEFAULT_CUTSASCONSS TRUE
60#define SCIP_DEFAULT_LNSCHECK TRUE
61#define SCIP_DEFAULT_LNSMAXDEPTH -1
62#define SCIP_DEFAULT_LNSMAXCALLS 10
63#define SCIP_DEFAULT_LNSMAXCALLSROOT 0
64#define SCIP_DEFAULT_SUBPROBFRAC 1.0
65#define SCIP_DEFAULT_UPDATEAUXVARBOUND FALSE
66#define SCIP_DEFAULT_AUXVARSIMPLINT FALSE
67#define SCIP_DEFAULT_CUTCHECK TRUE
68#define SCIP_DEFAULT_STRENGTHENMULT 0.5
69#define SCIP_DEFAULT_NOIMPROVELIMIT 5
70#define SCIP_DEFAULT_STRENGTHENPERTURB 1e-06
71#define SCIP_DEFAULT_STRENGTHENENABLED FALSE
72#define SCIP_DEFAULT_STRENGTHENINTPOINT 'r'
73#define SCIP_DEFAULT_NUMTHREADS 1
74#define SCIP_DEFAULT_EXECFEASPHASE FALSE
75#define SCIP_DEFAULT_SLACKVARCOEF 1e+6
76#define SCIP_DEFAULT_MAXSLACKVARCOEF 1e+9
77#define SCIP_DEFAULT_CHECKCONSCONVEXITY TRUE
78#define SCIP_DEFAULT_NLPITERLIMIT 10000
80#define BENDERS_MAXPSEUDOSOLS 5
83#define BENDERS_ARRAYSIZE 1000
85#define AUXILIARYVAR_NAME "##bendersauxiliaryvar"
86#define SLACKVAR_NAME "##bendersslackvar"
88#define NLINEARCONSHDLRS 5
91#define NODEFOCUS_EVENTHDLR_NAME "bendersnodefocus"
92#define NODEFOCUS_EVENTHDLR_DESC "node focus event handler for Benders' decomposition"
94#define MIPNODEFOCUS_EVENTHDLR_NAME "bendersmipsolvenodefocus"
95#define MIPNODEFOCUS_EVENTHDLR_DESC "node focus event handler for the MIP solve method for Benders' decomposition"
97#define UPPERBOUND_EVENTHDLR_NAME "bendersupperbound"
98#define UPPERBOUND_EVENTHDLR_DESC "found solution event handler to terminate subproblem solve for a given upper bound"
100#define NODESOLVED_EVENTHDLR_NAME "bendersnodesolved"
101#define NODESOLVED_EVENTHDLR_DESC "node solved event handler for the Benders' integer cuts"
105struct SCIP_EventhdlrData
126 eventhdlrdata->filterpos = -1;
127 eventhdlrdata->numruns = 0;
129 eventhdlrdata->solvecip =
FALSE;
169 if( eventhdlrdata->filterpos >= 0 )
172 eventhdlrdata->filterpos = -1;
241 eventhdlrdata->filterpos = -1;
314 if( eventhdlrdata->numruns == 0 && !eventhdlrdata->solvecip )
320 eventhdlrdata->filterpos = -1;
322 eventhdlrdata->numruns++;
469 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
477 eventhdlrdata->upperbound = upperbound;
525 for(
i = 0;
i < nsubproblems;
i++)
542 SCIPdebugMsg(masterprob,
"Cut constant for subproblem %d: %g\n",
i,
621 return solvestat1->
idx - solvestat2->
idx;
627 int avgiterdiff = (int)solvestat2->
avgiter - (
int)solvestat1->
avgiter;
629 if( avgiterdiff != 0 )
632 return solvestat1->
idx - solvestat2->
idx;
636#ifdef SCIP_DISABLED_CODE
637 if( solvestat1->
ncalls == 0 )
638 if( solvestat2->
ncalls == 0 )
639 if( solvestat1->
idx < solvestat2->
idx )
645 else if( solvestat2->
ncalls == 0 )
690 vardata->vartype = -1;
698 shareauxvars =
FALSE;
768 vardata->vartype = -1;
775 shareauxvars =
FALSE;
795 while( targetvar ==
NULL && j <= subscipdepth )
807 (void) strncpy(prefix, tmpprefix, len);
812 if( targetvar !=
NULL )
847 for(
i = 0;
i < nsubproblems;
i++ )
850 if( subproblem !=
NULL )
917 if( targetvar !=
NULL )
951 SCIP_CALL( benders->benderscopy(targetset->
scip, benders, threadsafe) );
1037 if( (benderssolvesubconvex ==
NULL && benderssolvesub ==
NULL && bendersfreesub !=
NULL)
1038 || ((benderssolvesubconvex !=
NULL || benderssolvesub !=
NULL) && bendersfreesub ==
NULL) )
1040 SCIPerrorMessage(
"Benders' decomposition <%s> requires that if bendersFreesub%s is implemented, then at least "
1041 "one of bendersSolvesubconvex%s or bendersSolvesub%s are implemented.\n", name, name, name, name);
1049 (*benders)->priority = priority;
1050 (*benders)->cutlp = cutlp;
1051 (*benders)->cutpseudo = cutpseudo;
1052 (*benders)->cutrelax = cutrelax;
1053 (*benders)->shareauxvars = shareauxvars;
1054 (*benders)->benderscopy = benderscopy;
1055 (*benders)->bendersfree = bendersfree;
1056 (*benders)->bendersinit = bendersinit;
1057 (*benders)->bendersexit = bendersexit;
1058 (*benders)->bendersinitpre = bendersinitpre;
1059 (*benders)->bendersexitpre = bendersexitpre;
1060 (*benders)->bendersinitsol = bendersinitsol;
1061 (*benders)->bendersexitsol = bendersexitsol;
1062 (*benders)->bendersgetvar = bendersgetvar;
1063 (*benders)->benderscreatesub = benderscreatesub;
1064 (*benders)->benderspresubsolve = benderspresubsolve;
1065 (*benders)->benderssolvesubconvex = benderssolvesubconvex;
1066 (*benders)->benderssolvesub = benderssolvesub;
1067 (*benders)->benderspostsolve = benderspostsolve;
1068 (*benders)->bendersfreesub = bendersfreesub;
1069 (*benders)->bendersdata = bendersdata;
1078 &(*benders)->priority,
FALSE, priority, INT_MIN/4, INT_MAX/4,
1083 "should Benders' cuts be generated for LP solutions?", &(*benders)->cutlp,
FALSE, cutlp,
NULL,
NULL) );
1087 "should Benders' cuts be generated for pseudo solutions?", &(*benders)->cutpseudo,
FALSE, cutpseudo,
NULL,
NULL) );
1091 "should Benders' cuts be generated for relaxation solutions?", &(*benders)->cutrelax,
FALSE, cutrelax,
NULL,
NULL) );
1098 "should Benders' cuts from LNS heuristics be transferred to the main SCIP instance?", &(*benders)->transfercuts,
1108 "maximum depth at which the LNS check is performed (-1: no limit)", &(*benders)->lnsmaxdepth,
TRUE,
1113 "the maximum number of Benders' decomposition calls in LNS heuristics (-1: no limit)", &(*benders)->lnsmaxcalls,
1118 "the maximum number of root node Benders' decomposition calls in LNS heuristics (-1: no limit)",
1123 "should the transferred cuts be added as constraints?", &(*benders)->cutsasconss,
FALSE,
1128 "fraction of subproblems that are solved in each iteration", &(*benders)->subprobfrac,
FALSE,
1133 "should the auxiliary variable bound be updated by solving the subproblem?", &(*benders)->updateauxvarbound,
1138 "if the subproblem objective is integer, then define the auxiliary variables as implicit integers?",
1143 "should Benders' cuts be generated while checking solutions?",
1148 "the convex combination multiplier for the cut strengthening", &(*benders)->convexmult,
FALSE,
1153 "the maximum number of cut strengthening without improvement", &(*benders)->noimprovelimit,
TRUE,
1158 "the constant use to perturb the cut strengthening core point", &(*benders)->perturbeps,
FALSE,
1163 "should the core point cut strengthening be employed (only applied to fractional solutions or continuous subproblems)?",
1168 "where should the strengthening interior point be sourced from ('l'p relaxation, 'f'irst solution, 'i'ncumbent solution, 'r'elative interior point, vector of 'o'nes, vector of 'z'eros)",
1173 "the number of threads to use when solving the subproblems", &(*benders)->numthreads,
TRUE,
1178 "should a feasibility phase be executed during the root node, i.e. adding slack variables to constraints to ensure feasibility",
1183 "the initial objective coefficient of the slack variables in the subproblem", &(*benders)->slackvarcoef,
FALSE,
1188 "the maximal objective coefficient of the slack variables in the subproblem", &(*benders)->maxslackvarcoef,
FALSE,
1193 "should the constraints of the subproblems be checked for convexity?", &(*benders)->checkconsconvexity,
FALSE,
1198 "iteration limit for NLP solver", &(*benders)->nlpparam.iterlimit,
FALSE,
1243 cutrelax, shareauxvars, benderscopy, bendersfree, bendersinit, bendersexit, bendersinitpre, bendersexitpre,
1244 bendersinitsol, bendersexitsol, bendersgetvar, benderscreatesub, benderspresubsolve, benderssolvesubconvex,
1245 benderssolvesub, benderspostsolve, bendersfreesub, bendersdata), (
void)
SCIPbendersFree(benders,
set) );
1268 for(
i = 0;
i < nentries; ++
i )
1296 assert(!(*benders)->initialized);
1300 if( (*benders)->bendersfree !=
NULL )
1302 SCIP_CALL( (*benders)->bendersfree(
set->scip, *benders) );
1308 if( (*benders)->iscopy && (*benders)->mastervarsmap !=
NULL )
1315 for(
i = 0;
i < (*benders)->nbenderscuts;
i++ )
1338 int nlinearconshdlrs
1357 for(
i = 0;
i < nlinearconshdlrs; ++
i )
1359 if( conshdlr == linearconshdlrs[
i] )
1366 if( !linearcons && conshdlr != nlconshdlr )
1369 "This is not supported and the slack variable will not be added to the constraint. Feasibility cuts may be invalid.\n",
1506 (*infeasible) =
FALSE;
1522 (*success) = !(*infeasible);
1558 eventExecBendersNodefocus, eventhdlrdata) );
1610 assumevarfixed =
NULL;
1611 if( probnumber >= 0 )
1614 subproblem =
set->scip;
1619 discretevar =
FALSE;
1620 isnonlinear =
FALSE;
1653 if( probnumber >= 0 && nlconshdlr !=
NULL )
1666 if( mappedvar !=
NULL )
1679 if( conshdlr == linearconshdlrs[j] )
1685#ifdef SCIP_MOREDEBUG
1692 if( conshdlr == nlconshdlr )
1703 if( havelhs && haverhs )
1727#ifdef SCIP_MOREDEBUG
1734#ifdef SCIP_MOREDEBUG
1741#ifdef SCIP_MOREDEBUG
1756 if( probnumber >= 0 )
1760 if( convexcons && !discretevar )
1762 else if( convexcons && discretevar )
1764 else if( !convexcons && !discretevar )
1766 else if( !convexcons && discretevar )
1773 if( probnumber >= 0 )
1778 if( probnumber >= 0 )
1785 if( assumevarfixed !=
NULL )
1819 for(
i = 0;
i < nsubproblems;
i++ )
1822 SCIP_CALL( benders->benderscreatesub(
set->scip, benders,
i) );
1833 if( subproblem !=
NULL )
1856 for( j = 0; j <
nvars; j++ )
1865 "coefficient of copy of master problem variable <%s> in subproblem %d to zero.\n",
1877 "copied of master problem variables has been changed to zero.\n");
1919 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL
1941 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL
1975 SCIPerrorMessage(
"If the subproblem is set to NULL, then the subproblem type must be specified.\n");
1976 SCIPerrorMessage(
"In the subproblem creation callback, call SCIPbendersSetSubproblemType with the appropriate problem type.\n");
2011 if(
set->misc_resetstat )
2024 if( benders->bendersinit !=
NULL )
2143 if( sourcevar ==
NULL )
2222 for(
i = 0;
i < naddedcuts;
i++ )
2259 if( benders->bendersexit !=
NULL )
2286 for(
i = 0;
i < nsubproblems;
i++ )
2346 for(
i = 0;
i < nsubproblems;
i++ )
2353 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL
2354 && benders->bendersfreesub ==
NULL )
2358 for( j = 0; j <
nvars; j++ )
2366 if( subprobvar !=
NULL )
2368 independent =
FALSE;
2401 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL )
2409 if( benders->bendersinitpre !=
NULL )
2414 SCIP_CALL( benders->bendersinitpre(
set->scip, benders) );
2436 if( benders->bendersexitpre !=
NULL )
2441 SCIP_CALL( benders->bendersexitpre(
set->scip, benders) );
2462 if( benders->bendersinitsol !=
NULL )
2467 SCIP_CALL( benders->bendersinitsol(
set->scip, benders) );
2499 for(
i = 0;
i < nsubproblems;
i++ )
2512 if( benders->bendersexitsol !=
NULL )
2517 SCIP_CALL( benders->bendersexitsol(
set->scip, benders) );
2557 set->nactivebenders++;
2582 benders->benderssubcomp ==
NULL ? benderssubcompdefault : benders->benderssubcomp,
NULL) );
2617 eventExecBendersNodesolved, eventhdlrdata) );
2645 for(
i = 0;
i < nsubproblems;
i++ )
2660 set->nactivebenders--;
2666 for(
i = nsubproblems - 1;
i >= 0;
i-- )
2716 for(
i = 0;
i < nsubproblems;
i++ )
2807 if ( timelimit > 0.0 )
2866 (*skipsolve) =
FALSE;
2928 newsolval = lpsolval;
2970 SCIPsetDebugMsg(
set,
"solving Benders' decomposition subproblems with stabilised point.\n");
2975 SCIPsetDebugMsg(
set,
"solved Benders' decomposition subproblems with stabilised point. noimprovecount %d result %d\n",
2980 (*skipsolve) =
TRUE;
3048 int subproblemcount;
3063 subproblemcount = 0;
3064 while( subproblemcount < nsubproblems && subproblemcount < numtocheck )
3069 (*solveidx)[(*nsolveidx)] = solvestat->
idx;
3090 for(
i = 0;
i < nsolveidx;
i++ )
3102 if( subproblem ==
NULL )
3153 int locnverified = *nverified;
3180 SCIPsetDebugMsg(
set,
"Performing the subproblem solving process. Number of subproblems to check %d\n", nsolveidx);
3187 locinfeasible =
TRUE;
3194#ifndef __INTEL_COMPILER
3195 #pragma omp parallel for num_threads(numthreads) private(i) reduction(&&:locoptimal) reduction(||:locinfeasible) reduction(+:locnverified) reduction(||:locstopped) reduction(min:retcode)
3197 for( j = 0; j < nsolveidx; j++ )
3208 (*subprobsolved)[
i] =
FALSE;
3250 SCIPsetDebugMsg(
set,
"Benders' decomposition: subproblem %d is not active, but has not been solved."
3251 " setting status to UNKNOWN\n",
i);
3267 SCIPsetDebugMsg(
set,
"Benders' decomposition: subproblem %d is not active, setting status to OPTIMAL\n",
i);
3270 (*subprobsolved)[
i] =
TRUE;
3291 (*subprobsolved)[
i] = solved;
3293 locinfeasible = locinfeasible || subinfeas;
3301 if( checkint && (*subprobsolved)[
i] )
3312 if( subproboptimal )
3325 if( convexsub || onlyconvexcheck
3328 locoptimal = locoptimal && subproboptimal;
3333 if( subproboptimal )
3360 || onlyconvexcheck )
3373 SCIPsetDebugMsg(
set,
"Local variable values: nverified %d infeasible %u optimal %u stopped %u\n", locnverified,
3374 locinfeasible, locoptimal, locstopped);
3375 *nverified = locnverified;
3376 *infeasible = locinfeasible;
3377 *optimal = locoptimal;
3378 *stopped = locstopped;
3411 int* npriomergecands,
3447 for( k = 0; k < nsolveidx; k++ )
3464 for( j = 0; j < nbenderscuts; j++ )
3490 subprobresult = cutresult;
3501 subprobresult = cutresult;
3503 subprobresult = cutresult;
3513 solveloopresult = subprobresult;
3519 solveloopresult = subprobresult;
3525 solveloopresult = subprobresult;
3532 (*mergecands)[(*nmergecands)] =
i;
3544 (*mergecands)[(*nmergecands)] = (*mergecands)[(*npriomergecands)];
3545 (*mergecands)[(*npriomergecands)] =
i;
3546 (*npriomergecands)++;
3551 (*mergecands)[(*nmergecands)] =
i;
3562 (*result) = solveloopresult;
3568 (*result) = solveloopresult;
3574 (*result) = solveloopresult;
3579 && checkint && !onlyconvexcheck )
3608 int subproblemcount;
3613 int npriomergecands;
3632 SCIPsetDebugMsg(
set,
"Starting Benders' decomposition subproblem solving. type %d checkint %u\n", type, checkint);
3634#ifdef SCIP_MOREDEBUG
3644 (*infeasible) =
FALSE;
3714 SCIP_CALL( benders->benderspresubsolve(
set->scip, benders,
sol, type, checkint, infeasible, auxviol, &skipsolve,
3724 SCIPerrorMessage(
"the user-defined pre subproblem solving method for the Benders' decomposition <%s> returned "
3725 "invalid result <%d>\n", benders->
name, *
result);
3732 SCIPsetDebugMsg(
set,
"skipping the subproblem solving for Benders' decomposition <%s>. "
3733 "returning result <%d>\n", benders->
name, *
result);
3759 SCIPsetDebugMsg(
set,
"skipping the subproblem solving because cut strengthening found a cut "
3760 "for Benders' decomposition <%s>. Returning result <%d>\n", benders->
name, *
result);
3772 npriomergecands = 0;
3785 while( nsolved < nsubproblems )
3796 for( l = 0; l < nsolveloops; l++ )
3801 if( benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL )
3813 solveidx, nsolveidx, &subprobsolved, &substatus, infeasible, &optimal, &stopped) );
3825 substatus, solveidx, nsolveidx, &mergecands, &npriomergecands, &nmergecands, &nsolveloops) );
3839 nsolved += nsolveidx;
3842 for(
i = 0;
i < nsolveidx;
i++ )
3843 executedidx[nexecutedidx++] = solveidx[
i];
3858 allverified = (nverified == nsubproblems);
3860 SCIPsetDebugMsg(
set,
"End Benders' decomposition subproblem solve. result %d infeasible %u auxviol %u nverified %d\n",
3861 *
result, *infeasible, *auxviol, nverified);
3886 if( npriomergecands == 0 )
3892 npriomergecands = 1;
3893 for(
i = 0;
i < nsubproblems;
i++ )
3898 mergecands[nmergecands] =
i;
3904 "limit of %d. All active subproblems are merge candidates, with subproblem %d a priority candidate.\n",
3926 SCIPerrorMessage(
"An error was found when generating cuts for non-optimal subproblems of Benders' "
3927 "decomposition <%s>. Consider merging the infeasible subproblems into the master problem.\n",
SCIPbendersGetName(benders));
3943 if( (*infeasible) || !allverified )
3953 (*auxviol) = !optimal;
3962 if( (*infeasible) || !allverified )
3972 (*auxviol) = !optimal;
3979 if( benders->benderspostsolve !=
NULL )
3985 SCIP_CALL( benders->benderspostsolve(
set->scip, benders,
sol, type, mergecands, npriomergecands, nmergecands,
3986 checkint, (*infeasible), &merged) );
3999 SCIPerrorMessage(
"An error occurred during Benders' decomposition cut generations and no merging had been "
4000 "performed. It is not possible to continue solving the problem by Benders' decomposition\n");
4007 nfree = nsubproblems;
4009 nfree = nexecutedidx;
4012 subproblemcount = 0;
4013 while( subproblemcount < nfree )
4018 subidx = subproblemcount;
4020 subidx = executedidx[subproblemcount];
4028 for(
i = 0;
i < nsubproblems;
i++ )
4039 *infeasible, *auxviol);
4054 if( !success && !stopped )
4064 &skipsolve, &perturbresult) );
4068 (*result) = perturbresult;
4070 success = skipsolve;
4088 SCIPsetDebugMsg(
set,
"Type: %d Active slack: %u Feasibility Phase: %u\n", type, activeslack,
4145 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
4146 assert(benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL);
4156 if( benders->benderssolvesubconvex !=
NULL )
4158 SCIP_CALL( benders->benderssolvesubconvex(
set->scip, benders,
sol, probnumber,
4166 if( benders->benderssolvesub !=
NULL )
4180 SCIPerrorMessage(
"the user-defined solving method for the Benders' decomposition <%s> returned invalid result <%d>\n",
4186 (*infeasible) =
TRUE;
4191 SCIPerrorMessage(
"the user-defined solving method for the Benders' decomposition <%s> returned objective value %g\n",
4192 benders->
name, (*objective));
4222 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
4231 if( subproblem ==
NULL && (benders->benderssolvesubconvex ==
NULL || benders->benderssolvesub ==
NULL) )
4233 SCIPerrorMessage(
"The subproblem %d is set to NULL, but both bendersSolvesubconvex%s and bendersSolvesub%s "
4234 "are not defined.\n", probnumber, benders->
name, benders->
name);
4252 else if( subproblem !=
NULL )
4287 (*infeasible) =
TRUE;
4296 (*infeasible) =
TRUE;
4302 if( bestsol !=
NULL )
4332 "subproblem %d. No cut will be generated for this subproblem.\n", probnumber);
4337 SCIPerrorMessage(
"The Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4343 SCIPerrorMessage(
"Invalid status returned from solving Benders' decomposition subproblem %d. Solution status: %d\n",
4344 probnumber, solvestatus);
4357 SCIPerrorMessage(
"The Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4363 SCIPerrorMessage(
"Invalid result <%d> from user-defined subproblem solving method. This should not happen.\n",
4395 if( subproblem ==
NULL )
4397 SCIPerrorMessage(
"The subproblem %d is NULL. Thus, the subproblem setup must be performed manually in either "
4398 "bendersSolvesubconvex%s or bendersSolvesub%s.\n", probnumber, benders->
name, benders->
name);
4422 assert(success == !infeasible);
4449 if( mastervar !=
NULL )
4548 (*infeasible) =
FALSE;
4554 SCIPerrorMessage(
"Benders' decomposition subproblem %d must be set up before calling SCIPbendersSolveSubproblem(). Call SCIPsetupSubproblem() first.\n", probnumber);
4559 if( benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL)
4572 if( objective !=
NULL )
4573 (*objective) = subobj;
4590 (*infeasible) =
TRUE;
4591 if( objective !=
NULL )
4625 (*infeasible) =
TRUE;
4626 else if( objective !=
NULL )
4627 (*objective) = lpobjective;
4631 if( objective !=
NULL )
4660 subtimelimit =
MIN(subtimelimit, maxsubtimelimit);
4667 submemorylimit =
MIN(submemorylimit, maxsubmemorylimit);
4734#ifndef SCIP_MOREDEBUG
4840#ifdef SCIP_MOREDEBUG
4848 SCIPdebugMsg(
scip,
"NLP solstat %d termstat %d\n", nlpsolstat, nlptermstat);
4858#ifdef SCIP_MOREDEBUG
4870 SCIPerrorMessage(
"The NLP of Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4881 SCIPwarningMessage(
scip,
"The NLP solver stopped due to an iteration limit for Benders' decomposition subproblem %d. Consider increasing benders/%s/nlpiterlimit.\n", probnumber,
SCIPbendersGetName(benders));
4890 SCIPerrorMessage(
"Invalid solution status: %d. Termination status: %d. Solving the NLP relaxation of Benders' decomposition subproblem %d.\n",
4891 nlpsolstat, nlptermstat, probnumber);
4920 SCIPerrorMessage(
"The LP of Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4936 "relaxation of subproblem %d. No cut will be generated for this subproblem.\n", probnumber);
4944 SCIPerrorMessage(
"Invalid status: %d. Solving the LP relaxation of Benders' decomposition subproblem %d.\n",
5009 eventhdlrdata->solvecip =
TRUE;
5019#ifdef SCIP_EVENMOREDEBUG
5024#ifdef SCIP_MOREDEBUG
5038 SCIPerrorMessage(
"Invalid status: %d. Solving the CIP of Benders' decomposition subproblem %d.\n",
5039 *solvestatus, probnumber);
5061 || (benders->bendersfreesub ==
NULL && benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL));
5062 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
5064 if( benders->bendersfreesub !=
NULL )
5066 SCIP_CALL( benders->bendersfreesub(
set->scip, benders, probnumber) );
5115 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
5121 SCIPsetDebugMsg(
set,
"Subproblem %d - Auxiliary Variable: %g Subproblem Objective: %g Reldiff: %g Soltol: %g\n",
5174 if( benders->benderssolvesub !=
NULL || benders->benderssolvesubconvex !=
NULL )
5177 (*infeasible) =
FALSE;
5179 SCIPinfoMessage(
set->scip,
NULL,
"Benders' decomposition: a bendersSolvesub or bendersSolvesubconvex has been "
5180 "implemented. SCIPbendersComputeSubproblemLowerbound can not be executed.\n");
5182 "SCIPbendersUpdateSubproblemLowerbound in bendersCreatesub. The auxiliary variable %d will remain as %g\n",
5183 probnumber, (*lowerbound));
5190 " subproblem %d\n", probnumber);
5197 (*infeasible) =
FALSE;
5201#ifdef SCIP_MOREDEBUG
5243 SCIPdebugMsg(
set->scip,
"NLP solstat %d termstat %d\n", nlpsolstat, nlptermstat);
5248 (*infeasible) =
TRUE;
5260 (*infeasible) =
TRUE;
5273 eventhdlrdata->solvecip =
TRUE;
5278 (*infeasible) =
TRUE;
5284 (*lowerbound) = dualbound;
5339 const char* origvarname;
5343 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
5346 "be resolved. Subproblem %d is being merged into the master problem.\n", probnumber, probnumber);
5355 uselocalvarmap = (varmap ==
NULL);
5356 uselocalconsmap = (consmap ==
NULL);
5358 if( uselocalvarmap )
5364 localvarmap = varmap;
5366 if( uselocalconsmap )
5372 localconsmap = consmap;
5394 if( mastervar ==
NULL )
5441 for(
i = 0;
i < nconss;
i++ )
5451 initial = (
i < nconss/2);
5467 if( uselocalvarmap )
5473 if( uselocalconsmap )
5533 for(
i = 0;
i < nconsvars;
i++ )
5569 SCIPerrorMessage(
"It is not possible to copy constraint <%s>. Benders' decomposition could not be applied.\n",
5602 for(
i = nconss - 1;
i >= 0;
i-- )
5659 for(
i = 0;
i < nblocks;
i++ )
5666 SCIP_CALL(
SCIPcopyPlugins(
set->scip, subproblems[
i],
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
5691 for(
i = 0;
i < nblocks;
i++ )
5697 for(
i = 0;
i < nconss;
i++ )
5700 if( conslabels[
i] >= 0 )
5732 for(
i = nblocks - 1;
i >= 0;
i-- )
5761 (*mappedvar) =
NULL;
5767 SCIP_CALL( benders->bendersgetvar(
set->scip, benders,
var, mappedvar, probnumber) );
5801 benders->benderscopy = benderscopy;
5812 benders->bendersfree = bendersfree;
5823 benders->bendersinit = bendersinit;
5834 benders->bendersexit = bendersexit;
5845 benders->bendersinitpre = bendersinitpre;
5856 benders->bendersexitpre = bendersexitpre;
5867 benders->bendersinitsol = bendersinitsol;
5878 benders->bendersexitsol = bendersexitsol;
5889 benders->benderspresubsolve = benderspresubsolve;
5900 benders->benderssolvesubconvex = benderssolvesubconvex;
5911 benders->benderssolvesub = benderssolvesub;
5922 benders->benderspostsolve = benderspostsolve;
5933 benders->benderssubcomp = benderssubcomp;
5944 benders->bendersfreesub = bendersfreesub;
5954 return benders->
name;
5964 return benders->
desc;
6008 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
6112 return benders->
cutlp;
6157 if( subproblem ==
NULL && (!benders->benderssolvesubconvex || !benders->benderssolvesub) )
6159 SCIPerrorMessage(
"The subproblem can only be set to NULL if both bendersSolvesubconvex%s and bendersSolvesub%s "
6160 "are defined.\n", benders->
name, benders->
name);
6253 (*activeslack) =
FALSE;
6264 for(
i = 0;
i < nsubproblems && !(*activeslack);
i++ )
6290 for( j =
nvars - 1; j >=
nvars - ncontvars; j-- )
6296 (*activeslack) =
TRUE;
6567 if( chgvarscount > 0 && chgvarscount == origintvars )
6633 if( benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL || benders->bendersfreesub !=
NULL )
6635 SCIPerrorMessage(
"The user has defined either bendersSolvesubconvex%s, bendersSolvesub%s or bendersFreesub%s. "
6636 "Thus, it is not possible to declare the independence of a subproblem.\n", benders->
name, benders->
name,
6784 SCIPdebugMessage(
"The lowerbound %g for subproblem %d is less than the currently stored lower bound %g\n",
6828 assert(cutidx >= 0 && cutidx < benders->nstoredcuts);
6865 assert(cutidx >= 0 && cutidx < benders->nstoredcuts);
6872 if( varssize >= *
nvars )
6882 (*vars)[
i] = origvar;
SCIP_RETCODE SCIPbenderscutExit(SCIP_BENDERSCUT *benderscut, SCIP_SET *set)
SCIP_RETCODE SCIPbenderscutFree(SCIP_BENDERSCUT **benderscut, SCIP_SET *set)
SCIP_RETCODE SCIPbenderscutInitsol(SCIP_BENDERSCUT *benderscut, SCIP_SET *set)
SCIP_RETCODE SCIPbenderscutExitsol(SCIP_BENDERSCUT *benderscut, SCIP_SET *set)
SCIP_RETCODE SCIPbenderscutExec(SCIP_BENDERSCUT *benderscut, SCIP_SET *set, SCIP_BENDERS *benders, SCIP_SOL *sol, int probnumber, SCIP_BENDERSENFOTYPE type, SCIP_RESULT *result)
SCIP_RETCODE SCIPbenderscutCopyInclude(SCIP_BENDERS *benders, SCIP_BENDERSCUT *benderscut, SCIP_SET *set)
SCIP_RETCODE SCIPbenderscutInit(SCIP_BENDERSCUT *benderscut, SCIP_SET *set)
internal methods for Benders' decomposition cuts
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
void SCIPclockEnableOrDisable(SCIP_CLOCK *clck, SCIP_Bool enable)
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
void SCIPclockReset(SCIP_CLOCK *clck)
void SCIPclockFree(SCIP_CLOCK **clck)
SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)
internal methods for clocks and timing issues
Constraint handler for linear constraints in their most general form, .
constraint handler for nonlinear constraints specified by algebraic expressions
internal methods for decompositions and the decomposition store
common defines and data types used in all packages of SCIP
#define SCIP_MAXTREEDEPTH
#define SCIP_CALL_FINALLY(x, y)
SCIP_RETCODE SCIPcreateBendersDefault(SCIP *scip, SCIP **subproblems, int nsubproblems)
SCIP_RETCODE SCIPaddLinearVarNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real coef)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPcreateConsBasicLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs)
SCIP_EXPR * SCIPgetExprNonlinear(SCIP_CONS *cons)
SCIP_Real SCIPgetRhsNonlinear(SCIP_CONS *cons)
SCIP_EXPRCURV SCIPgetCurvatureNonlinear(SCIP_CONS *cons)
SCIP_Real SCIPgetLhsNonlinear(SCIP_CONS *cons)
SCIP_RETCODE SCIPcopyPlugins(SCIP *sourcescip, SCIP *targetscip, SCIP_Bool copyreaders, SCIP_Bool copypricers, SCIP_Bool copyconshdlrs, SCIP_Bool copyconflicthdlrs, SCIP_Bool copypresolvers, SCIP_Bool copyrelaxators, SCIP_Bool copyseparators, SCIP_Bool copycutselectors, SCIP_Bool copypropagators, SCIP_Bool copyheuristics, SCIP_Bool copyeventhdlrs, SCIP_Bool copynodeselectors, SCIP_Bool copybranchrules, SCIP_Bool copydisplays, SCIP_Bool copydialogs, SCIP_Bool copytables, SCIP_Bool copyexprhdlrs, SCIP_Bool copynlpis, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
int SCIPgetSubscipDepth(SCIP *scip)
SCIP_RETCODE SCIPgetConsCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_CONS *sourcecons, SCIP_CONS **targetcons, SCIP_CONSHDLR *sourceconshdlr, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)
int SCIPdecompGetNBlocks(SCIP_DECOMP *decomp)
void SCIPdecompGetConsLabels(SCIP_DECOMP *decomp, SCIP_CONS **conss, int *labels, int nconss)
void SCIPdecompGetVarsLabels(SCIP_DECOMP *decomp, SCIP_VAR **vars, int *labels, int nvars)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_RETCODE SCIPfree(SCIP **scip)
SCIP_RETCODE SCIPcreate(SCIP **scip)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
const char * SCIPgetProbName(SCIP *scip)
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
int SCIPgetNOrigConss(SCIP *scip)
SCIP_CONS ** SCIPgetConss(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNConss(SCIP *scip)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
SCIP_RETCODE SCIPdelVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool *deleted)
SCIP_RETCODE SCIPcreateProbBasic(SCIP *scip, const char *name)
SCIP_CONS ** SCIPgetOrigConss(SCIP *scip)
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
SCIP_Bool SCIPisObjIntegral(SCIP *scip)
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void * SCIPhashmapEntryGetImage(SCIP_HASHMAPENTRY *entry)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
int SCIPhashmapGetNEntries(SCIP_HASHMAP *hashmap)
SCIP_HASHMAPENTRY * SCIPhashmapGetEntry(SCIP_HASHMAP *hashmap, int entryidx)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_RETCODE SCIPhasExprCurvature(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPRCURV curv, SCIP_Bool *success, SCIP_HASHMAP *assumevarfixed)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
SCIP_PARAM * SCIPgetParam(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
SCIP_RETCODE SCIPsetHeuristics(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPsetCharParam(SCIP *scip, const char *name, char value)
SCIP_Bool SCIPgetSubscipsOff(SCIP *scip)
SCIP_RETCODE SCIPgetLongintParam(SCIP *scip, const char *name, SCIP_Longint *value)
SCIP_RETCODE SCIPgetIntParam(SCIP *scip, const char *name, int *value)
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
SCIP_RETCODE SCIPgetCharParam(SCIP *scip, const char *name, char *value)
SCIP_RETCODE SCIPpqueueCreate(SCIP_PQUEUE **pqueue, int initsize, SCIP_Real sizefac, SCIP_DECL_SORTPTRCOMP((*ptrcomp)),)
void SCIPpqueueFree(SCIP_PQUEUE **pqueue)
SCIP_RETCODE SCIPpqueueInsert(SCIP_PQUEUE *pqueue, void *elem)
int SCIPpqueueNElems(SCIP_PQUEUE *pqueue)
void * SCIPpqueueRemove(SCIP_PQUEUE *pqueue)
SCIP_Real SCIPbendersGetSetupTime(SCIP_BENDERS *benders)
void SCIPbendersSetSubproblemObjval(SCIP_BENDERS *benders, int probnumber, SCIP_Real objval)
SCIP_RETCODE SCIPbendersSolSlackVarsActive(SCIP_BENDERS *benders, SCIP_Bool *activeslack)
SCIP_Bool SCIPbendersCutRelaxation(SCIP_BENDERS *benders)
int SCIPbendersGetNTransferredCuts(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersSubproblemIsConvex(SCIP_BENDERS *benders, int probnumber)
int SCIPbendersGetNStrengthenFails(SCIP_BENDERS *benders)
int SCIPgetBendersNSubproblems(SCIP *scip, SCIP_BENDERS *benders)
SCIP_RETCODE SCIPbendersGetStoredCutOrigData(SCIP_BENDERS *benders, int cutidx, SCIP_VAR ***vars, SCIP_Real **vals, SCIP_Real *lhs, SCIP_Real *rhs, int *nvars, int varssize)
SCIP_BENDERS ** SCIPgetBenders(SCIP *scip)
void SCIPbendersSetSubproblemIsNonlinear(SCIP_BENDERS *benders, int probnumber, SCIP_Bool isnonlinear)
void SCIPbendersSetMasterIsNonlinear(SCIP_BENDERS *benders, SCIP_Bool isnonlinear)
SCIP_BENDERS * SCIPfindBenders(SCIP *scip, const char *name)
void SCIPbendersSetData(SCIP_BENDERS *benders, SCIP_BENDERSDATA *bendersdata)
SCIP_Bool SCIPbendersOnlyCheckConvexRelax(SCIP_BENDERS *benders, SCIP_Bool subscipsoff)
SCIP_Bool SCIPbendersSubproblemIsNonlinear(SCIP_BENDERS *benders, int probnumber)
int SCIPbendersGetPriority(SCIP_BENDERS *benders)
SCIP_VAR * SCIPbendersGetAuxiliaryVar(SCIP_BENDERS *benders, int probnumber)
SCIP_BENDERSCUT * SCIPfindBenderscut(SCIP_BENDERS *benders, const char *name)
const char * SCIPbendersGetDesc(SCIP_BENDERS *benders)
int SCIPbendersGetNConvexSubproblems(SCIP_BENDERS *benders)
SCIP_BENDERSSUBTYPE SCIPbendersGetSubproblemType(SCIP_BENDERS *benders, int probnumber)
SCIP_RETCODE SCIPbendersSolveSubproblemCIP(SCIP *scip, SCIP_BENDERS *benders, int probnumber, SCIP_STATUS *solvestatus, SCIP_Bool solvecip)
int SCIPbendersGetNNonlinearSubproblems(SCIP_BENDERS *benders)
void SCIPsetBendersPriority(SCIP *scip, SCIP_BENDERS *benders, int priority)
SCIP_NLPPARAM SCIPbendersGetNLPParam(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersSubproblemIsEnabled(SCIP_BENDERS *benders, int probnumber)
SCIP_RETCODE SCIPgetBendersMasterVar(SCIP *scip, SCIP_BENDERS *benders, SCIP_VAR *var, SCIP_VAR **mappedvar)
int SCIPbendersGetNStrengthenCalls(SCIP_BENDERS *benders)
SCIP_RETCODE SCIPgetBendersSubproblemVar(SCIP *scip, SCIP_BENDERS *benders, SCIP_VAR *var, SCIP_VAR **mappedvar, int probnumber)
int SCIPbendersGetNStoredCuts(SCIP_BENDERS *benders)
SCIP_RETCODE SCIPbendersSolveSubproblemLP(SCIP *scip, SCIP_BENDERS *benders, int probnumber, SCIP_STATUS *solvestatus, SCIP_Real *objective)
int SCIPbendersGetNBenderscuts(SCIP_BENDERS *benders)
void SCIPbendersSetSubproblemIsConvex(SCIP_BENDERS *benders, int probnumber, SCIP_Bool isconvex)
SCIP_Bool SCIPbendersIsActive(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersSubproblemsAreInfeasible(SCIP_BENDERS *benders)
void SCIPbendersSetSubproblemIsSetup(SCIP_BENDERS *benders, int probnumber, SCIP_Bool issetup)
SCIP_BENDERSDATA * SCIPbendersGetData(SCIP_BENDERS *benders)
const char * SCIPbendersGetName(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersCutPseudo(SCIP_BENDERS *benders)
SCIP_VAR ** SCIPbendersGetAuxiliaryVars(SCIP_BENDERS *benders)
int SCIPbendersGetNSubproblems(SCIP_BENDERS *benders)
void SCIPbendersSetSubproblemType(SCIP_BENDERS *benders, int probnumber, SCIP_BENDERSSUBTYPE subprobtype)
int SCIPbendersGetNStrengthenCutsFound(SCIP_BENDERS *benders)
void SCIPbendersUpdateSubproblemLowerbound(SCIP_BENDERS *benders, int probnumber, SCIP_Real lowerbound)
SCIP * SCIPbendersSubproblem(SCIP_BENDERS *benders, int probnumber)
SCIP_Bool SCIPbendersMasterIsNonlinear(SCIP_BENDERS *benders)
SCIP_RETCODE SCIPbendersGetStoredCutData(SCIP_BENDERS *benders, int cutidx, SCIP_VAR ***vars, SCIP_Real **vals, SCIP_Real *lhs, SCIP_Real *rhs, int *nvars)
int SCIPbendersGetNCalls(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersIsInitialized(SCIP_BENDERS *benders)
int SCIPbendersGetNCutsFound(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersShareAuxVars(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersCutLP(SCIP_BENDERS *benders)
SCIP_RETCODE SCIPbendersSetBenderscutPriority(SCIP_BENDERS *benders, SCIP_BENDERSCUT *benderscut, int priority)
SCIP_Real SCIPbendersGetTime(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersSubproblemIsIndependent(SCIP_BENDERS *benders, int probnumber)
SCIP_RETCODE SCIPsolveBendersSubproblems(SCIP *scip, SCIP_BENDERS *benders, SCIP_SOL *sol, SCIP_RESULT *result, SCIP_Bool *infeasible, SCIP_Bool *auxviol, SCIP_BENDERSENFOTYPE type, SCIP_Bool checkint)
SCIP_BENDERSCUT ** SCIPbendersGetBenderscuts(SCIP_BENDERS *benders)
SCIP_Real SCIPbendersGetSubproblemObjval(SCIP_BENDERS *benders, int probnumber)
void SCIPbendersSetSubproblemIsIndependent(SCIP_BENDERS *benders, int probnumber, SCIP_Bool isindep)
SCIP_Bool SCIPbendersInStrengthenRound(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersSubproblemIsSetup(SCIP_BENDERS *benders, int probnumber)
SCIP_Real SCIPbendersGetSubproblemLowerbound(SCIP_BENDERS *benders, int probnumber)
SCIP_Bool SCIPbenderscutIsLPCut(SCIP_BENDERSCUT *benderscut)
const char * SCIPbenderscutGetName(SCIP_BENDERSCUT *benderscut)
SCIP_Longint SCIPbenderscutGetNFound(SCIP_BENDERSCUT *benderscut)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPsetConsRemovable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPsetEventhdlrFree(SCIP *scip, SCIP_EVENTHDLR *eventhdlr,)
SCIP_RETCODE SCIPsetEventhdlrInitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr,)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
SCIP_RETCODE SCIPsetEventhdlrExit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr,)
SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetEventhdlrExitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr,)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_EVENTHDLRDATA * SCIPeventhdlrGetData(SCIP_EVENTHDLR *eventhdlr)
void SCIPeventhdlrSetData(SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTHDLRDATA *eventhdlrdata)
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_RETCODE SCIPevalExprActivity(SCIP *scip, SCIP_EXPR *expr)
SCIP_Bool SCIPinDive(SCIP *scip)
SCIP_RETCODE SCIPconstructLP(SCIP *scip, SCIP_Bool *cutoff)
SCIP_Bool SCIPisLPConstructed(SCIP *scip)
SCIP_RETCODE SCIPcomputeLPRelIntPoint(SCIP *scip, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_SOL **point)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
#define SCIPallocClearBlockMemoryArray(scip, ptr, num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
int SCIPgetNNlpis(SCIP *scip)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
SCIP_NLPSOLSTAT SCIPgetNLPSolstat(SCIP *scip)
SCIP_Real SCIPgetNLPObjval(SCIP *scip)
SCIP_RETCODE SCIPsolveNLPParam(SCIP *scip, SCIP_NLPPARAM param)
SCIP_NLPTERMSTAT SCIPgetNLPTermstat(SCIP *scip)
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPchgVarObjProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPcreateEmptyRowConshdlr(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
SCIP_RETCODE SCIPcreateCurrentSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPcreateNLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPcreateLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPunlinkSol(SCIP *scip, SCIP_SOL *sol)
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
SCIP_Real SCIPretransformObj(SCIP *scip, SCIP_Real obj)
SCIP_RETCODE SCIPrestartSolve(SCIP *scip)
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
SCIP_RETCODE SCIPinterruptSolve(SCIP *scip)
SCIP_RETCODE SCIPsolve(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
SCIP_Real SCIPgetDualbound(SCIP *scip)
SCIP_Real SCIPgetLowerbound(SCIP *scip)
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPinRepropagation(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
int SCIPvarGetNLocksDown(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
void SCIPvarSetData(SCIP_VAR *var, SCIP_VARDATA *vardata)
SCIP_Bool SCIPvarIsRemovable(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIPfreeSol(scip, &heurdata->sol))
SCIPcreateSol(scip, &heurdata->sol, heur))
assert(minobj< SCIPgetCutoffbound(scip))
internal methods for LP management
static const char * paramname[]
#define BMSfreeMemory(ptr)
#define BMSreallocMemoryArray(ptr, num)
#define BMSduplicateMemoryArray(ptr, source, num)
#define BMSclearMemory(ptr)
#define BMSallocMemoryArray(ptr, num)
#define BMSfreeMemoryArray(ptr)
#define BMSallocBlockMemoryArray(mem, ptr, num)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)
#define BMSclearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
#define BMSfreeMemoryArrayNull(ptr)
#define BMSallocMemory(ptr)
void SCIPmessagePrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, const char *formatstr,...)
SCIP_Real SCIPconsGetLhs(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
SCIP_RETCODE SCIPconsAddCoef(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPconsGetRhs(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
SCIP_PARAMDATA * SCIPparamGetData(SCIP_PARAM *param)
int SCIPparamGetInt(SCIP_PARAM *param)
SCIP_Real SCIPparamGetRealMax(SCIP_PARAM *param)
internal methods for handling parameter settings
internal methods for storing priced variables
internal methods for storing and manipulating the main problem
public methods for message output
public data structures and miscellaneous methods
SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Bool SCIPsetGetSubscipsOff(SCIP_SET *set)
SCIP_RETCODE SCIPsetAddCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPsetAddBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPsetAddRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_BENDERS * SCIPsetFindBenders(SCIP_SET *set, const char *name)
SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_RETCODE SCIPsetGetIntParam(SCIP_SET *set, const char *name, int *value)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPsetGetRealParam(SCIP_SET *set, const char *name, SCIP_Real *value)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
internal methods for global SCIP settings
SCIP_RETCODE SCIPbendersGetVar(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_VAR *var, SCIP_VAR **mappedvar, int probnumber)
void SCIPbendersSetInitsol(SCIP_BENDERS *benders,)
static void createSolveSubproblemIndexList(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_BENDERSENFOTYPE type, int **solveidx, int *nsolveidx)
#define SCIP_DEFAULT_LNSMAXCALLSROOT
#define AUXILIARYVAR_NAME
#define SCIP_DEFAULT_STRENGTHENPERTURB
SCIP_Bool SCIPbendersSubproblemIsOptimal(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_SOL *sol, int probnumber)
#define NODESOLVED_EVENTHDLR_NAME
#define SCIP_DEFAULT_LNSMAXDEPTH
SCIP_RETCODE SCIPbendersActivate(SCIP_BENDERS *benders, SCIP_SET *set, int nsubproblems)
SCIP_RETCODE SCIPbendersComputeSubproblemLowerbound(SCIP_BENDERS *benders, SCIP_SET *set, int probnumber, SCIP_Real *lowerbound, SCIP_Bool *infeasible)
void SCIPbendersSetCopy(SCIP_BENDERS *benders,)
void SCIPbendersRemoveSubproblems(SCIP_BENDERS *benders)
static SCIP_RETCODE executeUserDefinedSolvesub(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_SOL *sol, int probnumber, SCIP_BENDERSSOLVELOOP solveloop, SCIP_Bool *infeasible, SCIP_Real *objective, SCIP_RESULT *result)
static SCIP_RETCODE initsolEventhandler(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTTYPE eventtype)
static SCIP_RETCODE performInteriorSolCutStrengthening(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_SOL *sol, SCIP_BENDERSENFOTYPE type, SCIP_Bool checkint, SCIP_Bool perturbsol, SCIP_Bool *auxviol, SCIP_Bool *infeasible, SCIP_Bool *skipsolve, SCIP_RESULT *result)
#define SCIP_DEFAULT_STRENGTHENENABLED
#define SCIP_DEFAULT_UPDATEAUXVARBOUND
#define SCIP_DEFAULT_LNSMAXCALLS
#define SCIP_DEFAULT_SLACKVARCOEF
SCIP_RETCODE SCIPbendersFreeSubproblem(SCIP_BENDERS *benders, SCIP_SET *set, int probnumber)
#define SCIP_DEFAULT_LNSCHECK
#define BENDERS_MAXPSEUDOSOLS
void SCIPbendersSetPriority(SCIP_BENDERS *benders, SCIP_SET *set, int priority)
static SCIP_Bool subproblemIsActive(SCIP_BENDERS *benders, int probnumber)
static SCIP_RETCODE addSlackVars(SCIP *scip, SCIP_BENDERS *benders, SCIP_CONS *cons, SCIP_CONSHDLR **linearconshdlrs, SCIP_CONSHDLR *nlconshdlr, int nlinearconshdlrs)
SCIP_RETCODE SCIPbendersExit(SCIP_BENDERS *benders, SCIP_SET *set)
SCIP_RETCODE SCIPbendersChgMastervarsToCont(SCIP_BENDERS *benders, SCIP_SET *set, int probnumber)
#define SCIP_DEFAULT_NLPITERLIMIT
void SCIPbendersSortBenderscuts(SCIP_BENDERS *benders)
SCIP_RETCODE SCIPbendersSetupSubproblem(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_SOL *sol, int probnumber, SCIP_BENDERSENFOTYPE type)
static SCIP_RETCODE setAndUpdateCorePoint(SCIP *scip, SCIP_BENDERS *benders)
#define SCIP_DEFAULT_STRENGTHENMULT
#define SCIP_DEFAULT_NUMTHREADS
static SCIP_RETCODE createSubproblems(SCIP_BENDERS *benders, SCIP_SET *set)
SCIP_RETCODE SCIPbendersSetMastervarsCont(SCIP_BENDERS *benders, int probnumber, SCIP_Bool arecont)
static SCIP_RETCODE freeEventhandler(SCIP *scip, SCIP_EVENTHDLR *eventhdlr)
#define SCIP_DEFAULT_STRENGTHENINTPOINT
void SCIPbendersSetSubproblemsAreInfeasible(SCIP_BENDERS *benders, SCIP_SET *set)
void SCIPbendersSortBenderscutsName(SCIP_BENDERS *benders)
static SCIP_RETCODE resetOrigSubproblemParams(SCIP *subproblem, SCIP_SUBPROBPARAMS *origparams)
#define SCIP_DEFAULT_CHECKCONSCONVEXITY
SCIP_RETCODE SCIPbendersCreate(SCIP_BENDERS **benders, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, SCIP_Bool cutlp, SCIP_Bool cutpseudo, SCIP_Bool cutrelax, SCIP_Bool shareauxvars, SCIP_DECL_BENDERSCOPY((*benderscopy)), SCIP_DECL_BENDERSFREE((*bendersfree)), SCIP_DECL_BENDERSINIT((*bendersinit)), SCIP_DECL_BENDERSEXIT((*bendersexit)), SCIP_DECL_BENDERSINITPRE((*bendersinitpre)), SCIP_DECL_BENDERSEXITPRE((*bendersexitpre)), SCIP_DECL_BENDERSINITSOL((*bendersinitsol)), SCIP_DECL_BENDERSEXITSOL((*bendersexitsol)), SCIP_DECL_BENDERSGETVAR((*bendersgetvar)), SCIP_DECL_BENDERSCREATESUB((*benderscreatesub)), SCIP_DECL_BENDERSPRESUBSOLVE((*benderspresubsolve)), SCIP_DECL_BENDERSSOLVESUBCONVEX((*benderssolvesubconvex)), SCIP_DECL_BENDERSSOLVESUB((*benderssolvesub)), SCIP_DECL_BENDERSPOSTSOLVE((*benderspostsolve)), SCIP_DECL_BENDERSFREESUB((*bendersfreesub)), SCIP_BENDERSDATA *bendersdata)
static SCIP_RETCODE addSlackVarsToConstraints(SCIP_BENDERS *benders, SCIP_SET *set, int probnumber)
static SCIP_RETCODE updateAuxiliaryVarLowerbound(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_RESULT *result)
SCIP_RETCODE SCIPbendersApplyDecomposition(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_DECOMP *decomp)
#define SCIP_DEFAULT_MAXSLACKVARCOEF
static SCIP_RETCODE generateBendersCuts(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_SOL *sol, SCIP_RESULT *result, SCIP_BENDERSENFOTYPE type, SCIP_BENDERSSOLVELOOP solveloop, SCIP_Bool checkint, SCIP_Bool *subprobsolved, SCIP_BENDERSSUBSTATUS *substatus, int *solveidx, int nsolveidx, int **mergecands, int *npriomergecands, int *nmergecands, int *nsolveloops)
static SCIP_RETCODE exitEventhandler(SCIP *scip, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE solveBendersSubproblems(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_SOL *sol, SCIP_BENDERSENFOTYPE type, SCIP_BENDERSSOLVELOOP solveloop, SCIP_Bool checkint, int *nverified, int *solveidx, int nsolveidx, SCIP_Bool **subprobsolved, SCIP_BENDERSSUBSTATUS **substatus, SCIP_Bool *infeasible, SCIP_Bool *optimal, SCIP_Bool *stopped)
SCIP_RETCODE SCIPbendersCopyInclude(SCIP_BENDERS *benders, SCIP_SET *sourceset, SCIP_SET *targetset, SCIP_HASHMAP *varmap, SCIP_Bool threadsafe, SCIP_Bool *valid)
void SCIPbendersSetFreesub(SCIP_BENDERS *benders,)
static SCIP_RETCODE createAndAddTransferredCut(SCIP *sourcescip, SCIP_BENDERS *benders, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, int nvars)
SCIP_RETCODE SCIPbendersMergeSubproblemIntoMaster(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, int probnumber)
static SCIP_RETCODE doBendersCreate(SCIP_BENDERS **benders, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, SCIP_Bool cutlp, SCIP_Bool cutpseudo, SCIP_Bool cutrelax, SCIP_Bool shareauxvars, SCIP_DECL_BENDERSCOPY((*benderscopy)), SCIP_DECL_BENDERSFREE((*bendersfree)), SCIP_DECL_BENDERSINIT((*bendersinit)), SCIP_DECL_BENDERSEXIT((*bendersexit)), SCIP_DECL_BENDERSINITPRE((*bendersinitpre)), SCIP_DECL_BENDERSEXITPRE((*bendersexitpre)), SCIP_DECL_BENDERSINITSOL((*bendersinitsol)), SCIP_DECL_BENDERSEXITSOL((*bendersexitsol)), SCIP_DECL_BENDERSGETVAR((*bendersgetvar)), SCIP_DECL_BENDERSCREATESUB((*benderscreatesub)), SCIP_DECL_BENDERSPRESUBSOLVE((*benderspresubsolve)), SCIP_DECL_BENDERSSOLVESUBCONVEX((*benderssolvesubconvex)), SCIP_DECL_BENDERSSOLVESUB((*benderssolvesub)), SCIP_DECL_BENDERSPOSTSOLVE((*benderspostsolve)), SCIP_DECL_BENDERSFREESUB((*bendersfreesub)), SCIP_BENDERSDATA *bendersdata)
#define UPPERBOUND_EVENTHDLR_DESC
static SCIP_RETCODE addConstraintToBendersSubproblem(SCIP_SET *set, SCIP *subproblem, SCIP_HASHMAP *varmap, SCIP_CONS *sourcecons)
static SCIP_RETCODE initialiseSubproblem(SCIP_BENDERS *benders, SCIP_SET *set, int probnumber, SCIP_Bool *infeasible, SCIP_Bool *success)
void SCIPbendersSetExitsol(SCIP_BENDERS *benders,)
#define SCIP_DEFAULT_AUXVARSIMPLINT
static SCIP_RETCODE copyMemoryAndTimeLimits(SCIP *scip, SCIP *subproblem)
static SCIP_RETCODE transferBendersCuts(SCIP *sourcescip, SCIP *subscip, SCIP_BENDERS *benders)
void SCIPbendersSetBenderscutsSorted(SCIP_BENDERS *benders, SCIP_Bool sorted)
#define UPPERBOUND_EVENTHDLR_NAME
static SCIP_RETCODE assignAuxiliaryVariables(SCIP *scip, SCIP_BENDERS *benders)
#define NODEFOCUS_EVENTHDLR_DESC
void SCIPbendersSetExitpre(SCIP_BENDERS *benders,)
SCIP_RETCODE SCIPbendersFree(SCIP_BENDERS **benders, SCIP_SET *set)
void SCIPbendersSetSolvesub(SCIP_BENDERS *benders,)
SCIP_RETCODE SCIPbendersInitsol(SCIP_BENDERS *benders, SCIP_SET *set)
SCIP_RETCODE SCIPbendersExecSubproblemSolve(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_SOL *sol, int probnumber, SCIP_BENDERSSOLVELOOP solveloop, SCIP_Bool enhancement, SCIP_Bool *solved, SCIP_Bool *infeasible, SCIP_BENDERSENFOTYPE type)
#define MIPNODEFOCUS_EVENTHDLR_DESC
static SCIP_RETCODE releaseVarMappingHashmapVars(SCIP *scip, SCIP_BENDERS *benders)
static SCIP_RETCODE addAuxiliaryVariablesToMaster(SCIP *scip, SCIP_BENDERS *benders)
void SCIPbendersSetPostsolve(SCIP_BENDERS *benders,)
#define SCIP_DEFAULT_NOIMPROVELIMIT
static SCIP_RETCODE setSubproblemParams(SCIP *scip, SCIP *subproblem)
SCIP_RETCODE SCIPbendersDeactivate(SCIP_BENDERS *benders, SCIP_SET *set)
void SCIPbendersSetSubproblemComp(SCIP_BENDERS *benders,)
SCIP_RETCODE SCIPbendersStoreCut(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, int nvars)
SCIP_RETCODE SCIPbendersAddSubproblem(SCIP_BENDERS *benders, SCIP *subproblem)
#define SCIP_DEFAULT_TRANSFERCUTS
void SCIPbendersSetPresubsolve(SCIP_BENDERS *benders,)
SCIP_Real SCIPbendersGetAuxiliaryVarVal(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_SOL *sol, int probnumber)
SCIP_RETCODE SCIPbendersExec(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_SOL *sol, SCIP_RESULT *result, SCIP_Bool *infeasible, SCIP_Bool *auxviol, SCIP_BENDERSENFOTYPE type, SCIP_Bool checkint)
SCIP_Bool SCIPbendersGetMastervarsCont(SCIP_BENDERS *benders, int probnumber)
static SCIP_RETCODE exitsolEventhandler(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTTYPE eventtype)
static SCIP_RETCODE updateEventhdlrUpperbound(SCIP_BENDERS *benders, int probnumber, SCIP_Real upperbound)
static SCIP_RETCODE storeOrigSubproblemParams(SCIP *subproblem, SCIP_SUBPROBPARAMS *origparams)
#define MIPNODEFOCUS_EVENTHDLR_NAME
#define SCIP_DEFAULT_SUBPROBFRAC
void SCIPbendersSetExit(SCIP_BENDERS *benders,)
#define SCIP_DEFAULT_EXECFEASPHASE
void SCIPbendersSetInitpre(SCIP_BENDERS *benders,)
#define NODEFOCUS_EVENTHDLR_NAME
static SCIP_RETCODE removeVariablesAndConstraintsFromMaster(SCIP *scip, SCIP_CONS **conss, SCIP_VAR **vars, int *conslabels, int *varslabels, int nconss, int nvars)
SCIP_RETCODE SCIPbendersInitpre(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_STAT *stat)
void SCIPbendersEnableOrDisableClocks(SCIP_BENDERS *benders, SCIP_Bool enable)
static SCIP_RETCODE updateSubproblemStatQueue(SCIP_BENDERS *benders, int *solveidx, int nsolveidx, SCIP_Bool updatestat)
static SCIP_RETCODE checkSubproblemConvexity(SCIP_BENDERS *benders, SCIP_SET *set, int probnumber)
static SCIP_RETCODE updateSubproblemLowerbound(SCIP *masterprob, SCIP_BENDERS *benders)
#define SCIP_DEFAULT_CUTCHECK
#define SCIP_DEFAULT_CUTSASCONSS
static SCIP_RETCODE initEventhandlerData(SCIP *scip, SCIP_EVENTHDLRDATA *eventhdlrdata)
void SCIPbendersSetSubproblemEnabled(SCIP_BENDERS *benders, int probnumber, SCIP_Bool enabled)
void SCIPbendersSetSolvesubconvex(SCIP_BENDERS *benders,)
SCIP_RETCODE SCIPbendersIncludeBenderscut(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_BENDERSCUT *benderscut)
SCIP_RETCODE SCIPbendersExitpre(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_STAT *stat)
static int numSubproblemsToCheck(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_BENDERSENFOTYPE type)
SCIP_RETCODE SCIPbendersExitsol(SCIP_BENDERS *benders, SCIP_SET *set)
SCIP_RETCODE SCIPbendersSolveSubproblem(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_SOL *sol, int probnumber, SCIP_Bool *infeasible, SCIP_Bool solvecip, SCIP_Real *objective)
static void resetSubproblemObjectiveValue(SCIP_BENDERS *benders, SCIP_SET *set)
#define BENDERS_ARRAYSIZE
static SCIP_RETCODE initialiseLPSubproblem(SCIP_BENDERS *benders, SCIP_SET *set, int probnumber, SCIP_Bool *infeasible)
static SCIP_RETCODE createMasterVarMapping(SCIP_BENDERS *benders, SCIP_SET *sourceset, SCIP_HASHMAP *varmap)
#define NODESOLVED_EVENTHDLR_DESC
void SCIPbendersSetInit(SCIP_BENDERS *benders,)
static SCIP_RETCODE checkSubproblemIndependence(SCIP *scip, SCIP_BENDERS *benders)
void SCIPbendersSetFree(SCIP_BENDERS *benders,)
SCIP_RETCODE SCIPbendersInit(SCIP_BENDERS *benders, SCIP_SET *set)
internal methods for Benders' decomposition
SCIP_Bool subprobsinfeasible
SCIP_Bool * subprobisconvex
SCIP_Bool * subprobenabled
SCIP_BENDERSDATA * bendersdata
SCIP_SUBPROBLEMSOLVESTAT ** solvestat
SCIP_Bool strengthenround
SCIP_Bool * mastervarscont
SCIP_VAR ** auxiliaryvars
SCIP_Real * subprobobjval
SCIP_HASHMAP * mastervarsmap
SCIP_PQUEUE * subprobqueue
SCIP_Real * bestsubprobobjval
SCIP_Bool benderscutssorted
SCIP_Real maxslackvarcoef
SCIP_BENDERSSUBTYPE * subprobtype
SCIP_Bool * subprobisnonlinear
SCIP_Bool strengthenenabled
SCIP_Bool benderscutsnamessorted
SCIP_Bool masterisnonlinear
SCIP_BENDERSCUTCUT ** storedcuts
SCIP_Bool feasibilityphase
SCIP_BENDERSCUT ** benderscuts
SCIP_CLOCK * bendersclock
SCIP_Bool subprobscreated
SCIP_Bool updateauxvarbound
SCIP_Bool checkconsconvexity
SCIP_Real * subproblowerbound
SCIP_Bool benders_copybenders
SCIP_Bool lp_alwaysgetduals
SCIP_Bool conflict_enable
SCIP_Bool misc_catchctrlc
data structures required for Benders' decomposition
struct SCIP_SubproblemParams SCIP_SUBPROBPARAMS
struct SCIP_BenderscutCut SCIP_BENDERSCUTCUT
datastructures for Benders' decomposition cuts techniques
#define SCIP_DECL_BENDERSFREESUB(x)
#define SCIP_DECL_BENDERSCREATESUB(x)
struct SCIP_Benders SCIP_BENDERS
#define SCIP_DECL_BENDERSCOPY(x)
@ SCIP_BENDERSENFOTYPE_LP
@ SCIP_BENDERSENFOTYPE_CHECK
@ SCIP_BENDERSENFOTYPE_PSEUDO
#define SCIP_DECL_BENDERSSOLVESUB(x)
#define SCIP_DECL_BENDERSEXITPRE(x)
@ SCIP_BENDERSSUBSTATUS_AUXVIOL
@ SCIP_BENDERSSUBSTATUS_UNKNOWN
@ SCIP_BENDERSSUBSTATUS_INFEAS
@ SCIP_BENDERSSUBSTATUS_OPTIMAL
#define SCIP_DECL_BENDERSSOLVESUBCONVEX(x)
#define SCIP_DECL_BENDERSINIT(x)
#define SCIP_DECL_BENDERSFREE(x)
#define SCIP_DECL_BENDERSEXITSOL(x)
#define SCIP_DECL_BENDERSPRESUBSOLVE(x)
struct SCIP_SubproblemSolveStat SCIP_SUBPROBLEMSOLVESTAT
@ SCIP_BENDERSSUBTYPE_NONCONVEXDIS
@ SCIP_BENDERSSUBTYPE_CONVEXCONT
@ SCIP_BENDERSSUBTYPE_NONCONVEXCONT
@ SCIP_BENDERSSUBTYPE_CONVEXDIS
@ SCIP_BENDERSSUBTYPE_UNKNOWN
enum SCIP_BendersSubType SCIP_BENDERSSUBTYPE
@ SCIP_BENDERSSOLVELOOP_CIP
@ SCIP_BENDERSSOLVELOOP_CONVEX
@ SCIP_BENDERSSOLVELOOP_USERCONVEX
@ SCIP_BENDERSSOLVELOOP_USERCIP
enum SCIP_BendersSolveLoop SCIP_BENDERSSOLVELOOP
enum SCIP_BendersEnfoType SCIP_BENDERSENFOTYPE
#define SCIP_DECL_BENDERSGETVAR(x)
enum SCIP_BendersSubStatus SCIP_BENDERSSUBSTATUS
#define SCIP_DECL_BENDERSPOSTSOLVE(x)
#define SCIP_DECL_BENDERSINITPRE(x)
#define SCIP_DECL_BENDERSEXIT(x)
#define SCIP_DECL_BENDERSINITSOL(x)
struct SCIP_BendersData SCIP_BENDERSDATA
struct SCIP_Benderscut SCIP_BENDERSCUT
struct SCIP_Cons SCIP_CONS
struct SCIP_Conshdlr SCIP_CONSHDLR
struct SCIP_Decomp SCIP_DECOMP
struct SCIP_Eventhdlr SCIP_EVENTHDLR
#define SCIP_DECL_EVENTINITSOL(x)
#define SCIP_DECL_EVENTEXIT(x)
#define SCIP_EVENTTYPE_NODEFOCUSED
struct SCIP_EventhdlrData SCIP_EVENTHDLRDATA
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_NODESOLVED
#define SCIP_EVENTTYPE_BESTSOLFOUND
#define SCIP_DECL_EVENTFREE(x)
#define SCIP_DECL_EVENTEXITSOL(x)
@ SCIP_LPSOLSTAT_NOTSOLVED
@ SCIP_LPSOLSTAT_TIMELIMIT
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
@ SCIP_LPSOLSTAT_ITERLIMIT
struct SCIP_Messagehdlr SCIP_MESSAGEHDLR
struct SCIP_HashMap SCIP_HASHMAP
#define SCIP_DECL_SORTPTRCOMP(x)
struct SCIP_HashMapEntry SCIP_HASHMAPENTRY
#define SCIP_NLPPARAM_DEFAULT(scip)
enum SCIP_NlpSolStat SCIP_NLPSOLSTAT
@ SCIP_NLPTERMSTAT_TIMELIMIT
@ SCIP_NLPTERMSTAT_ITERLIMIT
@ SCIP_NLPTERMSTAT_INTERRUPT
@ SCIP_NLPSOLSTAT_UNBOUNDED
@ SCIP_NLPSOLSTAT_GLOBINFEASIBLE
@ SCIP_NLPSOLSTAT_LOCINFEASIBLE
@ SCIP_NLPSOLSTAT_FEASIBLE
@ SCIP_NLPSOLSTAT_GLOBOPT
struct SCIP_NlpParam SCIP_NLPPARAM
enum SCIP_NlpTermStat SCIP_NLPTERMSTAT
struct SCIP_ParamData SCIP_PARAMDATA
#define SCIP_DECL_PARAMCHGD(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STATUS_BESTSOLLIMIT
@ SCIP_STATUS_USERINTERRUPT
enum SCIP_Status SCIP_STATUS
struct SCIP_Stat SCIP_STAT
struct SCIP_VarData SCIP_VARDATA
@ SCIP_VARTYPE_CONTINUOUS
enum SCIP_Vartype SCIP_VARTYPE