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
79#define BENDERS_MAXPSEUDOSOLS 5
82#define BENDERS_ARRAYSIZE 1000
84#define AUXILIARYVAR_NAME "##bendersauxiliaryvar"
85#define SLACKVAR_NAME "##bendersslackvar"
87#define NLINEARCONSHDLRS 5
90#define NODEFOCUS_EVENTHDLR_NAME "bendersnodefocus"
91#define NODEFOCUS_EVENTHDLR_DESC "node focus event handler for Benders' decomposition"
93#define MIPNODEFOCUS_EVENTHDLR_NAME "bendersmipsolvenodefocus"
94#define MIPNODEFOCUS_EVENTHDLR_DESC "node focus event handler for the MIP solve method for Benders' decomposition"
96#define UPPERBOUND_EVENTHDLR_NAME "bendersupperbound"
97#define UPPERBOUND_EVENTHDLR_DESC "found solution event handler to terminate subproblem solve for a given upper bound"
99#define NODESOLVED_EVENTHDLR_NAME "bendersnodesolved"
100#define NODESOLVED_EVENTHDLR_DESC "node solved event handler for the Benders' integer cuts"
104struct SCIP_EventhdlrData
108 SCIP_Real upperbound;
125 eventhdlrdata->filterpos = -1;
126 eventhdlrdata->numruns = 0;
128 eventhdlrdata->solvecip =
FALSE;
168 if( eventhdlrdata->filterpos >= 0 )
171 eventhdlrdata->filterpos = -1;
240 eventhdlrdata->filterpos = -1;
313 if( eventhdlrdata->numruns == 0 && !eventhdlrdata->solvecip )
319 eventhdlrdata->filterpos = -1;
321 eventhdlrdata->numruns++;
476 eventhdlrdata->upperbound = upperbound;
524 for(
i = 0;
i < nsubproblems;
i++)
635#ifdef SCIP_DISABLED_CODE
684 SCIP_Bool shareauxvars;
689 vardata->vartype = -1;
697 shareauxvars =
FALSE;
757 SCIP_Bool shareauxvars;
767 vardata->vartype = -1;
774 shareauxvars =
FALSE;
846 for(
i = 0;
i < nsubproblems;
i++ )
933 SCIP_Bool threadsafe,
1007 SCIP_Bool cutpseudo,
1009 SCIP_Bool shareauxvars,
1039 SCIPerrorMessage(
"Benders' decomposition <%s> requires that if bendersFreesub%s is implemented, then at least "
1040 "one of bendersSolvesubconvex%s or bendersSolvesub%s are implemented.\n", name, name, name, name);
1048 (*benders)->priority = priority;
1049 (*benders)->cutlp = cutlp;
1050 (*benders)->cutpseudo = cutpseudo;
1051 (*benders)->cutrelax = cutrelax;
1052 (*benders)->shareauxvars = shareauxvars;
1068 (*benders)->bendersdata = bendersdata;
1081 "should Benders' cuts be generated for LP solutions?", &(*benders)->cutlp,
FALSE, cutlp,
NULL,
NULL) );
1085 "should Benders' cuts be generated for pseudo solutions?", &(*benders)->cutpseudo,
FALSE, cutpseudo,
NULL,
NULL) );
1089 "should Benders' cuts be generated for relaxation solutions?", &(*benders)->cutrelax,
FALSE, cutrelax,
NULL,
NULL) );
1096 "should Benders' cuts from LNS heuristics be transferred to the main SCIP instance?", &(*benders)->transfercuts,
1106 "maximum depth at which the LNS check is performed (-1: no limit)", &(*benders)->lnsmaxdepth,
TRUE,
1111 "the maximum number of Benders' decomposition calls in LNS heuristics (-1: no limit)", &(*benders)->lnsmaxcalls,
1116 "the maximum number of root node Benders' decomposition calls in LNS heuristics (-1: no limit)",
1121 "should the transferred cuts be added as constraints?", &(*benders)->cutsasconss,
FALSE,
1126 "fraction of subproblems that are solved in each iteration", &(*benders)->subprobfrac,
FALSE,
1131 "should the auxiliary variable bound be updated by solving the subproblem?", &(*benders)->updateauxvarbound,
1136 "if the subproblem objective is integer, then define the auxiliary variables as implicit integers?",
1141 "should Benders' cuts be generated while checking solutions?",
1146 "the convex combination multiplier for the cut strengthening", &(*benders)->convexmult,
FALSE,
1151 "the maximum number of cut strengthening without improvement", &(*benders)->noimprovelimit,
TRUE,
1156 "the constant use to perturb the cut strengthening core point", &(*benders)->perturbeps,
FALSE,
1161 "should the core point cut strengthening be employed (only applied to fractional solutions or continuous subproblems)?",
1166 "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)",
1171 "the number of threads to use when solving the subproblems", &(*benders)->numthreads,
TRUE,
1176 "should a feasibility phase be executed during the root node, i.e. adding slack variables to constraints to ensure feasibility",
1181 "the initial objective coefficient of the slack variables in the subproblem", &(*benders)->slackvarcoef,
FALSE,
1186 "the maximal objective coefficient of the slack variables in the subproblem", &(*benders)->maxslackvarcoef,
FALSE,
1191 "should the constraints of the subproblems be checked for convexity?", &(*benders)->checkconsconvexity,
FALSE,
1210 SCIP_Bool cutpseudo,
1212 SCIP_Bool shareauxvars,
1261 for(
i = 0;
i < nentries; ++
i )
1289 assert(!(*benders)->initialized);
1293 if( (*benders)->bendersfree !=
NULL )
1295 SCIP_CALL( (*benders)->bendersfree(
set->scip, *benders) );
1301 if( (*benders)->iscopy && (*benders)->mastervarsmap !=
NULL )
1308 for(
i = 0;
i < (*benders)->nbenderscuts;
i++ )
1362 "This is not supported and the slack variable will not be added to the constraint. Feasibility cuts may be invalid.\n",
1674#ifdef SCIP_MOREDEBUG
1716#ifdef SCIP_MOREDEBUG
1723#ifdef SCIP_MOREDEBUG
1730#ifdef SCIP_MOREDEBUG
1808 for(
i = 0;
i < nsubproblems;
i++ )
1811 SCIP_CALL( benders->benderscreatesub(
set->scip, benders,
i) );
1842 SCIP_Bool objchanged =
FALSE;
1854 "coefficient of copy of master problem variable <%s> in subproblem %d to zero.\n",
1866 "copied of master problem variables has been changed to zero.\n");
1908 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL
1922 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL
1956 SCIPerrorMessage(
"If the subproblem is set to NULL, then the subproblem type must be specified.\n");
1957 SCIPerrorMessage(
"In the subproblem creation callback, call SCIPbendersSetSubproblemType with the appropriate problem type.\n");
1992 if(
set->misc_resetstat )
2005 if( benders->bendersinit !=
NULL )
2240 if( benders->bendersexit !=
NULL )
2267 for(
i = 0;
i < nsubproblems;
i++ )
2327 for(
i = 0;
i < nsubproblems;
i++ )
2334 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL
2335 && benders->bendersfreesub ==
NULL )
2382 if( benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL )
2390 if( benders->bendersinitpre !=
NULL )
2395 SCIP_CALL( benders->bendersinitpre(
set->scip, benders) );
2417 if( benders->bendersexitpre !=
NULL )
2422 SCIP_CALL( benders->bendersexitpre(
set->scip, benders) );
2443 if( benders->bendersinitsol !=
NULL )
2448 SCIP_CALL( benders->bendersinitsol(
set->scip, benders) );
2480 for(
i = 0;
i < nsubproblems;
i++ )
2493 if( benders->bendersexitsol !=
NULL )
2498 SCIP_CALL( benders->bendersexitsol(
set->scip, benders) );
2538 set->nactivebenders++;
2626 for(
i = 0;
i < nsubproblems;
i++ )
2641 set->nactivebenders--;
2647 for(
i = nsubproblems - 1;
i >= 0;
i-- )
2697 for(
i = 0;
i < nsubproblems;
i++ )
2700 SCIP_Real lowerbound;
2701 SCIP_Bool infeasible;
2767 SCIP_Real timelimit;
2788 if ( timelimit > 0.0 )
2832 SCIP_Bool* infeasible,
2847 (*skipsolve) =
FALSE;
2951 SCIPsetDebugMsg(
set,
"solving Benders' decomposition subproblems with stabilised point.\n");
2956 SCIPsetDebugMsg(
set,
"solved Benders' decomposition subproblems with stabilised point. noimprovecount %d result %d\n",
2961 (*skipsolve) =
TRUE;
2985 SCIP_Bool subscipsoff
3050 (*solveidx)[(*nsolveidx)] = solvestat->
idx;
3087 /(SCIP_Real)(solvestat->
ncalls + 1);
3120 SCIP_Bool* infeasible,
3175#ifndef __INTEL_COMPILER
3176 #pragma omp parallel for num_threads(numthreads) private(i) reduction(&&:locoptimal) reduction(||:locinfeasible) reduction(+:locnverified) reduction(||:locstopped) reduction(min:retcode)
3189 (*subprobsolved)[
i] =
FALSE;
3231 SCIPsetDebugMsg(
set,
"Benders' decomposition: subproblem %d is not active, but has not been solved."
3232 " setting status to UNKNOWN\n",
i);
3248 SCIPsetDebugMsg(
set,
"Benders' decomposition: subproblem %d is not active, setting status to OPTIMAL\n",
i);
3251 (*subprobsolved)[
i] =
TRUE;
3272 (*subprobsolved)[
i] = solved;
3445 for(
j = 0;
j < nbenderscuts;
j++ )
3513 (*mergecands)[(*nmergecands)] =
i;
3525 (*mergecands)[(*nmergecands)] = (*mergecands)[(*npriomergecands)];
3526 (*mergecands)[(*npriomergecands)] =
i;
3527 (*npriomergecands)++;
3532 (*mergecands)[(*nmergecands)] =
i;
3582 SCIP_Bool* infeasible,
3615#ifdef SCIP_MOREDEBUG
3625 (*infeasible) =
FALSE;
3705 SCIPerrorMessage(
"the user-defined pre subproblem solving method for the Benders' decomposition <%s> returned "
3706 "invalid result <%d>\n", benders->
name, *
result);
3713 SCIPsetDebugMsg(
set,
"skipping the subproblem solving for Benders' decomposition <%s>. "
3714 "returning result <%d>\n", benders->
name, *
result);
3740 SCIPsetDebugMsg(
set,
"skipping the subproblem solving because cut strengthening found a cut "
3741 "for Benders' decomposition <%s>. Returning result <%d>\n", benders->
name, *
result);
3766 while(
nsolved < nsubproblems )
3782 if( benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL )
3841 SCIPsetDebugMsg(
set,
"End Benders' decomposition subproblem solve. result %d infeasible %u auxviol %u nverified %d\n",
3874 for(
i = 0;
i < nsubproblems;
i++ )
3885 "limit of %d. All active subproblems are merge candidates, with subproblem %d a priority candidate.\n",
3907 SCIPerrorMessage(
"An error was found when generating cuts for non-optimal subproblems of Benders' "
3908 "decomposition <%s>. Consider merging the infeasible subproblems into the master problem.\n",
SCIPbendersGetName(benders));
3960 if( benders->benderspostsolve !=
NULL )
3967 checkint, (*infeasible), &merged) );
3980 SCIPerrorMessage(
"An error occurred during Benders' decomposition cut generations and no merging had been "
3981 "performed. It is not possible to continue solving the problem by Benders' decomposition\n");
3988 nfree = nsubproblems;
4009 for(
i = 0;
i < nsubproblems;
i++ )
4020 *infeasible, *auxviol);
4120 SCIP_Bool* infeasible,
4121 SCIP_Real* objective,
4127 assert(benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL);
4137 if( benders->benderssolvesubconvex !=
NULL )
4147 if( benders->benderssolvesub !=
NULL )
4161 SCIPerrorMessage(
"the user-defined solving method for the Benders' decomposition <%s> returned invalid result <%d>\n",
4167 (*infeasible) =
TRUE;
4172 SCIPerrorMessage(
"the user-defined solving method for the Benders' decomposition <%s> returned objective value %g\n",
4173 benders->
name, (*objective));
4193 SCIP_Bool* infeasible,
4199 SCIP_Real objective;
4214 SCIPerrorMessage(
"The subproblem %d is set to NULL, but both bendersSolvesubconvex%s and bendersSolvesub%s "
4268 (*infeasible) =
TRUE;
4277 (*infeasible) =
TRUE;
4283 if( bestsol !=
NULL )
4313 "subproblem %d. No cut will be generated for this subproblem.\n",
probnumber);
4318 SCIPerrorMessage(
"The Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4324 SCIPerrorMessage(
"Invalid status returned from solving Benders' decomposition subproblem %d. Solution status: %d\n",
4338 SCIPerrorMessage(
"The Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4344 SCIPerrorMessage(
"Invalid result <%d> from user-defined subproblem solving method. This should not happen.\n",
4378 SCIPerrorMessage(
"The subproblem %d is NULL. Thus, the subproblem setup must be performed manually in either "
4379 "bendersSolvesubconvex%s or bendersSolvesub%s.\n",
probnumber, benders->
name, benders->
name);
4510 SCIP_Bool* infeasible,
4512 SCIP_Real* objective
4519 (*infeasible) =
FALSE;
4525 SCIPerrorMessage(
"Benders' decomposition subproblem %d must be set up before calling SCIPbendersSolveSubproblem(). Call SCIPsetupSubproblem() first.\n",
probnumber);
4530 if( benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL)
4543 if( objective !=
NULL )
4561 (*infeasible) =
TRUE;
4562 if( objective !=
NULL )
4596 (*infeasible) =
TRUE;
4597 else if( objective !=
NULL )
4602 if( objective !=
NULL )
4705#ifndef SCIP_MOREDEBUG
4758 SCIP_Real* objective
4801#ifdef SCIP_MOREDEBUG
4819#ifdef SCIP_MOREDEBUG
4831 SCIPerrorMessage(
"The NLP of Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4845 SCIPerrorMessage(
"Invalid solution status: %d. Termination status: %d. Solving the NLP relaxation of Benders' decomposition subproblem %d.\n",
4875 SCIPerrorMessage(
"The LP of Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4891 "relaxation of subproblem %d. No cut will be generated for this subproblem.\n",
probnumber);
4899 SCIPerrorMessage(
"Invalid status: %d. Solving the LP relaxation of Benders' decomposition subproblem %d.\n",
4964 eventhdlrdata->solvecip =
TRUE;
4974#ifdef SCIP_EVENMOREDEBUG
4979#ifdef SCIP_MOREDEBUG
4993 SCIPerrorMessage(
"Invalid status: %d. Solving the CIP of Benders' decomposition subproblem %d.\n",
5016 || (benders->bendersfreesub ==
NULL && benders->benderssolvesubconvex ==
NULL && benders->benderssolvesub ==
NULL));
5019 if( benders->bendersfreesub !=
NULL )
5076 SCIPsetDebugMsg(
set,
"Subproblem %d - Auxiliary Variable: %g Subproblem Objective: %g Reldiff: %g Soltol: %g\n",
5112 SCIP_Real* lowerbound,
5113 SCIP_Bool* infeasible
5117 SCIP_Real dualbound;
5118 SCIP_Real memorylimit;
5119 SCIP_Real timelimit;
5129 if( benders->benderssolvesub !=
NULL || benders->benderssolvesubconvex !=
NULL )
5132 (*infeasible) =
FALSE;
5134 SCIPinfoMessage(
set->scip,
NULL,
"Benders' decomposition: a bendersSolvesub or bendersSolvesubconvex has been "
5135 "implemented. SCIPbendersComputeSubproblemLowerbound can not be executed.\n");
5137 "SCIPbendersUpdateSubproblemLowerbound in bendersCreatesub. The auxiliary variable %d will remain as %g\n",
5152 (*infeasible) =
FALSE;
5156#ifdef SCIP_MOREDEBUG
5203 (*infeasible) =
TRUE;
5216 (*infeasible) =
TRUE;
5229 eventhdlrdata->solvecip =
TRUE;
5234 (*infeasible) =
TRUE;
5240 (*lowerbound) = dualbound;
5302 "be resolved. Subproblem %d is being merged into the master problem.\n",
probnumber,
probnumber);
5397 for(
i = 0;
i < nconss;
i++ )
5407 initial = (
i < nconss/2);
5489 for(
i = 0;
i < nconsvars;
i++ )
5525 SCIPerrorMessage(
"It is not possible to copy constraint <%s>. Benders' decomposition could not be applied.\n",
5558 for(
i = nconss - 1;
i >= 0;
i-- )
5615 for(
i = 0;
i < nblocks;
i++ )
5622 SCIP_CALL(
SCIPcopyPlugins(
set->scip, subproblems[
i],
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
5647 for(
i = 0;
i < nblocks;
i++ )
5653 for(
i = 0;
i < nconss;
i++ )
5688 for(
i = nblocks - 1;
i >= 0;
i-- )
5717 (*mappedvar) =
NULL;
5910 return benders->
name;
5920 return benders->
desc;
6068 return benders->
cutlp;
6113 if(
subproblem ==
NULL && (!benders->benderssolvesubconvex || !benders->benderssolvesub) )
6115 SCIPerrorMessage(
"The subproblem can only be set to NULL if both bendersSolvesubconvex%s and bendersSolvesub%s "
6116 "are defined.\n", benders->
name, benders->
name);
6209 (*activeslack) =
FALSE;
6220 for(
i = 0;
i < nsubproblems && !(*activeslack);
i++ )
6252 (*activeslack) =
TRUE;
6451 SCIP_Bool infeasible;
6555 if( benders->benderssolvesubconvex !=
NULL || benders->benderssolvesub !=
NULL || benders->bendersfreesub !=
NULL )
6557 SCIPerrorMessage(
"The user has defined either bendersSolvesubconvex%s, bendersSolvesub%s or bendersFreesub%s. "
6558 "Thus, it is not possible to declare the independence of a subproblem.\n", benders->
name, benders->
name,
6696 SCIP_Real lowerbound
6706 SCIPdebugMessage(
"The lowerbound %g for subproblem %d is less than the currently stored lower bound %g\n",
6794 if( varssize >= *
nvars )
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_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)
#define SCIPsolveNLP(...)
SCIP_Real SCIPgetNLPObjval(SCIP *scip)
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)
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
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)
enum SCIP_NlpSolStat SCIP_NLPSOLSTAT
@ SCIP_NLPTERMSTAT_TIMELIMIT
@ 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