55#define AGERESETAVG_INIT 1000.0
56#define AGERESETAVG_MIN 100.0
57#define AGERESETAVG_DECAY 0.0005
58#define AGERESETAVG_AGELIMIT 2.0
60#define AGERESETAVG_OBSOLETEAGE 1.8
91 assert(num <= conshdlr->consssize);
115 assert(num <= conshdlr->initconsssize);
139 assert(num <= conshdlr->sepaconsssize);
163 assert(num <= conshdlr->enfoconsssize);
187 assert(num <= conshdlr->checkconsssize);
211 assert(num <= conshdlr->propconsssize);
235 assert(num <= conshdlr->updateconsssize);
247#define checkConssArrays(conshdlr)
249#ifdef CHECKCONSARRAYS
250#undef checkConssArrays
365 && ((
set->cons_agelimit > 0 && cons->
age >
set->cons_agelimit)
380 && ((
set->cons_obsoleteage > 0 && cons->
age >
set->cons_obsoleteage)
866 if( delpos < conshdlr->ninitconsskept )
874 if( delpos < conshdlr->ninitconss-1 )
951 assert(0 <= delpos && delpos < conshdlr->nusefulsepaconss);
953 if( delpos < conshdlr->lastnusefulsepaconss )
964 if( delpos < conshdlr->nsepaconss-1 )
1052 assert(0 <= delpos && delpos < conshdlr->nusefulenfoconss);
1054 if( delpos < conshdlr->lastnusefulenfoconss )
1073 if( delpos < conshdlr->nenfoconss-1 )
1118 assert(0 <= insertpos && insertpos <= conshdlr->ncheckconss);
1149 assert(0 <= delpos && delpos < conshdlr->nusefulcheckconss);
1156 if( delpos < conshdlr->ncheckconss-1 )
1256 assert(0 <= delpos && delpos < conshdlr->nusefulpropconss);
1258 if( delpos < conshdlr->lastnusefulpropconss )
1270 if( delpos < conshdlr->npropconss-1 )
1327 SCIPdebugMessage(
"disable separation of constraint <%s> in constraint handler <%s>\n", cons->
name, conshdlr->
name);
1387 SCIPdebugMessage(
"disable propagation of constraint <%s> in constraint handler <%s>\n", cons->
name, conshdlr->
name);
1454 if( conshdlr->consenable !=
NULL )
1456 SCIP_CALL( conshdlr->consenable(
set->scip, conshdlr, cons) );
1493 if( conshdlr->consdisable !=
NULL )
1495 SCIP_CALL( conshdlr->consdisable(
set->scip, conshdlr, cons) );
1563 SCIPsetDebugMsg(
set,
"activate constraint <%s> in constraint handler <%s> (depth %d, focus=%u)\n",
1590 if( conshdlr->consactive !=
NULL )
1592 SCIP_CALL( conshdlr->consactive(
set->scip, conshdlr, cons) );
1640 if( conshdlr->consdeactive !=
NULL )
1642 SCIP_CALL( conshdlr->consdeactive(
set->scip, conshdlr, cons) );
1706 SCIPsetDebugMsg(
set,
"processing %d constraints that have to be updated in constraint handler <%s>\n",
1722 SCIPsetDebugMsg(
set,
" -> constraint <%s>: insert=%u, activate=%u, deactivate=%u, enable=%u, disable=%u, sepaenable=%u, sepadisable=%u, propenable=%u, propdisable=%u, obsolete=%u, free=%u (consdata=%p)\n",
1889 SCIPdebugMessage(
"constraint updates of constraint handler <%s> will be delayed (count:%d)\n",
1909 SCIPsetDebugMsg(
set,
"constraint updates of constraint handler <%s> will be processed immediately (count:%d)\n",
1938 SCIPsetDebugMsg(
set,
"constraint <%s> of age %g has to be updated in constraint handler <%s> (consdata=%p)\n",
1976 return ((
SCIP_CONS*)elem2)->conshdlr->checkpriority - ((
SCIP_CONS*)elem1)->conshdlr->checkpriority;
1991 if( conshdlr->conshdlrcopy !=
NULL )
2017 SCIP_Bool delaysepa,
2018 SCIP_Bool delayprop,
2019 SCIP_Bool needscons,
2067 assert(conssepalp !=
NULL || conssepasol !=
NULL || sepafreq == -1);
2070 assert(!needscons || ((conshdlrcopy ==
NULL) == (conscopy ==
NULL)));
2077 SCIPmessagePrintError(
"ERROR: 'PRESOLDELAY'-flag no longer available since SCIP 3.2, use an appropriate "
2078 "'SCIP_PRESOLTIMING' for <%s> constraint handler instead.\n", name);
2091 (*conshdlr)->sepapriority = sepapriority;
2092 (*conshdlr)->enfopriority = enfopriority;
2093 (*conshdlr)->checkpriority = checkpriority;
2094 (*conshdlr)->sepafreq = sepafreq;
2095 (*conshdlr)->propfreq = propfreq;
2096 (*conshdlr)->eagerfreq = eagerfreq;
2097 (*conshdlr)->maxprerounds = maxprerounds;
2098 (*conshdlr)->conshdlrcopy = conshdlrcopy;
2099 (*conshdlr)->consfree = consfree;
2100 (*conshdlr)->consinit = consinit;
2101 (*conshdlr)->consexit = consexit;
2102 (*conshdlr)->consinitpre = consinitpre;
2103 (*conshdlr)->consexitpre = consexitpre;
2104 (*conshdlr)->consinitsol = consinitsol;
2105 (*conshdlr)->consexitsol = consexitsol;
2106 (*conshdlr)->consdelete = consdelete;
2107 (*conshdlr)->constrans = constrans;
2108 (*conshdlr)->consinitlp = consinitlp;
2109 (*conshdlr)->conssepalp = conssepalp;
2110 (*conshdlr)->conssepasol = conssepasol;
2111 (*conshdlr)->consenfolp = consenfolp;
2112 (*conshdlr)->consenforelax = consenforelax;
2113 (*conshdlr)->consenfops = consenfops;
2114 (*conshdlr)->conscheck = conscheck;
2115 (*conshdlr)->consprop = consprop;
2116 (*conshdlr)->conspresol = conspresol;
2117 (*conshdlr)->consresprop = consresprop;
2118 (*conshdlr)->conslock = conslock;
2119 (*conshdlr)->consactive = consactive;
2120 (*conshdlr)->consdeactive = consdeactive;
2121 (*conshdlr)->consenable = consenable;
2122 (*conshdlr)->consdisable = consdisable;
2123 (*conshdlr)->consprint = consprint;
2124 (*conshdlr)->consdelvars = consdelvars;
2125 (*conshdlr)->conscopy = conscopy;
2126 (*conshdlr)->consparse = consparse;
2127 (*conshdlr)->consgetvars = consgetvars;
2128 (*conshdlr)->consgetnvars = consgetnvars;
2129 (*conshdlr)->conshdlrdata = conshdlrdata;
2130 (*conshdlr)->consgetdivebdchgs = consgetdivebdchgs;
2131 (*conshdlr)->consgetpermsymgraph = consgetpermsymgraph;
2132 (*conshdlr)->consgetsignedpermsymgraph = consgetsignedpermsymgraph;
2133 (*conshdlr)->conss =
NULL;
2134 (*conshdlr)->consssize = 0;
2135 (*conshdlr)->nconss = 0;
2136 (*conshdlr)->nactiveconss = 0;
2137 (*conshdlr)->maxnactiveconss = 0;
2138 (*conshdlr)->startnactiveconss = 0;
2139 (*conshdlr)->initconss =
NULL;
2140 (*conshdlr)->initconsssize = 0;
2141 (*conshdlr)->ninitconss = 0;
2142 (*conshdlr)->ninitconsskept = 0;
2143 (*conshdlr)->sepaconss =
NULL;
2144 (*conshdlr)->sepaconsssize = 0;
2145 (*conshdlr)->nsepaconss = 0;
2146 (*conshdlr)->nusefulsepaconss = 0;
2147 (*conshdlr)->enfoconss =
NULL;
2148 (*conshdlr)->enfoconsssize = 0;
2149 (*conshdlr)->nenfoconss = 0;
2150 (*conshdlr)->nusefulenfoconss = 0;
2151 (*conshdlr)->checkconss =
NULL;
2152 (*conshdlr)->checkconsssize = 0;
2153 (*conshdlr)->ncheckconss = 0;
2154 (*conshdlr)->nusefulcheckconss = 0;
2155 (*conshdlr)->propconss =
NULL;
2156 (*conshdlr)->propconsssize = 0;
2157 (*conshdlr)->npropconss = 0;
2158 (*conshdlr)->nusefulpropconss = 0;
2159 (*conshdlr)->nmarkedpropconss = 0;
2160 (*conshdlr)->updateconss =
NULL;
2161 (*conshdlr)->updateconsssize = 0;
2162 (*conshdlr)->nupdateconss = 0;
2163 (*conshdlr)->nenabledconss = 0;
2164 (*conshdlr)->lastnusefulpropconss = 0;
2165 (*conshdlr)->lastnusefulsepaconss = 0;
2166 (*conshdlr)->lastnusefulenfoconss = 0;
2168 (*conshdlr)->storedpropconss =
NULL;
2169 (*conshdlr)->storedpropconsssize = 0;
2170 (*conshdlr)->storednmarkedpropconss = 0;
2171 (*conshdlr)->storedpropdomchgcount = 0;
2184 (*conshdlr)->nsepacalls = 0;
2185 (*conshdlr)->nenfolpcalls = 0;
2186 (*conshdlr)->nenfopscalls = 0;
2187 (*conshdlr)->nenforelaxcalls = 0;
2188 (*conshdlr)->npropcalls = 0;
2189 (*conshdlr)->ncheckcalls = 0;
2190 (*conshdlr)->nrespropcalls = 0;
2191 (*conshdlr)->ncutoffs = 0;
2192 (*conshdlr)->ncutsfound = 0;
2193 (*conshdlr)->ncutsapplied = 0;
2194 (*conshdlr)->nconssfound = 0;
2195 (*conshdlr)->ndomredsfound = 0;
2196 (*conshdlr)->nchildren = 0;
2197 (*conshdlr)->lastpropdomchgcount = -1;
2198 (*conshdlr)->lastsepalpcount = -1;
2199 (*conshdlr)->lastenfolplpcount = -1;
2200 (*conshdlr)->lastenfolpdomchgcount = -1;
2201 (*conshdlr)->lastenfopsdomchgcount = -1;
2202 (*conshdlr)->lastenforelaxdomchgcount = -1;
2203 (*conshdlr)->lastenforelaxrelaxcount = -1;
2204 (*conshdlr)->lastenfolpnode = -1;
2205 (*conshdlr)->lastenfopsnode = -1;
2209 (*conshdlr)->lastnfixedvars = 0;
2210 (*conshdlr)->lastnaggrvars = 0;
2211 (*conshdlr)->lastnchgvartypes = 0;
2212 (*conshdlr)->lastnchgbds = 0;
2213 (*conshdlr)->lastnaddholes = 0;
2214 (*conshdlr)->lastndelconss = 0;
2215 (*conshdlr)->lastnaddconss = 0;
2216 (*conshdlr)->lastnupgdconss = 0;
2217 (*conshdlr)->lastnchgcoefs = 0;
2218 (*conshdlr)->lastnchgsides = 0;
2219 (*conshdlr)->nfixedvars = 0;
2220 (*conshdlr)->naggrvars = 0;
2221 (*conshdlr)->nchgvartypes = 0;
2222 (*conshdlr)->nchgbds = 0;
2223 (*conshdlr)->naddholes = 0;
2224 (*conshdlr)->ndelconss = 0;
2225 (*conshdlr)->naddconss = 0;
2226 (*conshdlr)->nupgdconss = 0;
2227 (*conshdlr)->nchgcoefs = 0;
2228 (*conshdlr)->nchgsides = 0;
2229 (*conshdlr)->npresolcalls = 0;
2230 (*conshdlr)->delayupdatecount = 0;
2232 (*conshdlr)->needscons = needscons;
2233 (*conshdlr)->sepalpwasdelayed =
FALSE;
2234 (*conshdlr)->sepasolwasdelayed =
FALSE;
2235 (*conshdlr)->propwasdelayed =
FALSE;
2236 (*conshdlr)->duringsepa =
FALSE;
2237 (*conshdlr)->duringprop =
FALSE;
2238 (*conshdlr)->initialized =
FALSE;
2243 "frequency for separating cuts (-1: never, 0: only in root node)",
2248 "frequency for propagating domains (-1: never, 0: only in root node)",
2258 "frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)",
2263 "maximal number of presolving rounds the constraint handler participates in (-1: no limit)",
2264 &(*conshdlr)->maxprerounds,
TRUE, maxprerounds, -1, INT_MAX,
NULL,
NULL) );
2268 "should separation method be delayed, if other separators found cuts?",
2269 &(*conshdlr)->delaysepa,
TRUE, delaysepa,
NULL,
NULL) );
2273 "should propagation method be delayed, if other propagators found reductions?",
2274 &(*conshdlr)->delayprop,
TRUE, delayprop,
NULL,
NULL) );
2277 (void)
SCIPsnprintf(paramdesc,
SCIP_MAXSTRLEN,
"timing mask of the constraint handler's presolving method (%u:FAST, %u:MEDIUM, %u:EXHAUSTIVE, %u:FINAL)",
2301 SCIP_Bool delaysepa,
2302 SCIP_Bool delayprop,
2303 SCIP_Bool needscons,
2348 assert(conssepalp !=
NULL || conssepasol !=
NULL || sepafreq == -1);
2351 assert(!needscons || ((conshdlrcopy ==
NULL) == (conscopy ==
NULL)));
2354 checkpriority, sepafreq, propfreq, eagerfreq, maxprerounds, delaysepa, delayprop, needscons, proptiming,
2355 presoltiming, conshdlrcopy, consfree, consinit, consexit, consinitpre, consexitpre, consinitsol, consexitsol,
2356 consdelete, constrans, consinitlp, conssepalp, conssepasol, consenfolp, consenforelax, consenfops, conscheck,
2357 consprop, conspresol, consresprop, conslock, consactive, consdeactive, consenable, consdisable, consdelvars,
2358 consprint, conscopy, consparse, consgetvars, consgetnvars, consgetdivebdchgs, consgetpermsymgraph,
2359 consgetsignedpermsymgraph, conshdlrdata),
2372 if( *conshdlr ==
NULL )
2374 assert(!(*conshdlr)->initialized);
2375 assert((*conshdlr)->nconss == 0);
2379 if( (*conshdlr)->consfree !=
NULL )
2381 SCIP_CALL( (*conshdlr)->consfree(
set->scip, *conshdlr) );
2427 if(
set->misc_resetstat )
2497 if( conshdlr->consinit !=
NULL )
2541 if( conshdlr->consexit !=
NULL )
2608 if( conshdlr->consinitpre !=
NULL )
2632 if( stat->
nruns >= 2 )
2664 if( conshdlr->consexitpre !=
NULL )
2708 if( conshdlr->consinitsol !=
NULL )
2745 if( conshdlr->consexitsol !=
NULL )
2776 SCIP_Bool initkeptconss,
2790 if( conshdlr->consinitlp !=
NULL )
2796 SCIPsetDebugMsg(
set,
"initializing LP with %d initial constraints of handler <%s> (ninitconss=%d, kept=%d, initkept=%u)\n",
2841 assert(currentdepth >= 0);
2884 SCIP_Bool execdelayed,
2901 if( conshdlr->conssepalp !=
NULL
2907 if( !conshdlr->
delaysepa || execdelayed )
2920 nusefulconss = nconss;
2931 assert(firstcons + nconss <= conshdlr->nsepaconss);
2932 assert(nusefulconss <= nconss);
2938 SCIP_Longint oldndomchgs;
2939 SCIP_Longint oldnprobdomchgs;
2940 SCIP_Longint lastsepalpcount;
2942 int oldnactiveconss;
2943 int lastnusefulsepaconss;
2945 SCIPsetDebugMsg(
set,
"separating constraints %d to %d of %d constraints of handler <%s> (%s LP solution)\n",
2946 firstcons, firstcons + nconss - 1, conshdlr->
nsepaconss, conshdlr->
name,
2950 lastsepalpcount = stat->
lpcount;
2954 conss = &(conshdlr->
sepaconss[firstcons]);
2964 nusefulconss = nconss;
2977 SCIP_CALL( conshdlr->conssepalp(
set->scip, conshdlr, conss, nconss, nusefulconss,
result) );
3014 SCIPerrorMessage(
"LP separation method of constraint handler <%s> returned invalid result <%d>\n",
3042 SCIP_Bool execdelayed,
3057 if( conshdlr->conssepasol !=
NULL
3063 if( !conshdlr->
delaysepa || execdelayed )
3071 assert(nusefulconss <= nconss);
3073 if( nconss > 0 || !conshdlr->
needscons )
3076 SCIP_Longint oldndomchgs;
3077 SCIP_Longint oldnprobdomchgs;
3079 int oldnactiveconss;
3081 SCIPsetDebugMsg(
set,
"separating %d constraints of handler <%s> (primal solution %p)\n",
3082 nconss, conshdlr->
name, (
void*)
sol);
3095 nusefulconss = nconss;
3141 SCIPerrorMessage(
"SOL separation method of constraint handler <%s> returned invalid result <%d>\n",
3171 SCIP_Bool solinfeasible,
3178 SCIP_Bool relaxchanged;
3179 SCIP_Bool lastinfeasible;
3207 && ( strcmp(conshdlr->
name,
"integral") != 0 )
3222 lastinfeasible =
TRUE;
3225 lastinfeasible =
FALSE;
3231 nusefulconss = nconss;
3233 relaxchanged =
FALSE;
3241 relaxchanged =
TRUE;
3242 lastinfeasible =
FALSE;
3245 assert(firstcons + nconss <= conshdlr->nenfoconss);
3246 assert(nusefulconss <= nconss);
3249 if( nconss > 0 || (!conshdlr->
needscons && relaxchanged) )
3252 SCIP_Longint oldndomchgs;
3253 SCIP_Longint oldnprobdomchgs;
3255 int oldnactiveconss;
3259 SCIPdebugMessage(
"enforcing constraints %d to %d of %d constraints of handler <%s> (%s relaxation solution)\n",
3260 firstcons, firstcons + nconss - 1, conshdlr->
nenfoconss, conshdlr->
name, relaxchanged ?
"new" :
"old");
3269 conss = &(conshdlr->
enfoconss[firstcons]);
3279 nusefulconss = nconss;
3291 SCIP_CALL( conshdlr->consenforelax(
set->scip, relaxsol, conshdlr, conss, nconss, nusefulconss, solinfeasible,
result) );
3332 SCIPerrorMessage(
"enforcing method of constraint handler <%s> for relaxation solutions returned invalid result <%d>\n",
3358 SCIP_Bool solinfeasible,
3379 if( conshdlr->consenfolp !=
NULL )
3384 SCIP_Bool lpchanged;
3385 SCIP_Bool lastinfeasible;
3401 lastinfeasible =
FALSE;
3406 lastinfeasible =
TRUE;
3413 nusefulconss = nconss;
3424 lastinfeasible =
FALSE;
3427 assert(firstcons + nconss <= conshdlr->nenfoconss);
3428 assert(nusefulconss <= nconss);
3431 if( nconss > 0 || (!conshdlr->
needscons && lpchanged) )
3434 SCIP_Longint oldndomchgs;
3435 SCIP_Longint oldnprobdomchgs;
3437 int oldnactiveconss;
3439 SCIPsetDebugMsg(
set,
"enforcing constraints %d to %d of %d constraints of handler <%s> (%s LP solution)\n",
3440 firstcons, firstcons + nconss - 1, conshdlr->
nenfoconss, conshdlr->
name, lpchanged ?
"new" :
"old");
3449 conss = nconss > 0 ? conshdlr->
enfoconss + firstcons :
NULL;
3459 nusefulconss = nconss;
3471 SCIP_CALL( conshdlr->consenfolp(
set->scip, conshdlr, conss, nconss, nusefulconss, solinfeasible,
result) );
3511 SCIPerrorMessage(
"enforcing method of constraint handler <%s> for LP solutions returned invalid result <%d>\n",
3535 SCIP_Bool* infeasible
3545 if( conshdlr->consgetdivebdchgs !=
NULL )
3563 SCIP_Bool solinfeasible,
3564 SCIP_Bool objinfeasible,
3591 if( conshdlr->consenfops !=
NULL )
3596 SCIP_Bool pschanged;
3597 SCIP_Bool lastinfeasible;
3618 lastinfeasible =
TRUE;
3621 lastinfeasible =
FALSE;
3627 nusefulconss = nconss;
3638 lastinfeasible =
FALSE;
3641 assert(firstcons + nconss <= conshdlr->nenfoconss);
3642 assert(nusefulconss <= nconss);
3645 if( nconss > 0 || (!conshdlr->
needscons && pschanged) )
3648 SCIP_Longint oldndomchgs;
3649 SCIP_Longint oldnprobdomchgs;
3651 SCIPsetDebugMsg(
set,
"enforcing constraints %d to %d of %d constraints of handler <%s> (%s pseudo solution, objinfeasible=%u)\n",
3652 firstcons, firstcons + nconss - 1, conshdlr->
nenfoconss, conshdlr->
name, pschanged ?
"new" :
"old", objinfeasible);
3660 conss = &(conshdlr->
enfoconss[firstcons]);
3668 nusefulconss = nconss;
3680 SCIP_CALL( conshdlr->consenfops(
set->scip, conshdlr, conss, nconss, nusefulconss, solinfeasible, objinfeasible,
result) );
3692 else if( !objinfeasible )
3694 SCIPerrorMessage(
"enforcing method of constraint handler <%s> for pseudo solutions was skipped, even though the solution was not objective-infeasible\n",
3734 SCIPerrorMessage(
"enforcing method of constraint handler <%s> for pseudo solutions returned invalid result <%d>\n",
3746 else if( objinfeasible )
3766 SCIP_Bool checkintegrality,
3767 SCIP_Bool checklprows,
3768 SCIP_Bool printreason,
3769 SCIP_Bool completely,
3798 sol, checkintegrality, checklprows, printreason, completely,
result) );
3828 SCIP_Bool fullpropagation,
3829 SCIP_Bool execdelayed,
3830 SCIP_Bool instrongbranching,
3849 if( conshdlr->consprop !=
NULL
3856 if( !conshdlr->
delayprop || execdelayed )
3860 int nmarkedpropconss;
3870 nusefulconss = nconss;
3881 assert(firstcons + nconss <= conshdlr->npropconss);
3882 assert(nusefulconss <= nconss);
3887 if( nconss > 0 || fullpropagation
3891 SCIP_Longint oldndomchgs;
3892 SCIP_Longint oldnprobdomchgs;
3893 SCIP_Longint lastpropdomchgcount;
3894 int lastnusefulpropconss;
3896 SCIPsetDebugMsg(
set,
"propagating constraints %d to %d of %d constraints of handler <%s> (%s pseudo solution, %d useful)\n",
3897 firstcons, firstcons + nconss - 1, conshdlr->
npropconss, conshdlr->
name,
3905 conss = nconss > 0 ? (conshdlr->
propconss + firstcons) :
NULL;
3913 nusefulconss = nconss;
3923 if( instrongbranching )
3928 assert(nusefulconss <= nconss);
3929 assert(nmarkedpropconss <= nconss);
3932 SCIP_CALL( conshdlr->consprop(
set->scip, conshdlr, conss, nconss, nusefulconss, nmarkedpropconss, proptiming,
result) );
3936 if( instrongbranching )
3973 SCIPerrorMessage(
"propagation method of constraint handler <%s> returned invalid result <%d>\n",
4033 if( conshdlr->conspresol !=
NULL
4044 int nnewchgvartypes;
4088 nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes,
4089 nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides,
4090 nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes,
4091 ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides,
result) );
4119 SCIPerrorMessage(
"presolving method of constraint handler <%s> returned invalid result <%d>\n",
4146 if( conshdlr->consdelvars !=
NULL )
4203 return conshdlr->
name;
4213 return conshdlr->
desc;
4249 assert(conssepalp !=
NULL || conssepasol !=
NULL || sepafreq == -1);
4251 conshdlr->conssepalp = conssepalp;
4252 conshdlr->conssepasol = conssepasol;
4263 SCIP_Bool delayprop,
4271 conshdlr->consprop = consprop;
4285 conshdlr->consenforelax = consenforelax;
4299 conshdlr->conshdlrcopy = conshdlrcopy;
4300 conshdlr->conscopy = conscopy;
4311 conshdlr->consfree = consfree;
4322 conshdlr->consinit = consinit;
4333 conshdlr->consexit = consexit;
4344 conshdlr->consinitsol = consinitsol;
4355 conshdlr->consexitsol = consexitsol;
4366 conshdlr->consinitpre = consinitpre;
4377 conshdlr->consexitpre = consexitpre;
4390 conshdlr->conspresol = conspresol;
4398 SCIPmessagePrintError(
"ERROR: 'PRESOLDELAY'-flag no longer available since SCIP 3.2, use an appropriate "
4399 "'SCIP_PRESOLTIMING' for <%s> constraint handler instead.\n", conshdlr->
name);
4417 conshdlr->consdelete = consdelete;
4428 conshdlr->constrans = constrans;
4439 conshdlr->consinitlp = consinitlp;
4450 conshdlr->consresprop = consresprop;
4461 conshdlr->consactive = consactive;
4472 conshdlr->consdeactive = consdeactive;
4483 conshdlr->consenable = consenable;
4494 conshdlr->consdisable = consdisable;
4505 conshdlr->consdelvars = consdelvars;
4516 conshdlr->consprint = consprint;
4527 conshdlr->consparse = consparse;
4538 conshdlr->consgetvars = consgetvars;
4549 conshdlr->consgetnvars = consgetnvars;
4560 conshdlr->consgetdivebdchgs = consgetdivebdchgs;
4572 conshdlr->consgetpermsymgraph = consgetpermsymgraph;
4584 conshdlr->consgetsignedpermsymgraph = consgetsignedpermsymgraph;
4599 return conshdlr->
conss;
5176 return (conshdlr->conspresol !=
NULL);
5246 return (conshdlr->conshdlrcopy !=
NULL);
5299 return conshdlr->consgetpermsymgraph !=
NULL;
5309 return conshdlr->consgetsignedpermsymgraph !=
NULL;
5327 (*conssetchg)->addedconss =
NULL;
5328 (*conssetchg)->disabledconss =
NULL;
5329 (*conssetchg)->addedconsssize = 0;
5330 (*conssetchg)->naddedconss = 0;
5331 (*conssetchg)->disabledconsssize = 0;
5332 (*conssetchg)->ndisabledconss = 0;
5378 if( *conssetchg !=
NULL )
5411 assert(num <= conssetchg->addedconsssize);
5435 assert(num <= conssetchg->disabledconsssize);
5450 SCIP_Bool focusnode,
5458 if( *conssetchg ==
NULL )
5465 (*conssetchg)->addedconss[(*conssetchg)->naddedconss] = cons;
5466 (*conssetchg)->naddedconss++;
5500 if( *conssetchg ==
NULL )
5507 (*conssetchg)->disabledconss[(*conssetchg)->ndisabledconss] = cons;
5508 (*conssetchg)->ndisabledconss++;
5529 assert(0 <= arraypos && arraypos < conssetchg->naddedconss);
5534 SCIPsetDebugMsg(
set,
"delete added constraint <%s> at position %d from constraint set change data\n", cons->
name, arraypos);
5547 for( ; arraypos < conssetchg->
naddedconss-1; ++arraypos )
5572 assert(0 <= arraypos && arraypos < conssetchg->ndisabledconss);
5575 SCIPsetDebugMsg(
set,
"delete disabled constraint <%s> at position %d from constraint set change data\n",
5602 if( nconss !=
NULL )
5619 if( conssetchg ==
NULL )
5622 SCIPsetDebugMsg(
set,
"applying constraint set changes at %p: %d constraint additions, %d constraint disablings\n",
5670 SCIPsetDebugMsg(
set,
"constraint <%s> of handler <%s> was deactivated -> remove it from disabledconss array\n",
5704 if( conssetchg ==
NULL )
5707 SCIPsetDebugMsg(
set,
"undoing constraint set changes at %p: %d constraint additions, %d constraint disablings\n",
5730 SCIPsetDebugMsg(
set,
"constraint <%s> of handler <%s> was deactivated -> remove it from disabledconss array\n",
5795 if( *conssetchg ==
NULL )
5798 SCIPsetDebugMsg(
set,
"moving constraint set changes at %p to global problem: %d constraint additions, %d constraint disablings\n",
5799 (
void*)*conssetchg, (*conssetchg)->
naddedconss, (*conssetchg)->ndisabledconss);
5804 for(
i = (*conssetchg)->naddedconss-1;
i >= 0; --
i )
5806 cons = (*conssetchg)->addedconss[
i];
5833 for(
i = (*conssetchg)->ndisabledconss-1;
i >= 0; --
i )
5835 cons = (*conssetchg)->disabledconss[
i];
5853 if( (*conssetchg)->naddedconss == 0 && (*conssetchg)->ndisabledconss == 0 )
5895 SCIP_Bool modifiable,
5901 SCIP_Bool removable,
5903 SCIP_Bool stickingatnode,
5907 SCIP_Bool deleteconsdata
5917 assert(!original || deleteconsdata);
5923 (*cons)->scip =
set->scip;
5925 (*cons)->conshdlr = conshdlr;
5926 (*cons)->consdata = consdata;
5927 (*cons)->transorigcons =
NULL;
5928 (*cons)->addconssetchg =
NULL;
5929 (*cons)->addarraypos = -1;
5930 (*cons)->consspos = -1;
5931 (*cons)->initconsspos = -1;
5932 (*cons)->sepaconsspos = -1;
5933 (*cons)->enfoconsspos = -1;
5934 (*cons)->checkconsspos = -1;
5935 (*cons)->propconsspos = -1;
5936 (*cons)->activedepth = -2;
5937 (*cons)->validdepth = (local ? -1 : 0);
5940 (*cons)->nupgradelocks = 0;
5941 (*cons)->initial = initial;
5942 (*cons)->separate = separate;
5943 (*cons)->enforce = enforce;
5944 (*cons)->check = check;
5946 (*cons)->sepaenabled = separate;
5948 (*cons)->local = local;
5949 (*cons)->modifiable = modifiable;
5950 (*cons)->dynamic = dynamic;
5951 (*cons)->removable = removable;
5952 (*cons)->stickingatnode = stickingatnode;
5953 (*cons)->original = original;
5954 (*cons)->deleteconsdata = deleteconsdata;
5955 (*cons)->active =
FALSE;
5956 (*cons)->conflict =
FALSE;
5957 (*cons)->enabled =
FALSE;
5958 (*cons)->obsolete =
FALSE;
5959 (*cons)->markpropagate =
TRUE;
5960 (*cons)->deleted =
FALSE;
5961 (*cons)->update =
FALSE;
5962 (*cons)->updateinsert =
FALSE;
5963 (*cons)->updateactivate =
FALSE;
5964 (*cons)->updatedeactivate =
FALSE;
5965 (*cons)->updateenable =
FALSE;
5966 (*cons)->updatedisable =
FALSE;
5967 (*cons)->updatesepaenable =
FALSE;
5968 (*cons)->updatesepadisable =
FALSE;
5969 (*cons)->updatepropenable =
FALSE;
5970 (*cons)->updatepropdisable =
FALSE;
5971 (*cons)->updateobsolete =
FALSE;
5972 (*cons)->updatemarkpropagate =
FALSE;
5973 (*cons)->updateunmarkpropagate =
FALSE;
5974 (*cons)->updatefree =
FALSE;
5975 (*cons)->updateactfocus =
FALSE;
5979 (*cons)->nlockspos[
i] = 0;
5980 (*cons)->nlocksneg[
i] = 0;
5993 (*cons)->updateinsert =
TRUE;
5996 assert((*cons)->nuses == 2);
6035 SCIP_Bool modifiable,
6037 SCIP_Bool removable,
6038 SCIP_Bool stickingatnode,
6056 if( sourceconshdlr->conscopy !=
NULL )
6058 SCIP_CALL( sourceconshdlr->conscopy(
set->scip, cons, name, sourcescip, sourceconshdlr, sourcecons, varmap, consmap,
6059 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
valid) );
6091 SCIP_Bool modifiable,
6097 SCIP_Bool removable,
6099 SCIP_Bool stickingatnode,
6118 if ( endptr ==
NULL || endptr == str )
6128 if ( endptr ==
NULL || endptr == str )
6157 if( conshdlr ==
NULL )
6159 SCIPmessagePrintWarning(messagehdlr,
"constraint handler <%s> doesn't exist in SCIP data structure\n", conshdlrname);
6164 if ( conshdlr->consparse ==
NULL )
6166 SCIPmessagePrintWarning(messagehdlr,
"constraint handler <%s> does not support parsing constraints\n", conshdlrname);
6170 SCIP_CALL( conshdlr->consparse(
set->scip, conshdlr, cons, consname, str,
6171 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, success) );
6208 assert((*cons)->nuses == 0);
6209 assert(!(*cons)->active);
6210 assert(!(*cons)->update);
6211 assert(!(*cons)->original || (*cons)->transorigcons ==
NULL);
6217 (*cons)->name, (*cons)->consspos, (*cons)->conshdlr->name);
6220 if( (*cons)->conshdlr->consdelete !=
NULL && (*cons)->consdata !=
NULL && (*cons)->deleteconsdata )
6222 SCIP_CALL( (*cons)->conshdlr->consdelete(
set->scip, (*cons)->conshdlr, *cons, &(*cons)->
consdata) );
6224 else if( !(*cons)->deleteconsdata )
6225 (*cons)->consdata =
NULL;
6229 if( (*cons)->transorigcons !=
NULL )
6231 assert(!(*cons)->original);
6232 assert((*cons)->transorigcons->original);
6233 assert((*cons)->transorigcons->transorigcons == *cons);
6235 (*cons)->transorigcons->transorigcons =
NULL;
6239 if( !(*cons)->original )
6244 assert((*cons)->consspos == -1);
6276 assert((*cons)->nuses >= 1);
6280 SCIPsetDebugMsg(
set,
"release constraint <%s> with nuses=%d, cons pointer %p\n", (*cons)->name, (*cons)->nuses, (
void*)(*cons));
6282 if( (*cons)->nuses == 0 )
6284 assert(!(*cons)->active || (*cons)->updatedeactivate);
6290 (*cons)->updatefree =
TRUE;
6293 assert((*cons)->nuses == 1);
6324 if( conshdlr->consprint !=
NULL )
6326 SCIP_CALL( conshdlr->consprint(
set->scip, conshdlr, cons, file) );
6329 SCIPmessageFPrintInfo(messagehdlr, file,
"constraint handler <%s> doesn't support printing constraint", conshdlr->
name);
6362 if( conshdlr->consgetvars !=
NULL )
6364 SCIP_CALL( conshdlr->consgetvars(
set->scip, conshdlr, cons,
vars, varssize, success) );
6397 if( conshdlr->consgetnvars !=
NULL )
6433 if( conshdlr->consgetpermsymgraph !=
NULL )
6435 SCIP_CALL( conshdlr->consgetpermsymgraph(
set->scip, conshdlr, cons, graph, success) );
6466 if( conshdlr->consgetsignedpermsymgraph !=
NULL )
6468 SCIP_CALL( conshdlr->consgetsignedpermsymgraph(
set->scip, conshdlr, cons, graph, success) );
6600 if( cons->
initial != initial )
6668 if( cons->
enforce != enforce )
6703 if( cons->
check != check )
6705 cons->
check = check;
6783 cons->
local = local;
6791 SCIP_Bool modifiable
6824 SCIP_Bool stickingatnode
6842 cons->
name = (
char*)name;
6882 SCIPsetDebugMsg(
set,
"delayed activation of constraint <%s> in constraint handler <%s> (depth %d)\n",
6918 SCIPsetDebugMsg(
set,
"delayed deactivation of constraint <%s> in constraint handler <%s>\n",
7220 cons->
age += deltaage;
7325 SCIP_Real relaxedbd,
7345 if( conshdlr->consresprop !=
NULL )
7350 SCIP_CALL( conshdlr->consresprop(
set->scip, conshdlr, cons, infervar, inferinfo, inferboundtype, bdchgidx,
7362 SCIPerrorMessage(
"propagation conflict resolving method of constraint handler <%s> returned invalid result <%d>\n",
7369 SCIPerrorMessage(
"propagation conflict resolving method of constraint handler <%s> is not implemented\n",
7397 assert(-2 <= nlockspos && nlockspos <= 2);
7398 assert(-2 <= nlocksneg && nlocksneg <= 2);
7403 oldnlockspos = cons->
nlockspos[locktype];
7404 oldnlocksneg = cons->
nlocksneg[locktype];
7411 updlockpos = (int)(cons->
nlockspos[locktype] > 0) - (int)(oldnlockspos > 0);
7412 updlockneg = (int)(cons->
nlocksneg[locktype] > 0) - (int)(oldnlocksneg > 0);
7415 if( updlockpos != 0 || updlockneg != 0 )
7428 SCIP_Bool checkintegrality,
7429 SCIP_Bool checklprows,
7430 SCIP_Bool printreason,
7447 SCIP_CALL( conshdlr->conscheck(
set->scip, conshdlr, &cons, 1,
sol, checkintegrality, checklprows, printreason,
7453 SCIPerrorMessage(
"feasibility check of constraint handler <%s> on constraint <%s> returned invalid result <%d>\n",
7465 SCIP_Bool solinfeasible,
7466 SCIP_Bool objinfeasible,
7483 SCIP_CALL( conshdlr->consenfops(
set->scip, conshdlr, &cons, 1, 1, solinfeasible, objinfeasible,
result) );
7495 SCIPerrorMessage(
"enforcing method of constraint handler <%s> for pseudo solutions returned invalid result <%d>\n",
7509 SCIP_Bool solinfeasible,
7526 SCIP_CALL( conshdlr->consenfolp(
set->scip, conshdlr, &cons, 1, 1, solinfeasible,
result) );
7537 SCIPerrorMessage(
"enforcing method of constraint handler <%s> for LP returned invalid result <%d>\n",
7552 SCIP_Bool solinfeasible,
7581 SCIPerrorMessage(
"enforcing method of constraint handler <%s> for relaxation returned invalid result <%d>\n",
7595 SCIP_Bool* infeasible
7609 if( conshdlr->consinitlp !=
NULL )
7611 SCIP_CALL( conshdlr->consinitlp(
set->scip, conshdlr, &cons, 1, infeasible) );
7635 if( conshdlr->conssepalp !=
NULL )
7649 SCIPerrorMessage(
"separation method of constraint handler <%s> returned invalid result <%d>\n", conshdlr->
name,
7678 if( conshdlr->conssepasol !=
NULL )
7692 SCIPerrorMessage(
"separation method of constraint handler for arbitrary primal solution <%s> returned invalid result <%d>\n",
7720 if( conshdlr->consprop !=
NULL )
7722 SCIP_CALL( conshdlr->consprop(
set->scip, conshdlr, &cons, 1, 1, 1, proptiming,
result) );
7732 SCIPerrorMessage(
"propagation method of constraint handler <%s> returned invalid result <%d>\n",
7749 SCIP_Real relaxedbd,
7766 if( conshdlr->consresprop !=
NULL )
7768 SCIP_CALL( conshdlr->consresprop(
set->scip, conshdlr, cons, infervar, inferinfo, boundtype, bdchgidx, relaxedbd,
result) );
7774 SCIPerrorMessage(
"propagation conflict resolving method of constraint handler <%s> returned invalid result <%d>\n",
7791 int nnewchgvartypes,
7833 if( conshdlr->conspresol !=
NULL )
7835 SCIP_CALL( conshdlr->conspresol(
set->scip, conshdlr, &cons, 1, nrounds, timing,
7836 nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss,
7837 nnewupgdconss, nnewchgcoefs, nnewchgsides, nfixedvars, naggrvars, nchgvartypes,
7838 nchgbds, naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides,
result) );
7848 SCIPerrorMessage(
"presolving method of constraint handler <%s> returned invalid result <%d>\n",
7873 if( conshdlr->consactive !=
NULL )
7875 SCIP_CALL( conshdlr->consactive(
set->scip, conshdlr, cons) );
7897 if( conshdlr->consdeactive !=
NULL )
7899 SCIP_CALL( conshdlr->consdeactive(
set->scip, conshdlr, cons) );
7945 assert(num <= conshdlr->storedpropconsssize);
7961 assert(conshdlrs !=
NULL || nconshdlrs == 0);
7963 for(
c = nconshdlrs - 1;
c >= 0; --
c )
7965 conshdlr = conshdlrs[
c];
8003 assert(conshdlrs !=
NULL || nconshdlrs == 0);
8005 for(
c = nconshdlrs - 1;
c >= 0; --
c )
8007 conshdlr = conshdlrs[
c];
8081 linconsstats->
sum = 0;
8094 return linconsstats->
counter[(int)linconstype];
8104 return linconsstats->
sum;
8119 linconsstats->
counter[(int)linconstype] += increment;
8120 linconsstats->
sum += increment;
8167#undef SCIPconsGetName
8168#undef SCIPconsGetPos
8169#undef SCIPconsGetHdlr
8170#undef SCIPconsGetData
8171#undef SCIPconsGetNUses
8172#undef SCIPconsGetActiveDepth
8173#undef SCIPconsGetValidDepth
8174#undef SCIPconsIsActive
8175#undef SCIPconsIsEnabled
8176#undef SCIPconsIsSeparationEnabled
8177#undef SCIPconsIsPropagationEnabled
8178#undef SCIPconsIsDeleted
8179#undef SCIPconsIsObsolete
8180#undef SCIPconsIsConflict
8181#undef SCIPconsGetAge
8182#undef SCIPconsIsInitial
8183#undef SCIPconsIsSeparated
8184#undef SCIPconsIsEnforced
8185#undef SCIPconsIsChecked
8186#undef SCIPconsIsMarkedPropagate
8187#undef SCIPconsIsPropagated
8188#undef SCIPconsIsGlobal
8189#undef SCIPconsIsLocal
8190#undef SCIPconsIsModifiable
8191#undef SCIPconsIsDynamic
8192#undef SCIPconsIsRemovable
8193#undef SCIPconsIsStickingAtNode
8194#undef SCIPconsIsInProb
8195#undef SCIPconsIsOriginal
8196#undef SCIPconsIsTransformed
8197#undef SCIPconsIsLockedPos
8198#undef SCIPconsIsLockedNeg
8199#undef SCIPconsIsLocked
8200#undef SCIPconsGetNLocksPos
8201#undef SCIPconsGetNLocksNeg
8202#undef SCIPconsIsLockedTypePos
8203#undef SCIPconsIsLockedTypeNeg
8204#undef SCIPconsIsLockedType
8205#undef SCIPconsGetNLocksTypePos
8206#undef SCIPconsGetNLocksTypeNeg
8207#undef SCIPconsIsAdded
8208#undef SCIPconsGetNUpgradeLocks
8304 return (!cons->
local ? 0
8449 return !cons->
local;
static GRAPHNODE ** active
int SCIPbranchcandGetNPseudoCands(SCIP_BRANCHCAND *branchcand)
internal methods for branching rules and branching candidate storage
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
void SCIPclockEnableOrDisable(SCIP_CLOCK *clck, SCIP_Bool enable)
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
void SCIPclockReset(SCIP_CLOCK *clck)
void SCIPclockFree(SCIP_CLOCK **clck)
SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)
internal methods for clocks and timing issues
SCIP_RETCODE SCIPconshdlrsStorePropagationStatus(SCIP_SET *set, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
void SCIPconshdlrSetExitpre(SCIP_CONSHDLR *conshdlr,)
static SCIP_RETCODE conshdlrAddInitcons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)
SCIP_RETCODE SCIPconsAddLocks(SCIP_CONS *cons, SCIP_SET *set, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)
SCIP_RETCODE SCIPconshdlrSeparateLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)
SCIP_RETCODE SCIPconsParse(SCIP_CONS **cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *str, 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 *success)
void SCIPconshdlrSetGetPermsymGraph(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconssetchgUndo(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPconsEnableSeparation(SCIP_CONS *cons, SCIP_SET *set)
static SCIP_RETCODE conssetchgEnsureAddedconssSize(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
SCIP_RETCODE SCIPconshdlrSetPresol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
void SCIPconshdlrIncNCutsFound(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPconshdlrInit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
static SCIP_RETCODE conssetchgDelAddedCons(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int arraypos)
static SCIP_RETCODE conshdlrEnableCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)
void SCIPconshdlrSetDelvars(SCIP_CONSHDLR *conshdlr,)
void SCIPconsMarkConflict(SCIP_CONS *cons)
SCIP_RETCODE SCIPconsEnable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
void SCIPconsCapture(SCIP_CONS *cons)
SCIP_RETCODE SCIPconsProp(SCIP_CONS *cons, SCIP_SET *set, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
static SCIP_RETCODE conssetchgCreate(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPconsPrint(SCIP_CONS *cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
SCIP_RETCODE SCIPconsCreate(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set, 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 original, SCIP_Bool deleteconsdata)
void SCIPconshdlrIncNAppliedCuts(SCIP_CONSHDLR *conshdlr)
static SCIP_RETCODE conshdlrEnsureCheckconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)
static void conshdlrDelPropcons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
static SCIP_Bool conshdlrAreUpdatesDelayed(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetInit(SCIP_CONSHDLR *conshdlr,)
void SCIPconsSetLocal(SCIP_CONS *cons, SCIP_Bool local)
SCIP_RETCODE SCIPconsMarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
SCIP_RETCODE SCIPconshdlrEnforceRelaxSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_SOL *relaxsol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
static SCIP_RETCODE conshdlrDisableConsSeparation(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
static SCIP_Real conshdlrGetAgeresetavg(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetGetNVars(SCIP_CONSHDLR *conshdlr,)
static SCIP_RETCODE conssetchgEnsureDisabledconssSize(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
void SCIPconshdlrSetGetSignedPermsymGraph(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconsDeactivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
static SCIP_RETCODE conshdlrEnsurePropconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)
SCIP_RETCODE SCIPconshdlrExitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool restart)
SCIP_RETCODE SCIPconshdlrSeparateSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)
SCIP_RETCODE SCIPconsDisable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPconsDeactive(SCIP_CONS *cons, SCIP_SET *set)
static SCIP_RETCODE conshdlrMarkConsObsolete(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
SCIP_RETCODE SCIPconshdlrLockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
SCIP_RETCODE SCIPconshdlrEnforceLPSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_Bool solinfeasible, SCIP_RESULT *result)
SCIP_RETCODE SCIPconsGetPermsymGraph(SCIP_CONS *cons, SCIP_SET *set, SYM_GRAPH *graph, SCIP_Bool *success)
SCIP_RETCODE SCIPconsGetNVars(SCIP_CONS *cons, SCIP_SET *set, int *nvars, SCIP_Bool *success)
static SCIP_RETCODE conshdlrEnsureUpdateconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)
void SCIPconsSetStickingAtNode(SCIP_CONS *cons, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPconsSetSeparated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool separate)
#define checkConssArrays(conshdlr)
SCIP_RETCODE SCIPconsSepalp(SCIP_CONS *cons, SCIP_SET *set, SCIP_RESULT *result)
static SCIP_RETCODE conssetchgRelease(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set)
static SCIP_RETCODE conshdlrProcessUpdates(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPconsEnfops(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
SCIP_RETCODE SCIPconsActive(SCIP_CONS *cons, SCIP_SET *set)
#define AGERESETAVG_AGELIMIT
SCIP_RETCODE SCIPconsResetAge(SCIP_CONS *cons, SCIP_SET *set)
static SCIP_RETCODE conshdlrEnsureInitconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)
void SCIPconshdlrSetExit(SCIP_CONSHDLR *conshdlr,)
void SCIPconshdlrSetResprop(SCIP_CONSHDLR *conshdlr,)
void SCIPconshdlrSetTrans(SCIP_CONSHDLR *conshdlr,)
static SCIP_RETCODE conshdlrAddCheckcons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)
static SCIP_RETCODE ensurePropagationStorage(SCIP_SET *set, SCIP_CONSHDLR *conshdlr, int num)
void SCIPconshdlrSetDelete(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconsResprop(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
void SCIPconshdlrSetParse(SCIP_CONSHDLR *conshdlr,)
void SCIPconsSetRemovable(SCIP_CONS *cons, SCIP_Bool removable)
void SCIPconshdlrSetExitsol(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconshdlrCreate(SCIP_CONSHDLR **conshdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int sepapriority, int enfopriority, int checkpriority, int sepafreq, int propfreq, int eagerfreq, int maxprerounds, SCIP_Bool delaysepa, SCIP_Bool delayprop, SCIP_Bool needscons, SCIP_PROPTIMING proptiming, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSFREE((*consfree)), SCIP_DECL_CONSINIT((*consinit)), SCIP_DECL_CONSEXIT((*consexit)), SCIP_DECL_CONSINITPRE((*consinitpre)), SCIP_DECL_CONSEXITPRE((*consexitpre)), SCIP_DECL_CONSINITSOL((*consinitsol)), SCIP_DECL_CONSEXITSOL((*consexitsol)), SCIP_DECL_CONSDELETE((*consdelete)), SCIP_DECL_CONSTRANS((*constrans)), SCIP_DECL_CONSINITLP((*consinitlp)), SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFORELAX((*consenforelax)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSPROP((*consprop)), SCIP_DECL_CONSPRESOL((*conspresol)), SCIP_DECL_CONSRESPROP((*consresprop)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_DECL_CONSACTIVE((*consactive)), SCIP_DECL_CONSDEACTIVE((*consdeactive)), SCIP_DECL_CONSENABLE((*consenable)), SCIP_DECL_CONSDISABLE((*consdisable)), SCIP_DECL_CONSDELVARS((*consdelvars)), SCIP_DECL_CONSPRINT((*consprint)), SCIP_DECL_CONSCOPY((*conscopy)), SCIP_DECL_CONSPARSE((*consparse)), SCIP_DECL_CONSGETVARS((*consgetvars)), SCIP_DECL_CONSGETNVARS((*consgetnvars)), SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)), SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)), SCIP_CONSHDLRDATA *conshdlrdata)
void SCIPconshdlrEnableOrDisableClocks(SCIP_CONSHDLR *conshdlr, SCIP_Bool enable)
static SCIP_RETCODE conssetchgDelDisabledCons(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int arraypos)
void SCIPconshdlrSetDisable(SCIP_CONSHDLR *conshdlr,)
void SCIPconshdlrSetActive(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconsTransform(SCIP_CONS *origcons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS **transcons)
static SCIP_Bool consExceedsAgelimit(SCIP_CONS *cons, SCIP_SET *set)
static SCIP_RETCODE conshdlrAddSepacons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)
SCIP_RETCODE SCIPconsCheck(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)
#define AGERESETAVG_OBSOLETEAGE
static void conshdlrDelEnfocons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
SCIP_RETCODE SCIPconssetchgAddAddedCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons, int depth, SCIP_Bool focusnode, SCIP_Bool active)
SCIP_RETCODE SCIPconshdlrInitLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Bool initkeptconss, SCIP_Bool *cutoff)
static SCIP_RETCODE conshdlrDisableConsPropagation(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
static SCIP_RETCODE conshdlrEnsureConssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)
static void conshdlrUnmarkConsPropagate(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
static void conshdlrMarkConsPropagate(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
SCIP_RETCODE SCIPconsAddAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_Real deltaage, SCIP_REOPT *reopt)
SCIP_RETCODE SCIPconsEnablePropagation(SCIP_CONS *cons, SCIP_SET *set)
static void conshdlrDelCheckcons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
static void conshdlrDelayUpdates(SCIP_CONSHDLR *conshdlr)
static void conshdlrDelInitcons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
static SCIP_RETCODE conshdlrForceUpdates(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPconsEnfolp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_RESULT *result)
static SCIP_RETCODE conshdlrAddCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)
SCIP_RETCODE SCIPconsSetInitial(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool initial)
SCIP_RETCODE SCIPconssetchgFree(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set)
static SCIP_RETCODE conshdlrEnsureEnfoconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)
SCIP_RETCODE SCIPconsChgName(SCIP_CONS *cons, BMS_BLKMEM *blkmem, const char *name)
static SCIP_RETCODE conshdlrDisableCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)
SCIP_RETCODE SCIPconsIncAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
static SCIP_Bool consExceedsObsoleteage(SCIP_CONS *cons, SCIP_SET *set)
void SCIPconshdlrSetEnable(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconshdlrInitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
void SCIPconsSetDynamic(SCIP_CONS *cons, SCIP_Bool dynamic)
SCIP_RETCODE SCIPconsSepasol(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_RESULT *result)
SCIP_RETCODE SCIPconsFree(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
static SCIP_RETCODE conshdlrMarkConsUseful(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
static SCIP_RETCODE conshdlrEnableConsPropagation(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)
SCIP_RETCODE SCIPconssetchgAddDisabledCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS *cons)
void SCIPconshdlrSetDeactive(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconsDelete(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
void SCIPconshdlrSetGetVars(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconsPresol(SCIP_CONS *cons, SCIP_SET *set, int nrounds, SCIP_PRESOLTIMING timing, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
SCIP_RETCODE SCIPconsDisablePropagation(SCIP_CONS *cons, SCIP_SET *set)
SCIP_RETCODE SCIPconsCopy(SCIP_CONS **cons, SCIP_SET *set, const char *name, SCIP *sourcescip, SCIP_CONSHDLR *sourceconshdlr, SCIP_CONS *sourcecons, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)
static void conshdlrDelCons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
void SCIPconshdlrSetGetDiveBdChgs(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
SCIP_RETCODE SCIPconsResolvePropagation(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE inferboundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
SCIP_RETCODE SCIPconsSetPropagated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool propagate)
SCIP_RETCODE SCIPconsDisableSeparation(SCIP_CONS *cons, SCIP_SET *set)
static SCIP_RETCODE conshdlrEnsureSepaconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)
void SCIPconshdlrSetInitsol(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconsGetSignedPermsymGraph(SCIP_CONS *cons, SCIP_SET *set, SYM_GRAPH *graph, SCIP_Bool *success)
SCIP_RETCODE SCIPconshdlrUnlockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
SCIP_RETCODE SCIPconsSetChecked(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool check)
SCIP_RETCODE SCIPconsInitlp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPconsEnforelax(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
static SCIP_RETCODE conshdlrAddUpdateCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)
static SCIP_RETCODE doConshdlrCreate(SCIP_CONSHDLR **conshdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int sepapriority, int enfopriority, int checkpriority, int sepafreq, int propfreq, int eagerfreq, int maxprerounds, SCIP_Bool delaysepa, SCIP_Bool delayprop, SCIP_Bool needscons, SCIP_PROPTIMING proptiming, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSFREE((*consfree)), SCIP_DECL_CONSINIT((*consinit)), SCIP_DECL_CONSEXIT((*consexit)), SCIP_DECL_CONSINITPRE((*consinitpre)), SCIP_DECL_CONSEXITPRE((*consexitpre)), SCIP_DECL_CONSINITSOL((*consinitsol)), SCIP_DECL_CONSEXITSOL((*consexitsol)), SCIP_DECL_CONSDELETE((*consdelete)), SCIP_DECL_CONSTRANS((*constrans)), SCIP_DECL_CONSINITLP((*consinitlp)), SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFORELAX((*consenforelax)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSPROP((*consprop)), SCIP_DECL_CONSPRESOL((*conspresol)), SCIP_DECL_CONSRESPROP((*consresprop)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_DECL_CONSACTIVE((*consactive)), SCIP_DECL_CONSDEACTIVE((*consdeactive)), SCIP_DECL_CONSENABLE((*consenable)), SCIP_DECL_CONSDISABLE((*consdisable)), SCIP_DECL_CONSDELVARS((*consdelvars)), SCIP_DECL_CONSPRINT((*consprint)), SCIP_DECL_CONSCOPY((*conscopy)), SCIP_DECL_CONSPARSE((*consparse)), SCIP_DECL_CONSGETVARS((*consgetvars)), SCIP_DECL_CONSGETNVARS((*consgetnvars)), SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)), SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)), SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPconshdlrsResetPropagationStatus(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
SCIP_RETCODE SCIPconshdlrCopyInclude(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_Bool *valid)
SCIP_RETCODE SCIPconsActivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
static SCIP_RETCODE conshdlrAddEnfocons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)
static SCIP_RETCODE conshdlrEnableConsSeparation(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)
static void conshdlrDelSepacons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
SCIP_CONS * SCIPconsGetTransformed(SCIP_CONS *cons)
#define AGERESETAVG_DECAY
SCIP_RETCODE SCIPconshdlrPropagate(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool fullpropagation, SCIP_Bool execdelayed, SCIP_Bool instrongbranching, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
void SCIPconshdlrSetInitlp(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconsUnmarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
SCIP_RETCODE SCIPconshdlrGetDiveBoundChanges(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)
static void conshdlrUpdateAgeresetavg(SCIP_CONSHDLR *conshdlr, SCIP_Real age)
void SCIPconshdlrSetCopy(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)),)
void SCIPconshdlrSetFree(SCIP_CONSHDLR *conshdlr,)
static SCIP_RETCODE conshdlrAddPropcons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)
SCIP_RETCODE SCIPconshdlrPresolve(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRESOLTIMING timing, int nrounds, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
SCIP_RETCODE SCIPconsGetVars(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
void SCIPconsSetNamePointer(SCIP_CONS *cons, const char *name)
SCIP_RETCODE SCIPconshdlrEnforcePseudoSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_BRANCHCAND *branchcand, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_Bool forced, SCIP_RESULT *result)
void SCIPconshdlrSetInitpre(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconssetchgApply(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
SCIP_RETCODE SCIPconshdlrDelVars(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPconsSetEnforced(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool enforce)
void SCIPconsSetModifiable(SCIP_CONS *cons, SCIP_Bool modifiable)
static SCIP_RETCODE conshdlrDeactivateCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)
SCIP_RETCODE SCIPconshdlrExitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPconshdlrInitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPconssetchgMakeGlobal(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
void SCIPconshdlrSetPrint(SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPconshdlrCheck(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT *result)
SCIP_RETCODE SCIPconshdlrExit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
static SCIP_RETCODE conshdlrActivateCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons, int depth, SCIP_Bool focusnode)
SCIP_RETCODE SCIPconshdlrFree(SCIP_CONSHDLR **conshdlr, SCIP_SET *set)
internal methods for constraints and constraint handlers
common defines and data types used in all packages of SCIP
#define SCIP_MAXTREEDEPTH
#define SCIP_CALL_FINALLY(x, y)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
void SCIPconshdlrSetEnforelax(SCIP_CONSHDLR *conshdlr,)
int SCIPconshdlrGetMaxNActiveConss(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetCheckTime(SCIP_CONSHDLR *conshdlr)
SCIP_PROPTIMING SCIPconshdlrGetPropTiming(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrWasSolSeparationDelayed(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNCheckCalls(SCIP_CONSHDLR *conshdlr)
SCIP_CONS ** SCIPconshdlrGetCheckConss(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNChgSides(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetPresolTime(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetEagerFreq(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrDoesPresolve(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetProp(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING timingmask)
int SCIPconshdlrGetNFixedVars(SCIP_CONSHDLR *conshdlr)
SCIP_PRESOLTIMING SCIPconshdlrGetPresolTiming(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetEnfoLPTime(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNPresolCalls(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNDomredsFound(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNCutsApplied(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNChgCoefs(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetPresolTiming(SCIP_CONSHDLR *conshdlr, SCIP_PRESOLTIMING presoltiming)
int SCIPconshdlrGetNUpdateConss(SCIP_CONSHDLR *conshdlr)
SCIP_CONS ** SCIPconshdlrGetEnfoConss(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetSepa(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
SCIP_Real SCIPconshdlrGetStrongBranchPropTime(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNCutsFound(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrSupportsSignedPermsymDetection(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrIsPropagationDelayed(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetPropTime(SCIP_CONSHDLR *conshdlr)
void SCIPconssetchgGetAddedConsData(SCIP_CONSSETCHG *conssetchg, SCIP_CONS ***conss, int *nconss)
SCIP_Real SCIPconshdlrGetEnfoPSTime(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetPropFreq(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNCutoffs(SCIP_CONSHDLR *conshdlr)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNEnabledConss(SCIP_CONSHDLR *conshdlr)
SCIP_CONS ** SCIPconshdlrGetUpdateConss(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrIsSeparationDelayed(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNSepaCalls(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNDelConss(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrWasLPSeparationDelayed(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNChildren(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetEnfoRelaxTime(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetPropTiming(SCIP_CONSHDLR *conshdlr, SCIP_PROPTIMING proptiming)
SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNAggrVars(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNEnfoPSCalls(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNAddHoles(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNEnfoConss(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrIsInitialized(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNUpgdConss(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetStartNActiveConss(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrWasPropagationDelayed(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNAddConss(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrSupportsPermsymDetection(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNChgBds(SCIP_CONSHDLR *conshdlr)
const char * SCIPconshdlrGetDesc(SCIP_CONSHDLR *conshdlr)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNConssFound(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetCheckPriority(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetSepaFreq(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNPropCalls(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNEnfoLPCalls(SCIP_CONSHDLR *conshdlr)
SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetEnfoPriority(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetSetupTime(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNRespropCalls(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetSepaTime(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrIsClonable(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNChgVarTypes(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetRespropTime(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNEnfoRelaxCalls(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsLockedNeg(SCIP_CONS *cons)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
void SCIPconsAddUpgradeLocks(SCIP_CONS *cons, int nlocks)
int SCIPconsGetPos(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsConflict(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_Real SCIPconsGetAge(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
int SCIPconsGetActiveDepth(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLockedPos(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsPropagationEnabled(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
int SCIPconsGetNUpgradeLocks(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)
int SCIPconsGetNLocksTypeNeg(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
int SCIPconsGetValidDepth(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsOriginal(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)
int SCIPconsGetNLocksPos(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLockedType(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInProb(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsGlobal(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
int SCIPconsGetNLocksNeg(SCIP_CONS *cons)
int SCIPconsGetNUses(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLockedTypePos(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsSeparationEnabled(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLockedTypeNeg(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsAdded(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsObsolete(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
int SCIPconsGetNLocksTypePos(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
int SCIPlinConsStatsGetSum(SCIP_LINCONSSTATS *linconsstats)
void SCIPlinConsStatsIncTypeCount(SCIP_LINCONSSTATS *linconsstats, SCIP_LINCONSTYPE linconstype, int increment)
int SCIPlinConsStatsGetTypeCount(SCIP_LINCONSSTATS *linconsstats, SCIP_LINCONSTYPE linconstype)
void SCIPlinConsStatsFree(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)
void SCIPlinConsStatsReset(SCIP_LINCONSSTATS *linconsstats)
void SCIPprintLinConsStats(SCIP *scip, FILE *file, SCIP_LINCONSSTATS *linconsstats)
SCIP_RETCODE SCIPlinConsStatsCreate(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPsnprintf(char *t, int len, const char *s,...)
void SCIPstrCopySection(const char *str, char startchar, char endchar, char *token, int size, char **endptr)
SCIP_RETCODE SCIPskipSpace(char **s)
static SCIP_DIVESET * diveset
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
static const char * paramname[]
#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)
#define BMSfreeMemory(ptr)
#define BMSfreeBlockMemory(mem, ptr)
#define BMSallocBlockMemory(mem, ptr)
#define BMSreallocMemoryArray(ptr, num)
#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)
#define BMSduplicateMemoryArray(ptr, source, num)
#define BMSclearMemory(ptr)
#define BMScopyMemoryArray(ptr, source, num)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)
#define BMSclearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
#define BMSfreeMemoryArrayNull(ptr)
#define BMSallocMemory(ptr)
void SCIPmessagePrintError(const char *formatstr,...)
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
SCIP_RETCODE SCIPprobDelCons(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)
SCIP_RETCODE SCIPprobAddCons(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)
internal methods for storing and manipulating the main problem
public data structures and miscellaneous methods
SCIP_Bool SCIPreoptConsCanBeDeleted(SCIP_REOPT *reopt, SCIP_CONS *cons)
data structures and methods for collecting reoptimization information
int SCIPsepastoreGetNCuts(SCIP_SEPASTORE *sepastore)
internal methods for storing separated cuts
SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPsetAddBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_CONSHDLR * SCIPsetFindConshdlr(SCIP_SET *set, const char *name)
SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
internal methods for global SCIP settings
internal methods for problem statistics
SCIP_CONS ** disabledconss
unsigned int nupgradelocks
int nlocksneg[NLOCKTYPES]
unsigned int updatesepaenable
unsigned int updateobsolete
unsigned int updatesepadisable
SCIP_CONSSETCHG * addconssetchg
unsigned int updateenable
unsigned int updateactfocus
unsigned int updateunmarkpropagate
unsigned int updateactivate
SCIP_CONS * transorigcons
unsigned int updatedisable
unsigned int updatedeactivate
unsigned int updatepropenable
unsigned int stickingatnode
int nlockspos[NLOCKTYPES]
unsigned int markpropagate
unsigned int updatemarkpropagate
unsigned int updatepropdisable
unsigned int updateinsert
SCIP_RESULT lastenfolpresult
SCIP_Longint ndomredsfound
SCIP_PRESOLTIMING presoltiming
SCIP_Longint lastenfolpdomchgcount
SCIP_CLOCK * enforelaxtime
int storednmarkedpropconss
SCIP_Longint nenfolpcalls
SCIP_RESULT lastenfopsresult
SCIP_Longint nenforelaxcalls
SCIP_Longint lastsepalpcount
SCIP_Longint lastenfolplpcount
SCIP_Bool sepasolwasdelayed
SCIP_Bool sepalpwasdelayed
SCIP_Longint ncutsapplied
SCIP_RESULT lastenforelaxresult
SCIP_Longint nenfopscalls
SCIP_Longint lastenforelaxrelaxcount
SCIP_Longint storedpropdomchgcount
SCIP_Longint lastenfolpnode
SCIP_PROPTIMING proptiming
SCIP_Longint lastenforelaxnode
SCIP_CONS ** storedpropconss
SCIP_Longint lastpropdomchgcount
SCIP_Longint lastenfopsnode
SCIP_Longint lastenforelaxdomchgcount
SCIP_Longint nrespropcalls
SCIP_CONSHDLRDATA * conshdlrdata
SCIP_Longint lastenfopsdomchgcount
int counter[SCIP_NLINCONSTYPES]
SCIP_Longint nprobholechgs
SCIP_Longint ninitconssadded
SCIP_Longint nprobboundchgs
datastructures for constraints and constraint handlers
SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)
int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)
internal methods for branch and bound tree
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSINITPRE(x)
#define SCIP_DECL_CONSDELETE(x)
#define SCIP_DECL_CONSEXIT(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSINITSOL(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSSEPALP(x)
#define SCIP_DECL_CONSDISABLE(x)
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSRESPROP(x)
@ SCIP_LINCONSTYPE_BINPACKING
@ SCIP_LINCONSTYPE_VARBOUND
@ SCIP_LINCONSTYPE_INVKNAPSACK
@ SCIP_LINCONSTYPE_PRECEDENCE
@ SCIP_LINCONSTYPE_AGGREGATION
@ SCIP_LINCONSTYPE_MIXEDBINARY
@ SCIP_LINCONSTYPE_SINGLETON
@ SCIP_LINCONSTYPE_SETCOVERING
@ SCIP_LINCONSTYPE_EQKNAPSACK
@ SCIP_LINCONSTYPE_KNAPSACK
@ SCIP_LINCONSTYPE_SETPARTITION
@ SCIP_LINCONSTYPE_INTKNAPSACK
@ SCIP_LINCONSTYPE_SETPACKING
@ SCIP_LINCONSTYPE_GENERAL
@ SCIP_LINCONSTYPE_CARDINALITY
#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_CONSENABLE(x)
#define SCIP_DECL_CONSINITLP(x)
#define SCIP_DECL_CONSEXITPRE(x)
#define SCIP_DECL_CONSLOCK(x)
#define SCIP_DECL_CONSCOPY(x)
#define SCIP_DECL_CONSINIT(x)
struct SCIP_ConsData SCIP_CONSDATA
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSHDLRCOPY(x)
#define SCIP_DECL_CONSEXITSOL(x)
#define SCIP_NLINCONSTYPES
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
enum SCIP_LinConstype SCIP_LINCONSTYPE
#define SCIP_DECL_CONSDELVARS(x)
enum SCIP_BoundType SCIP_BOUNDTYPE
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_HASHGETKEY(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
#define SCIP_PRESOLTIMING_MAX
#define SCIP_PRESOLTIMING_FINAL
unsigned int SCIP_PROPTIMING
#define SCIP_PRESOLTIMING_MEDIUM
unsigned int SCIP_PRESOLTIMING
#define SCIP_PROPTIMING_AFTERLPLOOP
#define SCIP_PRESOLTIMING_FAST
#define SCIP_PRESOLTIMING_EXHAUSTIVE
#define SCIP_PROPTIMING_BEFORELP
#define SCIP_PROPTIMING_ALWAYS
#define SCIP_PROPTIMING_DURINGLPLOOP
enum SCIP_LockType SCIP_LOCKTYPE
internal methods for problem variables