68#define CONSHDLR_NAME "cumulative"
69#define CONSHDLR_DESC "cumulative constraint handler"
70#define CONSHDLR_SEPAPRIORITY 2100000
71#define CONSHDLR_ENFOPRIORITY -2040000
72#define CONSHDLR_CHECKPRIORITY -3030000
73#define CONSHDLR_SEPAFREQ 1
74#define CONSHDLR_PROPFREQ 1
75#define CONSHDLR_EAGERFREQ 100
77#define CONSHDLR_MAXPREROUNDS -1
78#define CONSHDLR_DELAYSEPA FALSE
79#define CONSHDLR_DELAYPROP FALSE
80#define CONSHDLR_NEEDSCONS TRUE
82#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_ALWAYS
83#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
95#define DEFAULT_USEBINVARS FALSE
96#define DEFAULT_LOCALCUTS FALSE
97#define DEFAULT_USECOVERCUTS TRUE
98#define DEFAULT_CUTSASCONSS TRUE
99#define DEFAULT_SEPAOLD TRUE
102#define DEFAULT_TTINFER TRUE
103#define DEFAULT_EFCHECK FALSE
104#define DEFAULT_EFINFER FALSE
105#define DEFAULT_USEADJUSTEDJOBS FALSE
106#define DEFAULT_TTEFCHECK TRUE
107#define DEFAULT_TTEFINFER TRUE
110#define DEFAULT_DUALPRESOLVE TRUE
111#define DEFAULT_COEFTIGHTENING FALSE
112#define DEFAULT_NORMALIZE TRUE
113#define DEFAULT_PRESOLPAIRWISE TRUE
114#define DEFAULT_DISJUNCTIVE TRUE
115#define DEFAULT_DETECTDISJUNCTIVE TRUE
116#define DEFAULT_DETECTVARBOUNDS TRUE
117#define DEFAULT_MAXNODES 10000LL
120#define DEFAULT_FILLBRANCHCANDS FALSE
123#define DEFAULT_USEBDWIDENING TRUE
132#define EVENTHDLR_NAME "cumulative"
133#define EVENTHDLR_DESC "bound change event handler for cumulative constraints"
145 SCIP_Bool* downlocks;
153 SCIP_Real resstrength1;
154 SCIP_Real resstrength2;
155 SCIP_Real cumfactor1;
156 SCIP_Real disjfactor1;
157 SCIP_Real disjfactor2;
158 SCIP_Real estimatedstrength;
172 unsigned int signature;
174 unsigned int validsignature:1;
175 unsigned int normalized:1;
176 unsigned int covercuts:1;
177 unsigned int propagated:1;
178 unsigned int varbounds:1;
179 unsigned int triedsolving:1;
187struct SCIP_ConshdlrData
191 SCIP_Bool usebinvars;
192 SCIP_Bool cutsasconss;
196 SCIP_Bool useadjustedjobs;
200 SCIP_Bool usecovercuts;
203 SCIP_Bool fillbranchcands;
205 SCIP_Bool dualpresolve;
206 SCIP_Bool coeftightening;
208 SCIP_Bool disjunctive;
209 SCIP_Bool detectdisjunctive;
210 SCIP_Bool detectvarbounds;
211 SCIP_Bool usebdwidening;
212 SCIP_Bool presolpairwise;
213 SCIP_Bool detectedredundant;
215 SCIP_Longint maxnodes;
276 unsigned int proprule:2;
277 unsigned int data1:15;
278 unsigned int data2:15;
293 inferinfo.val.asint =
i;
304 return inferinfo.val.asint;
313 return (
PROPRULE) inferinfo.val.asbits.proprule;
322 return (
int) inferinfo.val.asbits.data1;
331 return (
int) inferinfo.val.asbits.data2;
340 return (inferinfo.val.asint != 0);
357 inferinfo.val.asint = 0;
363 inferinfo.val.asbits.proprule = proprule;
364 inferinfo.val.asbits.data1 = (
unsigned int) data1;
365 inferinfo.val.asbits.data2 = (
unsigned int) data2;
401#define computeCoreWithInterval(begin, end, ect, lst) (MAX(0, MIN((end), (ect)) - MAX((lst), (begin))))
445 duration = (int)(
size_t)image;
575 duration = consdata->durations[
varidx];
576 demand = consdata->demands[
varidx];
621 (*vars)[*
nvars] = binvars[
b];
622 (*coefs)[*
nvars] = demand;
679 duration = consdata->durations[
varidx];
688 endtime =
MIN(starttime + duration, consdata->hmax);
693 (*activevars)[counter] =
var;
821 var = consdata->vars[
j];
823 assert(consdata->durations[
j] > 0);
824 assert(consdata->demands[
j] > 0);
839 SCIPdebugMsg(
scip,
"%d: variable <%s>[%g,%g] (sol %g, duration %d) starttime %d, endtime = %d, demand = %d\n",
841 consdata->durations[
j],
843 consdata->demands[startindices[*
nvars]]);
859 SCIPdebugMsg(
scip,
"%d: variable <%s>[%g,%g] (sol %g, duration %d) starttime %d, endtime = %d, demand = %d\n",
861 consdata->durations[
j],
863 consdata->demands[startindices[*
nvars]]);
880 consdata->demands[startindices[
j]]);
945 (*cumulativedemands)[0] = 0;
968 (*cumulativedemands)[*ntimepoints] = 0;
979 idx = startindices[
j];
983 if( (*timepoints)[*ntimepoints] <
curtime )
986 (*timepoints)[*ntimepoints] =
curtime;
987 (*cumulativedemands)[*ntimepoints] = 0;
996 idx = startindices[
j];
1014 (*cumulativedemands)[*ntimepoints] = 0;
1028 for(
j = 0;
j < *ntimepoints; ++
j )
1030 if( (*timepoints)[
j] >= hmin && (*timepoints)[
j] < hmax )
1056 SCIP_Real disjfactor2;
1057 SCIP_Real cumfactor1;
1058 SCIP_Real resstrength1;
1059 SCIP_Real resstrength2;
1069 nvars = consdata->nvars;
1070 capacity = consdata->capacity;
1079 for( v = 0; v <
nvars; ++v )
1090 peak = consdata->demands[v];
1095 if( consdata->demands[v] > capacity / 3 )
1110 peak += consdata->demands[
j];
1113 if( consdata->demands[
j] > consdata->capacity / 3 )
1122 if(
peak > capacity )
1133 consdata->disjfactor2 = disjfactor2;
1134 consdata->cumfactor1 = cumfactor1;
1135 consdata->resstrength2 = resstrength2;
1136 consdata->resstrength1 = resstrength1;
1153 consdata->durations, consdata->demands,
1164 SCIPstatisticPrintf(
"cumulative constraint<%s>: DISJ1=%g, DISJ2=%g, CUM=%g, RS1 = %g, RS2 = %g, EST = %g\n",
1165 SCIPconsGetName(cons), consdata->disjfactor1, disjfactor2, cumfactor1, resstrength1, resstrength2,
1166 consdata->estimatedstrength);
1230 for(
j = 0;
j < njobs; ++
j )
1231 energy += (SCIP_Longint) durations[
j] * demands[
j];
1254 SCIP_Longint maxnodes,
1255 SCIP_Real timelimit,
1256 SCIP_Real memorylimit,
1259 SCIP_Bool* infeasible,
1283 for( v = 0; v < njobs; ++v )
1301 njobs, subvars, durations, demands, capacity) );
1346 (*infeasible) =
TRUE;
1350 (*unbounded) =
TRUE;
1361 for( v = 0; v < njobs; ++v )
1378 for( v = 0; v < njobs; ++v )
1398 for( v = 0; v < njobs; ++v )
1419 (*infeasible) =
FALSE;
1420 (*unbounded) =
FALSE;
1423 SCIPdebugMessage(
"solve independent cumulative condition with %d variables\n", njobs);
1430 njobs, capacity, hmin, hmax,
1431 maxnodes, timelimit, memorylimit,
1460 (*infeasible) =
FALSE;
1461 (*unbounded) =
FALSE;
1464 SCIPdebugMsg(
scip,
"solve independent cumulative condition with %d variables\n", njobs);
1483 for( v = 0; v < njobs; ++v )
1527 binvars[v][t] = binvar;
1543 for( t = hmin; t < hmax; ++t )
1554 for( v = 0; v < njobs; ++v )
1567 duration = durations[v];
1574 demand = demands[v];
1577 start =
MAX(t - duration + 1, est);
1619 (*infeasible) =
TRUE;
1623 (*unbounded) =
TRUE;
1633 for( v = 0; v < njobs; ++v )
1666 for( v = 0; v < njobs; ++v )
1712 for( v = 0; v < njobs; ++v )
1765 (*conshdlrdata)->eventhdlr = eventhdlr;
1770#ifdef SCIP_STATISTIC
1771 (*conshdlrdata)->nlbtimetable = 0;
1772 (*conshdlrdata)->nubtimetable = 0;
1773 (*conshdlrdata)->ncutofftimetable = 0;
1774 (*conshdlrdata)->nlbedgefinder = 0;
1775 (*conshdlrdata)->nubedgefinder = 0;
1776 (*conshdlrdata)->ncutoffedgefinder = 0;
1777 (*conshdlrdata)->ncutoffoverload = 0;
1778 (*conshdlrdata)->ncutoffoverloadTTEF = 0;
1780 (*conshdlrdata)->nirrelevantjobs = 0;
1781 (*conshdlrdata)->nalwaysruns = 0;
1782 (*conshdlrdata)->nremovedlocks = 0;
1783 (*conshdlrdata)->ndualfixs = 0;
1784 (*conshdlrdata)->ndecomps = 0;
1785 (*conshdlrdata)->ndualbranchs = 0;
1786 (*conshdlrdata)->nallconsdualfixs = 0;
1787 (*conshdlrdata)->naddedvarbounds = 0;
1788 (*conshdlrdata)->naddeddisjunctives = 0;
1830 for( v = 0; v < consdata->nvars; ++v )
1874 for( v = 0; v < consdata->nvars; ++v )
1892 nvars = consdata->nvars;
1895 for( v = 0; v <
nvars; ++v )
1897 consdata->downlocks[v] = locked;
1898 consdata->uplocks[v] = locked;
1932 (*consdata)->hmin = hmin;
1933 (*consdata)->hmax = hmax;
1935 (*consdata)->capacity = capacity;
1936 (*consdata)->demandrows =
NULL;
1937 (*consdata)->demandrowssize = 0;
1938 (*consdata)->ndemandrows = 0;
1939 (*consdata)->scoverrows =
NULL;
1940 (*consdata)->nscoverrows = 0;
1941 (*consdata)->scoverrowssize = 0;
1942 (*consdata)->bcoverrows =
NULL;
1943 (*consdata)->nbcoverrows = 0;
1944 (*consdata)->bcoverrowssize = 0;
1945 (*consdata)->nvars =
nvars;
1946 (*consdata)->varssize =
nvars;
1947 (*consdata)->signature = 0;
1948 (*consdata)->validsignature =
FALSE;
1949 (*consdata)->normalized =
FALSE;
1950 (*consdata)->covercuts =
FALSE;
1951 (*consdata)->propagated =
FALSE;
1952 (*consdata)->varbounds =
FALSE;
1953 (*consdata)->triedsolving =
FALSE;
1962 (*consdata)->linkingconss =
NULL;
1970 if( linkingconss !=
NULL )
1986 for( v = 0; v <
nvars; ++v )
1991 if( linkingconss !=
NULL )
1996 for( v = 0; v <
nvars; ++v )
2005 for( v = 0; v < (*consdata)->nvars; ++v )
2011 (*consdata)->vars =
NULL;
2012 (*consdata)->downlocks =
NULL;
2013 (*consdata)->uplocks =
NULL;
2014 (*consdata)->demands =
NULL;
2015 (*consdata)->durations =
NULL;
2016 (*consdata)->linkingconss =
NULL;
2020 (*consdata)->resstrength1 = -1.0;
2021 (*consdata)->resstrength2 = -1.0;
2022 (*consdata)->cumfactor1 = -1.0;
2023 (*consdata)->disjfactor1 = -1.0;
2024 (*consdata)->disjfactor2 = -1.0;
2025 (*consdata)->estimatedstrength = -1.0;
2044 for(
r = 0;
r < (*consdata)->ndemandrows; ++
r )
2052 (*consdata)->ndemandrows = 0;
2053 (*consdata)->demandrowssize = 0;
2056 for(
r = 0;
r < (*consdata)->nscoverrows; ++
r )
2064 (*consdata)->nscoverrows = 0;
2065 (*consdata)->scoverrowssize = 0;
2067 for(
r = 0;
r < (*consdata)->nbcoverrows; ++
r )
2075 (*consdata)->nbcoverrows = 0;
2076 (*consdata)->bcoverrowssize = 0;
2078 (*consdata)->covercuts =
FALSE;
2096 nvars = (*consdata)->nvars;
2097 varssize = (*consdata)->varssize;
2107 if( (*consdata)->linkingconss !=
NULL )
2109 for( v =
nvars-1; v >= 0; --v )
2111 assert((*consdata)->linkingconss[v] !=
NULL );
2147 for( v = 0; v < consdata->nvars; ++v )
2154 consdata->durations[v], consdata->demands[v]);
2156 SCIPinfoMessage(
scip, file,
")[%d,%d) <= %d", consdata->hmin, consdata->hmax, consdata->capacity);
2183 consdata->downlocks[pos] =
FALSE;
2184 consdata->uplocks[pos] =
FALSE;
2186 if( consdata->linkingconss !=
NULL )
2201 SCIPdebugMsg(
scip,
"remove variable <%s>[%g,%g] from cumulative constraint <%s>\n",
2207 if( pos != consdata->nvars - 1 )
2209 consdata->vars[pos] = consdata->vars[consdata->nvars-1];
2210 consdata->downlocks[pos] = consdata->downlocks[consdata->nvars-1];
2211 consdata->uplocks[pos] = consdata->uplocks[consdata->nvars-1];
2212 consdata->demands[pos] = consdata->demands[consdata->nvars-1];
2213 consdata->durations[pos] = consdata->durations[consdata->nvars-1];
2215 if( consdata->linkingconss !=
NULL )
2217 consdata->linkingconss[pos]= consdata->linkingconss[consdata->nvars-1];
2222 consdata->validsignature =
FALSE;
2223 consdata->normalized =
FALSE;
2241 nvars = consdata->nvars;
2247 for( v = 0; v <
nvars; ++v )
2252 var = consdata->vars[v];
2268 consdata->linkingconss[v] = cons;
2307 SCIP_Bool* violated,
2328 (*violated) =
FALSE;
2357 startindices[
j] =
j;
2421 ";\nviolation: at time point %d available capacity = %d, needed capacity = %d\n",
2424 for(
i = 0;
i <=
j; ++
i )
2430 demands[startindices[
i]]);
2459 SCIP_Bool* violated,
2476 consdata->durations, consdata->demands, consdata->capacity, consdata->hmin, consdata->hmax,
2505 SCIP_Bool usebdwidening,
2521 SCIPdebugMsg(
scip,
"variable <%s>: (demand %d) resolve propagation of core time algorithm (peak %d)\n",
2545 duration = durations[
j];
2554 SCIPdebugMsg(
scip,
"variable <%s>: glb=[%g,%g] conflict=[%g,%g] (duration %d, demand %d)\n",
2566 capacity -= demands[
j];
2593 capacity -= demands[
j];
2626 duration = durations[
j];
2639 SCIPdebugMsg(
scip,
"variable <%s>: loc=[%g,%g] glb=[%g,%g] (duration %d, demand %d)\n",
2650 capacity -= demands[
j];
2669 for(
c = 0;
c < ncands; ++
c )
2674 duration = durations[cands[
c]];
2703 for(
c = 0;
c < ncands; ++
c )
2710 duration = durations[cands[
c]];
2753 SCIP_Bool usebdwidening,
2806 duration = durations[
j];
2812 left = (est == hmin && lb + duration > hmin) || lb >= est;
2817 right = (lct == hmax && ub < hmax) || ub + duration <= lct;
2858 ect = est + duration;
2859 lct =
lst + duration;
2895 SCIP_Bool usebdwidening,
2918 for( v = 0; v <
nvars; ++v )
2934 demand = demands[v];
2937 duration = durations[v];
2949 SCIPdebugMsg(
scip,
"inference variable <%s>[%g,%g] %s %g (duration %d, demand %d)\n",
2986 overlap =
MIN(left, right);
2989 assert(overlap <= duration);
3033 overlap =
MIN(left, right);
3036 assert(overlap <= duration);
3116 duration = durations[idx];
3128 demand = demands[idx];
3144 SCIPdebugMsg(
scip,
"variable <%s> glb=[%g,%g] loc=[%g,%g], conf=[%g,%g], added=[%d,%d] (demand %d, duration %d)\n",
3183 SCIP_Bool usebdwidening,
3220 SCIPdebugMsg(
scip,
"variable <%s>: upper bound changed from %g to %g (relaxed %g)\n",
3247 SCIPdebugMsg(
scip,
"variable <%s>: lower bound changed from %g to %g (relaxed %g)\n",
3360 for( v = 0; v <
nvars; ++v )
3422#if defined SCIP_DEBUG && !defined NDEBUG
3439 (*freecapacity) -= consdata->demands[startindices[*idx]];
3444 (*freecapacity) -= consdata->demands[startindices[(*idx)]];
3464#if defined SCIP_DEBUG && !defined NDEBUG
3472 (*freecapacity) += consdata->demands[
endindices[*idx]];
3507 nvars = consdata->nvars;
3525 hmin = consdata->hmin;
3526 hmax = consdata->hmax;
3589 for(
c = 0;
c < nconss; ++
c )
3613 for(
j = 0;
j < consdata->nvars; ++
j )
3619 var = consdata->vars[
j];
3635 score =
MIN(solval - lb, ub - solval) / ((
SCIP_Real)ub-lb);
3682 for(
c = 0;
c < nconss && !violated; ++
c )
3714 SCIP_Bool* downlocks;
3722 nvars = consdata->nvars;
3723 vars = consdata->vars;
3724 downlocks = consdata->downlocks;
3725 uplocks = consdata->uplocks;
3728 for( v = 0; v <
nvars; ++v )
3750 SCIP_Longint maxnodes,
3763 SCIP_Real timelimit;
3764 SCIP_Real memorylimit;
3793 if( ncheckconss == 1 )
3843 if( consdata->triedsolving )
3853 consdata->triedsolving =
TRUE;
3855 SCIPdebugMsg(
scip,
"the cumulative constraint <%s> is independent from rest of the problem (%d variables, %d constraints)\n",
3859 nvars = consdata->nvars;
3860 vars = consdata->vars;
3866 for( v = 0; v <
nvars; ++v )
3897 consdata->hmin, consdata->hmax, timelimit, memorylimit, maxnodes, &solved,
cutoff,
unbounded, &
error) );
3901 SCIP_Bool infeasible;
3902 SCIP_Bool tightened;
3907 for( v = 0; v <
nvars; ++v )
3910 if( lbs[v] + 0.5 > ubs[v] )
3918 consdata->triedsolving =
FALSE;
3929 consdata->triedsolving =
FALSE;
3938 consdata->triedsolving =
FALSE;
3975 SCIP_Bool usebdwidening,
3976 SCIP_Bool* initialized,
3980 SCIPdebugMsg(
scip,
"detected infeasibility due to adding a core to the core resource profile\n");
4006 *initialized =
TRUE;
4031 SCIP_Bool usebdwidening,
4032 SCIP_Bool* initialized,
4034 SCIP_Bool* infeasible
4050 duration = durations[idx];
4053 demand = demands[idx];
4065 SCIPdebugMsg(
scip,
"propagate earliest start time (lower bound) (pos %d)\n", pos);
4071 SCIP_Bool tightened;
4083 ect = est + duration;
4212 lct =
lst + duration;
4230 SCIP_Bool tightened;
4231 SCIP_Bool infeasible;
4304 lct =
lst + duration;
4336 t = ntimepoints - 1;
4340 for( v =
nvars-1; v >= 0; --v )
4361 t = ntimepoints - 1;
4365 for( v =
nvars-1; v >= 0; --v )
4408 for( v = 0; v <
nvars; ++ v)
4419 duration = durations[v];
4424 ect = est + duration;
4425 lct =
lst + duration;
4436 leftadjust =
MAX(0, hmin - est);
4439 rightadjust =
MAX(0, lct - hmax);
4478 SCIP_Bool* initialized,
4489 if( !conshdlrdata->ttefinfer )
4525 if(
newlb > lct - duration )
4547 (*initialized) =
TRUE;
4591 SCIP_Bool* initialized,
4603 if( !conshdlrdata->ttefinfer )
4661 (*initialized) =
TRUE;
4705 SCIP_Bool* initialized,
4725 for( v = 0; v <
nvars; ++v )
4735 hmin =
MAX(hmin, est);
4736 hmax =
MIN(hmax, lct);
4754 for( v =
nvars-1; v >= 0 && !(*cutoff); --v )
4857 duration = durations[idx];
4860 demand = demands[idx];
4878 var, duration, demand, est,
lst, lct,
minbegin,
end,
minavailable, &(
newubs[idx]), &(
ubinferinfos[idx]),
4885 SCIPdebugMsg(
scip,
"check variable <%s>[%g,%g] (duration %d, demands %d, est <%d>, lst of free part <%d>\n",
4956 (*initialized) =
TRUE;
5001 (*initialized) =
TRUE;
5056 SCIP_Bool* initialized,
5082 for( v = 0; v <
nvars; ++v )
5107 for( v = 0; v <
nvars; ++v )
5186 duration = durations[idx];
5189 demand = demands[idx];
5207 var, duration, demand, est,
ect, lct,
begin,
minend,
minavailable, &(
newlbs[idx]), &(
lbinferinfos[idx]),
5214 SCIPdebugMsg(
scip,
"check variable <%s>[%g,%g] (duration %d, demands %d, est <%d>, ect of free part <%d>\n",
5285 (*initialized) =
TRUE;
5303 duration = durations[
ubcand];
5332 (*initialized) =
TRUE;
5388 SCIP_Bool* initialized,
5415 if( !conshdlrdata->ttefcheck )
5436 for( v = 0; v <
nvars; ++v )
5445 collectDataTTEF(
scip,
nvars,
vars, durations, demands, hmin, hmax,
permests,
ests,
permlcts,
lcts,
ects,
lsts,
flexenergies);
5467 for( v = 0; v <
nvars && !(*cutoff); ++v )
5469 SCIP_Bool infeasible;
5470 SCIP_Bool tightened;
5475 TRUE, &infeasible, &tightened) );
5496 TRUE, &infeasible, &tightened) );
5541 (*initialized) =
TRUE;
5597 SCIP_Bool* initialized,
5602 SCIP_Bool infeasible;
5615 if( !conshdlrdata->ttinfer )
5620 SCIPdebugMsg(
scip,
"propagate cores of cumulative condition of constraint <%s>[%d,%d) <= %d\n",
5630 for( v = 0; v <
nvars; ++v )
5643 duration = durations[v];
5660 end =
MIN(hmax, est + duration);
5662 demand = demands[v];
5668 SCIPdebugMsg(
scip,
"variable <%s>[%g,%g] (duration %d, demand %d): remove core [%d,%d)\n",
5676 profile, v, nchgbds, conshdlrdata->usebdwidening, initialized,
explanation,
cutoff) );
5683 profile, v, nchgbds) );
5694 end =
MIN(hmax, est + duration);
5701 SCIPdebugMsg(
scip,
"variable <%s>[%d,%d] (duration %d, demand %d): add core [%d,%d)\n",
5740 SCIP_Longint enveloptheta;
5743 SCIP_Longint enveloplambda;
5763 SCIPdebugMsg(
scip,
"update envelop starting from node <%p>\n", (
void*)node);
5768 while( node !=
NULL )
5823 else if(
leftdata->energylambda >= 0 )
6054 if( parent !=
NULL )
6432 SCIPdebugMessage(
"variable <%s>: loc=[%g,%g] glb=[%g,%g] (duration %d, demand %d)\n",
6437 return nodedata->demand * duration;
6479 SCIP_Bool usebdwidening,
6480 SCIP_Bool* initialized,
6491 SCIPdebugMsg(
scip,
"est=%d, lct=%d, propest %u, reportedenergy %d, shift %d\n", est, lct,
propest,
reportedenergy, shift);
6546 for(
j = nleaves-1;
j >= 0; --
j )
6570 (*initialized) =
TRUE;
6595 if(
energy > ((SCIP_Longint) capacity - demand) * ((SCIP_Longint) lct - est) )
6597 if(
energy + (SCIP_Longint) demand * duration > capacity * ((SCIP_Longint) lct - est) )
6623 SCIP_Bool* initialized,
6638 for(
j = ncands-1;
j >= 0 && !(*cutoff); --
j )
6696 assert(nelements < ncands);
6703 SCIPdebugMsg(
scip,
"an overload was detected duration edge-finder propagattion\n");
6707 conshdlrdata->usebdwidening, initialized,
explanation) );
6715 SCIP_Bool infeasible;
6716 SCIP_Bool tightened;
6735 TRUE, &infeasible, &tightened) );
6757 TRUE, &infeasible, &tightened) );
6790 for(
i = 0;
i < nelements; ++
i )
6802 (*initialized) =
TRUE;
6849 SCIP_Bool* initialized,
6901 shift =
MAX(shift, lct);
6922 duration = durations[
j];
6934 if( conshdlrdata->useadjustedjobs )
6938 leftadjust = (hmin - est);
6943 rightadjust = (lct - hmax);
6950 if( duration - leftadjust - rightadjust <= 0 )
6956 energy = demands[
j] * (duration - leftadjust - rightadjust);
6994 nodedata->rightadjust = rightadjust;
7019 for(
j = 0;
j < ncands; ++
j )
7079 for(
j =
j+1;
j < ncands; ++
j )
7098 duration -= (est -
glbest);
7101 duration -= (
glblct - lct);
7114 conshdlrdata->usebdwidening, initialized,
explanation) );
7152 SCIP_Bool* initialized,
7163 if( !conshdlrdata->efcheck )
7175 if( !conshdlrdata->efinfer )
7199 SCIP_Bool* redundant
7219 (*redundant) =
TRUE;
7247 if( lb >= hmax || ub + durations[
j] <= hmin )
7251 startindices[njobs] =
j;
7267 for(
j = 0;
j < njobs; ++
j )
7294 (*redundant) =
FALSE;
7323 SCIP_Bool* initialized,
7331 for( v = 0; v <
nvars; ++v )
7334 SCIP_Bool infeasible;
7348 duration = durations[v];
7351 demand = demands[v];
7364 end =
MIN(hmax, est + duration);
7370 SCIPdebugMsg(
scip,
"variable <%s>[%d,%d] (duration %d, demand %d): add core [%d,%d)\n",
7416 SCIP_Bool* redundant,
7417 SCIP_Bool* initialized,
7443 SCIP_CALL_TERMINATE( retcode,
createCoreProfile(
scip, conshdlrdata, profile,
nvars,
vars, durations, demands, capacity, hmin, hmax,
7449 SCIP_CALL_TERMINATE( retcode,
propagateTimetable(
scip, conshdlrdata, profile,
nvars,
vars, durations, demands, capacity, hmin, hmax, cons,
7456 SCIP_CALL_TERMINATE( retcode,
propagateEdgeFinding(
scip, conshdlrdata,
nvars,
vars, durations, demands, capacity, hmin, hmax,
7463 SCIP_CALL_TERMINATE( retcode,
propagateTTEF(
scip, conshdlrdata, profile,
nvars,
vars, durations, demands, capacity, hmin, hmax, cons,
7486 SCIP_Bool initialized;
7487 SCIP_Bool redundant;
7497 initialized =
FALSE;
7511 consdata->nvars, consdata->vars, consdata->durations, consdata->demands, consdata->capacity,
7512 consdata->hmin, consdata->hmax, cons,
7513 nchgbds, &redundant, &initialized,
NULL,
cutoff) );
7517 SCIPdebugMsg(
scip,
"%s deletes cumulative constraint <%s> since it is redundant\n",
7544 consdata->propagated =
TRUE;
7577 SCIP_Bool tightened;
7771 for(
c = 0;
c < nconss; ++
c )
7788 assert(consdata->nvars > 1);
7813 hmin = consdata->hmin;
7814 hmax = consdata->hmax;
7820 nvars = consdata->nvars;
7822 for( v = 0; v <
nvars; ++v )
7828 var = consdata->vars[v];
7843 if( consdata->downlocks[v] )
7850 ect = est + consdata->durations[v];
7854 else if( est < hmin &&
alternativelbs[idx] >= (hmin + 1 - constant) / scalar )
7862 if( consdata->uplocks[v] )
7868 duration = consdata->durations[v];
7872 lct =
lst + duration;
7874 if(
lst >= hmax || hmin >= hmax )
7876 else if( lct > hmax &&
alternativeubs[idx] <= ((hmax - 1 - constant) / scalar) - duration )
7878 alternativeubs[idx] = ((hmax - 1 - constant) / scalar) - duration;
7922 for( v = 0; v <
nvars; ++v )
7925 SCIP_Bool infeasible;
8078 for( v = 0; v <
nvars; ++v )
8146 nvars = consdata->nvars;
8163 if(
startvalues[
j] <= time && ub + consdata->durations[
j] > time )
8240 start = time - consdata->durations[idx] + 1;
8246 if( vals[
b] <
start || vals[
b] < lb )
8260 if( consdata->bcoverrowssize == 0 )
8262 consdata->bcoverrowssize = 10;
8265 if( consdata->nbcoverrows == consdata->bcoverrowssize )
8267 consdata->bcoverrowssize *= 2;
8271 consdata->bcoverrows[consdata->nbcoverrows] = row;
8272 consdata->nbcoverrows++;
8290 while(
j > 0 && demands[
j] == demands[
nflexible-1] )
8329 start = time - consdata->durations[idx] + 1;
8335 if( vals[
b] <
start || vals[
b] < lb )
8348 if( consdata->scoverrowssize == 0 )
8350 consdata->scoverrowssize = 10;
8353 if( consdata->nscoverrows == consdata->scoverrowssize )
8355 consdata->scoverrowssize *= 2;
8359 consdata->scoverrows[consdata->nscoverrows] = row;
8360 consdata->nscoverrows++;
8404 if( consdata->vars ==
NULL )
8407 nvars = consdata->nvars;
8408 hmin = consdata->hmin;
8409 hmax = consdata->hmax;
8427 startindices[
j] =
j;
8494 consdata->covercuts =
TRUE;
8518 SCIP_Bool cutsasconss
8533 assert(consdata->nvars > 0);
8535 capacity = consdata->capacity;
8576 if( consdata->demandrowssize == 0 )
8578 consdata->demandrowssize = 10;
8581 if( consdata->ndemandrows == consdata->demandrowssize )
8583 consdata->demandrowssize *= 2;
8587 consdata->demandrows[consdata->ndemandrows] = row;
8588 consdata->ndemandrows++;
8604 SCIP_Bool cutsasconss
8630 nvars = consdata->nvars;
8643 SCIPdebugMsg(
scip,
"create sorted event points for cumulative constraint <%s> with %d jobs\n",
8652 hmin = consdata->hmin;
8653 hmax = consdata->hmax;
8735 SCIP_Bool cutsasconss
8743 assert(consdata->ndemandrows == 0);
8746 if( consdata->linkingconss ==
NULL )
8778 SCIP_Bool cutsasconss,
8779 SCIP_Bool* infeasible
8788 if( consdata->demandrows ==
NULL )
8790 assert(consdata->ndemandrows == 0);
8797 for(
r = 0;
r < consdata->ndemandrows && !(*infeasible); ++
r )
8836 if( consdata->demandrows ==
NULL )
8838 assert(consdata->ndemandrows == 0);
8848 for(
r = 0;
r < consdata->ndemandrows; ++
r )
8879 (*separated) =
TRUE;
8914 if( consdata->linkingconss ==
NULL )
8919 if( !consdata->covercuts )
8928 for(
r = 0;
r < consdata->nscoverrows; ++
r )
8943 row = consdata->scoverrows[
r];
8952 SCIPdebugMsg(
scip,
"cumulative constraint <%s> separated 1 cover cut with feasibility %g\n",
8959 (*separated) =
TRUE;
8966 for(
r = 0;
r < consdata->nbcoverrows; ++
r )
8981 row = consdata->bcoverrows[
r];
8990 SCIPdebugMsg(
scip,
"cumulative constraint <%s> separated 1 cover cut with feasibility %g\n",
8998 (*separated) =
TRUE;
9030 assert(consdata->nvars > 0);
9103 nvars = consdata->nvars;
9116 SCIPdebugMsg(
scip,
"create sorted event points for cumulative constraint <%s> with %d jobs\n",
9126 hmin = consdata->hmin;
9127 hmax = consdata->hmax;
9130 for(
j = 0;
j <
nvars && !(*cutoff); ++
j )
9196 nvars = consdata->nvars;
9203 capacity = consdata->capacity;
9208 if( consdata->demands[
j] > capacity )
9236 if( consdata->nvars == 0 )
9243 else if( consdata->nvars == 1 )
9245 if( consdata->demands[0] > consdata->capacity )
9284 hmin = consdata->hmin;
9285 hmax = consdata->hmax;
9287 SCIPdebugMsg(
scip,
"check for irrelevant jobs within cumulative constraint <%s>[%d,%d)\n",
9290 for(
j = consdata->nvars-1;
j >= 0; --
j )
9292 var = consdata->vars[
j];
9293 demand = consdata->demands[
j];
9294 duration = consdata->durations[
j];
9300 if( demand == 0 || duration == 0 )
9309 else if( est >= hmax || lct <= hmin )
9337 SCIP_Bool tightened;
9345 assert(consdata->durations[pos] > 0);
9346 assert(consdata->demands[pos] > 0);
9348 var = consdata->vars[pos];
9350 duration = consdata->durations[pos];
9353 SCIPdebugMsg(
scip,
" variable <%s>: demand <%d> is larger than the capacity <%d>\n",
9377 else if(
ect > consdata->hmin )
9453 capacity = consdata->capacity;
9455 for(
j = consdata->nvars-1;
j >= 0 && !(*cutoff); --
j )
9457 if( consdata->demands[
j] > capacity )
9481 SCIP_Bool infeasible;
9482 SCIP_Bool tightened;
9533 SCIP_Bool infeasible;
9534 SCIP_Bool tightened;
9587 if( *capacity == 1 ||
nvars <= 1 )
9600 assert(demands[v] <= *capacity);
9617 for( v = 0; v <
nvars; ++v )
9622 (*nchgcoefs) +=
nvars;
9629 for( v = 0; v <
nvars; ++v )
9630 demands[v] /= (
int)
gcd;
9632 (*capacity) /= (int)
gcd;
9634 (*nchgcoefs) +=
nvars;
9661 if( consdata->normalized )
9664 capacity = consdata->capacity;
9670 consdata->normalized =
TRUE;
9672 if( capacity > consdata->capacity )
9673 consdata->varbounds =
FALSE;
9729 for( t = 0; t < ntimepoints; ++t )
9732 if( timepoints[t] <= *hmin )
9736 if( timepoints[t] >= *hmax )
9742 if( loads[t] <= capacity )
9744 (*split) = timepoints[t];
9780 SCIP_Bool modifiable,
9786 SCIP_Bool removable,
9788 SCIP_Bool stickingatnode
9797 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
9828 if( consdata->nvars <= 1 )
9832 consdata->durations, consdata->demands, consdata->capacity, &hmin, &hmax, &
split) );
9835 if( consdata->hmin < hmin )
9839 consdata->hmin = hmin;
9844 if( consdata->hmax > hmax )
9847 consdata->hmax = hmax;
9852 if( consdata->hmax <= consdata->hmin )
9854 SCIPdebugMsg(
scip,
"constraint <%s> is redundant since hmax(%d) <= hmin(%d)\n",
9865 SCIPdebugMsg(
scip,
"split cumulative constraint <%s>[%d,%d) with %d jobs at time point %d\n",
9872 consdata->durations, consdata->demands, consdata->capacity,
split, consdata->hmax,
9877 consdata->hmax =
split;
9879 assert(consdata->hmin < consdata->hmax);
9923 SCIP_Bool* downlocks,
9959 SCIPdebugMsg(
scip,
"check for irrelevant variable for cumulative condition (hmin %d) w.r.t. earlier start time\n", hmin);
9965 for( v = 0; v <
nvars; ++v )
9981 for( v = 0; v <
nvars; ++v )
9996 duration = durations[v];
10003 ect = est + duration;
10005 lct =
lst + duration;
10022 SCIPdebugMsg(
scip,
" variable <%s>[%g,%g] with duration <%d> is irrelevant\n",
10049 SCIPdebugMsg(
scip,
" variables <%s>[%d,%d] (duration <%d>) is irrelevant due to no up lock\n",
10061 SCIPdebugMsg(
scip,
" remove down lock of variable <%s>[%g,%g] with duration <%d>\n",
10065 downlocks[v] =
FALSE;
10072 else if(
ect <= hmin )
10090 SCIPdebugMsg(
scip,
" variable <%s>[%d,%d] with duration <%d> is irrelevant due to dual fixing wrt EST\n",
10122 SCIP_Bool infeasible;
10157 SCIPdebugMsg(
scip,
"********* check variable <%s>[%g,%g] with duration <%d> (hmin %d)\n",
10208 SCIP_Bool* downlocks,
10209 SCIP_Bool* uplocks,
10244 SCIPdebugMsg(
scip,
"check for irrelevant variable for cumulative condition (hmax %d) w.r.t. latest completion time\n", hmax);
10250 for( v = 0; v <
nvars; ++v )
10266 for( v = 0; v <
nvars; ++v )
10280 duration = durations[v];
10287 ect = est + duration;
10305 SCIPdebugMsg(
scip,
" variable <%s>[%g,%g] with duration <%d> is irrelevant\n",
10323 if( !downlocks[v] )
10329 SCIPdebugMsg(
scip,
" variables <%s>[%d,%d] with duration <%d> is irrelevant due to no down lock\n",
10341 SCIPdebugMsg(
scip,
" remove up lock of variable <%s>[%g,%g] with duration <%d>\n",
10345 uplocks[v] =
FALSE;
10352 else if(
lst >= hmax )
10370 SCIPdebugMsg(
scip,
" variable <%s>[%d,%d] with duration <%d> is irrelevant due to dual fixing wrt LCT\n",
10402 SCIP_Bool infeasible;
10474 nvars = consdata->nvars;
10484 consdata->hmin, consdata->hmax, consdata->downlocks, consdata->uplocks, cons,
10489 consdata->hmin, consdata->hmax, consdata->downlocks, consdata->uplocks, cons,
10495 for( v =
nvars-1; v >= 0; --v )
10503 var = consdata->vars[v];
10512 if( consdata->capacity < consdata->demands[v] )
10518 consdata->capacity -= consdata->demands[v];
10519 consdata->varbounds =
FALSE;
10541 SCIP_Longint** demands,
10575 if( consdata->demands[
varidx] < consdata->capacity )
10602 SCIP_Longint* demands;
10613 assert(consdata->nvars > 0);
10614 assert(consdata->capacity > 0);
10681 nvars = consdata->nvars;
10689 SCIPdebugMsg(
scip,
"try to tighten capacity for cumulative constraint <%s> with capacity %d\n",
10746 if(
freecapacity == 0 && consdata->demands[startindices[
j]] < consdata->capacity)
10749 SCIPdebugMsg(
scip,
"--> cannot decrease capacity since sum equals capacity\n");
10766 SCIPdebugMsg(
scip,
"+-+-+-+-+-+ --> CHANGE capacity of cons<%s> from %d to %d\n",
10771 if( consdata->demands[
j] == consdata->capacity )
10783 consdata->varbounds =
FALSE;
10814 nvars = consdata->nvars;
10833 if(
mindemand + consdata->demands[
j] > consdata->capacity && consdata->demands[
j] < consdata->capacity )
10836 consdata->demands[
j], consdata->capacity);
10837 consdata->demands[
j] = consdata->capacity;
10853 assert(consdata->demands[
j] <= consdata->capacity);
10855 if( consdata->demands[
j] == consdata->capacity )
10877 if( consdata->demands[
j] + consdata->demands[
i] <= consdata->capacity )
10887 consdata->demands[
j], consdata->capacity);
10888 consdata->demands[
j] = consdata->capacity;
10895 SCIPdebugMsg(
scip,
"+-+-+-+-+-+changed %d coefficients of variables of cumulative constraint<%s>\n",
10920 nvars = consdata->nvars;
10923 hmin = consdata->hmin;
10924 hmax = consdata->hmax;
10927 for( v = 0; v <
nvars; ++v )
10936 var = consdata->vars[v];
10939 duration = consdata->durations[v];
10942 ect = est + duration;
10944 lct =
lst + duration;
10949 if(
lst <= hmin && est < hmin - lct +
MIN(hmin,
ect) )
10953 SCIP_Bool infeasible;
10954 SCIP_Bool redundant;
10958 shift = est - (hmin - lct +
MIN(hmin,
ect));
10961 duration = hmin - lct;
10977 consdata->durations[v] = duration;
11015 capacity = consdata->capacity;
11017 if( capacity == 1 )
11029 for( v = 0; v < consdata->nvars; ++v )
11034 demands[
nvars] = 1;
11035 durations[
nvars] = consdata->durations[v];
11047 for( v = 0; v < consdata->nvars; ++v )
11052 if(
mindemand + consdata->demands[v] > capacity )
11054 demands[
nvars] = 1;
11055 durations[
nvars] = consdata->durations[v];
11132 if( conshdlrdata->normalize )
11144 if( conshdlrdata->coeftightening )
11168struct TCLIQUE_Graph
11172 SCIP_Bool** precedencematrix;
11173 SCIP_Bool** demandmatrix;
11188 return tcliquegraph->nnodes;
11197 return tcliquegraph->weights;
11209 if( tcliquegraph->precedencematrix[node1][node2] || tcliquegraph->precedencematrix[node2][node1] )
11213 if( tcliquegraph->demandmatrix[node1][node2] )
11238 assert(0 <= nodes[
i] && nodes[
i] < tcliquegraph->nnodes);
11239 assert(
i == 0 || nodes[
i-1] < nodes[
i]);
11274 nnodes = tcliquegraph->nnodes;
11395 if( tcliquegraph->size == tcliquegraph->nnodes )
11400 tcliquegraph->size = size;
11408 for( v = 0; v < tcliquegraph->nnodes; ++v )
11414 assert(tcliquegraph->nnodes < tcliquegraph->size);
11416 pos = tcliquegraph->nnodes;
11419 tcliquegraph->durations[pos] = 0;
11420 tcliquegraph->weights[pos] = 0;
11421 tcliquegraph->vars[pos] =
var;
11431 tcliquegraph->nnodes++;
11433 for( v = 0; v < tcliquegraph->nnodes; ++v )
11435 tcliquegraph->precedencematrix[v][pos] = 0;
11436 tcliquegraph->demandmatrix[v][pos] = 0;
11439 (*idx) = tcliquegraph->nnodes;
11476 for( v = 0; v <
nvars; ++v )
11492 if( tcliquegraph->durations[
idx1] == 0 )
11507 if( tcliquegraph->durations[
idx2] == 0 )
11526 if( tcliquegraph->durations[
idx2] == 0 )
11540 if( tcliquegraph->durations[
idx2] == 0 )
11600 for(
c = 0;
c < nconss; ++
c )
11612 vars = consdata->vars;
11613 demands = consdata->demands;
11615 nvars = consdata->nvars;
11616 capacity = consdata->capacity;
11629 if( tcliquegraph->durations[
idx1] == 0 || tcliquegraph->durations[
idx1] > consdata->durations[
i] )
11634 assert(consdata->durations[
j] > 0);
11636 if( demands[
i] + demands[
j] > capacity )
11656 if(
lct1 > consdata->hmax &&
lct2 > consdata->hmax )
11663 if( tcliquegraph->durations[
idx2] == 0 || tcliquegraph->durations[
idx2] > consdata->durations[
j] )
11699 transitiveClosure(tcliquegraph->precedencematrix, tcliquegraph->ninarcs, tcliquegraph->noutarcs, tcliquegraph->nnodes);
11732 durations[v] = tcliquegraph->durations[
cliquenodes[v]];
11733 assert(durations[v] > 0);
11775 nnodes = tcliquegraph->nnodes;
11779 for( v = 0; v <
nnodes; ++v )
11781 tcliquegraph->weights[v] = tcliquegraph->durations[v];
11801 if( tcliquegraph->durations[v] == 0 )
11822 tcliquegraph->demandmatrix[v][
c] =
FALSE;
11823 tcliquegraph->demandmatrix[
c][v] =
FALSE;
11827 tcliquegraph->precedencematrix[
c][v] =
FALSE;
11828 tcliquegraph->precedencematrix[v][
c] =
FALSE;
11873 (*naddconss) += nconss;
11929 if( !tcliquegraph->precedencematrix[
source][
sink] )
11932 nnodes = tcliquegraph->nnodes;
11933 vars = tcliquegraph->vars;
11951 duration = tcliquegraph->durations[
i];
11956 tcliquegraph->weights[
i] = 0;
11958 else if( tcliquegraph->precedencematrix[
source][
i] && tcliquegraph->precedencematrix[
i][
sink] )
11961 tcliquegraph->weights[
i] = duration;
11967 tcliquegraph->weights[
i] = duration;
11970 tcliquegraph->weights[
i] = 0;
12023 nnodes = tcliquegraph->nnodes;
12035 if( tcliquegraph->ninarcs[
i] == 0 )
12041 if( tcliquegraph->ninarcs[
i] == 0 )
12064 (*naddconss) += nconss;
12087 for(
c = 0;
c < nconss; ++
c )
12097 vars = consdata->vars;
12098 nvars = consdata->nvars;
12100 for( v = 0; v <
nvars; ++v )
12111 tcliquegraph->durations[idx] =
MAX(tcliquegraph->durations[idx], consdata->durations[v]);
12112 assert(tcliquegraph->durations[idx] > 0);
12128 SCIP_Bool** precedencematrix;
12129 SCIP_Bool** demandmatrix;
12169 for( v = 0; v <
nvars; ++v )
12187 (*tcliquegraph)->nnodes =
nvars;
12188 (*tcliquegraph)->varmap = varmap;
12189 (*tcliquegraph)->precedencematrix = precedencematrix;
12190 (*tcliquegraph)->demandmatrix = demandmatrix;
12191 (*tcliquegraph)->weights = weights;
12192 (*tcliquegraph)->ninarcs = ninarcs;
12193 (*tcliquegraph)->noutarcs = noutarcs;
12194 (*tcliquegraph)->durations = durations;
12195 (*tcliquegraph)->size =
nvars;
12209 for( v = (*tcliquegraph)->nnodes-1; v >= 0; --v )
12251 if( conshdlrdata->detectvarbounds )
12257 if( conshdlrdata->detectdisjunctive )
12278 if( consdata->validsignature )
12281 vars = consdata->vars;
12282 nvars = consdata->nvars;
12284 for( v = 0; v <
nvars; ++v )
12286 consdata->signature |= ((
unsigned int)1 << ((
unsigned int)
SCIPvarGetIndex(
vars[v]) % (
sizeof(
unsigned int) * 8)));
12289 consdata->validsignature =
TRUE;
12317 for(
i = 0;
i < nconss; ++
i )
12331 for(
j =
i+1;
j < nconss; ++
j )
12417 else if(
comp > 0 )
12468 if( consdata->varbounds )
12471 vars = consdata->vars;
12472 durations = consdata->durations;
12473 demands = consdata->demands;
12474 capacity = consdata->capacity;
12475 nvars = consdata->nvars;
12489 var = consdata->vars[
i];
12513 SCIP_Bool infeasible;
12535 (*naddconss) += nconss;
12537 consdata->varbounds =
TRUE;
12569 sol ==
NULL ?
"LP" :
"relaxation");
12576 if( conshdlrdata->usebinvars )
12588 SCIP_Bool violated;
12609 SCIP_Bool violated;
12676#ifdef SCIP_STATISTIC
12677 if( !conshdlrdata->iscopy )
12681 conshdlrdata->nlbtimetable, conshdlrdata->nubtimetable, conshdlrdata->ncutofftimetable);
12683 conshdlrdata->nlbedgefinder, conshdlrdata->nubedgefinder, conshdlrdata->ncutoffedgefinder);
12685 conshdlrdata->ncutoffoverload, conshdlrdata->ncutoffoverloadTTEF);
12707 conshdlrdata->detectedredundant =
FALSE;
12709 for(
c = 0;
c < nconss; ++
c )
12722#ifdef SCIP_STATISTIC
12732 for(
c = 0;
c < nconss; ++
c )
12741 if( !conshdlrdata->iscopy )
12743 SCIPstatisticPrintf(
"@11 added variables bounds constraints %d\n", conshdlrdata->naddedvarbounds);
12744 SCIPstatisticPrintf(
"@22 added disjunctive constraints %d\n", conshdlrdata->naddeddisjunctives);
12770 for(
c = 0;
c < nconss; ++
c )
12862 *infeasible =
FALSE;
12864 SCIPdebugMsg(
scip,
"initialize LP relaxation for %d cumulative constraints\n", nconss);
12866 if( conshdlrdata->usebinvars )
12869 for(
c = 0;
c < nconss && !(*infeasible); ++
c )
12874 if( conshdlrdata->cutsasconss )
12916 if( conshdlrdata->usebinvars )
12924 if( !
cutoff && conshdlrdata->usecovercuts )
12933 if( conshdlrdata->sepaold )
12977 if( conshdlrdata->usebinvars )
12985 if( !
cutoff && conshdlrdata->usecovercuts )
12993 if( conshdlrdata->sepaold )
13075 SCIP_Bool violated =
FALSE;
13126 &nchgbds, &naggrvars, &nchgbds, &ndelconss, &nchgbds, &nchgbds, &nchgbds, &
cutoff, &
cutoff) );
13129 &nchgbds, &nchgbds, &ndelconss, &nchgbds, &nchgbds, &nchgbds, &
cutoff, &
cutoff) );
13141 if( !
cutoff && nchgbds == 0 )
13162 else if( nchgbds > 0 )
13164 SCIPdebugMsg(
scip,
"delete (locally) %d constraints and changed %d variable bounds\n", ndelconss, nchgbds);
13213 for(
c = 0;
c < nconss && !
cutoff; ++
c )
13226 nfixedvars, naggrvars, nchgbds, ndelconss, naddconss, nchgcoefs, nchgsides, &
cutoff, &
unbounded) );
13229 nfixedvars, nchgbds, ndelconss, naddconss, nchgcoefs, nchgsides, &
cutoff, &
unbounded) );
13263 && (conshdlrdata->detectvarbounds || conshdlrdata->detectdisjunctive)
13270 conshdlrdata->detectedredundant =
TRUE;
13278 SCIPdebugMsg(
scip,
"delete %d constraints and changed %d variable bounds (cutoff %u)\n",
13317 SCIPdebugMsg(
scip,
"resolve propagation: variable <%s>, cumulative constraint <%s> (capacity %d, propagation %d, H=[%d,%d))\n",
13322 consdata->durations, consdata->demands, consdata->capacity, consdata->hmin, consdata->hmax,
13345 vars = consdata->vars;
13348 for( v = 0; v < consdata->nvars; ++v )
13350 if( consdata->downlocks[v] && consdata->uplocks[v] )
13355 else if( consdata->downlocks[v] )
13359 else if( consdata->uplocks[v] )
13389 const char* consname;
13426 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
13511 demands[
nvars] = demand;
13512 durations[
nvars] = duration;
13515 while( *
str !=
')' );
13526 hmax = (int)(value);
13534 capacity = (int)value;
13538 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
13565 (*success) =
FALSE;
13586 (*nvars) = consdata->nvars;
13616 consdata->propagated =
FALSE;
13653#ifdef SCIP_STATISTIC
13677 "should time-table (core-times) propagator be used to infer bounds?",
13681 "should edge-finding be used to detect an overload?",
13685 "should edge-finding be used to infer bounds?",
13688 "constraints/" CONSHDLR_NAME "/useadjustedjobs",
"should edge-finding be executed?",
13692 "should time-table edge-finding be used to detect an overload?",
13696 "should time-table edge-finding be used to infer bounds?",
13700 "constraints/" CONSHDLR_NAME "/usebinvars",
"should the binary representation be used?",
13703 "constraints/" CONSHDLR_NAME "/localcuts",
"should cuts be added only locally?",
13706 "constraints/" CONSHDLR_NAME "/usecovercuts",
"should covering cuts be added every node?",
13710 "should the cumulative constraint create cuts as knapsack constraints?",
13714 "shall old sepa algo be applied?",
13718 "constraints/" CONSHDLR_NAME "/fillbranchcands",
"should branching candidates be added to storage?",
13723 "constraints/" CONSHDLR_NAME "/dualpresolve",
"should dual presolving be applied?",
13726 "constraints/" CONSHDLR_NAME "/coeftightening",
"should coefficient tightening be applied?",
13729 "constraints/" CONSHDLR_NAME "/normalize",
"should demands and capacity be normalized?",
13733 "should pairwise constraint comparison be performed in presolving?",
13736 "constraints/" CONSHDLR_NAME "/disjunctive",
"extract disjunctive constraints?",
13741 "number of branch-and-bound nodes to solve an independent cumulative constraint (-1: no limit)?",
13744 "constraints/" CONSHDLR_NAME "/detectdisjunctive",
"search for conflict set via maximal cliques to detect disjunctive constraints",
13747 "constraints/" CONSHDLR_NAME "/detectvarbounds",
"search for conflict set via maximal cliques to detect variable bound constraints",
13752 "constraints/" CONSHDLR_NAME "/usebdwidening",
"should bound widening be used during the conflict analysis?",
13770 SCIP_Bool separate,
13780 SCIP_Bool modifiable,
13786 SCIP_Bool removable,
13788 SCIP_Bool stickingatnode
13800 if( conshdlr ==
NULL )
13809 SCIP_CALL(
consdataCreate(
scip, &consdata,
vars,
NULL, durations, demands,
nvars, capacity, 0,
INT_MAX, check) );
13813 initial, separate, enforce, check,
propagate,
13814 local, modifiable, dynamic, removable, stickingatnode) );
13878 consdata->hmin = hmin;
13900 return consdata->hmin;
13920 assert(hmax >= consdata->hmin);
13922 consdata->hmax = hmax;
13944 return consdata->hmax;
13965 return consdata->vars;
13986 return consdata->nvars;
14007 return consdata->capacity;
14028 return consdata->durations;
14049 return consdata->demands;
14065 SCIP_Bool* violated,
14110 hmin, hmax,
split) );
14123 SCIP_Bool* downlocks,
14124 SCIP_Bool* uplocks,
14159 SCIP_Bool* initialized,
14166 SCIP_Bool redundant;
14177 if( conshdlr ==
NULL )
14189 nvars,
vars, durations, demands, capacity, hmin, hmax, cons,
14238 file =
fopen(filename,
"w");
14251 nvars = consdata->nvars;
14259 for( v = 0; v <
nvars; ++v )
14263 var = consdata->vars[v];
14270 else if( !consdata->downlocks[v] || !consdata->uplocks[v] )
14278 for( v = 0; v <
nvars; ++v )
14284 var = consdata->vars[v];
14334 if( conshdlr ==
NULL )
14365 SCIP_Real timelimit,
14366 SCIP_Real memorylimit,
14367 SCIP_Longint maxnodes,
14369 SCIP_Bool* infeasible,
14378 (*infeasible) =
FALSE;
14379 (*unbounded) =
FALSE;
14387 if( conshdlr ==
NULL )
14398 if( timelimit > 0.0 && memorylimit > 10 )
14401 hmin, hmax, timelimit, memorylimit, maxnodes, solved, infeasible,
unbounded,
error) );
14437 for( v = 0; v <
nvars; ++v )
14445 for( v = 0; v <
nvars; ++v )
14455 duration = durations[idx];
14466 SCIP_Bool infeasible;
14505 for( t = 0; t < ntimepoints - 1; ++t )
14508 if( loads[t] > capacity )
14510 assert(t == 0 || loads[t-1] <= capacity);
14511 return timepoints[t];
14535 for( t = ntimepoints - 1; t >= 0; --t )
14538 if( loads[t] > capacity )
14540 assert(t == ntimepoints-1 || loads[t+1] <= capacity);
14541 return timepoints[t+1];
static SCIP_RETCODE branch(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_RESULT *result)
static SCIP_RETCODE adjustOversizedJobBounds(SCIP *scip, SCIP_CONSDATA *consdata, int pos, int *nchgbds, int *naddconss, SCIP_Bool *cutoff)
static int inferInfoGetData1(INFERINFO inferinfo)
static SCIP_RETCODE createTcliqueGraph(SCIP *scip, TCLIQUE_GRAPH **tcliquegraph)
#define DEFAULT_USEBDWIDENING
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
static void createSortedEventpointsSol(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, int *durations, int *starttimes, int *endtimes, int *startindices, int *endindices)
static void createSortedEventpoints(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *starttimes, int *endtimes, int *startindices, int *endindices, SCIP_Bool local)
static void consdataCalcSignature(SCIP_CONSDATA *consdata)
static SCIP_RETCODE propagateUbTTEF(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, int *newlbs, int *newubs, int *lbinferinfos, int *ubinferinfos, int *lsts, int *flexenergies, int *perm, int *ests, int *lcts, int *coreEnergyAfterEst, int *coreEnergyAfterLct, SCIP_Bool *initialized, SCIP_Bool *explanation, SCIP_Bool *cutoff)
#define DEFAULT_NORMALIZE
static PROPRULE inferInfoGetProprule(INFERINFO inferinfo)
static SCIP_RETCODE collectIntVars(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR ***activevars, int *startindices, int curtime, int nstarted, int nfinished, SCIP_Bool lower, int *lhs)
static SCIP_RETCODE getActiveVar(SCIP *scip, SCIP_VAR **var, int *scalar, int *constant)
#define DEFAULT_DETECTVARBOUNDS
static SCIP_RETCODE createConsCumulative(SCIP *scip, const char *name, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, 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)
#define CONSHDLR_CHECKPRIORITY
static SCIP_RETCODE presolveConsEst(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int hmin, int hmax, SCIP_Bool *downlocks, SCIP_Bool *uplocks, SCIP_CONS *cons, SCIP_Bool *irrelevants, int *nfixedvars, int *nchgsides, SCIP_Bool *cutoff)
#define DEFAULT_TTEFINFER
static void subtractStartingJobDemands(SCIP_CONSDATA *consdata, int curtime, int *starttimes, int *startindices, int *freecapacity, int *idx, int nvars)
static SCIP_RETCODE varMayRoundUp(SCIP *scip, SCIP_VAR *var, SCIP_Bool *roundable)
#define DEFAULT_USECOVERCUTS
static SCIP_Longint computeCoreWithInterval(int begin, int end, int ect, int lst)
static SCIP_RETCODE applyAlternativeBoundsFixing(SCIP *scip, SCIP_VAR **vars, int nvars, int *alternativelbs, int *alternativeubs, int *downlocks, int *uplocks, int *nfixedvars, SCIP_Bool *cutoff)
#define DEFAULT_LOCALCUTS
static SCIP_RETCODE checkOverloadViaThetaTree(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_CONS *cons, SCIP_Bool propest, SCIP_Bool *initialized, SCIP_Bool *explanation, int *nchgbds, SCIP_Bool *cutoff)
#define DEFAULT_COEFTIGHTENING
static SCIP_RETCODE propagateCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_PRESOLTIMING presoltiming, int *nchgbds, int *ndelconss, SCIP_Bool *cutoff)
static SCIP_RETCODE createPrecedenceCons(SCIP *scip, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, int distance)
static SCIP_Bool isConsIndependently(SCIP_CONS *cons)
#define CONSHDLR_PROP_TIMING
static SCIP_RETCODE separateConsOnIntegerVariables(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool lower, SCIP_Bool *separated, SCIP_Bool *cutoff)
static SCIP_RETCODE analyzeConflictOverload(SCIP *scip, SCIP_BTNODE **leaves, int capacity, int nleaves, int est, int lct, int reportedenergy, SCIP_Bool propest, int shift, SCIP_Bool usebdwidening, SCIP_Bool *initialized, SCIP_Bool *explanation)
static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)
static void freeTcliqueGraph(SCIP *scip, TCLIQUE_GRAPH **tcliquegraph)
static SCIP_Bool checkDemands(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE createCoverCuts(SCIP *scip, SCIP_CONS *cons)
static void consdataPrint(SCIP *scip, SCIP_CONSDATA *consdata, FILE *file)
#define CONSHDLR_MAXPREROUNDS
static SCIP_RETCODE tightenUbTTEF(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_VAR *var, int duration, int demand, int est, int lst, int lct, int begin, int end, SCIP_Longint energy, int *bestub, int *inferinfos, SCIP_Bool *initialized, SCIP_Bool *explanation, SCIP_Bool *cutoff)
static SCIP_RETCODE propagateTimetable(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_PROFILE *profile, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_CONS *cons, int *nchgbds, SCIP_Bool *initialized, SCIP_Bool *explanation, SCIP_Bool *cutoff)
static SCIP_RETCODE computeImpliedEst(SCIP *scip, SCIP_VAR *var, SCIP_HASHMAP *addedvars, int *est)
static SCIP_RETCODE enforceConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
static SCIP_RETCODE collectBranchingCands(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, int *nbranchcands)
static SCIP_RETCODE presolveCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_PRESOLTIMING presoltiming, int *nfixedvars, int *nchgbds, int *ndelconss, int *naddconss, int *nchgcoefs, int *nchgsides, SCIP_Bool *cutoff, SCIP_Bool *unbounded)
static int computeEnergyContribution(SCIP_BTNODE *node)
#define DEFAULT_PRESOLPAIRWISE
static SCIP_RETCODE inferboundsEdgeFinding(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS *cons, SCIP_BT *tree, SCIP_BTNODE **leaves, int capacity, int ncands, SCIP_Bool propest, int shift, SCIP_Bool *initialized, SCIP_Bool *explanation, int *nchgbds, SCIP_Bool *cutoff)
static SCIP_RETCODE presolveConsEffectiveHorizon(SCIP *scip, SCIP_CONS *cons, int *nfixedvars, int *nchgcoefs, int *nchgsides, SCIP_Bool *cutoff)
#define CONSHDLR_SEPAPRIORITY
static SCIP_RETCODE constraintNonOverlappingGraph(SCIP *scip, TCLIQUE_GRAPH *tcliquegraph, SCIP_CONS **conss, int nconss)
static SCIP_RETCODE createCoreProfile(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_PROFILE *profile, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_Bool *initialized, SCIP_Bool *explanation, SCIP_Bool *cutoff)
static SCIP_RETCODE consCheckRedundancy(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_Bool *redundant)
static SCIP_RETCODE detectRedundantConss(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS **conss, int nconss, int *naddconss)
static SCIP_RETCODE getNodeIdx(SCIP *scip, TCLIQUE_GRAPH *tcliquegraph, SCIP_VAR *var, int *idx)
static SCIP_RETCODE computeAlternativeBounds(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool local, int *alternativelbs, int *alternativeubs, int *downlocks, int *uplocks)
static SCIP_RETCODE removeRedundantConss(SCIP *scip, SCIP_CONS **conss, int nconss, int *ndelconss)
static SCIP_RETCODE findPrecedenceConss(SCIP *scip, TCLIQUE_GRAPH *tcliquegraph, int *naddconss)
static SCIP_RETCODE fixIntegerVariableUb(SCIP *scip, SCIP_VAR *var, SCIP_Bool uplock, int *nfixedvars)
static SCIP_RETCODE createCapacityRestriction(SCIP *scip, SCIP_CONS *cons, int *startindices, int curtime, int nstarted, int nfinished, SCIP_Bool cutsasconss)
#define DEFAULT_DETECTDISJUNCTIVE
static void addEndingJobDemands(SCIP_CONSDATA *consdata, int curtime, int *endtimes, int *endindices, int *freecapacity, int *idx, int nvars)
static INFERINFO getInferInfo(PROPRULE proprule, int data1, int data2)
static SCIP_RETCODE setupAndSolveCumulativeSubscip(SCIP *subscip, SCIP_Real *objvals, int *durations, int *demands, int njobs, int capacity, int hmin, int hmax, SCIP_Longint maxnodes, SCIP_Real timelimit, SCIP_Real memorylimit, SCIP_Real *ests, SCIP_Real *lsts, SCIP_Bool *infeasible, SCIP_Bool *unbounded, SCIP_Bool *solved, SCIP_Bool *error)
static int computeOverlap(int begin, int end, int est, int lst, int duration)
static SCIP_Longint computeTotalEnergy(int *durations, int *demands, int njobs)
static SCIP_RETCODE strengthenVarbounds(SCIP *scip, SCIP_CONS *cons, int *nchgbds, int *naddconss)
static SCIP_RETCODE respropCumulativeCondition(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_VAR *infervar, INFERINFO inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_Bool usebdwidening, SCIP_Bool *explanation, SCIP_RESULT *result)
static SCIP_RETCODE removeIrrelevantJobs(SCIP *scip, SCIP_CONS *cons)
static INFERINFO intToInferInfo(int i)
static void createSelectedSortedEventpointsSol(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol, int *starttimes, int *endtimes, int *startindices, int *endindices, int *nvars, SCIP_Bool lower)
static void updateEnvelope(SCIP *scip, SCIP_BTNODE *node)
static SCIP_RETCODE propagateEdgeFinding(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_CONS *cons, SCIP_Bool *initialized, SCIP_Bool *explanation, int *nchgbds, SCIP_Bool *cutoff)
struct SCIP_NodeData SCIP_NODEDATA
#define DEFAULT_CUTSASCONSS
#define DEFAULT_DUALPRESOLVE
static SCIP_RETCODE analyzeEnergyRequirement(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int begin, int end, SCIP_VAR *infervar, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_Bool usebdwidening, SCIP_Bool *explanation)
static SCIP_RETCODE applyAlternativeBoundsBranching(SCIP *scip, SCIP_VAR **vars, int nvars, int *alternativelbs, int *alternativeubs, int *downlocks, int *uplocks, SCIP_Bool *branched)
static SCIP_RETCODE applyProbingVar(SCIP *scip, SCIP_VAR **vars, int nvars, int probingpos, SCIP_Real leftub, SCIP_Real rightlb, SCIP_Real *leftimpllbs, SCIP_Real *leftimplubs, SCIP_Real *leftproplbs, SCIP_Real *leftpropubs, SCIP_Real *rightimpllbs, SCIP_Real *rightimplubs, SCIP_Real *rightproplbs, SCIP_Real *rightpropubs, int *nfixedvars, SCIP_Bool *success, SCIP_Bool *cutoff)
#define DEFAULT_TTEFCHECK
static void normalizeDemands(SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgsides)
static SCIP_Bool inferInfoIsValid(INFERINFO inferinfo)
static void computeCoreEnergyAfter(SCIP_PROFILE *profile, int nvars, int *ests, int *lcts, int *coreEnergyAfterEst, int *coreEnergyAfterLct)
static SCIP_RETCODE consCapacityConstraintsFinder(SCIP *scip, SCIP_CONS *cons, SCIP_Bool cutsasconss)
static SCIP_RETCODE createCumulativeCons(SCIP *scip, const char *name, TCLIQUE_GRAPH *tcliquegraph, int *cliquenodes, int ncliquenodes)
static void collectDataTTEF(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int hmin, int hmax, int *permests, int *ests, int *permlcts, int *lcts, int *ects, int *lsts, int *flexenergies)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_VAR **vars, SCIP_CONS **linkingconss, int *durations, int *demands, int nvars, int capacity, int hmin, int hmax, SCIP_Bool check)
static SCIP_RETCODE createCoverCutsTimepoint(SCIP *scip, SCIP_CONS *cons, int *startvalues, int time)
static SCIP_RETCODE tightenLbTTEF(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_VAR *var, int duration, int demand, int est, int ect, int lct, int begin, int end, SCIP_Longint energy, int *bestlb, int *inferinfos, SCIP_Bool *initialized, SCIP_Bool *explanation, SCIP_Bool *cutoff)
static SCIP_RETCODE consdataDeletePos(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_CONS *cons, int pos)
static SCIP_RETCODE propagateAllConss(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool local, int *nfixedvars, SCIP_Bool *cutoff, SCIP_Bool *branched)
static SCIP_RETCODE presolveConsLct(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int hmin, int hmax, SCIP_Bool *downlocks, SCIP_Bool *uplocks, SCIP_CONS *cons, SCIP_Bool *irrelevants, int *nfixedvars, int *nchgsides, SCIP_Bool *cutoff)
static int inferInfoGetData2(INFERINFO inferinfo)
static void traceThetaEnvelop(SCIP_BTNODE *node, SCIP_BTNODE **omegaset, int *nelements, int *est, int *lct, int *energy)
static SCIP_RETCODE propagateCumulativeCondition(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_PRESOLTIMING presoltiming, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_CONS *cons, int *nchgbds, SCIP_Bool *redundant, SCIP_Bool *initialized, SCIP_Bool *explanation, SCIP_Bool *cutoff)
static SCIP_RETCODE resolvePropagationCoretimes(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_VAR *infervar, int inferdemand, int inferpeak, int relaxedpeak, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool usebdwidening, int *provedpeak, SCIP_Bool *explanation)
static SCIP_RETCODE consdataDropAllEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE collectBinaryVars(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR ***vars, int **coefs, int *nvars, int *startindices, int curtime, int nstarted, int nfinished)
#define DEFAULT_USEADJUSTEDJOBS
static SCIP_RETCODE projectVbd(SCIP *scip, TCLIQUE_GRAPH *tcliquegraph)
static SCIP_RETCODE createDisjuctiveCons(SCIP *scip, SCIP_CONS *cons, int *naddconss)
static SCIP_RETCODE deleteLambdaLeaf(SCIP *scip, SCIP_BT *tree, SCIP_BTNODE *node)
static SCIP_RETCODE createRelaxation(SCIP *scip, SCIP_CONS *cons, SCIP_Bool cutsasconss)
static SCIP_RETCODE computeEffectiveHorizon(SCIP *scip, SCIP_CONS *cons, int *ndelconss, int *naddconss, int *nchgsides)
static SCIP_RETCODE enforceSolution(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_Bool branch, SCIP_RESULT *result)
static SCIP_RETCODE deleteTrivilCons(SCIP *scip, SCIP_CONS *cons, int *ndelconss, SCIP_Bool *cutoff)
static SCIP_RETCODE computeMinDistance(SCIP *scip, TCLIQUE_GRAPH *tcliquegraph, int source, int sink, int *naddconss)
static SCIP_RETCODE varMayRoundDown(SCIP *scip, SCIP_VAR *var, SCIP_Bool *roundable)
static void collectDemands(SCIP *scip, SCIP_CONSDATA *consdata, int *startindices, int curtime, int nstarted, int nfinished, SCIP_Longint **demands, int *ndemands)
#define CONSHDLR_PROPFREQ
static SCIP_RETCODE createCapacityRestrictionIntvars(SCIP *scip, SCIP_CONS *cons, int *startindices, int curtime, int nstarted, int nfinished, SCIP_Bool lower, SCIP_Bool *cutoff)
static SCIP_RETCODE computeImpliedLct(SCIP *scip, SCIP_VAR *var, int duration, SCIP_HASHMAP *addedvars, int *lct)
static SCIP_RETCODE findCumulativeConss(SCIP *scip, TCLIQUE_GRAPH *tcliquegraph, int *naddconss)
static SCIP_RETCODE tightenCoefs(SCIP *scip, SCIP_CONS *cons, int *nchgcoefs)
static SCIP_RETCODE tightenCapacity(SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgsides)
static SCIP_BTNODE * findResponsibleLambdaLeafTraceEnergy(SCIP_BTNODE *node)
static SCIP_RETCODE analyseInfeasibelCoreInsertion(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_VAR *infervar, int inferduration, int inferdemand, int inferpeak, SCIP_Bool usebdwidening, SCIP_Bool *initialized, SCIP_Bool *explanation)
static SCIP_RETCODE consdataFreeRows(SCIP *scip, SCIP_CONSDATA **consdata)
#define CONSHDLR_PRESOLTIMING
static SCIP_RETCODE initializeDurations(SCIP *scip, TCLIQUE_GRAPH *tcliquegraph, SCIP_CONS **conss, int nconss)
static SCIP_Bool impliesVlbPrecedenceCondition(SCIP *scip, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconst, int duration)
static SCIP_RETCODE separateCoverCutsCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *separated, SCIP_Bool *cutoff)
static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)
static SCIP_RETCODE coretimesUpdateLb(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_CONS *cons, SCIP_PROFILE *profile, int idx, int *nchgbds, SCIP_Bool usebdwidening, SCIP_Bool *initialized, SCIP_Bool *explanation, SCIP_Bool *infeasible)
static SCIP_RETCODE solveIndependentCons(SCIP *scip, SCIP_CONS *cons, SCIP_Longint maxnodes, int *nchgbds, int *nfixedvars, int *ndelconss, SCIP_Bool *cutoff, SCIP_Bool *unbounded)
static void initializeLocks(SCIP_CONSDATA *consdata, SCIP_Bool locked)
static SCIP_BTNODE * findResponsibleLambdaLeafTraceEnvelop(SCIP_BTNODE *node)
static SCIP_RETCODE fixIntegerVariableLb(SCIP *scip, SCIP_VAR *var, SCIP_Bool downlock, int *nfixedvars)
#define CONSHDLR_EAGERFREQ
#define DEFAULT_USEBINVARS
static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE coretimesUpdateUb(SCIP *scip, SCIP_VAR *var, int duration, int demand, int capacity, SCIP_CONS *cons, SCIP_PROFILE *profile, int idx, int *nchgbds)
static SCIP_RETCODE checkCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *violated, SCIP_Bool printreason)
static void collectThetaSubtree(SCIP_BTNODE *node, SCIP_BTNODE **omegaset, int *nelements, int *est, int *lct, int *energy)
static int computeEstOmegaset(SCIP *scip, int duration, int demand, int capacity, int est, int lct, int energy)
#define CONSHDLR_ENFOPRIORITY
struct InferInfo INFERINFO
static SCIP_RETCODE propagateTTEF(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_PROFILE *profile, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_CONS *cons, int *nchgbds, SCIP_Bool *initialized, SCIP_Bool *explanation, SCIP_Bool *cutoff)
static SCIP_RETCODE insertThetanode(SCIP *scip, SCIP_BT *tree, SCIP_BTNODE *node, SCIP_NODEDATA *nodedatas, int *nodedataidx, int *nnodedatas)
static void traceLambdaEnvelop(SCIP_BTNODE *node, SCIP_BTNODE **omegaset, int *nelements, int *est, int *lct, int *energy)
#define CONSHDLR_DELAYSEPA
static SCIP_RETCODE computePeak(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol, int *timepoint)
#define DEFAULT_FILLBRANCHCANDS
static SCIP_RETCODE consdataCollectLinkingCons(SCIP *scip, SCIP_CONSDATA *consdata)
static SCIP_RETCODE propagateLbTTEF(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, int *newlbs, int *newubs, int *lbinferinfos, int *ubinferinfos, int *ects, int *flexenergies, int *perm, int *ests, int *lcts, int *coreEnergyAfterEst, int *coreEnergyAfterLct, SCIP_Bool *initialized, SCIP_Bool *explanation, SCIP_Bool *cutoff)
static void transitiveClosure(SCIP_Bool **adjmatrix, int *ninarcs, int *noutarcs, int nnodes)
static SCIP_RETCODE getHighestCapacityUsage(SCIP *scip, SCIP_CONS *cons, int *startindices, int curtime, int nstarted, int nfinished, int *bestcapacity)
static SCIP_RETCODE constructIncompatibilityGraph(SCIP *scip, TCLIQUE_GRAPH *tcliquegraph, SCIP_CONS **conss, int nconss)
static SCIP_RETCODE removeOversizedJobs(SCIP *scip, SCIP_CONS *cons, int *nchgbds, int *nchgcoefs, int *naddconss, SCIP_Bool *cutoff)
static void updateKeyOnTrace(SCIP_BTNODE *node, SCIP_Real key)
static int inferInfoToInt(INFERINFO inferinfo)
static SCIP_RETCODE consdataDropEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos)
static void traceLambdaEnergy(SCIP_BTNODE *node, SCIP_BTNODE **omegaset, int *nelements, int *est, int *lct, int *energy)
static SCIP_RETCODE computeEffectiveHorizonCumulativeCondition(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int *hmin, int *hmax, int *split)
static SCIP_RETCODE separateConsBinaryRepresentation(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *separated, SCIP_Bool *cutoff)
static void normalizeCumulativeCondition(SCIP *scip, int nvars, int *demands, int *capacity, int *nchgcoefs, int *nchgsides)
static SCIP_Bool impliesVubPrecedenceCondition(SCIP *scip, SCIP_VAR *var, SCIP_Real vubcoef, SCIP_Real vubconst, int duration)
#define CONSHDLR_DELAYPROP
static SCIP_RETCODE moveNodeToLambda(SCIP *scip, SCIP_BT *tree, SCIP_BTNODE *node)
#define DEFAULT_DISJUNCTIVE
static SCIP_RETCODE consdataCatchEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE addRelaxation(SCIP *scip, SCIP_CONS *cons, SCIP_Bool cutsasconss, SCIP_Bool *infeasible)
static SCIP_RETCODE checkCumulativeCondition(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_Bool *violated, SCIP_CONS *cons, SCIP_Bool printreason)
constraint handler for cumulative constraints
Constraint handler for knapsack constraints of the form , x binary and .
constraint handler for linking binary variables to a linking (continuous or integer) variable
static SCIP_RETCODE solveCumulative(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_Bool local, SCIP_Real *ests, SCIP_Real *lsts, SCIP_Longint maxnodes, SCIP_Bool *solved, SCIP_Bool *infeasible, SCIP_Bool *unbounded, SCIP_Bool *error)
#define SCIP_CALL_TERMINATE(retcode, x, TERM)
#define SCIP_CALL_FINALLY(x, y)
static const NodeData nodedata[]
void SCIPbtnodeSetRightchild(SCIP_BTNODE *node, SCIP_BTNODE *right)
SCIP_BTNODE * SCIPbtnodeGetRightchild(SCIP_BTNODE *node)
SCIP_Bool SCIPbtIsEmpty(SCIP_BT *tree)
SCIP_RETCODE SCIPbtCreate(SCIP_BT **tree, BMS_BLKMEM *blkmem)
void SCIPbtnodeFree(SCIP_BT *tree, SCIP_BTNODE **node)
SCIP_Bool SCIPbtnodeIsLeaf(SCIP_BTNODE *node)
void * SCIPbtnodeGetData(SCIP_BTNODE *node)
SCIP_RETCODE SCIPbtnodeCreate(SCIP_BT *tree, SCIP_BTNODE **node, void *dataptr)
SCIP_Bool SCIPbtnodeIsRightchild(SCIP_BTNODE *node)
void SCIPbtnodeSetParent(SCIP_BTNODE *node, SCIP_BTNODE *parent)
SCIP_Bool SCIPbtnodeIsLeftchild(SCIP_BTNODE *node)
void SCIPbtnodeSetLeftchild(SCIP_BTNODE *node, SCIP_BTNODE *left)
SCIP_BTNODE * SCIPbtnodeGetParent(SCIP_BTNODE *node)
void SCIPbtFree(SCIP_BT **tree)
SCIP_BTNODE * SCIPbtnodeGetLeftchild(SCIP_BTNODE *node)
void SCIPbtSetRoot(SCIP_BT *tree, SCIP_BTNODE *root)
SCIP_Bool SCIPbtnodeIsRoot(SCIP_BTNODE *node)
SCIP_BTNODE * SCIPbtGetRoot(SCIP_BT *tree)
int SCIPgetHminCumulative(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPpropCumulativeCondition(SCIP *scip, SCIP_PRESOLTIMING presoltiming, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_CONS *cons, int *nchgbds, SCIP_Bool *initialized, SCIP_Bool *explanation, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPgetBinvarsLinking(SCIP *scip, SCIP_CONS *cons, SCIP_VAR ***binvars, int *nbinvars)
SCIP_RETCODE SCIPcreateConsBasicSetpart(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars)
int * SCIPgetDurationsCumulative(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPexistsConsLinking(SCIP *scip, SCIP_VAR *linkvar)
SCIP_RETCODE SCIPsplitCumulativeCondition(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int *hmin, int *hmax, int *split)
SCIP_RETCODE SCIPaddCoefKnapsack(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Longint weight)
SCIP_RETCODE SCIPvisualizeConsCumulative(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBasicCumulative(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity)
#define SCIP_DECL_SOLVECUMULATIVE(x)
int SCIPcomputeHmax(SCIP *scip, SCIP_PROFILE *profile, int capacity)
SCIP_CONS * SCIPgetConsLinking(SCIP *scip, SCIP_VAR *linkvar)
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)
SCIP_RETCODE SCIPpresolveCumulativeCondition(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int hmin, int hmax, SCIP_Bool *downlocks, SCIP_Bool *uplocks, SCIP_CONS *cons, SCIP_Bool *irrelevants, int *nfixedvars, int *nchgsides, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPcheckCumulativeCondition(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_Bool *violated, SCIP_CONS *cons, SCIP_Bool printreason)
SCIP_RETCODE SCIPsetSolveCumulative(SCIP *scip,)
SCIP_VAR ** SCIPgetVarsCumulative(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBasicKnapsack(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Longint *weights, SCIP_Longint capacity)
int * SCIPgetDemandsCumulative(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPsolveCumulative(SCIP *scip, int njobs, SCIP_Real *ests, SCIP_Real *lsts, SCIP_Real *objvals, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_Real timelimit, SCIP_Real memorylimit, SCIP_Longint maxnodes, SCIP_Bool *solved, SCIP_Bool *infeasible, SCIP_Bool *unbounded, SCIP_Bool *error)
SCIP_RETCODE SCIPcreateConsLinking(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *linkvar, SCIP_VAR **binvars, SCIP_Real *vals, int nbinvars, 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 SCIPsolveKnapsackExactly(SCIP *scip, int nitems, SCIP_Longint *weights, SCIP_Real *profits, SCIP_Longint capacity, int *items, int *solitems, int *nonsolitems, int *nsolitems, int *nnonsolitems, SCIP_Real *solval, SCIP_Bool *success)
SCIP_RETCODE SCIPaddCoefSetppc(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
SCIP_RETCODE SCIPcreateConsKnapsack(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Longint *weights, SCIP_Longint capacity, 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 SCIPgetHmaxCumulative(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPrespropCumulativeCondition(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_Bool *explanation, SCIP_RESULT *result)
int SCIPgetCapacityCumulative(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPnormalizeCumulativeCondition(SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int *capacity, int *nchgcoefs, int *nchgsides)
SCIP_RETCODE SCIPcreateWorstCaseProfile(SCIP *scip, SCIP_PROFILE *profile, int nvars, SCIP_VAR **vars, int *durations, int *demands)
SCIP_RETCODE SCIPcreateConsVarbound(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, 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_Real * SCIPgetValsLinking(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPsetHminCumulative(SCIP *scip, SCIP_CONS *cons, int hmin)
int SCIPgetNVarsCumulative(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPsetHmaxCumulative(SCIP *scip, SCIP_CONS *cons, int hmax)
SCIP_RETCODE SCIPcreateConsCumulative(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, 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 SCIPcomputeHmin(SCIP *scip, SCIP_PROFILE *profile, int capacity)
SCIP_RETCODE SCIPincludeConshdlrCumulative(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)
void SCIPgmlWriteNode(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)
void SCIPgmlWriteClosing(FILE *file)
void SCIPgmlWriteOpening(FILE *file, SCIP_Bool directed)
void SCIPgmlWriteArc(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)
SCIP_Bool SCIPisTransformed(SCIP *scip)
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)
int SCIPgetNCheckConss(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 SCIPcreateProbBasic(SCIP *scip, const char *name)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)
SCIP_RETCODE SCIPhashmapRemove(SCIP_HASHMAP *hashmap, void *origin)
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)
SCIP_RETCODE SCIPhashtableCreate(SCIP_HASHTABLE **hashtable, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)
SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
SCIP_Longint SCIPcalcGreComDiv(SCIP_Longint val1, SCIP_Longint val2)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPapplyProbingVar(SCIP *scip, SCIP_VAR **vars, int nvars, int probingpos, SCIP_BOUNDTYPE boundtype, SCIP_Real bound, int maxproprounds, SCIP_Real *impllbs, SCIP_Real *implubs, SCIP_Real *proplbs, SCIP_Real *propubs, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPaddLongintParam(SCIP *scip, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
SCIP_RETCODE SCIPsetSubscipsOff(SCIP *scip, SCIP_Bool quiet)
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
SCIP_RETCODE SCIPsetCharParam(SCIP *scip, const char *name, char value)
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
void SCIPswapInts(int *value1, int *value2)
void SCIPswapPointers(void **pointer1, void **pointer2)
SCIP_RETCODE SCIPaddExternBranchCand(SCIP *scip, SCIP_VAR *var, SCIP_Real score, SCIP_Real solval)
SCIP_RETCODE SCIPbranchVarHole(SCIP *scip, SCIP_VAR *var, SCIP_Real left, SCIP_Real right, SCIP_NODE **downchild, SCIP_NODE **upchild)
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPaddConflictRelaxedLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedlb)
SCIP_RETCODE SCIPaddConflictRelaxedUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedub)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_Real SCIPgetConflictVarUb(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPgetConflictVarLb(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
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,)
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 SCIPsetConshdlrDelete(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 SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitlp(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_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_RETCODE SCIPtransformConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
SCIP_RETCODE SCIPsetConsSeparated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool separate)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
SCIP_RETCODE SCIPsetConsEnforced(SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)
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)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
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_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_Longint SCIPgetMemExternEstim(SCIP *scip)
#define SCIPfreeBuffer(scip, ptr)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
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 SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPallocBuffer(scip, ptr)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_SOL * SCIPgetBestSol(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)
SCIP_RETCODE SCIPrestartSolve(SCIP *scip)
SCIP_RETCODE SCIPsolve(SCIP *scip)
int SCIPgetNRuns(SCIP *scip)
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
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 SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPconvertRealToInt(SCIP *scip, SCIP_Real real)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
SCIP_Bool SCIPinRepropagation(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
int SCIPvarGetNVlbs(SCIP_VAR *var)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Real * SCIPvarGetVlbCoefs(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
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_Real SCIPvarGetObj(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_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetIndex(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
SCIP_RETCODE SCIPaddVarVlb(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)
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)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real * SCIPvarGetVlbConstants(SCIP_VAR *var)
int SCIPvarGetNVubs(SCIP_VAR *var)
SCIP_Bool SCIPvarIsRemovable(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetVlbVars(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 SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
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)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
SCIP_Real * SCIPvarGetVubConstants(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetVubVars(SCIP_VAR *var)
SCIP_Real * SCIPvarGetVubCoefs(SCIP_VAR *var)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)
int * SCIPprofileGetTimepoints(SCIP_PROFILE *profile)
SCIP_Bool SCIPprofileFindLeft(SCIP_PROFILE *profile, int timepoint, int *pos)
int SCIPprofileGetNTimepoints(SCIP_PROFILE *profile)
void SCIPprofileFree(SCIP_PROFILE **profile)
int SCIPprofileGetLoad(SCIP_PROFILE *profile, int pos)
int * SCIPprofileGetLoads(SCIP_PROFILE *profile)
SCIP_RETCODE SCIPprofileCreate(SCIP_PROFILE **profile, int capacity)
int SCIPprofileGetTime(SCIP_PROFILE *profile, int pos)
SCIP_RETCODE SCIPprofileDeleteCore(SCIP_PROFILE *profile, int left, int right, int demand)
SCIP_RETCODE SCIPprofileInsertCore(SCIP_PROFILE *profile, int left, int right, int demand, int *pos, SCIP_Bool *infeasible)
void SCIPprofilePrint(SCIP_PROFILE *profile, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
void SCIPsortDownIntInt(int *intarray1, int *intarray2, int len)
void SCIPsortInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
void SCIPsortIntInt(int *intarray1, int *intarray2, int len)
void SCIPsortDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownIntIntInt(int *intarray1, int *intarray2, int *intarray3, int len)
void SCIPsort(int *perm, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
void SCIPsortInt(int *intarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
void SCIPstrCopySection(const char *str, char startchar, char endchar, char *token, int size, char **endptr)
void SCIPprintSysError(const char *message)
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
#define BMScopyMemoryArray(ptr, source, num)
#define BMSclearMemoryArray(ptr, num)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
#define SCIPdebugPrintCons(x, y, z)
#define SCIPstatisticPrintf
SCIP_RETCODE SCIPincludeDefaultPlugins(SCIP *scip)
#define TCLIQUE_GETWEIGHTS(x)
#define TCLIQUE_GETNNODES(x)
#define TCLIQUE_ISEDGE(x)
#define TCLIQUE_SELECTADJNODES(x)
enum TCLIQUE_Status TCLIQUE_STATUS
void tcliqueMaxClique(TCLIQUE_GETNNODES((*getnnodes)), TCLIQUE_GETWEIGHTS((*getweights)), TCLIQUE_ISEDGE((*isedge)), TCLIQUE_SELECTADJNODES((*selectadjnodes)), TCLIQUE_GRAPH *tcliquegraph, TCLIQUE_NEWSOL((*newsol)), TCLIQUE_DATA *tcliquedata, int *maxcliquenodes, int *nmaxcliquenodes, TCLIQUE_WEIGHT *maxcliqueweight, TCLIQUE_WEIGHT maxfirstnodeweight, TCLIQUE_WEIGHT minweight, int maxntreenodes, int backtrackfreq, int maxnzeroextensions, int fixednode, int *ntreenodes, TCLIQUE_STATUS *status)
struct TCLIQUE_Graph TCLIQUE_GRAPH
#define TCLIQUE_NEWSOL(x)
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSINITPRE(x)
#define SCIP_DECL_CONSDELETE(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSSEPALP(x)
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSRESPROP(x)
#define SCIP_DECL_CONSENFOPS(x)
#define SCIP_DECL_CONSPARSE(x)
#define SCIP_DECL_CONSTRANS(x)
#define SCIP_DECL_CONSPRESOL(x)
#define SCIP_DECL_CONSINITLP(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_CONSEXITSOL(x)
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_BOUNDTIGHTENED
enum SCIP_BoundType SCIP_BOUNDTYPE
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_SORTINDCOMP(x)
@ SCIP_PARAMEMPHASIS_CPSOLVER
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_TRANSFORMING
@ SCIP_STATUS_TOTALNODELIMIT
@ SCIP_STATUS_BESTSOLLIMIT
@ SCIP_STATUS_USERINTERRUPT
@ SCIP_STATUS_STALLNODELIMIT
@ SCIP_STATUS_RESTARTLIMIT
#define SCIP_PRESOLTIMING_ALWAYS
#define SCIP_PRESOLTIMING_MEDIUM
unsigned int SCIP_PRESOLTIMING
#define SCIP_PRESOLTIMING_FAST
#define SCIP_PRESOLTIMING_EXHAUSTIVE
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED