SCIP_EventhdlrData
124assert(eventhdlrdata !=
NULL);
126eventhdlrdata->filterpos = -1;
127eventhdlrdata->numruns = 0;
129eventhdlrdata->solvecip =
FALSE;
145assert(eventhdlr !=
NULL);
165assert(eventhdlr !=
NULL);
169 if( eventhdlrdata->filterpos >= 0 )
172eventhdlrdata->filterpos = -1;
188assert(eventhdlr !=
NULL);
208assert(eventhdlr !=
NULL);
211assert(eventhdlrdata !=
NULL);
231assert(eventhdlr !=
NULL);
241eventhdlrdata->filterpos = -1;
251assert(eventhdlr !=
NULL);
264assert(eventhdlr !=
NULL);
277assert(eventhdlr !=
NULL);
290assert(eventhdlr !=
NULL);
308assert(eventhdlr !=
NULL);
314 if( eventhdlrdata->numruns == 0 && !eventhdlrdata->solvecip )
320eventhdlrdata->filterpos = -1;
322eventhdlrdata->numruns++;
332assert(eventhdlr !=
NULL);
345assert(eventhdlr !=
NULL);
358assert(eventhdlr !=
NULL);
371assert(eventhdlr !=
NULL);
389assert(eventhdlr !=
NULL);
393assert(eventhdlrdata !=
NULL);
410assert(eventhdlr !=
NULL);
423assert(eventhdlr !=
NULL);
436assert(eventhdlr !=
NULL);
449assert(eventhdlr !=
NULL);
468assert(benders !=
NULL);
469assert(probnumber >= 0 && probnumber < benders->nsubproblems);
472assert(eventhdlr !=
NULL);
475assert(eventhdlrdata !=
NULL);
477eventhdlrdata->upperbound = upperbound;
500assert(masterprob !=
NULL);
501assert(benders !=
NULL);
516 for( i = 0; i < nvars; i++ )
525 for( i = 0; i < nsubproblems; i++)
542 SCIPdebugMsg(masterprob,
"Cut constant for subproblem %d: %g\n", i,
560assert(eventhdlr !=
NULL);
583assert(eventhdlr !=
NULL);
613assert(elem1 !=
NULL);
614assert(elem2 !=
NULL);
621 returnsolvestat1->
idx- solvestat2->
idx;
627 intavgiterdiff = (int)solvestat2->
avgiter- (
int)solvestat1->
avgiter;
629 if( avgiterdiff != 0 )
632 returnsolvestat1->
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 )
690vardata->vartype = -1;
698shareauxvars =
FALSE;
700shareauxvars =
TRUE;
764assert(benders !=
NULL);
768vardata->vartype = -1;
775shareauxvars =
FALSE;
777shareauxvars =
TRUE;
795 while( targetvar ==
NULL&& j <= subscipdepth )
807(void) strncpy(prefix, tmpprefix, len);
812 if( targetvar !=
NULL)
843assert(benders !=
NULL);
847 for( i = 0; i < nsubproblems; i++ )
850 if( subproblem !=
NULL)
878assert(paramdata !=
NULL);
900assert(benders !=
NULL);
901assert(sourceset !=
NULL);
902assert(benders->
iscopy);
912 for( i = 0; i < nvars; i++ )
917 if( targetvar !=
NULL)
941assert(benders !=
NULL);
942assert(targetset !=
NULL);
943assert(valid !=
NULL);
951 SCIP_CALL( benders->benderscopy(targetset->
scip, benders, threadsafe) );
982 if( varmap !=
NULL)
1032assert(benders !=
NULL);
1033assert(name !=
NULL);
1034assert(desc !=
NULL);
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,
1238assert(benders !=
NULL);
1239assert(name !=
NULL);
1240assert(desc !=
NULL);
1243cutrelax, shareauxvars, benderscopy, bendersfree, bendersinit, bendersexit, bendersinitpre, bendersexitpre,
1244bendersinitsol, bendersexitsol, bendersgetvar, benderscreatesub, benderspresubsolve, benderssolvesubconvex,
1245benderssolvesub, benderspostsolve, bendersfreesub, bendersdata), (
void)
SCIPbendersFree(benders,
set) );
1262assert(benders !=
NULL);
1268 for( i = 0; i < nentries; ++i )
1273 if( entry !=
NULL)
1294assert(benders !=
NULL);
1295assert(*benders !=
NULL);
1296assert(!(*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 intnlinearconshdlrs
1354linearcons =
FALSE;
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",
1456assert(benders !=
NULL);
1501assert(benders !=
NULL);
1503assert(success !=
NULL);
1505(*success) =
FALSE;
1506(*infeasible) =
FALSE;
1509assert(subproblem !=
NULL);
1522(*success) = !(*infeasible);
1545assert(benders !=
NULL);
1547assert(infeasible !=
NULL);
1550assert(subproblem !=
NULL);
1558eventExecBendersNodefocus, eventhdlrdata) );
1563assert(eventhdlr !=
NULL);
1606assert(benders !=
NULL);
1610assumevarfixed =
NULL;
1611 if( probnumber >= 0 )
1614subproblem =
set->scip;
1616assert(subproblem !=
NULL);
1618convexcons =
FALSE;
1619discretevar =
FALSE;
1620isnonlinear =
FALSE;
1626 if( nbinvars != 0 || nintvars != 0 || nimplintvars != 0 )
1628discretevar =
TRUE;
1653 if( probnumber >= 0 && nlconshdlr !=
NULL)
1660 for( i = 0; i < nvars; i++ )
1666 if( mappedvar !=
NULL)
1679 if( conshdlr == linearconshdlrs[j] )
1685#ifdef SCIP_MOREDEBUG 1692 if( conshdlr == nlconshdlr )
1699isnonlinear =
TRUE;
1703 if( havelhs && haverhs )
1727#ifdef SCIP_MOREDEBUG 1734#ifdef SCIP_MOREDEBUG 1741#ifdef SCIP_MOREDEBUG 1756 if( probnumber >= 0 )
1760 if( convexcons && !discretevar )
1762 else if( convexcons && discretevar )
1764 else if( !convexcons && !discretevar )
1766 else if( !convexcons && discretevar )
1773 if( probnumber >= 0 )
1778 if( probnumber >= 0 )
1785 if( assumevarfixed !=
NULL)
1807assert(benders !=
NULL);
1819 for( i = 0; i < nsubproblems; i++ )
1822 SCIP_CALL( benders->benderscreatesub(
set->scip, benders, i) );
1833 if( subproblem !=
NULL)
1856 for( j = 0; j < nvars; j++ )
1865 "coefficient of copy of master problem variable <%s> in subproblem %d to zero.\n",
1877 "copied of master problem variables has been changed to zero.\n");
1919 if( benders->benderssolvesubconvex ==
NULL&& benders->benderssolvesub ==
NULL 1941 if( benders->benderssolvesubconvex ==
NULL&& benders->benderssolvesub ==
NULL 1957assert(eventhdlr !=
NULL);
1966assert(eventhdlr !=
NULL);
1975 SCIPerrorMessage(
"If the subproblem is set to NULL, then the subproblem type must be specified.\n");
1976 SCIPerrorMessage(
"In the subproblem creation callback, call SCIPbendersSetSubproblemType with the appropriate problem type.\n");
2002assert(benders !=
NULL);
2011 if(
set->misc_resetstat )
2024 if( benders->bendersinit !=
NULL)
2026 SCIP_CALL( benders->bendersinit(
set->scip, benders) );
2097assert(sourcescip !=
NULL);
2098assert(benders !=
NULL);
2099assert(vars !=
NULL);
2100assert(vals !=
NULL);
2130 for( i = 0; i < nvars; i++ )
2143 if( sourcevar ==
NULL)
2151assert( transfercons !=
NULL);
2156assert( transfercut !=
NULL);
2208assert(subscip !=
NULL);
2209assert(benders !=
NULL);
2222 for( i = 0; i < naddedcuts; i++ )
2247assert(benders !=
NULL);
2259 if( benders->bendersexit !=
NULL)
2261 SCIP_CALL( benders->bendersexit(
set->scip, benders) );
2273 for( i = benders->
nstoredcuts- 1; i >= 0; i-- )
2286 for( i = 0; i < nsubproblems; i++ )
2338assert(benders !=
NULL);
2346 for( i = 0; i < nsubproblems; i++ )
2353 if( benders->benderssolvesubconvex ==
NULL&& benders->benderssolvesub ==
NULL 2354&& benders->bendersfreesub ==
NULL)
2356independent =
TRUE;
2358 for( j = 0; j < nvars; j++ )
2366 if( subprobvar !=
NULL)
2368independent =
FALSE;
2388assert(benders !=
NULL);
2390assert(stat !=
NULL);
2401 if( benders->benderssolvesubconvex ==
NULL&& benders->benderssolvesub ==
NULL)
2409 if( benders->bendersinitpre !=
NULL)
2414 SCIP_CALL( benders->bendersinitpre(
set->scip, benders) );
2431assert(benders !=
NULL);
2433assert(stat !=
NULL);
2436 if( benders->bendersexitpre !=
NULL)
2441 SCIP_CALL( benders->bendersexitpre(
set->scip, benders) );
2458assert(benders !=
NULL);
2462 if( benders->bendersinitsol !=
NULL)
2467 SCIP_CALL( benders->bendersinitsol(
set->scip, benders) );
2492assert(benders !=
NULL);
2499 for( i = 0; i < nsubproblems; i++ )
2512 if( benders->bendersexitsol !=
NULL)
2517 SCIP_CALL( benders->bendersexitsol(
set->scip, benders) );
2550assert(benders !=
NULL);
2557 set->nactivebenders++;
2582benders->benderssubcomp ==
NULL? benderssubcompdefault : benders->benderssubcomp,
NULL) );
2603solvestat->
idx= i;
2617eventExecBendersNodesolved, eventhdlrdata) );
2619assert(eventhdlr !=
NULL);
2633assert(benders !=
NULL);
2645 for( i = 0; i < nsubproblems; i++ )
2660 set->nactivebenders--;
2666 for( i = nsubproblems - 1; i >= 0; i-- )
2693assert(benders !=
NULL);
2695 returnbenders->
active;
2709assert(benders !=
NULL);
2716 for( i = 0; i < nsubproblems; i++ )
2722infeasible =
FALSE;
2765assert(benders !=
NULL);
2807 if( timelimit > 0.0 )
2828 for( i = 0; i < nvars; i++ )
2862assert(benders !=
NULL);
2866(*skipsolve) =
FALSE;
2915assert(vars !=
NULL);
2918 for( i = 0; i < nvars; i++ )
2928newsolval = lpsolval;
2970 SCIPsetDebugMsg(
set,
"solving Benders' decomposition subproblems with stabilised point.\n");
2975 SCIPsetDebugMsg(
set,
"solved Benders' decomposition subproblems with stabilised point. noimprovecount %d result %d\n",
2980(*skipsolve) =
TRUE;
3048 intsubproblemcount;
3050assert(benders !=
NULL);
3052assert((*solveidx) !=
NULL);
3053assert(nsolveidx !=
NULL);
3063subproblemcount = 0;
3064 while( subproblemcount < nsubproblems && subproblemcount < numtocheck )
3069(*solveidx)[(*nsolveidx)] = solvestat->
idx;
3087assert(benders !=
NULL);
3088assert(solveidx !=
NULL);
3090 for( i = 0; i < nsolveidx; i++ )
3096solvestat = benders->
solvestat[solveidx[i]];
3097assert(solvestat->
idx== solveidx[i]);
3102 if( subproblem ==
NULL)
3153 intlocnverified = *nverified;
3160assert(benders !=
NULL);
3180 SCIPsetDebugMsg(
set,
"Performing the subproblem solving process. Number of subproblems to check %d\n", nsolveidx);
3187locinfeasible =
TRUE;
3194#ifndef __INTEL_COMPILER 3195 #pragma omp parallel for num_threads(numthreads) private(i) reduction(&&:locoptimal) reduction(||:locinfeasible) reduction(+:locnverified) reduction(||:locstopped) reduction(min:retcode) 3197 for( j = 0; j < nsolveidx; j++ )
3208(*subprobsolved)[i] =
FALSE;
3248locoptimal =
FALSE;
3250 SCIPsetDebugMsg(
set,
"Benders' decomposition: subproblem %d is not active, but has not been solved." 3251 " setting status to UNKNOWN\n", i);
3267 SCIPsetDebugMsg(
set,
"Benders' decomposition: subproblem %d is not active, setting status to OPTIMAL\n", i);
3270(*subprobsolved)[i] =
TRUE;
3276 else if( solvesub )
3291(*subprobsolved)[i] = solved;
3293locinfeasible = locinfeasible || subinfeas;
3301 if( checkint && (*subprobsolved)[i] )
3312 if( subproboptimal )
3325 if( convexsub || onlyconvexcheck
3328locoptimal = locoptimal && subproboptimal;
3333 if( subproboptimal )
3360|| onlyconvexcheck )
3373 SCIPsetDebugMsg(
set,
"Local variable values: nverified %d infeasible %u optimal %u stopped %u\n", locnverified,
3374locinfeasible, locoptimal, locstopped);
3375*nverified = locnverified;
3376*infeasible = locinfeasible;
3377*optimal = locoptimal;
3378*stopped = locstopped;
3411 int* npriomergecands,
3425assert(benders !=
NULL);
3447 for( k = 0; k < nsolveidx; k++ )
3464 for( j = 0; j < nbenderscuts; j++ )
3469assert(benderscuts[j] !=
NULL);
3490subprobresult = cutresult;
3501subprobresult = cutresult;
3503subprobresult = cutresult;
3513solveloopresult = subprobresult;
3519solveloopresult = subprobresult;
3525solveloopresult = subprobresult;
3532(*mergecands)[(*nmergecands)] = i;
3544(*mergecands)[(*nmergecands)] = (*mergecands)[(*npriomergecands)];
3545(*mergecands)[(*npriomergecands)] = i;
3546(*npriomergecands)++;
3551(*mergecands)[(*nmergecands)] = i;
3562(*result) = solveloopresult;
3568(*result) = solveloopresult;
3574(*result) = solveloopresult;
3579&& checkint && !onlyconvexcheck )
3608 intsubproblemcount;
3613 intnpriomergecands;
3632 SCIPsetDebugMsg(
set,
"Starting Benders' decomposition subproblem solving. type %d checkint %u\n", type, checkint);
3634#ifdef SCIP_MOREDEBUG 3643(*auxviol) =
FALSE;
3644(*infeasible) =
FALSE;
3656assert(benders !=
NULL);
3657assert(result !=
NULL);
3658assert(infeasible !=
NULL);
3659assert(auxviol !=
NULL);
3665 if( benders->
iscopy&&
set->subscipsoff
3714 SCIP_CALL( benders->benderspresubsolve(
set->scip, benders, sol, type, checkint, infeasible, auxviol, &skipsolve,
3724 SCIPerrorMessage(
"the user-defined pre subproblem solving method for the Benders' decomposition <%s> returned " 3725 "invalid result <%d>\n", benders->
name, *result);
3732 SCIPsetDebugMsg(
set,
"skipping the subproblem solving for Benders' decomposition <%s>. " 3733 "returning result <%d>\n", benders->
name, *result);
3753&skipsolve, result) );
3759 SCIPsetDebugMsg(
set,
"skipping the subproblem solving because cut strengthening found a cut " 3760 "for Benders' decomposition <%s>. Returning result <%d>\n", benders->
name, *result);
3772npriomergecands = 0;
3785 while( nsolved < nsubproblems )
3796 for( l = 0; l < nsolveloops; l++ )
3801 if( benders->benderssolvesubconvex !=
NULL|| benders->benderssolvesub !=
NULL)
3813solveidx, nsolveidx, &subprobsolved, &substatus, infeasible, &optimal, &stopped) );
3825substatus, solveidx, nsolveidx, &mergecands, &npriomergecands, &nmergecands, &nsolveloops) );
3839nsolved += nsolveidx;
3842 for( i = 0; i < nsolveidx; i++ )
3843executedidx[nexecutedidx++] = solveidx[i];
3858allverified = (nverified == nsubproblems);
3860 SCIPsetDebugMsg(
set,
"End Benders' decomposition subproblem solve. result %d infeasible %u auxviol %u nverified %d\n",
3861*result, *infeasible, *auxviol, nverified);
3886 if( npriomergecands == 0 )
3892npriomergecands = 1;
3893 for( i = 0; i < nsubproblems; i++ )
3898mergecands[nmergecands] = i;
3904 "limit of %d. All active subproblems are merge candidates, with subproblem %d a priority candidate.\n",
3926 SCIPerrorMessage(
"An error was found when generating cuts for non-optimal subproblems of Benders' " 3927 "decomposition <%s>. Consider merging the infeasible subproblems into the master problem.\n",
SCIPbendersGetName(benders));
3943 if( (*infeasible) || !allverified )
3953(*auxviol) = !optimal;
3962 if( (*infeasible) || !allverified )
3972(*auxviol) = !optimal;
3979 if( benders->benderspostsolve !=
NULL)
3985 SCIP_CALL( benders->benderspostsolve(
set->scip, benders, sol, type, mergecands, npriomergecands, nmergecands,
3986checkint, (*infeasible), &merged) );
3997 else if( !success )
3999 SCIPerrorMessage(
"An error occurred during Benders' decomposition cut generations and no merging had been " 4000 "performed. It is not possible to continue solving the problem by Benders' decomposition\n");
4007nfree = nsubproblems;
4009nfree = nexecutedidx;
4012subproblemcount = 0;
4013 while( subproblemcount < nfree )
4018subidx = subproblemcount;
4020subidx = executedidx[subproblemcount];
4028 for( i = 0; i < nsubproblems; i++ )
4038 SCIPsetDebugMsg(
set,
"End Benders' decomposition execution method. result %d infeasible %u auxviol %u\n", *result,
4039*infeasible, *auxviol);
4054 if( !success && !stopped )
4064&skipsolve, &perturbresult) );
4068(*result) = perturbresult;
4070success = skipsolve;
4088 SCIPsetDebugMsg(
set,
"Type: %d Active slack: %u Feasibility Phase: %u\n", type, activeslack,
4144assert(benders !=
NULL);
4145assert(probnumber >= 0 && probnumber < benders->nsubproblems);
4146assert(benders->benderssolvesubconvex !=
NULL|| benders->benderssolvesub !=
NULL);
4156 if( benders->benderssolvesubconvex !=
NULL)
4158 SCIP_CALL( benders->benderssolvesubconvex(
set->scip, benders, sol, probnumber,
4166 if( benders->benderssolvesub !=
NULL)
4168 SCIP_CALL( benders->benderssolvesub(
set->scip, benders, sol, probnumber, objective, result) );
4180 SCIPerrorMessage(
"the user-defined solving method for the Benders' decomposition <%s> returned invalid result <%d>\n",
4181benders->
name, *result);
4186(*infeasible) =
TRUE;
4191 SCIPerrorMessage(
"the user-defined solving method for the Benders' decomposition <%s> returned objective value %g\n",
4192benders->
name, (*objective));
4221assert(benders !=
NULL);
4222assert(probnumber >= 0 && probnumber < benders->nsubproblems);
4224 SCIPsetDebugMsg(
set,
"Benders' decomposition: solving subproblem %d\n", probnumber);
4231 if( subproblem ==
NULL&& (benders->benderssolvesubconvex ==
NULL|| benders->benderssolvesub ==
NULL) )
4233 SCIPerrorMessage(
"The subproblem %d is set to NULL, but both bendersSolvesubconvex%s and bendersSolvesub%s " 4234 "are not defined.\n", probnumber, benders->
name, benders->
name);
4252 else if( subproblem !=
NULL)
4287(*infeasible) =
TRUE;
4296(*infeasible) =
TRUE;
4302 if( bestsol !=
NULL)
4332 "subproblem %d. No cut will be generated for this subproblem.\n", probnumber);
4337 SCIPerrorMessage(
"The Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4343 SCIPerrorMessage(
"Invalid status returned from solving Benders' decomposition subproblem %d. Solution status: %d\n",
4344probnumber, solvestatus);
4357 SCIPerrorMessage(
"The Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4363 SCIPerrorMessage(
"Invalid result <%d> from user-defined subproblem solving method. This should not happen.\n",
4388assert(benders !=
NULL);
4395 if( subproblem ==
NULL)
4397 SCIPerrorMessage(
"The subproblem %d is NULL. Thus, the subproblem setup must be performed manually in either " 4398 "bendersSolvesubconvex%s or bendersSolvesub%s.\n", probnumber, benders->
name, benders->
name);
4401assert(subproblem !=
NULL);
4422assert(success == !infeasible);
4445 for( i = 0; i < nvars; i++ )
4449 if( mastervar !=
NULL)
4543assert(benders !=
NULL);
4547assert(infeasible !=
NULL);
4548(*infeasible) =
FALSE;
4554 SCIPerrorMessage(
"Benders' decomposition subproblem %d must be set up before calling SCIPbendersSolveSubproblem(). Call SCIPsetupSubproblem() first.\n", probnumber);
4559 if( benders->benderssolvesubconvex !=
NULL|| benders->benderssolvesub !=
NULL)
4572 if( objective !=
NULL)
4573(*objective) = subobj;
4580assert(subproblem !=
NULL);
4590(*infeasible) =
TRUE;
4591 if( objective !=
NULL)
4625(*infeasible) =
TRUE;
4626 else if( objective !=
NULL)
4627(*objective) = lpobjective;
4631 if( objective !=
NULL)
4660subtimelimit =
MIN(subtimelimit, maxsubtimelimit);
4667submemorylimit =
MIN(submemorylimit, maxsubmemorylimit);
4680assert(subproblem !=
NULL);
4681assert(origparams !=
NULL);
4708assert(subproblem !=
NULL);
4734#ifndef SCIP_MOREDEBUG 4758assert(subproblem !=
NULL);
4759assert(origparams !=
NULL);
4783assert(benders !=
NULL);
4804assert(benders !=
NULL);
4805assert(solvestatus !=
NULL);
4806assert(objective !=
NULL);
4812assert(subproblem !=
NULL);
4840#ifdef SCIP_MOREDEBUG 4848 SCIPdebugMsg(
scip,
"NLP solstat %d termstat %d\n", nlpsolstat, nlptermstat);
4858#ifdef SCIP_MOREDEBUG 4870 SCIPerrorMessage(
"The NLP of Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4881 SCIPwarningMessage(
scip,
"The NLP solver stopped due to an iteration limit for Benders' decomposition subproblem %d. Consider increasing benders/%s/nlpiterlimit.\n", probnumber,
SCIPbendersGetName(benders));
4890 SCIPerrorMessage(
"Invalid solution status: %d. Termination status: %d. Solving the NLP relaxation of Benders' decomposition subproblem %d.\n",
4891nlpsolstat, nlptermstat, probnumber);
4920 SCIPerrorMessage(
"The LP of Benders' decomposition subproblem %d is unbounded. This should not happen.\n",
4936 "relaxation of subproblem %d. No cut will be generated for this subproblem.\n", probnumber);
4944 SCIPerrorMessage(
"Invalid status: %d. Solving the LP relaxation of Benders' decomposition subproblem %d.\n",
4973assert(benders !=
NULL);
4974assert(solvestatus !=
NULL);
4977assert(subproblem !=
NULL);
4998 else if( solvecip )
5009eventhdlrdata->solvecip =
TRUE;
5019#ifdef SCIP_EVENMOREDEBUG 5024#ifdef SCIP_MOREDEBUG 5038 SCIPerrorMessage(
"Invalid status: %d. Solving the CIP of Benders' decomposition subproblem %d.\n",
5039*solvestatus, probnumber);
5059assert(benders !=
NULL);
5060assert(benders->bendersfreesub !=
NULL 5061|| (benders->bendersfreesub ==
NULL&& benders->benderssolvesubconvex ==
NULL&& benders->benderssolvesub ==
NULL));
5062assert(probnumber >= 0 && probnumber < benders->nsubproblems);
5064 if( benders->bendersfreesub !=
NULL)
5066 SCIP_CALL( benders->bendersfreesub(
set->scip, benders, probnumber) );
5113assert(benders !=
NULL);
5115assert(probnumber >= 0 && probnumber < benders->nsubproblems);
5121 SCIPsetDebugMsg(
set,
"Subproblem %d - Auxiliary Variable: %g Subproblem Objective: %g Reldiff: %g Soltol: %g\n",
5141assert(benders !=
NULL);
5145assert(auxiliaryvar !=
NULL);
5171assert(benders !=
NULL);
5174 if( benders->benderssolvesub !=
NULL|| benders->benderssolvesubconvex !=
NULL)
5177(*infeasible) =
FALSE;
5179 SCIPinfoMessage(
set->scip,
NULL,
"Benders' decomposition: a bendersSolvesub or bendersSolvesubconvex has been " 5180 "implemented. SCIPbendersComputeSubproblemLowerbound can not be executed.\n");
5182 "SCIPbendersUpdateSubproblemLowerbound in bendersCreatesub. The auxiliary variable %d will remain as %g\n",
5183probnumber, (*lowerbound));
5190 " subproblem %d\n", probnumber);
5197(*infeasible) =
FALSE;
5201#ifdef SCIP_MOREDEBUG 5243 SCIPdebugMsg(
set->scip,
"NLP solstat %d termstat %d\n", nlpsolstat, nlptermstat);
5248(*infeasible) =
TRUE;
5260(*infeasible) =
TRUE;
5273eventhdlrdata->solvecip =
TRUE;
5278(*infeasible) =
TRUE;
5284(*lowerbound) = dualbound;
5339 const char* origvarname;
5341assert(benders !=
NULL);
5343assert(probnumber >= 0 && probnumber < benders->nsubproblems);
5346 "be resolved. Subproblem %d is being merged into the master problem.\n", probnumber, probnumber);
5355uselocalvarmap = (varmap ==
NULL);
5356uselocalconsmap = (consmap ==
NULL);
5358 if( uselocalvarmap )
5364localvarmap = varmap;
5366 if( uselocalconsmap )
5372localconsmap = consmap;
5384 for( i = 0; i < nvars; i++ )
5394 if( mastervar ==
NULL)
5441 for( i = 0; i < nconss; i++ )
5451initial = (i < nconss/2);
5467 if( uselocalvarmap )
5473 if( uselocalconsmap )
5515assert(subproblem !=
NULL);
5516assert(varmap !=
NULL);
5517assert(sourcecons !=
NULL);
5533 for( i = 0; i < nconsvars; i++ )
5569 SCIPerrorMessage(
"It is not possible to copy constraint <%s>. Benders' decomposition could not be applied.\n",
5597assert(conss !=
NULL);
5598assert(conslabels !=
NULL);
5599assert((vars !=
NULL&& varslabels !=
NULL) || (vars ==
NULL&& varslabels ==
NULL));
5602 for( i = nconss - 1; i >= 0; i-- )
5611 for( i = nvars - 1; i >= 0; i-- )
5633 SCIP** subproblems;
5645assert(benders !=
NULL);
5647assert(decomp !=
NULL);
5653assert(nblocks > 0);
5659 for( i = 0; i < nblocks; i++ )
5666 SCIP_CALL(
SCIPcopyPlugins(
set->scip, subproblems[i],
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
5691 for( i = 0; i < nblocks; i++ )
5697 for( i = 0; i < nconss; i++ )
5700 if( conslabels[i] >= 0 )
5732 for( i = nblocks - 1; i >= 0; i-- )
5755assert(benders !=
NULL);
5757assert(var !=
NULL);
5758assert(mappedvar !=
NULL);
5759assert(benders->bendersgetvar !=
NULL);
5761(*mappedvar) =
NULL;
5767 SCIP_CALL( benders->bendersgetvar(
set->scip, benders, var, mappedvar, probnumber) );
5777assert(benders !=
NULL);
5788assert(benders !=
NULL);
5799assert(benders !=
NULL);
5801benders->benderscopy = benderscopy;
5810assert(benders !=
NULL);
5812benders->bendersfree = bendersfree;
5821assert(benders !=
NULL);
5823benders->bendersinit = bendersinit;
5832assert(benders !=
NULL);
5834benders->bendersexit = bendersexit;
5843assert(benders !=
NULL);
5845benders->bendersinitpre = bendersinitpre;
5854assert(benders !=
NULL);
5856benders->bendersexitpre = bendersexitpre;
5865assert(benders !=
NULL);
5867benders->bendersinitsol = bendersinitsol;
5876assert(benders !=
NULL);
5878benders->bendersexitsol = bendersexitsol;
5887assert(benders !=
NULL);
5889benders->benderspresubsolve = benderspresubsolve;
5898assert(benders !=
NULL);
5900benders->benderssolvesubconvex = benderssolvesubconvex;
5909assert(benders !=
NULL);
5911benders->benderssolvesub = benderssolvesub;
5920assert(benders !=
NULL);
5922benders->benderspostsolve = benderspostsolve;
5931assert(benders !=
NULL);
5933benders->benderssubcomp = benderssubcomp;
5942assert(benders !=
NULL);
5944benders->bendersfreesub = bendersfreesub;
5952assert(benders !=
NULL);
5954 returnbenders->
name;
5962assert(benders !=
NULL);
5964 returnbenders->
desc;
5972assert(benders !=
NULL);
5984assert(benders !=
NULL);
5996assert(benders !=
NULL);
6007assert(benders !=
NULL);
6008assert(probnumber >= 0 && probnumber < benders->nsubproblems);
6018assert(benders !=
NULL);
6020 returnbenders->
ncalls;
6028assert(benders !=
NULL);
6038assert(benders !=
NULL);
6048assert(benders !=
NULL);
6058assert(benders !=
NULL);
6068assert(benders !=
NULL);
6078assert(benders !=
NULL);
6089assert(benders !=
NULL);
6100assert(benders !=
NULL);
6110assert(benders !=
NULL);
6112 returnbenders->
cutlp;
6120assert(benders !=
NULL);
6130assert(benders !=
NULL);
6140assert(benders !=
NULL);
6153assert(benders !=
NULL);
6157 if( subproblem ==
NULL&& (!benders->benderssolvesubconvex || !benders->benderssolvesub) )
6159 SCIPerrorMessage(
"The subproblem can only be set to NULL if both bendersSolvesubconvex%s and bendersSolvesub%s " 6160 "are defined.\n", benders->
name, benders->
name);
6176assert(benders !=
NULL);
6189assert(benders !=
NULL);
6200assert(benders !=
NULL);
6212assert(benders !=
NULL);
6216 if( objval < benders->bestsubprobobjval[probnumber] )
6228assert(benders !=
NULL);
6250assert(benders !=
NULL);
6251assert(activeslack !=
NULL);
6253(*activeslack) =
FALSE;
6264 for( i = 0; i < nsubproblems && !(*activeslack); i++ )
6290 for( j = nvars - 1; j >= nvars - ncontvars; j-- )
6296(*activeslack) =
TRUE;
6326assert(benders !=
NULL);
6350assert(benders !=
NULL);
6369assert(benders !=
NULL);
6391assert(benders !=
NULL);
6402assert(benders !=
NULL);
6414assert(benders !=
NULL);
6433assert(benders !=
NULL);
6444assert(benders !=
NULL);
6455assert(benders !=
NULL);
6465assert(benders !=
NULL);
6475assert(benders !=
NULL);
6488assert(benders !=
NULL);
6502assert(benders !=
NULL);
6524assert(benders !=
NULL);
6529assert(subproblem !=
NULL);
6539origintvars = nbinvars + nintvars + nimplvars;
6545 while( i < nbinvars + nintvars + nimplvars )
6554assert(!infeasible);
6567 if( chgvarscount > 0 && chgvarscount == origintvars )
6601assert(benders !=
NULL);
6613assert(benders !=
NULL);
6626assert(benders !=
NULL);
6633 if( benders->benderssolvesubconvex !=
NULL|| benders->benderssolvesub !=
NULL|| benders->bendersfreesub !=
NULL)
6635 SCIPerrorMessage(
"The user has defined either bendersSolvesubconvex%s, bendersSolvesub%s or bendersFreesub%s. " 6636 "Thus, it is not possible to declare the independence of a subproblem.\n", benders->
name, benders->
name,
6665assert(benders !=
NULL);
6682assert(benders !=
NULL);
6705assert(benders !=
NULL);
6718assert(benders !=
NULL);
6752assert(benders !=
NULL);
6763assert(benders !=
NULL);
6777assert(benders !=
NULL);
6784 SCIPdebugMessage(
"The lowerbound %g for subproblem %d is less than the currently stored lower bound %g\n",
6795assert(benders !=
NULL);
6806assert(benders !=
NULL);
6822assert(benders !=
NULL);
6823assert(vars !=
NULL);
6824assert(vals !=
NULL);
6825assert(lhs !=
NULL);
6826assert(rhs !=
NULL);
6827assert(nvars !=
NULL);
6828assert(cutidx >= 0 && cutidx < benders->nstoredcuts);
6859assert(benders !=
NULL);
6860assert(vars !=
NULL);
6861assert(vals !=
NULL);
6862assert(lhs !=
NULL);
6863assert(rhs !=
NULL);
6864assert(nvars !=
NULL);
6865assert(cutidx >= 0 && cutidx < benders->nstoredcuts);
6872 if( varssize >= *nvars )
6874 for( i = 0; i < *nvars; i++ )
6882(*vars)[i] = origvar;
6903assert(benders !=
NULL);
6905assert(vars !=
NULL);
6906assert(vals !=
NULL);
6916cut->
nvars= nvars;
6944assert(benders !=
NULL);
6957assert(benders !=
NULL);
6958assert(benderscut !=
NULL);
6982assert(benders !=
NULL);
6983assert(name !=
NULL);
7001assert(benders !=
NULL);
7018assert(benders !=
NULL);
7030assert(benders !=
NULL);
7031assert(benderscut !=
NULL);
7044assert(benders !=
NULL);
7059assert(benders !=
NULL);
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)
void SCIPpqueueFree(SCIP_PQUEUE **pqueue)
SCIP_RETCODE SCIPpqueueInsert(SCIP_PQUEUE *pqueue, void *elem)
int SCIPpqueueNElems(SCIP_PQUEUE *pqueue)
SCIP_RETCODE SCIPpqueueCreate(SCIP_PQUEUE **pqueue, int initsize, SCIP_Real sizefac, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_DECL_PQUEUEELEMCHGPOS((*elemchgpos)))
void * SCIPpqueueRemove(SCIP_PQUEUE *pqueue)
SCIP_Real SCIPbendersGetSetupTime(SCIP_BENDERS *benders)
void SCIPbendersSetSubproblemObjval(SCIP_BENDERS *benders, int probnumber, SCIP_Real objval)
SCIP_RETCODE SCIPbendersSolSlackVarsActive(SCIP_BENDERS *benders, SCIP_Bool *activeslack)
SCIP_Bool SCIPbendersCutRelaxation(SCIP_BENDERS *benders)
int SCIPbendersGetNTransferredCuts(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersSubproblemIsConvex(SCIP_BENDERS *benders, int probnumber)
int SCIPbendersGetNStrengthenFails(SCIP_BENDERS *benders)
int SCIPgetBendersNSubproblems(SCIP *scip, SCIP_BENDERS *benders)
SCIP_RETCODE SCIPbendersGetStoredCutOrigData(SCIP_BENDERS *benders, int cutidx, SCIP_VAR ***vars, SCIP_Real **vals, SCIP_Real *lhs, SCIP_Real *rhs, int *nvars, int varssize)
SCIP_BENDERS ** SCIPgetBenders(SCIP *scip)
void SCIPbendersSetSubproblemIsNonlinear(SCIP_BENDERS *benders, int probnumber, SCIP_Bool isnonlinear)
void SCIPbendersSetMasterIsNonlinear(SCIP_BENDERS *benders, SCIP_Bool isnonlinear)
SCIP_BENDERS * SCIPfindBenders(SCIP *scip, const char *name)
void SCIPbendersSetData(SCIP_BENDERS *benders, SCIP_BENDERSDATA *bendersdata)
SCIP_Bool SCIPbendersOnlyCheckConvexRelax(SCIP_BENDERS *benders, SCIP_Bool subscipsoff)
SCIP_Bool SCIPbendersSubproblemIsNonlinear(SCIP_BENDERS *benders, int probnumber)
int SCIPbendersGetPriority(SCIP_BENDERS *benders)
SCIP_VAR * SCIPbendersGetAuxiliaryVar(SCIP_BENDERS *benders, int probnumber)
SCIP_BENDERSCUT * SCIPfindBenderscut(SCIP_BENDERS *benders, const char *name)
const char * SCIPbendersGetDesc(SCIP_BENDERS *benders)
int SCIPbendersGetNConvexSubproblems(SCIP_BENDERS *benders)
SCIP_BENDERSSUBTYPE SCIPbendersGetSubproblemType(SCIP_BENDERS *benders, int probnumber)
SCIP_RETCODE SCIPbendersSolveSubproblemCIP(SCIP *scip, SCIP_BENDERS *benders, int probnumber, SCIP_STATUS *solvestatus, SCIP_Bool solvecip)
int SCIPbendersGetNNonlinearSubproblems(SCIP_BENDERS *benders)
void SCIPsetBendersPriority(SCIP *scip, SCIP_BENDERS *benders, int priority)
SCIP_NLPPARAM SCIPbendersGetNLPParam(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersSubproblemIsEnabled(SCIP_BENDERS *benders, int probnumber)
SCIP_RETCODE SCIPgetBendersMasterVar(SCIP *scip, SCIP_BENDERS *benders, SCIP_VAR *var, SCIP_VAR **mappedvar)
int SCIPbendersGetNStrengthenCalls(SCIP_BENDERS *benders)
SCIP_RETCODE SCIPgetBendersSubproblemVar(SCIP *scip, SCIP_BENDERS *benders, SCIP_VAR *var, SCIP_VAR **mappedvar, int probnumber)
int SCIPbendersGetNStoredCuts(SCIP_BENDERS *benders)
SCIP_RETCODE SCIPbendersSolveSubproblemLP(SCIP *scip, SCIP_BENDERS *benders, int probnumber, SCIP_STATUS *solvestatus, SCIP_Real *objective)
int SCIPbendersGetNBenderscuts(SCIP_BENDERS *benders)
void SCIPbendersSetSubproblemIsConvex(SCIP_BENDERS *benders, int probnumber, SCIP_Bool isconvex)
SCIP_Bool SCIPbendersIsActive(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersSubproblemsAreInfeasible(SCIP_BENDERS *benders)
void SCIPbendersSetSubproblemIsSetup(SCIP_BENDERS *benders, int probnumber, SCIP_Bool issetup)
SCIP_BENDERSDATA * SCIPbendersGetData(SCIP_BENDERS *benders)
const char * SCIPbendersGetName(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersCutPseudo(SCIP_BENDERS *benders)
SCIP_VAR ** SCIPbendersGetAuxiliaryVars(SCIP_BENDERS *benders)
int SCIPbendersGetNSubproblems(SCIP_BENDERS *benders)
void SCIPbendersSetSubproblemType(SCIP_BENDERS *benders, int probnumber, SCIP_BENDERSSUBTYPE subprobtype)
int SCIPbendersGetNStrengthenCutsFound(SCIP_BENDERS *benders)
void SCIPbendersUpdateSubproblemLowerbound(SCIP_BENDERS *benders, int probnumber, SCIP_Real lowerbound)
SCIP * SCIPbendersSubproblem(SCIP_BENDERS *benders, int probnumber)
SCIP_Bool SCIPbendersMasterIsNonlinear(SCIP_BENDERS *benders)
SCIP_RETCODE SCIPbendersGetStoredCutData(SCIP_BENDERS *benders, int cutidx, SCIP_VAR ***vars, SCIP_Real **vals, SCIP_Real *lhs, SCIP_Real *rhs, int *nvars)
int SCIPbendersGetNCalls(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersIsInitialized(SCIP_BENDERS *benders)
int SCIPbendersGetNCutsFound(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersShareAuxVars(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersCutLP(SCIP_BENDERS *benders)
SCIP_RETCODE SCIPbendersSetBenderscutPriority(SCIP_BENDERS *benders, SCIP_BENDERSCUT *benderscut, int priority)
SCIP_Real SCIPbendersGetTime(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersSubproblemIsIndependent(SCIP_BENDERS *benders, int probnumber)
SCIP_RETCODE SCIPsolveBendersSubproblems(SCIP *scip, SCIP_BENDERS *benders, SCIP_SOL *sol, SCIP_RESULT *result, SCIP_Bool *infeasible, SCIP_Bool *auxviol, SCIP_BENDERSENFOTYPE type, SCIP_Bool checkint)
SCIP_BENDERSCUT ** SCIPbendersGetBenderscuts(SCIP_BENDERS *benders)
SCIP_Real SCIPbendersGetSubproblemObjval(SCIP_BENDERS *benders, int probnumber)
void SCIPbendersSetSubproblemIsIndependent(SCIP_BENDERS *benders, int probnumber, SCIP_Bool isindep)
SCIP_Bool SCIPbendersInStrengthenRound(SCIP_BENDERS *benders)
SCIP_Bool SCIPbendersSubproblemIsSetup(SCIP_BENDERS *benders, int probnumber)
SCIP_Real SCIPbendersGetSubproblemLowerbound(SCIP_BENDERS *benders, int probnumber)
SCIP_Bool SCIPbenderscutIsLPCut(SCIP_BENDERSCUT *benderscut)
const char * SCIPbenderscutGetName(SCIP_BENDERSCUT *benderscut)
SCIP_Longint SCIPbenderscutGetNFound(SCIP_BENDERSCUT *benderscut)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPsetConsRemovable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPsetEventhdlrInitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINITSOL((*eventinitsol)))
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_EVENTHDLRDATA * SCIPeventhdlrGetData(SCIP_EVENTHDLR *eventhdlr)
SCIP_RETCODE SCIPsetEventhdlrExitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXITSOL((*eventexitsol)))
void SCIPeventhdlrSetData(SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTHDLRDATA *eventhdlrdata)
SCIP_RETCODE SCIPsetEventhdlrFree(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTFREE((*eventfree)))
SCIP_RETCODE SCIPsetEventhdlrExit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXIT((*eventexit)))
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 SCIPendProbing(SCIP *scip)
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 SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
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,...)
internal methods for LP management
static const char * paramname[]
#define BMSfreeMemory(ptr)
#define BMSreallocMemoryArray(ptr, num)
#define BMSduplicateMemoryArray(ptr, source, num)
#define BMSclearMemory(ptr)
#define BMSallocMemoryArray(ptr, num)
#define BMSfreeMemoryArray(ptr)
#define BMSallocBlockMemoryArray(mem, ptr, num)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)
#define BMSclearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
#define BMSfreeMemoryArrayNull(ptr)
#define BMSallocMemory(ptr)
void SCIPmessagePrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, const char *formatstr,...)
SCIP_Real SCIPconsGetLhs(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
SCIP_RETCODE SCIPconsAddCoef(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPconsGetRhs(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
SCIP_PARAMDATA * SCIPparamGetData(SCIP_PARAM *param)
int SCIPparamGetInt(SCIP_PARAM *param)
SCIP_Real SCIPparamGetRealMax(SCIP_PARAM *param)
internal methods for handling parameter settings
internal methods for storing priced variables
internal methods for storing and manipulating the main problem
public methods for message output
public data structures and miscellaneous methods
SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Bool SCIPsetGetSubscipsOff(SCIP_SET *set)
SCIP_RETCODE SCIPsetAddCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPsetAddBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPsetAddRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_BENDERS * SCIPsetFindBenders(SCIP_SET *set, const char *name)
SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_RETCODE SCIPsetGetIntParam(SCIP_SET *set, const char *name, int *value)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPsetGetRealParam(SCIP_SET *set, const char *name, SCIP_Real *value)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
internal methods for global SCIP settings
SCIP_RETCODE SCIPbendersGetVar(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_VAR *var, SCIP_VAR **mappedvar, int probnumber)
void SCIPbendersSetSolvesubconvex(SCIP_BENDERS *benders, SCIP_DECL_BENDERSSOLVESUBCONVEX((*benderssolvesubconvex)))
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)
void SCIPbendersSetPresubsolve(SCIP_BENDERS *benders, SCIP_DECL_BENDERSPRESUBSOLVE((*benderspresubsolve)))
#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 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)
void SCIPbendersSetExit(SCIP_BENDERS *benders, SCIP_DECL_BENDERSEXIT((*bendersexit)))
#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_DECL_SORTPTRCOMP(benderssubcompdefault)
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)
void SCIPbendersSetInitsol(SCIP_BENDERS *benders, SCIP_DECL_BENDERSINITSOL((*bendersinitsol)))
static SCIP_DECL_EVENTINITSOL(eventInitsolBendersNodefocus)
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 SCIPbendersSetSolvesub(SCIP_BENDERS *benders, SCIP_DECL_BENDERSSOLVESUB((*benderssolvesub)))
void SCIPbendersSetSubproblemsAreInfeasible(SCIP_BENDERS *benders, SCIP_SET *set)
void SCIPbendersSetExitsol(SCIP_BENDERS *benders, SCIP_DECL_BENDERSEXITSOL((*bendersexitsol)))
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)
static SCIP_RETCODE createAndAddTransferredCut(SCIP *sourcescip, SCIP_BENDERS *benders, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, int nvars)
SCIP_RETCODE SCIPbendersMergeSubproblemIntoMaster(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, int probnumber)
static SCIP_RETCODE doBendersCreate(SCIP_BENDERS **benders, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, SCIP_Bool cutlp, SCIP_Bool cutpseudo, SCIP_Bool cutrelax, SCIP_Bool shareauxvars, SCIP_DECL_BENDERSCOPY((*benderscopy)), SCIP_DECL_BENDERSFREE((*bendersfree)), SCIP_DECL_BENDERSINIT((*bendersinit)), SCIP_DECL_BENDERSEXIT((*bendersexit)), SCIP_DECL_BENDERSINITPRE((*bendersinitpre)), SCIP_DECL_BENDERSEXITPRE((*bendersexitpre)), SCIP_DECL_BENDERSINITSOL((*bendersinitsol)), SCIP_DECL_BENDERSEXITSOL((*bendersexitsol)), SCIP_DECL_BENDERSGETVAR((*bendersgetvar)), SCIP_DECL_BENDERSCREATESUB((*benderscreatesub)), SCIP_DECL_BENDERSPRESUBSOLVE((*benderspresubsolve)), SCIP_DECL_BENDERSSOLVESUBCONVEX((*benderssolvesubconvex)), SCIP_DECL_BENDERSSOLVESUB((*benderssolvesub)), SCIP_DECL_BENDERSPOSTSOLVE((*benderspostsolve)), SCIP_DECL_BENDERSFREESUB((*bendersfreesub)), SCIP_BENDERSDATA *bendersdata)
#define UPPERBOUND_EVENTHDLR_DESC
static SCIP_RETCODE addConstraintToBendersSubproblem(SCIP_SET *set, SCIP *subproblem, SCIP_HASHMAP *varmap, SCIP_CONS *sourcecons)
static SCIP_DECL_EVENTEXITSOL(eventExitsolBendersNodefocus)
static SCIP_RETCODE initialiseSubproblem(SCIP_BENDERS *benders, SCIP_SET *set, int probnumber, SCIP_Bool *infeasible, SCIP_Bool *success)
#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
SCIP_RETCODE SCIPbendersFree(SCIP_BENDERS **benders, SCIP_SET *set)
void SCIPbendersSetSubproblemComp(SCIP_BENDERS *benders, SCIP_DECL_SORTPTRCOMP((*benderssubcomp)))
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)
void SCIPbendersSetFreesub(SCIP_BENDERS *benders, SCIP_DECL_BENDERSFREESUB((*bendersfreesub)))
#define MIPNODEFOCUS_EVENTHDLR_DESC
static SCIP_DECL_EVENTFREE(eventFreeBendersNodefocus)
static SCIP_RETCODE releaseVarMappingHashmapVars(SCIP *scip, SCIP_BENDERS *benders)
static SCIP_RETCODE addAuxiliaryVariablesToMaster(SCIP *scip, SCIP_BENDERS *benders)
#define SCIP_DEFAULT_NOIMPROVELIMIT
static SCIP_DECL_EVENTEXIT(eventExitBendersNodefocus)
static SCIP_DECL_EVENTEXEC(eventExecBendersNodefocus)
static SCIP_RETCODE setSubproblemParams(SCIP *scip, SCIP *subproblem)
void SCIPbendersSetInit(SCIP_BENDERS *benders, SCIP_DECL_BENDERSINIT((*bendersinit)))
SCIP_RETCODE SCIPbendersDeactivate(SCIP_BENDERS *benders, SCIP_SET *set)
static SCIP_DECL_PARAMCHGD(paramChgdBendersPriority)
SCIP_RETCODE SCIPbendersStoreCut(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, int nvars)
void SCIPbendersSetCopy(SCIP_BENDERS *benders, SCIP_DECL_BENDERSCOPY((*benderscopy)))
SCIP_RETCODE SCIPbendersAddSubproblem(SCIP_BENDERS *benders, SCIP *subproblem)
#define SCIP_DEFAULT_TRANSFERCUTS
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)
void SCIPbendersSetFree(SCIP_BENDERS *benders, SCIP_DECL_BENDERSFREE((*bendersfree)))
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
#define SCIP_DEFAULT_EXECFEASPHASE
#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)
void SCIPbendersSetExitpre(SCIP_BENDERS *benders, SCIP_DECL_BENDERSEXITPRE((*bendersexitpre)))
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 SCIPbendersSetInitpre(SCIP_BENDERS *benders, SCIP_DECL_BENDERSINITPRE((*bendersinitpre)))
void SCIPbendersSetSubproblemEnabled(SCIP_BENDERS *benders, int probnumber, SCIP_Bool enabled)
void SCIPbendersSetPostsolve(SCIP_BENDERS *benders, SCIP_DECL_BENDERSPOSTSOLVE((*benderspostsolve)))
SCIP_RETCODE SCIPbendersIncludeBenderscut(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_BENDERSCUT *benderscut)
SCIP_RETCODE SCIPbendersExitpre(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_STAT *stat)
static int numSubproblemsToCheck(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_BENDERSENFOTYPE type)
SCIP_RETCODE SCIPbendersExitsol(SCIP_BENDERS *benders, SCIP_SET *set)
SCIP_RETCODE SCIPbendersSolveSubproblem(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_SOL *sol, int probnumber, SCIP_Bool *infeasible, SCIP_Bool solvecip, SCIP_Real *objective)
static void resetSubproblemObjectiveValue(SCIP_BENDERS *benders, SCIP_SET *set)
#define BENDERS_ARRAYSIZE
static SCIP_RETCODE initialiseLPSubproblem(SCIP_BENDERS *benders, SCIP_SET *set, int probnumber, SCIP_Bool *infeasible)
static SCIP_RETCODE createMasterVarMapping(SCIP_BENDERS *benders, SCIP_SET *sourceset, SCIP_HASHMAP *varmap)
#define NODESOLVED_EVENTHDLR_DESC
static SCIP_RETCODE checkSubproblemIndependence(SCIP *scip, SCIP_BENDERS *benders)
SCIP_RETCODE SCIPbendersInit(SCIP_BENDERS *benders, SCIP_SET *set)
internal methods for Benders' decomposition
SCIP_Bool subprobsinfeasible
SCIP_Bool * subprobisconvex
SCIP_Bool * subprobenabled
SCIP_BENDERSDATA * bendersdata
SCIP_SUBPROBLEMSOLVESTAT ** solvestat
SCIP_Bool strengthenround
SCIP_Bool * mastervarscont
SCIP_VAR ** auxiliaryvars
SCIP_Real * subprobobjval
SCIP_HASHMAP * mastervarsmap
SCIP_PQUEUE * subprobqueue
SCIP_Real * bestsubprobobjval
SCIP_Bool benderscutssorted
SCIP_Real maxslackvarcoef
SCIP_BENDERSSUBTYPE * subprobtype
SCIP_Bool * subprobisnonlinear
SCIP_Bool strengthenenabled
SCIP_Bool benderscutsnamessorted
SCIP_Bool masterisnonlinear
SCIP_BENDERSCUTCUT ** storedcuts
SCIP_Bool feasibilityphase
SCIP_BENDERSCUT ** benderscuts
SCIP_CLOCK * bendersclock
SCIP_Bool subprobscreated
SCIP_Bool updateauxvarbound
SCIP_Bool checkconsconvexity
SCIP_Real * subproblowerbound
SCIP_Bool benders_copybenders
SCIP_Bool lp_alwaysgetduals
SCIP_Bool conflict_enable
SCIP_Bool misc_catchctrlc
data structures required for Benders' decomposition
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_EVENTTYPE_NODEFOCUSED
struct SCIP_EventhdlrData SCIP_EVENTHDLRDATA
#define SCIP_EVENTTYPE_NODESOLVED
#define SCIP_EVENTTYPE_BESTSOLFOUND
@ SCIP_LPSOLSTAT_NOTSOLVED
@ SCIP_LPSOLSTAT_TIMELIMIT
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
@ SCIP_LPSOLSTAT_ITERLIMIT
#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
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
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4