74#define CONSHDLR_NAME "bounddisjunction"
75#define CONSHDLR_DESC "bound disjunction constraints"
76#define CONSHDLR_ENFOPRIORITY -3000000
77#define CONSHDLR_CHECKPRIORITY -3000000
78#define CONSHDLR_PROPFREQ 1
79#define CONSHDLR_EAGERFREQ 100
81#define CONSHDLR_MAXPREROUNDS -1
82#define CONSHDLR_DELAYPROP FALSE
83#define CONSHDLR_NEEDSCONS TRUE
85#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_FAST
86#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
95#define EVENTHDLR_NAME "bounddisjunction"
96#define EVENTHDLR_DESC "event handler for bound disjunction constraints"
105#define CONFLICTHDLR_NAME "bounddisjunction"
106#define CONFLICTHDLR_DESC "conflict handler creating bound disjunction constraints"
107#define CONFLICTHDLR_PRIORITY -3000000
116#define DEFAULT_CONTINUOUSFRAC 0.4
127#define AGEINCREASE(n) (1.0 + 0.2*n)
129#define AGEINCREASE(n) (0.1*n)
140#ifdef SCIP_DISABLED_CODE
142#define isFeasLT(scip, var, val1, val2) (SCIPvarIsIntegral(var) ? (val2) - (val1) > 0.5 : SCIPisFeasLT(scip, val1, val2))
143#define isFeasLE(scip, var, val1, val2) (SCIPvarIsIntegral(var) ? (val2) - (val1) > -0.5 : SCIPisFeasLE(scip, val1, val2))
144#define isFeasGT(scip, var, val1, val2) (SCIPvarIsIntegral(var) ? (val1) - (val2) > 0.5 : SCIPisFeasGT(scip, val1, val2))
145#define isFeasGE(scip, var, val1, val2) (SCIPvarIsIntegral(var) ? (val1) - (val2) > -0.5 : SCIPisFeasGE(scip, val1, val2))
147#define isFeasLT(scip, var, val1, val2) SCIPisFeasLT(scip, val1, val2)
148#define isFeasLE(scip, var, val1, val2) SCIPisFeasLE(scip, val1, val2)
149#define isFeasGT(scip, var, val1, val2) SCIPisFeasGT(scip, val1, val2)
150#define isFeasGE(scip, var, val1, val2) SCIPisFeasGE(scip, val1, val2)
156struct SCIP_ConshdlrData
299 (*conshdlrdata)->eventhdlr = eventhdlr;
347 SCIP_Real* boundsbuffer;
356 for( v = 0; v <
nvars && !redundant; ++v )
360 SCIP_Real
bound = bounds[v];
370 boundtypesbuffer[0] = boundtype;
371 boundsbuffer[0] =
bound;
384 boundtypesbuffer[k] = boundtype;
385 boundsbuffer[k] =
bound;
397 (*consdata)->varssize = 1;
398 (*consdata)->nvars = 1;
403 assert(!redundant || k == 1);
409 (*consdata)->varssize = k;
410 (*consdata)->nvars = k;
424 (*consdata)->varssize =
nvars;
425 (*consdata)->nvars =
nvars;
430 (*consdata)->vars =
NULL;
431 (*consdata)->boundtypes =
NULL;
432 (*consdata)->bounds =
NULL;
433 (*consdata)->varssize = 0;
434 (*consdata)->nvars = 0;
436 (*consdata)->watchedvar1 = -1;
437 (*consdata)->watchedvar2 = -1;
438 (*consdata)->filterpos1 = -1;
439 (*consdata)->filterpos2 = -1;
471 SCIP_Real* boundsbuffer;
487 for( v = 0; v <
nvars; ++v )
506 boundtypesbuffer[0] = boundtypesbuffer[v];
507 boundsbuffer[0] = boundsbuffer[v];
521 for(
w = v + 1;
w <
nvars && varsbuffer[v] == varsbuffer[
w]; ++
w )
523 if( boundtypesbuffer[v] == boundtypesbuffer[
w] )
529 varsbuffer[v] =
NULL;
531 varsbuffer[
w] =
NULL;
539 varsbuffer[v] =
NULL;
541 varsbuffer[
w] =
NULL;
547 if( varsbuffer[v] !=
NULL )
550 varsbuffer[nvarsbuffer] = varsbuffer[v];
551 boundtypesbuffer[nvarsbuffer] = boundtypesbuffer[v];
552 boundsbuffer[nvarsbuffer] = boundsbuffer[v];
560 if( nvarsbuffer == 0 )
562 for( v = 0; v <
nvars; v++ )
573 for( v = 0; v < nvarsbuffer; v++ )
577 for( v2 = v+1; v2 < nvarsbuffer; v2++ )
578 assert(varsbuffer[v] != varsbuffer[v2] || boundtypesbuffer[v] != boundtypesbuffer[v2]);
590 (*consdata)->varssize = nvarsbuffer;
591 (*consdata)->nvars = nvarsbuffer;
600 (*consdata)->vars =
NULL;
601 (*consdata)->boundtypes =
NULL;
602 (*consdata)->bounds =
NULL;
603 (*consdata)->varssize = 0;
604 (*consdata)->nvars = 0;
606 (*consdata)->watchedvar1 = -1;
607 (*consdata)->watchedvar2 = -1;
608 (*consdata)->filterpos1 = -1;
609 (*consdata)->filterpos2 = -1;
651 for( v = 0; v < consdata->nvars; ++v )
679 assert(watchedvar1 == -1 || watchedvar1 != watchedvar2);
680 assert(watchedvar1 != -1 || watchedvar2 == -1);
681 assert(watchedvar1 == -1 || (0 <= watchedvar1 && watchedvar1 < consdata->
nvars));
682 assert(watchedvar2 == -1 || (0 <= watchedvar2 && watchedvar2 < consdata->
nvars));
689 if( watchedvar1 == consdata->watchedvar2 || watchedvar2 == consdata->watchedvar1 )
693 tmp = consdata->watchedvar1;
694 consdata->watchedvar1 = consdata->watchedvar2;
695 consdata->watchedvar2 = tmp;
696 tmp = consdata->filterpos1;
697 consdata->filterpos1 = consdata->filterpos2;
698 consdata->filterpos2 = tmp;
700 assert(watchedvar1 == -1 || watchedvar1 != consdata->watchedvar2);
701 assert(watchedvar2 == -1 || watchedvar2 != consdata->watchedvar1);
704 if( consdata->watchedvar1 != -1 && consdata->watchedvar1 != watchedvar1 )
706 assert(consdata->filterpos1 != -1);
708 consdata->watchedvar1 = -1;
710 if( consdata->watchedvar2 != -1 && consdata->watchedvar2 != watchedvar2 )
712 assert(consdata->filterpos2 != -1);
714 consdata->watchedvar2 = -1;
718 if( watchedvar1 != -1 && watchedvar1 != consdata->watchedvar1 )
722 if( watchedvar2 != -1 && watchedvar2 != consdata->watchedvar2 )
728 consdata->watchedvar1 = watchedvar1;
729 consdata->watchedvar2 = watchedvar2;
745 SCIP_Bool overlapping =
FALSE;
789 if( consdata->watchedvar1 == pos )
793 if( consdata->watchedvar2 == pos )
798 assert(pos != consdata->watchedvar1);
799 assert(pos != consdata->watchedvar2);
802 consdata->vars[pos] = consdata->vars[consdata->nvars-1];
803 consdata->boundtypes[pos] = consdata->boundtypes[consdata->nvars-1];
804 consdata->bounds[pos] = consdata->bounds[consdata->nvars-1];
808 if( consdata->watchedvar1 == consdata->nvars )
809 consdata->watchedvar1 = pos;
810 if( consdata->watchedvar2 == consdata->nvars )
811 consdata->watchedvar2 = pos;
843 if( consdata->varssize == consdata->nvars )
851 consdata->varssize = newsize;
853 assert(consdata->varssize > consdata->nvars);
863 for( v = 0; v < consdata->nvars; v++ )
866 if( consdata->vars[v] ==
var )
868 if( consdata->boundtypes[v] == boundtype )
881 if( samebndidx > -1 )
889 consdata->bounds[samebndidx] =
bound;
895 consdata->vars[consdata->nvars] =
var;
896 consdata->boundtypes[consdata->nvars] = boundtype;
897 consdata->bounds[consdata->nvars] =
bound;
906 if( consdata->watchedvar1 == -1 )
908 assert(consdata->watchedvar2 == -1);
911 else if( consdata->watchedvar2 == -1 )
941 assert(consdata->nvars == 0 || consdata->vars !=
NULL);
945 while( v < consdata->
nvars )
949 var = consdata->vars[v];
1014 return isFeasGE(
scip, consdata->vars[pos], bnd, consdata->bounds[pos]);
1019 return isFeasLE(
scip, consdata->vars[pos], bnd, consdata->bounds[pos]);
1039 return isFeasLT(
scip, consdata->vars[pos], bnd, consdata->bounds[pos]);
1044 return isFeasGT(
scip, consdata->vars[pos], bnd, consdata->bounds[pos]);
1054 SCIP_Bool* redundant
1071 while( v < consdata->
nvars )
1076 var = consdata->vars[v];
1103 bound = consdata->bounds[v];
1104 boundtype = consdata->boundtypes[v];
1151 SCIP_Bool allbinary;
1165 nvars = consdata->nvars;
1173 for( v =
nvars - 1; v >= 0; --v )
1191 newvars[v] = consdata->vars[v];
1203 newvars[v] = consdata->vars[v];
1264 for( v = 0; v < consdata->nvars; ++v )
1304 SCIP_Bool* infeasible,
1305 SCIP_Bool* reduceddom,
1306 SCIP_Bool* mustcheck
1313 SCIP_Longint nbranchings1;
1314 SCIP_Longint nbranchings2;
1328 assert(consdata->watchedvar1 == -1 || consdata->watchedvar1 != consdata->watchedvar2);
1332 *infeasible =
FALSE;
1333 *reduceddom =
FALSE;
1338 nvars = consdata->nvars;
1339 vars = consdata->vars;
1340 boundtypes = consdata->boundtypes;
1341 bounds = consdata->bounds;
1369 watchedvar1 = consdata->watchedvar1;
1374 if( watchedvar1 == -1 )
1376 watchedvar1 = consdata->watchedvar2;
1381 watchedvar2 = consdata->watchedvar2;
1385 assert(watchedvar1 >= 0 || watchedvar2 == -1);
1386 assert(nbranchings1 <= nbranchings2);
1391 if( watchedvar2 == -1 )
1395 for( v = 0; v <
nvars; ++v )
1397 SCIP_Longint nbranchings;
1400 if( v == consdata->watchedvar1 || v == consdata->watchedvar2 )
1410 assert(v != consdata->watchedvar1);
1411 assert(v != consdata->watchedvar2);
1416 SCIPdebugMsg(
scip,
" -> disabling constraint <%s> (variable <%s> fixed to 1.0)\n",
1418 if( consdata->watchedvar1 != -1 )
1433 if( nbranchings < nbranchings2 )
1435 if( nbranchings < nbranchings1 )
1437 watchedvar2 = watchedvar1;
1438 nbranchings2 = nbranchings1;
1440 nbranchings1 = nbranchings;
1445 nbranchings2 = nbranchings;
1450 assert(nbranchings1 <= nbranchings2);
1451 assert(watchedvar1 >= 0 || watchedvar2 == -1);
1453 if( watchedvar1 == -1 )
1459 assert(watchedvar2 == -1);
1474 else if( watchedvar2 == -1 )
1495 for (v = 0; v <
nvars; ++v)
1497 if ( v != watchedvar1 )
1505 SCIPdebugMsg(
scip,
" -> single-literal constraint <%s> (change bound <%s> %s %g) at depth %d\n",
1521 if( watchedvar1 != consdata->watchedvar1 )
1531 SCIPdebugMsg(
scip,
" -> new watched variables <%s> and <%s> of constraint <%s> are still undecided\n",
1572 nvars = consdata->nvars;
1573 vars = consdata->vars;
1574 boundtypes = consdata->boundtypes;
1575 bounds = consdata->bounds;
1583 for( v = 0; v <
nvars; ++v )
1589 if( viol < absviol )
1628 SCIP_Bool* neednarybranch
1635 SCIP_Real violation;
1649 nvars = consdata->nvars;
1650 vars = consdata->vars;
1651 boundtypes = consdata->boundtypes;
1652 bounds = consdata->bounds;
1658 *neednarybranch =
TRUE;
1660 for( v = 0; v <
nvars; ++v )
1700 *neednarybranch =
FALSE;
1716 SCIP_Bool* infeasible,
1717 SCIP_Bool* reduceddom,
1718 SCIP_Bool* registeredbrcand
1721 SCIP_Bool mustcheck;
1722 SCIP_Bool neednarybranch;
1753 if( !neednarybranch )
1754 *registeredbrcand =
TRUE;
1789 nvars = consdata->nvars;
1790 vars = consdata->vars;
1791 boundtypes = consdata->boundtypes;
1792 bounds = consdata->bounds;
1797 for( v = 0; v <
nvars; ++v )
1830 SCIPdebugMsg(
scip,
" -> creating child to enforce: <%s> %c= %g (priority: %g, estimate: %g)\n",
1895 SCIP_Bool infeasible;
1896 SCIP_Bool reduceddom;
1897 SCIP_Bool registeredbrcand;
1898 SCIP_Bool infeasiblecons;
1900 int nnarybranchconsvars;
1908 SCIPdebugMsg(
scip,
"Enforcing %d bound disjunction constraints for %s solution\n", nconss,
sol ==
NULL ?
"LP" :
"relaxation");
1918 registeredbrcand =
FALSE;
1919 narybranchcons =
NULL;
1920 nnarybranchconsvars = INT_MAX;
1923 for(
c = 0;
c < nconss && !
cutoff && !reduceddom; ++
c )
1925 infeasiblecons =
FALSE;
1927 ®isteredbrcand) );
1928 infeasible |= infeasiblecons;
1929 if( infeasiblecons && !registeredbrcand )
1934 narybranchcons = conss[
c];
1936 assert(nnarybranchconsvars > 0);
1943 else if( reduceddom )
1945 else if( infeasible )
1947 if( registeredbrcand )
1975 SCIP_Real
bound = 0.0;
1999 nconsvars = consdata->nvars;
2004 for(
i = 0;
i < nconsvars; ++
i )
2011 vars[0] = consdata->vars[
i];
2027 nodeidx = opnodeidx;
2096 SCIP_Bool redundant;
2107 for(
c = 0;
c < nconss; ++
c )
2151 for(
c = 0;
c < nconss; ++
c )
2169 if( consdata->nvars != 2 )
2172 if( consdata->vars[0] != consdata->vars[1] )
2177 a = consdata->bounds[0];
2178 b = consdata->bounds[1];
2182 a = consdata->bounds[1];
2183 b = consdata->bounds[0];
2248 sourcedata->boundtypes, sourcedata->bounds) );
2287 SCIP_Bool infeasible;
2288 SCIP_Bool reduceddom;
2289 SCIP_Bool registeredbrcand;
2298 SCIPdebugMsg(
scip,
"pseudo enforcing %d bound disjunction constraints\n", nconss);
2308 registeredbrcand =
FALSE;
2309 narybranchcons =
NULL;
2312 for(
c = 0;
c < nconss && !
cutoff && !reduceddom; ++
c )
2315 ®isteredbrcand) );
2316 if( infeasible && !registeredbrcand )
2320 narybranchcons = conss[
c];
2326 else if( reduceddom )
2328 else if( infeasible )
2330 if( registeredbrcand )
2375 for( v = 0; v < consdata->nvars; ++v )
2401 SCIP_Bool infeasible;
2402 SCIP_Bool reduceddom;
2403 SCIP_Bool mustcheck;
2404 SCIP_Bool consreduceddom;
2420 for(
c = 0;
c < nusefulconss && !
cutoff; ++
c )
2423 &
cutoff, &infeasible, &consreduceddom, &mustcheck) );
2424 reduceddom = reduceddom || consreduceddom;
2430 else if( reduceddom )
2446 SCIP_Bool infeasible;
2447 SCIP_Bool redundant;
2448 SCIP_Bool tightened;
2502 if( consdata->nvars == 0 )
2508 else if( consdata->nvars == 1 )
2510 SCIPdebugMsg(
scip,
"bound disjunction constraint <%s> has only one undecided literal\n",
2608 assert(consdata->nvars > 0);
2609 assert(0 <= inferinfo && inferinfo < consdata->
nvars);
2610 assert(consdata->vars[inferinfo] == infervar);
2612 vars = consdata->vars;
2613 boundtypes = consdata->boundtypes;
2615 bounds = consdata->bounds;
2620 SCIPdebugMsg(
scip,
"conflict resolving method of bound disjunction constraint handler\n");
2630 for( v = 0; v < consdata->nvars; ++v )
2632 if( v != inferinfo )
2634 assert(consdata->vars[v] != infervar || consdata->boundtypes[v] != consdata->boundtypes[inferinfo]);
2666 for(
i = 0;
i < consdata->nvars; ++
i )
2698 assert(consdata->watchedvar1 == -1 || consdata->watchedvar1 != consdata->watchedvar2);
2704 if( consdata->watchedvar1 != -1 )
2707 &consdata->filterpos1) );
2709 if( consdata->watchedvar2 != -1 )
2712 &consdata->filterpos2) );
2735 assert(consdata->watchedvar1 == -1 || consdata->watchedvar1 != consdata->watchedvar2);
2741 if( consdata->watchedvar1 != -1 )
2743 assert(consdata->filterpos1 != -1);
2744 SCIP_CALL(
dropEvents(
scip, cons, consdata, conshdlrdata->eventhdlr, consdata->watchedvar1, consdata->filterpos1) );
2745 consdata->watchedvar1 = -1;
2747 if( consdata->watchedvar2 != -1 )
2749 assert(consdata->filterpos2 != -1);
2750 SCIP_CALL(
dropEvents(
scip, cons, consdata, conshdlrdata->eventhdlr, consdata->watchedvar2, consdata->filterpos2) );
2751 consdata->watchedvar2 = -1;
2805 bounds, initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
2833 if( strncmp(str,
"bounddisjunction(", 16) != 0 )
2852 while( *str !=
')' )
2861 endptr = strchr(endptr,
')');
2863 if( endptr ==
NULL )
2917 if(
nvars > varssize )
2935 if( *success &&
nvars > 0 )
2938 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
2961 if( varssize < consdata->
nvars )
2985 (*nvars) = consdata->nvars;
3049struct SCIP_ConflicthdlrData
3051 SCIP_Real continuousfrac;
3070 assert(bdchginfos !=
NULL || nbdchginfos == 0);
3093 for(
i = 0;
i < nbdchginfos; ++
i )
3113 for( j = nliterals-1; j >= 0; --j )
3119 if( boundtypes[j] == boundtype )
3124 SCIPdebugMsg(
scip,
"relax lower bound of variable <%s> from %g to %g in bounddisjunction conflict\n",
3131 SCIPdebugMsg(
scip,
"relax upper bound of variable <%s> from %g to %g in bounddisjunction conflict\n",
3142 SCIPdebugMsg(
scip,
"redundant bounddisjunction conflict due to overlapping\n");
3143 goto DISCARDCONFLICT;
3148 boundtypes[nliterals] = boundtype;
3149 bounds[nliterals] =
bound;
3164 SCIPdebugMsg(
scip,
"redundant bounddisjunction conflict due to globally fulfilled literal\n");
3165 goto DISCARDCONFLICT;
3175 if(
i == nbdchginfos && ncontinuous < conflicthdlrdata->continuousfrac * nbdchginfos + 0.5 )
3229 eventExecBounddisjunction,
NULL) );
3236 "conflict/" CONSHDLR_NAME "/continuousfrac",
"maximal percantage of continuous variables within a conflict",
3241 conflictExecBounddisjunction, conflicthdlrdata) );
3251 consEnfolpBounddisjunction, consEnfopsBounddisjunction, consCheckBounddisjunction, consLockBounddisjunction,
3306 SCIP_Bool modifiable,
3312 SCIP_Bool removable,
3314 SCIP_Bool stickingatnode
3326 if( conshdlr ==
NULL )
3336 for( v1 = 0; v1 <
nvars; v1++ )
3339 for( v2 = v1+1; v2 <
nvars; v2++ )
3352 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
3353 local, modifiable, dynamic, removable, stickingatnode) );
3408 SCIP_Bool modifiable,
3414 SCIP_Bool removable,
3416 SCIP_Bool stickingatnode
3428 if( conshdlr ==
NULL )
3438 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
3439 local, modifiable, dynamic, removable, stickingatnode) );
3488 return consdata->nvars;
3509 return consdata->vars;
3530 return consdata->boundtypes;
3551 return consdata->bounds;
#define isFeasGE(scip, var, val1, val2)
static SCIP_RETCODE applyGlobalBounds(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *redundant)
static SCIP_Bool isConsViolated(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds)
#define CONSHDLR_NEEDSCONS
#define CONFLICTHDLR_PRIORITY
#define isFeasLT(scip, var, val1, val2)
#define CONFLICTHDLR_NAME
static SCIP_RETCODE removeFixedVariables(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *redundant)
static SCIP_RETCODE delCoefPos(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)
#define CONSHDLR_CHECKPRIORITY
static SCIP_RETCODE analyzeConflict(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE upgradeCons(SCIP *scip, SCIP_CONS *cons, int *ndelconss, int *naddconss)
#define CONSHDLR_PROP_TIMING
#define CONFLICTHDLR_DESC
static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)
static SCIP_RETCODE enforceCurrentSol(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, SCIP_Bool *infeasible, SCIP_Bool *reduceddom, SCIP_Bool *registeredbrcand)
#define CONSHDLR_MAXPREROUNDS
#define isFeasLE(scip, var, val1, val2)
static void consdataPrint(SCIP *scip, SCIP_CONSDATA *consdata, FILE *file, SCIP_Bool endline)
#define DEFAULT_CONTINUOUSFRAC
static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
static SCIP_Bool isLiteralViolated(SCIP *scip, SCIP_CONSDATA *consdata, int pos)
static SCIP_RETCODE lockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, int pos)
static SCIP_RETCODE switchWatchedvars(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int watchedvar1, int watchedvar2)
static SCIP_RETCODE dropEvents(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos, int filterpos)
#define isFeasGT(scip, var, val1, val2)
static SCIP_Bool isLiteralSatisfied(SCIP *scip, SCIP_CONSDATA *consdata, int pos)
static void consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)
static SCIP_RETCODE consdataCreateRedundant(SCIP *scip, SCIP_CONSDATA **consdata, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds)
#define CONSHDLR_PROPFREQ
static SCIP_RETCODE createNAryBranch(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
#define CONSHDLR_PRESOLTIMING
static SCIP_RETCODE catchEvents(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos, int *filterpos)
#define CONSHDLR_EAGERFREQ
static SCIP_RETCODE unlockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, int pos)
static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE registerBranchingCandidates(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *cutoff, SCIP_Bool *neednarybranch)
#define CONSHDLR_ENFOPRIORITY
static SCIP_RETCODE processWatchedVars(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, SCIP_Bool *infeasible, SCIP_Bool *reduceddom, SCIP_Bool *mustcheck)
static SCIP_RETCODE enforceConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_RESULT *result)
static SCIP_RETCODE disableCons(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE addCoef(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_Real bound, SCIP_Bool *redundant)
#define CONSHDLR_DELAYPROP
static SCIP_Bool isOverlapping(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype1, SCIP_Real bound1, SCIP_BOUNDTYPE boundtype2, SCIP_Real bound2)
constraint handler for bound disjunction constraints
Constraint handler for linear constraints in their most general form, .
Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...
Constraint handler for the set partitioning / packing / covering constraints .
#define SCIP_LONGINT_FORMAT
power and signed power expression handlers
variable expression handler
SCIP_Real * SCIPgetBoundsBounddisjunction(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBasicBounddisjunction(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds)
SCIP_RETCODE SCIPcreateConsBounddisjunction(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds, 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)
int SCIPgetNVarsBounddisjunction(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBounddisjunctionRedundant(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds, 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_BOUNDTYPE * SCIPgetBoundtypesBounddisjunction(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsSetpack(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, 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_RETCODE SCIPcreateConsLogicor(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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_RETCODE SCIPcreateConsBasicBounddisjunctionRedundant(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds)
SCIP_VAR ** SCIPgetVarsBounddisjunction(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPincludeConshdlrBounddisjunction(SCIP *scip)
SCIP_Bool SCIPisConsCompressionEnabled(SCIP *scip)
SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)
SCIP_RETCODE SCIPcreateExprVar(SCIP *scip, SCIP_EXPR **expr, SCIP_VAR *var, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPcreateExprPow(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_Real exponent, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
SCIP_RETCODE SCIPaddConflict(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, 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_Real SCIPcalcNodeselPriority(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdir, SCIP_Real targetvalue)
SCIP_RETCODE SCIPaddExternBranchCand(SCIP *scip, SCIP_VAR *var, SCIP_Real score, SCIP_Real solval)
SCIP_Real SCIPcalcChildEstimate(SCIP *scip, SCIP_VAR *var, SCIP_Real targetvalue)
SCIP_RETCODE SCIPcreateChild(SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)
SCIP_BOUNDTYPE SCIPboundtypeOpposite(SCIP_BOUNDTYPE boundtype)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
SCIP_CONFLICTHDLRDATA * SCIPconflicthdlrGetData(SCIP_CONFLICTHDLR *conflicthdlr)
const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)
SCIP_RETCODE SCIPaddConflictBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
SCIP_RETCODE SCIPsetConflicthdlrFree(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_RETCODE SCIPincludeConflicthdlrBasic(SCIP *scip, SCIP_CONFLICTHDLR **conflicthdlrptr, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)),)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsPropagationEnabled(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_RETCODE SCIPenableConsPropagation(SCIP *scip, SCIP_CONS *cons)
int SCIPconsGetValidDepth(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsUpdatedeactivate(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, 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 SCIPconsIsPropagated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsAdded(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_RETCODE SCIPdisableConsPropagation(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddConsAge(SCIP *scip, SCIP_CONS *cons, SCIP_Real deltaage)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
SCIP_RETCODE SCIPcreateNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)
SCIP_Bool SCIPinProbing(SCIP *scip)
void SCIPupdateSolConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
int SCIPgetNRuns(SCIP *scip)
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
SCIP_RETCODE SCIPaddSymgraphEdge(SCIP *scip, SYM_GRAPH *graph, int first, int second, SCIP_Bool hasval, SCIP_Real val)
SCIP_RETCODE SCIPaddSymgraphOpnode(SCIP *scip, SYM_GRAPH *graph, int op, int *nodeidx)
SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
SCIP_RETCODE SCIPaddSymgraphValnode(SCIP *scip, SYM_GRAPH *graph, SCIP_Real val, int *nodeidx)
SCIP_RETCODE SCIPaddSymgraphConsnode(SCIP *scip, SYM_GRAPH *graph, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, int *nodeidx)
SCIP_RETCODE SCIPaddSymgraphVarAggregation(SCIP *scip, SYM_GRAPH *graph, int rootidx, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real constant)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
int SCIPgetDepth(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
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)
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_Real SCIPcomputeVarLbGlobal(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Real SCIPcomputeVarLbLocal(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_Longint SCIPvarGetNBranchingsCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real SCIPcomputeVarUbGlobal(SCIP *scip, SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPcomputeVarUbLocal(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
void SCIPsortPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPskipSpace(char **s)
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
memory allocation routines
#define BMScopyMemoryArray(ptr, source, num)
public methods for conflict analysis handlers
public methods for managing constraints
public methods for managing events
public methods for LP management
public methods for message output
#define SCIPdebugPrintCons(x, y, z)
public data structures and miscellaneous methods
public methods for problem variables
public methods for branching rule plugins and branching
public methods for conflict handler plugins and conflict analysis
public methods for constraint handler plugins and constraints
public methods for problem copies
public methods for event handler plugins and event handlers
public functions to work with algebraic expressions
public methods for memory management
public methods for message handling
public methods for nonlinear relaxation
public methods for numerical tolerances
public methods for SCIP parameter handling
public methods for global and local (sub)problems
public methods for the probing mode
public methods for solutions
public methods for querying solving statistics
public methods for the branch-and-bound tree
public methods for SCIP variables
structs for symmetry computations
methods for dealing with symmetry detection graphs
#define SCIP_DECL_CONFLICTEXEC(x)
#define SCIP_DECL_CONFLICTFREE(x)
@ SCIP_CONFTYPE_PROPAGATION
struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSDELETE(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSINITSOL(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSRESPROP(x)
#define SCIP_DECL_CONSACTIVE(x)
#define SCIP_DECL_CONSENFOPS(x)
#define SCIP_DECL_CONSPARSE(x)
#define SCIP_DECL_CONSTRANS(x)
#define SCIP_DECL_CONSDEACTIVE(x)
#define SCIP_DECL_CONSPRESOL(x)
#define SCIP_DECL_CONSEXITPRE(x)
#define SCIP_DECL_CONSLOCK(x)
#define SCIP_DECL_CONSCOPY(x)
struct SCIP_ConsData SCIP_CONSDATA
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSHDLRCOPY(x)
#define SCIP_DECL_CONSFREE(x)
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_UBTIGHTENED
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_LBRELAXED
#define SCIP_EVENTTYPE_BOUNDRELAXED
#define SCIP_EVENTTYPE_BOUNDTIGHTENED
#define SCIP_EVENTTYPE_LBTIGHTENED
#define SCIP_EVENTTYPE_UBRELAXED
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_BoundType SCIP_BOUNDTYPE
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_TRANSFORMING
enum SYM_Symtype SYM_SYMTYPE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR