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
109 SCIP_Real upperbound;
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 )
685 SCIP_Bool shareauxvars;
690 vardata->vartype = -1;
698 shareauxvars =
FALSE;
758 SCIP_Bool shareauxvars;
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 )
934 SCIP_Bool threadsafe,
951 SCIP_CALL( benders->benderscopy(targetset->
scip, benders, threadsafe) );
1008 SCIP_Bool cutpseudo,
1010 SCIP_Bool shareauxvars,
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,
1217 SCIP_Bool cutpseudo,
1219 SCIP_Bool shareauxvars,
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
1347 SCIP_Bool linearcons;
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",
1554 eventExecBendersNodefocus, eventhdlrdata) );
1596 SCIP_Bool convexcons;
1597 SCIP_Bool discretevar;
1598 SCIP_Bool isnonlinear;
1606 assumevarfixed =
NULL;
1607 if( probnumber >= 0 )
1610 subproblem =
set->scip;
1615 discretevar =
FALSE;
1616 isnonlinear =
FALSE;
1649 if( probnumber >= 0 && nlconshdlr !=
NULL )
1662 if( mappedvar !=
NULL )
1675 if( conshdlr == linearconshdlrs[j] )
1681#ifdef SCIP_MOREDEBUG
1688 if( conshdlr == nlconshdlr )
1699 if( havelhs && haverhs )
1723#ifdef SCIP_MOREDEBUG
1730#ifdef SCIP_MOREDEBUG
1737#ifdef SCIP_MOREDEBUG
1752 if( probnumber >= 0 )
1756 if( convexcons && !discretevar )
1758 else if( convexcons && discretevar )
1760 else if( !convexcons && !discretevar )
1762 else if( !convexcons && discretevar )
1769 if( probnumber >= 0 )
1774 if( probnumber >= 0 )
1781 if( assumevarfixed !=
NULL )
1815 for(
i = 0;
i < nsubproblems;
i++ )
1818 SCIP_CALL( benders->benderscreatesub(
set->scip, benders,
i) );
1829 if( subproblem !=
NULL )
1849 SCIP_Bool objchanged =
FALSE;
1852 for( j = 0; j <
nvars; j++ )
1861 "coefficient of copy of master problem variable <%s> in subproblem %d to zero.\n",
1873 "copied of master problem variables has been changed to zero.\n");
1915 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL
1929 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL
1963 SCIPerrorMessage(
"If the subproblem is set to NULL, then the subproblem type must be specified.\n");
1964 SCIPerrorMessage(
"In the subproblem creation callback, call SCIPbendersSetSubproblemType with the appropriate problem type.\n");
1999 if(
set->misc_resetstat )
2012 if( benders->bendersinit !=
NULL )
2131 if( sourcevar ==
NULL )
2210 for(
i = 0;
i < naddedcuts;
i++ )
2247 if( benders->bendersexit !=
NULL )
2274 for(
i = 0;
i < nsubproblems;
i++ )
2334 for(
i = 0;
i < nsubproblems;
i++ )
2336 SCIP_Bool independent =
FALSE;
2341 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL
2342 && benders->bendersfreesub ==
NULL )
2346 for( j = 0; j <
nvars; j++ )
2354 if( subprobvar !=
NULL )
2356 independent =
FALSE;
2389 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL )
2397 if( benders->bendersinitpre !=
NULL )
2402 SCIP_CALL( benders->bendersinitpre(
set->scip, benders) );
2424 if( benders->bendersexitpre !=
NULL )
2429 SCIP_CALL( benders->bendersexitpre(
set->scip, benders) );
2450 if( benders->bendersinitsol !=
NULL )
2455 SCIP_CALL( benders->bendersinitsol(
set->scip, benders) );
2487 for(
i = 0;
i < nsubproblems;
i++ )
2500 if( benders->bendersexitsol !=
NULL )
2505 SCIP_CALL( benders->bendersexitsol(
set->scip, benders) );
2545 set->nactivebenders++;
2570 benders->benderssubcomp ==
NULL ? benderssubcompdefault : benders->benderssubcomp,
NULL) );
2605 eventExecBendersNodesolved, eventhdlrdata) );
2633 for(
i = 0;
i < nsubproblems;
i++ )
2648 set->nactivebenders--;
2654 for(
i = nsubproblems - 1;
i >= 0;
i-- )
2704 for(
i = 0;
i < nsubproblems;
i++ )
2707 SCIP_Real lowerbound;
2708 SCIP_Bool infeasible;
2774 SCIP_Real timelimit;
2795 if ( timelimit > 0.0 )
2837 SCIP_Bool perturbsol,
2839 SCIP_Bool* infeasible,
2840 SCIP_Bool* skipsolve,
2854 (*skipsolve) =
FALSE;
2909 SCIP_Real corepointval;
2911 SCIP_Real newsolval;
2916 newsolval = lpsolval;
2958 SCIPsetDebugMsg(
set,
"solving Benders' decomposition subproblems with stabilised point.\n");
2963 SCIPsetDebugMsg(
set,
"solved Benders' decomposition subproblems with stabilised point. noimprovecount %d result %d\n",
2968 (*skipsolve) =
TRUE;
2992 SCIP_Bool subscipsoff
3036 int subproblemcount;
3051 subproblemcount = 0;
3052 while( subproblemcount < nsubproblems && subproblemcount < numtocheck )
3057 (*solveidx)[(*nsolveidx)] = solvestat->
idx;
3070 SCIP_Bool updatestat
3078 for(
i = 0;
i < nsolveidx;
i++ )
3090 if( subproblem ==
NULL )
3125 SCIP_Bool** subprobsolved,
3127 SCIP_Bool* infeasible,
3132 SCIP_Bool onlyconvexcheck;
3141 int locnverified = *nverified;
3142 SCIP_Bool locinfeasible = *infeasible;
3143 SCIP_Bool locoptimal = *optimal;
3144 SCIP_Bool locstopped = *stopped;
3168 SCIPsetDebugMsg(
set,
"Performing the subproblem solving process. Number of subproblems to check %d\n", nsolveidx);
3175 locinfeasible =
TRUE;
3182#ifndef __INTEL_COMPILER
3183 #pragma omp parallel for num_threads(numthreads) private(i) reduction(&&:locoptimal) reduction(||:locinfeasible) reduction(+:locnverified) reduction(||:locstopped) reduction(min:retcode)
3185 for( j = 0; j < nsolveidx; j++ )
3187 SCIP_Bool subinfeas =
FALSE;
3188 SCIP_Bool convexsub;
3189 SCIP_Bool solvesub =
TRUE;
3196 (*subprobsolved)[
i] =
FALSE;
3238 SCIPsetDebugMsg(
set,
"Benders' decomposition: subproblem %d is not active, but has not been solved."
3239 " setting status to UNKNOWN\n",
i);
3255 SCIPsetDebugMsg(
set,
"Benders' decomposition: subproblem %d is not active, setting status to OPTIMAL\n",
i);
3258 (*subprobsolved)[
i] =
TRUE;
3279 (*subprobsolved)[
i] = solved;
3281 locinfeasible = locinfeasible || subinfeas;
3289 if( checkint && (*subprobsolved)[
i] )
3296 SCIP_Bool subproboptimal;
3300 if( subproboptimal )
3313 if( convexsub || onlyconvexcheck
3316 locoptimal = locoptimal && subproboptimal;
3321 if( subproboptimal )
3348 || onlyconvexcheck )
3361 SCIPsetDebugMsg(
set,
"Local variable values: nverified %d infeasible %u optimal %u stopped %u\n", locnverified,
3362 locinfeasible, locoptimal, locstopped);
3363 *nverified = locnverified;
3364 *infeasible = locinfeasible;
3365 *optimal = locoptimal;
3366 *stopped = locstopped;
3394 SCIP_Bool* subprobsolved,
3399 int* npriomergecands,
3407 SCIP_Longint addedcuts = 0;
3411 SCIP_Bool onlyconvexcheck;
3435 for( k = 0; k < nsolveidx; k++ )
3438 SCIP_Bool convexsub;
3452 for( j = 0; j < nbenderscuts; j++ )
3455 SCIP_Longint prevaddedcuts;
3478 subprobresult = cutresult;
3489 subprobresult = cutresult;
3491 subprobresult = cutresult;
3501 solveloopresult = subprobresult;
3507 solveloopresult = subprobresult;
3513 solveloopresult = subprobresult;
3520 (*mergecands)[(*nmergecands)] =
i;
3532 (*mergecands)[(*nmergecands)] = (*mergecands)[(*npriomergecands)];
3533 (*mergecands)[(*npriomergecands)] =
i;
3534 (*npriomergecands)++;
3539 (*mergecands)[(*nmergecands)] =
i;
3550 (*result) = solveloopresult;
3556 (*result) = solveloopresult;
3562 (*result) = solveloopresult;
3567 && checkint && !onlyconvexcheck )
3589 SCIP_Bool* infeasible,
3596 int subproblemcount;
3601 int npriomergecands;
3608 SCIP_Bool* subprobsolved;
3611 SCIP_Bool allverified;
3620 SCIPsetDebugMsg(
set,
"Starting Benders' decomposition subproblem solving. type %d checkint %u\n", type, checkint);
3622#ifdef SCIP_MOREDEBUG
3632 (*infeasible) =
FALSE;
3699 SCIP_Bool skipsolve;
3702 SCIP_CALL( benders->benderspresubsolve(
set->scip, benders,
sol, type, checkint, infeasible, auxviol, &skipsolve,
3712 SCIPerrorMessage(
"the user-defined pre subproblem solving method for the Benders' decomposition <%s> returned "
3713 "invalid result <%d>\n", benders->
name, *
result);
3720 SCIPsetDebugMsg(
set,
"skipping the subproblem solving for Benders' decomposition <%s>. "
3721 "returning result <%d>\n", benders->
name, *
result);
3736 SCIP_Bool skipsolve;
3747 SCIPsetDebugMsg(
set,
"skipping the subproblem solving because cut strengthening found a cut "
3748 "for Benders' decomposition <%s>. Returning result <%d>\n", benders->
name, *
result);
3760 npriomergecands = 0;
3773 while( nsolved < nsubproblems )
3784 for( l = 0; l < nsolveloops; l++ )
3789 if( benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL )
3801 solveidx, nsolveidx, &subprobsolved, &substatus, infeasible, &optimal, &stopped) );
3813 substatus, solveidx, nsolveidx, &mergecands, &npriomergecands, &nmergecands, &nsolveloops) );
3827 nsolved += nsolveidx;
3830 for(
i = 0;
i < nsolveidx;
i++ )
3831 executedidx[nexecutedidx++] = solveidx[
i];
3846 allverified = (nverified == nsubproblems);
3848 SCIPsetDebugMsg(
set,
"End Benders' decomposition subproblem solve. result %d infeasible %u auxviol %u nverified %d\n",
3849 *
result, *infeasible, *auxviol, nverified);
3874 if( npriomergecands == 0 )
3880 npriomergecands = 1;
3881 for(
i = 0;
i < nsubproblems;
i++ )
3886 mergecands[nmergecands] =
i;
3892 "limit of %d. All active subproblems are merge candidates, with subproblem %d a priority candidate.\n",
3914 SCIPerrorMessage(
"An error was found when generating cuts for non-optimal subproblems of Benders' "
3915 "decomposition <%s>. Consider merging the infeasible subproblems into the master problem.\n",
SCIPbendersGetName(benders));
3931 if( (*infeasible) || !allverified )
3941 (*auxviol) = !optimal;
3950 if( (*infeasible) || !allverified )
3960 (*auxviol) = !optimal;
3967 if( benders->benderspostsolve !=
NULL )
3973 SCIP_CALL( benders->benderspostsolve(
set->scip, benders,
sol, type, mergecands, npriomergecands, nmergecands,
3974 checkint, (*infeasible), &merged) );
3987 SCIPerrorMessage(
"An error occurred during Benders' decomposition cut generations and no merging had been "
3988 "performed. It is not possible to continue solving the problem by Benders' decomposition\n");
3995 nfree = nsubproblems;
3997 nfree = nexecutedidx;
4000 subproblemcount = 0;
4001 while( subproblemcount < nfree )
4006 subidx = subproblemcount;
4008 subidx = executedidx[subproblemcount];
4016 for(
i = 0;
i < nsubproblems;
i++ )
4027 *infeasible, *auxviol);
4042 if( !success && !stopped )
4044 SCIP_Bool skipsolve;
4052 &skipsolve, &perturbresult) );
4056 (*result) = perturbresult;
4058 success = skipsolve;
4073 SCIP_Bool activeslack;
4076 SCIPsetDebugMsg(
set,
"Type: %d Active slack: %u Feasibility Phase: %u\n", type, activeslack,
4127 SCIP_Bool* infeasible,
4128 SCIP_Real* objective,
4133 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
4134 assert(benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL);
4144 if( benders->benderssolvesubconvex !=
NULL )
4146 SCIP_CALL( benders->benderssolvesubconvex(
set->scip, benders,
sol, probnumber,
4154 if( benders->benderssolvesub !=
NULL )
4168 SCIPerrorMessage(
"the user-defined solving method for the Benders' decomposition <%s> returned invalid result <%d>\n",
4174 (*infeasible) =
TRUE;
4179 SCIPerrorMessage(
"the user-defined solving method for the Benders' decomposition <%s> returned objective value %g\n",
4180 benders->
name, (*objective));
4198 SCIP_Bool enhancement,
4200 SCIP_Bool* infeasible,
4206 SCIP_Real objective;
4210 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
4219 if( subproblem ==
NULL && (benders->benderssolvesubconvex ==
NULL || benders->benderssolvesub ==
NULL) )
4221 SCIPerrorMessage(
"The subproblem %d is set to NULL, but both bendersSolvesubconvex%s and bendersSolvesub%s "
4222 "are not defined.\n", probnumber, benders->
name, benders->
name);
4240 else if( subproblem !=
NULL )
4275 (*infeasible) =
TRUE;
4284 (*infeasible) =
TRUE;
4290 if( bestsol !=
NULL )
4320 "subproblem %d. No cut will be generated for this subproblem.\n", probnumber);
4325 SCIPerrorMessage(
"The Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4331 SCIPerrorMessage(
"Invalid status returned from solving Benders' decomposition subproblem %d. Solution status: %d\n",
4332 probnumber, solvestatus);
4345 SCIPerrorMessage(
"The Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4351 SCIPerrorMessage(
"Invalid result <%d> from user-defined subproblem solving method. This should not happen.\n",
4383 if( subproblem ==
NULL )
4385 SCIPerrorMessage(
"The subproblem %d is NULL. Thus, the subproblem setup must be performed manually in either "
4386 "bendersSolvesubconvex%s or bendersSolvesub%s.\n", probnumber, benders->
name, benders->
name);
4428 if( mastervar !=
NULL )
4517 SCIP_Bool* infeasible,
4519 SCIP_Real* objective
4526 (*infeasible) =
FALSE;
4532 SCIPerrorMessage(
"Benders' decomposition subproblem %d must be set up before calling SCIPbendersSolveSubproblem(). Call SCIPsetupSubproblem() first.\n", probnumber);
4537 if( benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL)
4550 if( objective !=
NULL )
4551 (*objective) = subobj;
4568 (*infeasible) =
TRUE;
4569 if( objective !=
NULL )
4598 SCIP_Real lpobjective;
4603 (*infeasible) =
TRUE;
4604 else if( objective !=
NULL )
4605 (*objective) = lpobjective;
4609 if( objective !=
NULL )
4625 SCIP_Real mastertimelimit;
4626 SCIP_Real subtimelimit;
4627 SCIP_Real maxsubtimelimit;
4628 SCIP_Real mastermemorylimit;
4629 SCIP_Real submemorylimit;
4630 SCIP_Real maxsubmemorylimit;
4638 subtimelimit =
MIN(subtimelimit, maxsubtimelimit);
4645 submemorylimit =
MIN(submemorylimit, maxsubmemorylimit);
4712#ifndef SCIP_MOREDEBUG
4775 SCIP_Real* objective
4818#ifdef SCIP_MOREDEBUG
4826 SCIPdebugMsg(
scip,
"NLP solstat %d termstat %d\n", nlpsolstat, nlptermstat);
4836#ifdef SCIP_MOREDEBUG
4848 SCIPerrorMessage(
"The NLP of Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4859 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));
4868 SCIPerrorMessage(
"Invalid solution status: %d. Termination status: %d. Solving the NLP relaxation of Benders' decomposition subproblem %d.\n",
4869 nlpsolstat, nlptermstat, probnumber);
4898 SCIPerrorMessage(
"The LP of Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4914 "relaxation of subproblem %d. No cut will be generated for this subproblem.\n", probnumber);
4922 SCIPerrorMessage(
"Invalid status: %d. Solving the LP relaxation of Benders' decomposition subproblem %d.\n",
4987 eventhdlrdata->solvecip =
TRUE;
4997#ifdef SCIP_EVENMOREDEBUG
5002#ifdef SCIP_MOREDEBUG
5016 SCIPerrorMessage(
"Invalid status: %d. Solving the CIP of Benders' decomposition subproblem %d.\n",
5017 *solvestatus, probnumber);
5039 || (benders->bendersfreesub ==
NULL && benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL));
5040 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
5042 if( benders->bendersfreesub !=
NULL )
5044 SCIP_CALL( benders->bendersfreesub(
set->scip, benders, probnumber) );
5088 SCIP_Real auxiliaryvarval;
5093 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
5099 SCIPsetDebugMsg(
set,
"Subproblem %d - Auxiliary Variable: %g Subproblem Objective: %g Reldiff: %g Soltol: %g\n",
5135 SCIP_Real* lowerbound,
5136 SCIP_Bool* infeasible
5140 SCIP_Real dualbound;
5141 SCIP_Real memorylimit;
5142 SCIP_Real timelimit;
5143 SCIP_Longint totalnodes;
5152 if( benders->benderssolvesub !=
NULL || benders->benderssolvesubconvex !=
NULL )
5155 (*infeasible) =
FALSE;
5157 SCIPinfoMessage(
set->scip,
NULL,
"Benders' decomposition: a bendersSolvesub or bendersSolvesubconvex has been "
5158 "implemented. SCIPbendersComputeSubproblemLowerbound can not be executed.\n");
5160 "SCIPbendersUpdateSubproblemLowerbound in bendersCreatesub. The auxiliary variable %d will remain as %g\n",
5161 probnumber, (*lowerbound));
5168 " subproblem %d\n", probnumber);
5175 (*infeasible) =
FALSE;
5179#ifdef SCIP_MOREDEBUG
5203 SCIP_Bool solvenlp =
FALSE;
5221 SCIPdebugMsg(
set->scip,
"NLP solstat %d termstat %d\n", nlpsolstat, nlptermstat);
5226 (*infeasible) =
TRUE;
5238 (*infeasible) =
TRUE;
5251 eventhdlrdata->solvecip =
TRUE;
5256 (*infeasible) =
TRUE;
5262 (*lowerbound) = dualbound;
5313 SCIP_Bool uselocalvarmap;
5314 SCIP_Bool uselocalconsmap;
5317 const char* origvarname;
5321 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
5324 "be resolved. Subproblem %d is being merged into the master problem.\n", probnumber, probnumber);
5333 uselocalvarmap = (varmap ==
NULL);
5334 uselocalconsmap = (consmap ==
NULL);
5336 if( uselocalvarmap )
5342 localvarmap = varmap;
5344 if( uselocalconsmap )
5350 localconsmap = consmap;
5365 SCIP_Bool releasevar =
FALSE;
5372 if( mastervar ==
NULL )
5419 for(
i = 0;
i < nconss;
i++ )
5429 initial = (
i < nconss/2);
5445 if( uselocalvarmap )
5451 if( uselocalconsmap )
5511 for(
i = 0;
i < nconsvars;
i++ )
5547 SCIPerrorMessage(
"It is not possible to copy constraint <%s>. Benders' decomposition could not be applied.\n",
5580 for(
i = nconss - 1;
i >= 0;
i-- )
5637 for(
i = 0;
i < nblocks;
i++ )
5644 SCIP_CALL(
SCIPcopyPlugins(
set->scip, subproblems[
i],
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
5669 for(
i = 0;
i < nblocks;
i++ )
5675 for(
i = 0;
i < nconss;
i++ )
5678 if( conslabels[
i] >= 0 )
5710 for(
i = nblocks - 1;
i >= 0;
i-- )
5739 (*mappedvar) =
NULL;
5745 SCIP_CALL( benders->bendersgetvar(
set->scip, benders,
var, mappedvar, probnumber) );
5779 benders->benderscopy = benderscopy;
5790 benders->bendersfree = bendersfree;
5801 benders->bendersinit = bendersinit;
5812 benders->bendersexit = bendersexit;
5823 benders->bendersinitpre = bendersinitpre;
5834 benders->bendersexitpre = bendersexitpre;
5845 benders->bendersinitsol = bendersinitsol;
5856 benders->bendersexitsol = bendersexitsol;
5867 benders->benderspresubsolve = benderspresubsolve;
5878 benders->benderssolvesubconvex = benderssolvesubconvex;
5889 benders->benderssolvesub = benderssolvesub;
5900 benders->benderspostsolve = benderspostsolve;
5911 benders->benderssubcomp = benderssubcomp;
5922 benders->bendersfreesub = bendersfreesub;
5932 return benders->
name;
5942 return benders->
desc;
5986 assert(probnumber >= 0 && probnumber < benders->nsubproblems);
6090 return benders->
cutlp;
6135 if( subproblem ==
NULL && (!benders->benderssolvesubconvex || !benders->benderssolvesub) )
6137 SCIPerrorMessage(
"The subproblem can only be set to NULL if both bendersSolvesubconvex%s and bendersSolvesub%s "
6138 "are defined.\n", benders->
name, benders->
name);
6215 SCIP_Bool* activeslack
6226 SCIP_Bool freesol =
FALSE;
6231 (*activeslack) =
FALSE;
6242 for(
i = 0;
i < nsubproblems && !(*activeslack);
i++ )
6268 for( j =
nvars - 1; j >=
nvars - ncontvars; j-- )
6274 (*activeslack) =
TRUE;
6389 SCIP_Bool isnonlinear
6430 SCIP_Bool isnonlinear
6473 SCIP_Bool infeasible;
6518 if( chgvarscount > 0 && chgvarscount == origintvars )
6577 if( benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL || benders->bendersfreesub !=
NULL )
6579 SCIPerrorMessage(
"The user has defined either bendersSolvesubconvex%s, bendersSolvesub%s or bendersFreesub%s. "
6580 "Thus, it is not possible to declare the independence of a subproblem.\n", benders->
name, benders->
name,
6586 SCIP_Bool activesubprob;
6624 SCIP_Bool activesubprob;
6718 SCIP_Real lowerbound
6728 SCIPdebugMessage(
"The lowerbound %g for subproblem %d is less than the currently stored lower bound %g\n",
6772 assert(cutidx >= 0 && cutidx < benders->nstoredcuts);
6809 assert(cutidx >= 0 && cutidx < benders->nstoredcuts);
6816 if( varssize >= *
nvars )
6826 (*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)
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)
static SCIP_RETCODE initialiseSubproblem(SCIP_BENDERS *benders, SCIP_SET *set, int probnumber, SCIP_Bool *success)
static SCIP_RETCODE initialiseLPSubproblem(SCIP_BENDERS *benders, SCIP_SET *set, 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 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)
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 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 * 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
datastructures for Benders' decomposition cuts techniques
#define SCIP_DECL_BENDERSFREESUB(x)
#define SCIP_DECL_BENDERSCREATESUB(x)
#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)
@ 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
#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
#define SCIP_DECL_SORTPTRCOMP(x)
#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
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_VarData SCIP_VARDATA
@ SCIP_VARTYPE_CONTINUOUS
enum SCIP_Vartype SCIP_VARTYPE