83#define CONSHDLR_NAME "nonlinear"
84#define CONSHDLR_DESC "handler for nonlinear constraints specified by algebraic expressions"
85#define CONSHDLR_ENFOPRIORITY -60
86#define CONSHDLR_CHECKPRIORITY -4000010
87#define CONSHDLR_EAGERFREQ 100
89#define CONSHDLR_NEEDSCONS TRUE
92#define CONSHDLR_SEPAPRIORITY 10
93#define CONSHDLR_SEPAFREQ 1
94#define CONSHDLR_DELAYSEPA FALSE
96#define CONSHDLR_PROPFREQ 1
97#define CONSHDLR_DELAYPROP FALSE
98#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
100#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_ALWAYS
101#define CONSHDLR_MAXPREROUNDS -1
104#define TABLE_NAME_NONLINEAR "cons_nonlinear"
105#define TABLE_DESC_NONLINEAR "nonlinear constraint handler statistics"
106#define TABLE_POSITION_NONLINEAR 14600
107#define TABLE_EARLIEST_STAGE_NONLINEAR SCIP_STAGE_TRANSFORMED
110#define TABLE_NAME_NLHDLR "nlhdlr"
111#define TABLE_DESC_NLHDLR "nonlinear handler statistics"
112#define TABLE_POSITION_NLHDLR 14601
113#define TABLE_EARLIEST_STAGE_NLHDLR SCIP_STAGE_PRESOLVING
115#define DIALOG_NAME "nlhdlrs"
116#define DIALOG_DESC "display nonlinear handlers"
117#define DIALOG_ISSUBMENU FALSE
119#define VERTEXPOLY_MAXPERTURBATION 1e-3
120#define VERTEXPOLY_USEDUALSIMPLEX TRUE
121#define VERTEXPOLY_RANDNUMINITSEED 20181029
122#define VERTEXPOLY_ADJUSTFACETFACTOR 1e1
124#define BRANCH_RANDNUMINITSEED 20191229
126#define BILIN_MAXNAUXEXPRS 10
132#define infty2infty(infty1, infty2, val) ((val) >= (infty1) ? (infty2) : (val))
135#define POWEROFTWO(x) (0x1u << (x))
138#define ENFOLOG(x) if( SCIPgetSubscipDepth(scip) == 0 && SCIPgetVerbLevel(scip) >= SCIP_VERBLEVEL_NORMAL ) { x }
161struct SCIP_Expr_OwnerData
169 int monotonicitysize;
173 unsigned int propboundstag;
174 SCIP_Bool inpropqueue;
179 unsigned int lastenforced;
180 unsigned int nactivityusesprop;
181 unsigned int nactivityusessepa;
182 unsigned int nauxvaruses;
186 SCIP_Real violscoresum;
187 SCIP_Real violscoremax;
189 unsigned int violscoretag;
195 SCIP_Bool consssorted;
211 SCIP_Bool catchedevents;
217 SCIP_Longint gradnormsoltag;
220 unsigned int ispropagated:1;
221 unsigned int issimplified:1;
230 SCIP_Real linvardecrcoef;
231 SCIP_Real linvarincrcoef;
248struct SCIP_ConshdlrData
255 SCIP_Bool registerusesactivitysepabelow;
256 SCIP_Bool registerusesactivitysepaabove;
260 int consupgradessize;
270 SCIP_Longint curboundstag;
271 SCIP_Longint lastboundrelax;
272 SCIP_Longint lastvaractivitymethodchange;
273 unsigned int enforound;
278 SCIP_Bool globalbounds;
280 SCIP_Bool forceboundtightening;
281 unsigned int curpropboundstag;
285 SCIP_Bool propauxvars;
287 SCIP_Real varboundrelaxamount;
288 SCIP_Real conssiderelaxamount;
289 SCIP_Real vp_maxperturb;
290 SCIP_Real vp_adjfacetthreshold;
291 SCIP_Bool vp_dualsimplex;
292 SCIP_Bool reformbinprods;
293 SCIP_Bool reformbinprodsand;
294 int reformbinprodsfac;
295 SCIP_Bool forbidmultaggrnlvar;
296 SCIP_Bool tightenlpfeastol;
297 SCIP_Bool propinenforce;
298 SCIP_Real weakcutthreshold;
299 SCIP_Real strongcutmaxcoef;
300 SCIP_Bool strongcutefficacy;
301 SCIP_Bool forcestrongcut;
302 SCIP_Real enfoauxviolfactor;
303 SCIP_Real weakcutminviolfactor;
304 char rownotremovable;
307 int branchauxmindepth;
308 SCIP_Bool branchexternal;
309 SCIP_Real branchhighviolfactor;
310 SCIP_Real branchhighscorefactor;
311 SCIP_Real branchviolweight;
312 SCIP_Real branchdualweight;
313 SCIP_Real branchpscostweight;
314 SCIP_Real branchdomainweight;
315 SCIP_Real branchvartypeweight;
317 char branchviolsplit;
318 SCIP_Real branchpscostreliable;
319 char linearizeheursol;
320 SCIP_Bool assumeconvex;
323 SCIP_Longint nweaksepa;
324 SCIP_Longint ntightenlp;
325 SCIP_Longint ndesperatetightenlp;
326 SCIP_Longint ndesperatebranch;
327 SCIP_Longint ndesperatecutoff;
328 SCIP_Longint nforcelp;
330 SCIP_Longint ncanonicalizecalls;
341 int bilinmaxnauxexprs;
345 char branchpscostupdatestrategy;
348 SCIP_Bool checkedvarlocks;
350 int newsoleventfilterpos;
376 SCIP_Bool* infeasible,
437 mydata->nactivityusesprop = 0;
438 mydata->nactivityusessepa = 0;
449 nlhdlr =
mydata->enfos[
e]->nlhdlr;
452 if(
mydata->enfos[
e]->issepainit )
489 assert((*ownerdata)->nlockspos == 0);
490 assert((*ownerdata)->nlocksneg == 0);
495 assert((*ownerdata)->nenfos <= 0);
504 assert((*ownerdata)->nconss == 0);
506 assert((*ownerdata)->filterpos == -1);
538 if( ownerdata->nenfos > 0 )
543 for(
i = 0;
i < ownerdata->nenfos; ++
i )
560 if( ownerdata->auxvar !=
NULL )
605 (*ownerdata)->nenfos = -1;
613 (*ownerdata)->filterpos = -1;
636 (*ownerdata)->filterpos = -2;
746 if( consdata->varexprs !=
NULL )
750 assert(consdata->nvarexprs == 0);
753 if( consdata->issimplified )
784 for(
i = 0;
i < consdata->nvarexprs; ++
i )
807 if( consdata->varexprs ==
NULL )
811 assert(consdata->nvarexprs >= 0);
814 for(
i = 0;
i < consdata->nvarexprs; ++
i )
823 consdata->varexprs =
NULL;
824 consdata->nvarexprs = 0;
848 if( conshdlrdata->globalbounds )
871 switch( conshdlrdata->varboundrelax )
886 lb =
MAX(
bnd, lb - conshdlrdata->varboundrelaxamount);
893 ub =
MIN(
bnd, ub + conshdlrdata->varboundrelaxamount);
906 lb -= conshdlrdata->varboundrelaxamount;
909 ub += conshdlrdata->varboundrelaxamount;
941 SCIPerrorMessage(
"Unsupported value '%c' for varboundrelax option.\n", conshdlrdata->varboundrelax);
997 assert(ownerdata->nconss > 0);
1032 for(
c = 0;
c < ownerdata->nconss; ++
c )
1042 consdata->ispropagated =
FALSE;
1048 consdata->issimplified =
FALSE;
1064 ++conshdlrdata->curboundstag;
1065 assert(conshdlrdata->curboundstag > 0);
1069 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
1112 for(
i = 0;
i < ownerdata->nconss; ++
i )
1113 assert(ownerdata->conss[
i] != cons);
1119 ownerdata->conss[ownerdata->nconss++] = cons;
1123 if( ownerdata->nconss <= 1 )
1124 ownerdata->consssorted =
TRUE;
1125 else if( ownerdata->consssorted )
1126 ownerdata->consssorted =
compIndexConsNonlinear(ownerdata->conss[ownerdata->nconss-2], ownerdata->conss[ownerdata->nconss-1]) > 0;
1129 if( ownerdata->filterpos < 0 )
1133 assert(ownerdata->nconss == 1);
1138 assert(ownerdata->filterpos >= 0);
1163 assert(consdata->nvarexprs >= 0);
1166 if( consdata->catchedevents )
1177 for(
i = 0;
i < consdata->nvarexprs; ++
i )
1179 expr = consdata->varexprs[
i];
1201 consdata->catchedevents =
TRUE;
1229 assert(ownerdata->nconss > 0);
1231 if( ownerdata->conss[ownerdata->nconss-1] == cons )
1233 pos = ownerdata->nconss-1;
1237 if( !ownerdata->consssorted )
1240 ownerdata->consssorted =
TRUE;
1250 assert(ownerdata->conss[pos] == cons);
1255 ownerdata->conss[pos] = ownerdata->conss[ownerdata->nconss-1];
1256 ownerdata->consssorted =
FALSE;
1258 --ownerdata->nconss;
1261 if( ownerdata->nconss == 0 )
1265 assert(ownerdata->filterpos >= 0);
1270 ownerdata->filterpos = -1;
1294 if( !consdata->catchedevents )
1298 assert(consdata->nvarexprs >= 0);
1302 for(
i = consdata->nvarexprs - 1;
i >= 0; --
i )
1309 consdata->catchedevents =
FALSE;
1340 SCIP_Bool modifiable,
1361 SCIPerrorMessage(
"Locally valid nonlinear constraints are not supported, yet.\n");
1368 SCIPerrorMessage(
"Non-initial nonlinear constraints are not supported, yet.\n");
1382 consdata->expr = expr;
1385 consdata->lhs = lhs;
1386 consdata->rhs = rhs;
1387 consdata->consindex = conshdlrdata->lastconsindex++;
1391 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
1392 local, modifiable, dynamic, removable,
FALSE) );
1505 if( ownerdata->nlocksneg > 0 &&
auxvarvalue > auxvalue )
1514 if( ownerdata->nlockspos > 0 && auxvalue >
auxvarvalue )
1583 return MAX3(0.0, consdata->lhsviol, consdata->rhsviol);
1615 if( conshdlrdata->violscale ==
'n' )
1624 if( conshdlrdata->violscale ==
'a' )
1629 if( consdata->lhsviol > 0.0 &&
REALABS(consdata->lhs) > scale )
1632 scale =
REALABS(consdata->lhs);
1634 else if( consdata->rhsviol > 0.0 &&
REALABS(consdata->rhs) > scale )
1637 scale =
REALABS(consdata->rhs);
1645 assert(conshdlrdata->violscale ==
'g');
1652 consdata->gradnorm = 0.0;
1661 for(
i = 0;
i < consdata->nvarexprs; ++
i )
1670 consdata->gradnorm = 0.0;
1677 consdata->gradnorm =
sqrt(consdata->gradnorm);
1678 consdata->gradnormsoltag =
soltag;
1681 *viol /=
MAX(1.0, consdata->gradnorm);
1716 consdata->linvarincr =
NULL;
1717 consdata->linvardecr =
NULL;
1718 consdata->linvarincrcoef = 0.0;
1719 consdata->linvardecrcoef = 0.0;
1755 if( (consdata->linvardecr ==
NULL) ||
1758 consdata->linvardecr =
var;
1759 consdata->linvardecrcoef = coef;
1768 if( (consdata->linvarincr ==
NULL) ||
1771 consdata->linvarincr =
var;
1772 consdata->linvarincrcoef = coef;
1778 assert(consdata->linvarincr ==
NULL || consdata->linvarincrcoef != 0.0);
1779 assert(consdata->linvardecr ==
NULL || consdata->linvardecrcoef != 0.0);
1781 if( consdata->linvarincr !=
NULL )
1785 if( consdata->linvardecr !=
NULL )
1833 SCIPdebugMsg(
scip,
"attempt to make solution from <%s> feasible by shifting linear variable\n",
1836 for(
c = 0;
c < nconss; ++
c )
1839 SCIP_Real viol = 0.0;
1847 viol = consdata->lhsviol;
1849 viol = -consdata->rhsviol;
1853 if( consdata->linvarincr !=
NULL &&
1859 delta = viol / consdata->linvarincrcoef;
1866 delta =
MIN(
MAX(0.0, gap), delta);
1875 SCIPdebugMsg(
scip,
"increase <%s> by %g to %g to remedy lhs-violation %g of cons <%s>\n",
1879 viol -= consdata->linvarincrcoef * delta;
1886 if( consdata->linvardecr !=
NULL &&
1892 delta = viol / consdata->linvardecrcoef;
1899 delta =
MAX(
MIN(0.0, gap), delta);
1908 SCIPdebugMsg(
scip,
"increase <%s> by %g to %g to remedy rhs-violation %g of cons <%s>\n",
1912 viol -= consdata->linvardecrcoef * delta;
1984 for(
c = 0;
c < nconss; ++
c )
2000 for(
i = 0;
i < consdata->nvarexprs; ++
i )
2022 if( ownerdata->auxvar !=
NULL )
2028 for(
e = 0;
e < ownerdata->nenfos; ++
e )
2032 ownerdata->enfos[
e]->nlhdlr, expr, ownerdata->enfos[
e]->nlhdlrexprdata,
sol,
solisbest,
2167 SCIP_Bool* infeasible,
2179 if( infeasible !=
NULL )
2180 *infeasible =
FALSE;
2190 SCIPdebugMsg(
scip,
"stored activity of root expr is empty and valid (activitytag >= lastboundrelax (%" SCIP_LONGINT_FORMAT ")), skip forwardPropExpr -> cutoff\n", conshdlrdata->lastboundrelax);
2192 if( infeasible !=
NULL )
2219 if( ownerdata->nenfos >= 0 && ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && !conshdlrdata->indetect)
2222 SCIPdebugMsg(
scip,
"root expr activity is not used but enfo initialized, skip inteval\n");
2270 SCIPexprGetActivityTag(expr) >= conshdlrdata->lastvaractivitymethodchange && !conshdlrdata->globalbounds )
2305 if( infeasible !=
NULL )
2307 SCIPdebugMsg(
scip,
"expr %p already has empty activity -> cutoff\n", (
void*)expr);
2317 if( ownerdata->nenfos >= 0 && ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && !conshdlrdata->indetect )
2320 SCIPdebugMsg(
scip,
"expr %p activity is not used but enfo initialized, skip inteval\n", (
void*)expr);
2332 if( ownerdata->nenfos > 0 )
2345 nlhdlr = ownerdata->enfos[
e]->nlhdlr;
2415 if( infeasible !=
NULL )
2425 if( infeasible !=
NULL )
2511 SCIP_Bool* infeasible,
2530 while( !
SCIPqueueIsEmpty(conshdlrdata->reversepropqueue) && !(*infeasible) )
2541 assert(ownerdata->inpropqueue);
2543 ownerdata->inpropqueue =
FALSE;
2548 assert(ownerdata->propboundstag == conshdlrdata->curpropboundstag);
2556#ifdef SCIP_DISABLED_CODE
2564 propbounds = ownerdata->propbounds;
2567 if( ownerdata->nenfos > 0 )
2570 for(
e = 0;
e < ownerdata->nenfos && !*infeasible; ++
e )
2579 nlhdlr = ownerdata->enfos[
e]->nlhdlr;
2610 assert(ownerdata->nenfos < 0);
2639 ownerdata->inpropqueue =
FALSE;
2709 assert(!conshdlrdata->globalbounds);
2715 conshdlrdata->forceboundtightening = force;
2718 ++conshdlrdata->curpropboundstag;
2721 if( conshdlrdata->propauxvars )
2736 for(
i = 0;
i < nconss; ++
i )
2748 if( consdata->ispropagated )
2769 if( !conshdlrdata->propauxvars || ownerdata->auxvar ==
NULL )
2775 if( ownerdata->auxvar ==
NULL )
2803 if( ownerdata->auxvar ==
NULL )
2806 if( ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 )
2829 consdata->ispropagated =
TRUE;
2852 if( conshdlrdata->propauxvars )
2857 conshdlrdata->forceboundtightening =
FALSE;
2860 ++conshdlrdata->curpropboundstag;
2910 for(
c = 0;
c < nconss && !
cutoff; ++
c )
2927 for(
e = 0;
e < ownerdata->nenfos; ++
e )
2932 nlhdlr = ownerdata->enfos[
e]->nlhdlr;
2937 SCIPdebugMsg(
scip,
"propExprDomains calling reverseprop for expression %p [%g,%g]\n", (
void*)expr,
3000 if( nlockspos == 0 && nlocksneg == 0 )
3033 ownerdata->nlockspos += nlockspos;
3034 ownerdata->nlocksneg += nlocksneg;
3037 if( ownerdata->nlockspos == nlockspos && ownerdata->nlocksneg == nlocksneg &&
SCIPexprGetNChildren(expr) > 0
3043 assert(ownerdata->monotonicitysize == 0);
3060 if( ownerdata->nlockspos == 0 && ownerdata->nlocksneg == 0 && ownerdata->monotonicity !=
NULL )
3062 assert(ownerdata->monotonicitysize > 0);
3067 ownerdata->monotonicitysize = 0;
3083 switch( monotonicity )
3094 ituserdata.intvals[0] = nlockspos + nlocksneg;
3095 ituserdata.intvals[1] = nlockspos + nlocksneg;
3150 if( nlockspos == 0 && nlocksneg == 0 )
3161 consdata->nlockspos += nlockspos;
3162 consdata->nlocksneg += nlocksneg;
3164 assert(consdata->nlockspos >= 0);
3165 assert(consdata->nlocksneg >= 0);
3201 if( consdata->nlrow !=
NULL )
3310 assert(conshdlrdata->auxvarid >= 0);
3311 assert(!conshdlrdata->indetect);
3314 assert(ownerdata->nenfos < 0);
3324 if( ownerdata->nauxvaruses == 0 )
3328 if( ownerdata->nlockspos == 0 )
3330 if( ownerdata->nlocksneg == 0 )
3333 if( ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 )
3342 ownerdata->nenfos = 0;
3345 conshdlrdata->indetect =
TRUE;
3347 SCIPdebugMsg(
scip,
"detecting nlhdlrs for %s expression %p (%s); requiring%s%s%s\n",
3353 for(
h = 0;
h < conshdlrdata->nnlhdlrs; ++
h )
3357 nlhdlr = conshdlrdata->nlhdlrs[
h];
3365 nlhdlrexprdata =
NULL;
3368 conshdlrdata->registerusesactivitysepabelow =
FALSE;
3369 conshdlrdata->registerusesactivitysepaabove =
FALSE;
3393 if( nlhdlrexprdata !=
NULL )
3405 SCIPdebugMsg(
scip,
"nlhdlr <%s> detect successful; sepabelow: %s, sepaabove: %s, activity: %s\n",
3414 ownerdata->enfos[ownerdata->nenfos]->nlhdlr = nlhdlr;
3415 ownerdata->enfos[ownerdata->nenfos]->nlhdlrexprdata = nlhdlrexprdata;
3417 ownerdata->enfos[ownerdata->nenfos]->issepainit =
FALSE;
3418 ownerdata->enfos[ownerdata->nenfos]->sepabelowusesactivity = conshdlrdata->registerusesactivitysepabelow;
3419 ownerdata->enfos[ownerdata->nenfos]->sepaaboveusesactivity = conshdlrdata->registerusesactivitysepaabove;
3420 ownerdata->nenfos++;
3426 conshdlrdata->indetect =
FALSE;
3433 SCIPerrorMessage(
"no nonlinear handler provided some of the required enforcement methods\n");
3437 assert(ownerdata->nenfos > 0);
3440 if( ownerdata->nenfos > 1 )
3481 conshdlrdata->globalbounds =
TRUE;
3482 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
3485 for(
i = 0;
i < nconss; ++
i )
3507 if( ownerdata->nenfos > 0 )
3510 assert(ownerdata->nenfos < 0);
3518 conshdlrdata->indetect =
TRUE;
3523 conshdlrdata->indetect =
FALSE;
3535 if( ownerdata->nenfos >= 0 )
3545 if( ownerdata->nauxvaruses > 0 || ownerdata->nactivityusesprop > 0 || ownerdata->nactivityusessepa > 0 )
3549 assert(ownerdata->nenfos >= 0);
3558 ownerdata->nenfos = 0;
3564 consdata->ispropagated =
FALSE;
3573 conshdlrdata->globalbounds =
FALSE;
3574 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
3610 for(
c = 0;
c < nconss; ++
c )
3661 if( consdata->nlrow ==
NULL )
3711 for(
c = 0;
c < nconss; ++
c )
3725 SCIPdebugMsg(
scip,
"exitsepa and free nonlinear handler data for expression %p\n", (
void*)expr);
3744 if( consdata->nlrow !=
NULL )
3758 consdata->linvardecr =
NULL;
3759 consdata->linvarincr =
NULL;
3884 SCIP_Bool integral =
TRUE;
3915 if( naddconss !=
NULL )
3926 if( naddconss !=
NULL )
3940 if( naddconss !=
NULL )
3953 if( naddconss !=
NULL )
4127 for(
i = 0;
i < nchildren; ++
i )
4197 strcpy(name,
"binreform");
4198 for(
i = 0;
i < nchildren; ++
i )
4243 if( naddconss !=
NULL )
4255 if( naddconss !=
NULL )
4313 SCIPdebugMsg(
scip,
" product expression %p has been considered for the first time\n", (
void*)prodexpr);
4315 if( nchildren == 2 )
4341 if( nchgcoefs !=
NULL )
4353 if( nchgcoefs !=
NULL )
4373 if( nchgcoefs !=
NULL )
4394 if( nchgcoefs !=
NULL )
4464 if( conshdlrdata->reformbinprodsfac > 1 )
4477 assert(naddconss ==
NULL || *naddconss > 0 || nchgcoefs ==
NULL || *nchgcoefs > 0);
4486 consdata->issimplified =
FALSE;
4562 for(
c = 0;
c < nconss; ++
c )
4573 if( conshdlrdata->reformbinprodsfac > 1 )
4585 consdata->issimplified =
FALSE;
4634 if( nchildren == 1 && constant == 0.0 && coefs[0] == -1.0 )
4637 expr = consdata->expr;
4645 consdata->lhs = -consdata->lhs;
4646 consdata->rhs = -consdata->rhs;
4654 for(
i = 0;
i < nchildren; ++
i )
4655 counter += coefs[
i] > 0 ? 1 : -1;
4665 for(
i = 0;
i < nchildren; ++
i )
4673 consdata->expr = expr;
4675 consdata->lhs = -consdata->lhs;
4676 consdata->rhs = -consdata->rhs;
4711 for(
c = 0;
c < nconss; ++
c )
4763 SCIP_Bool* infeasible,
4786 ++(conshdlrdata->ncanonicalizecalls);
4790 *infeasible =
FALSE;
4793 havechange = conshdlrdata->ncanonicalizecalls == 1;
4803 for(
i = 0;
i < nconss; ++
i )
4811 nlockspos[
i] = consdata->nlockspos;
4812 nlocksneg[
i] = consdata->nlocksneg;
4816 assert(consdata->nlockspos == 0);
4817 assert(consdata->nlocksneg == 0);
4822 for(
i = 0;
i < nconss; ++
i )
4856 if( naddconss !=
NULL )
4858 if( nchgcoefs !=
NULL )
4866 for(
i = 0;
i < nconss; ++
i )
4872 if( !consdata->issimplified && consdata->expr !=
NULL )
4879 consdata->issimplified =
TRUE;
4930 if( ndelconss !=
NULL )
4946 for(
i = 0;
i < nconss; ++
i )
4955 for(
i = 0;
i < nconss; ++
i )
4970 for(
i = nconss-1;
i >= 0; --
i )
4979 for(
i = 0;
i < nconss; ++
i )
4998 for(
i = 0;
i < nconss; ++
i )
5012 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
5037 SCIP_Bool* updatelocks;
5055 for(
c = 0;
c < nconss; ++
c )
5077 assert(idx >= 0 && idx < nconss);
5083 SCIPdebugMsg(
scip,
"merge constraint %g <= %s <= %g with %g <= %s <= %g\n", consdata->lhs,
5093 updatelocks[idx] =
TRUE;
5109 for(
c = 0;
c < nconss; ++
c )
5111 if( updatelocks[
c] )
5145 if( conshdlrdata->globalbounds )
5231 ++conshdlrdata->curboundstag;
5232 assert(conshdlrdata->curboundstag > 0);
5233 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
5234 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
5240 for(
i = 0;
i < nconss; ++
i )
5274 SCIP_Bool tightened;
5341 SCIPdebugMsg(
scip,
" -> redundant: activity [%g,%g] within sides [%g,%g]\n", activity.
inf, activity.
sup, consdata->lhs, consdata->rhs);
5349 SCIPdebugMsg(
scip,
" -> not redundant: activity [%g,%g] not within sides [%g,%g]\n", activity.
inf, activity.
sup, consdata->lhs, consdata->rhs);
5354 ++conshdlrdata->curboundstag;
5355 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
5356 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
5368 SCIP_Bool* upgraded,
5396 if( conshdlrdata->nconsupgrades == 0 )
5410 for(
i = 0;
i < conshdlrdata->nconsupgrades; ++
i )
5412 if( !conshdlrdata->consupgrades[
i]->active )
5415 assert(conshdlrdata->consupgrades[
i]->consupgd !=
NULL);
5535 SCIP_Bool* infeasible
5556 *infeasible =
FALSE;
5580 for(
i = 0;
i < consdata->nvarexprs; ++
i )
5606 for(
i = 0;
i < nchildren; ++
i )
5611 child = children[
i];
5647 valid = exponent > 1.0 &&
fmod(exponent, 2.0) == 0.0;
5679 SCIP_Real bounds[2];
5685 SCIPdebugMsg(
scip,
"found single locked variable %s in [%g,%g] that can be fixed to one of its bounds\n",
5739 SCIP_Bool* infeasible
5750 *infeasible =
FALSE;
5760 for(
c = 0;
c < nconss; ++
c )
5789 if( nchildren <= 1 )
5795 for(
i = 0;
i < nchildren; ++
i )
5817 for(
i = 0;
i < nchildren; ++
i )
5819 if( children[
i] ==
cand )
5840 SCIPdebugMsg(
scip,
"make variable <%s> implicit integer due to constraint <%s>\n",
5878 assert(ownerdata->nauxvaruses > 0);
5881 if( ownerdata->auxvar !=
NULL )
5896 assert(conshdlrdata->auxvarid >= 0);
5906 ++conshdlrdata->auxvarid;
5956#ifdef WITH_DEBUG_SOLUTION
5990 SCIP_Bool* infeasible
5999 int nreductions = 0;
6012 ++conshdlrdata->curpropboundstag;
6018 *infeasible =
FALSE;
6019 for(
c = 0;
c < nconss; ++
c )
6028#ifdef WITH_DEBUG_SOLUTION
6057 if( auxvar !=
NULL )
6059 SCIPdebugMsg(
scip,
"tighten auxvar <%s> bounds using constraint sides [%g,%g]\n",
6092 for(
c = 0;
c < nconss && !*infeasible; ++
c )
6108 if( ownerdata->nauxvaruses == 0 )
6111 for(
e = 0;
e < ownerdata->nenfos; ++
e )
6114 SCIP_Bool underestimate;
6115 SCIP_Bool overestimate;
6121 if( ownerdata->enfos[
e]->issepainit )
6128 nlhdlr = ownerdata->enfos[
e]->nlhdlr;
6136 overestimate = ownerdata->nlocksneg > 0;
6137 underestimate = ownerdata->nlockspos > 0;
6138 assert(underestimate || overestimate);
6140 SCIPdebugMsg(
scip,
"initsepa under=%u over=%u for expression %p\n", underestimate, overestimate, (
void*)expr);
6144 ownerdata->enfos[
e]->nlhdlrexprdata, overestimate, underestimate, infeasible) );
6145 ownerdata->enfos[
e]->issepainit =
TRUE;
6196 switch( conshdlrdata->branchviolsplit )
6205 return MAX(0.05, weight);
6216 return 10.0*
log10(width);
6218 return 0.1/(-
log10(width));
6223 SCIPerrorMessage(
"invalid value for parameter constraints/expr/branching/violsplit");
6249 SCIP_Real weightsum = 0.0;
6268 for(
i = 0;
i < nexprs; ++
i )
6280 for(
i = 0;
i < nexprs; ++
i )
6356 if( auxvar ==
NULL )
6362 assert(auxvars[pos] == auxvar);
6365 exprs[nexprs++] = expr;
6407 for(
c = 0;
c < nconss; ++
c )
6420 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6462 for(
c = 0;
c < nconss; ++
c )
6481 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6613 for(
c = 0;
c < nconss; ++
c )
6643 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6666 cands[*ncands].
expr = consdata->varexprs[
i];
6703 cands[*ncands].
expr = expr;
6789 for(
r = 0;
r < nrows; ++
r )
6868 for(
c = 0;
c < ncands; ++
c )
6870 if( conshdlrdata->branchviolweight > 0.0 )
6876 if( conshdlrdata->branchdomainweight > 0.0 )
6901 if( conshdlrdata->branchdualweight > 0.0 )
6933 strategy = conshdlrdata->branchpscostupdatestrategy;
7013 if( conshdlrdata->branchvartypeweight > 0.0 )
7042 for(
c = 0;
c < ncands; ++
c )
7044 SCIP_Real weightsum;
7052 cands[
c].weighted = 0.0;
7058 weightsum += conshdlrdata->branchviolweight;
7066 weightsum += conshdlrdata->branchdomainweight;
7074 weightsum += conshdlrdata->branchdualweight;
7085 weightsum += conshdlrdata->branchpscostweight;
7099 weightsum += conshdlrdata->branchvartypeweight;
7119 if( cands[
ind1].weighted != cands[
ind2].weighted )
7154 if( conshdlrdata->branchexternal )
7199 threshold = conshdlrdata->branchhighscorefactor * cands[perm[0]].weighted;
7200 while( left < right )
7202 int mid = (left + right) / 2;
7212 if( cands[perm[left]].weighted >=
threshold )
7214 assert(left + 1 == ncands || cands[perm[left + 1]].weighted <
threshold);
7232 if( conshdlrdata->branchrandnumgen ==
NULL )
7284 SCIP_Bool overestimate,
7342 for(
r = minidx;
r <= maxidx; ++
r )
7385 SCIP_Bool underestimate;
7386 SCIP_Bool overestimate;
7413 if( !overestimate && !underestimate )
7419 for(
e = 0;
e < ownerdata->nenfos; ++
e )
7427 nlhdlr = ownerdata->enfos[
e]->nlhdlr;
7455 "auxviolation %g << origviolation %g under:%d over:%d\n",
SCIPnlhdlrGetName(nlhdlr), (
void*)expr,
7467 underestimate, overestimate); )
7491 ownerdata->lastenforced = conshdlrdata->enforound;
7499 ownerdata->lastenforced = conshdlrdata->enforound;
7508 ownerdata->lastenforced = conshdlrdata->enforound;
7521 ownerdata->lastenforced = conshdlrdata->enforound;
7539 ownerdata->lastenforced = conshdlrdata->enforound;
7547 ownerdata->lastenforced = conshdlrdata->enforound;
7556 ownerdata->lastenforced = conshdlrdata->enforound;
7569 ownerdata->lastenforced = conshdlrdata->enforound;
7621 SCIP_Bool infeasible;
7644 if( ownerdata->auxvar ==
NULL )
7647 assert(ownerdata->lastenforced <= conshdlrdata->enforound);
7648 if( ownerdata->lastenforced == conshdlrdata->enforound )
7663 if( ownerdata->lastenforced == conshdlrdata->enforound )
7725 ++(conshdlrdata->enforound);
7732 for(
c = 0;
c < nconss; ++
c )
7758 for(
i = 0;
i < consdata->nvarexprs; ++
i )
7785 ++conshdlrdata->nweaksepa;
7857 for(
c = 0;
c < nconss; ++
c )
7894 if( ownerdata->auxvar ==
NULL )
7963 for(
e = 0;
e < ownerdata->nenfos; ++
e )
7971 nlhdlr = ownerdata->enfos[
e]->nlhdlr;
8024 for(
c = 0;
c < nconss; ++
c )
8043 "auxviolations in %g..%g, variable bounds violated by at most %g, LP feastol=%e\n",
8050 if( conshdlrdata->propinenforce )
8071 ++conshdlrdata->ntightenlp;
8087 ++conshdlrdata->ntightenlp;
8110 ++conshdlrdata->ntightenlp;
8132 ++conshdlrdata->ndesperatetightenlp;
8142 if( !conshdlrdata->propinenforce )
8164 ++conshdlrdata->ndesperatebranch;
8184 ++conshdlrdata->ndesperatecutoff;
8209 for(
c = 0;
c < nconss; ++
c )
8249 idx = ((int)(
size_t)
elem) - 1;
8252 return (
void*)&conshdlrdata->bilinterms[idx];
8305 for(
i = 0;
i < 3; ++
i )
8331 if(
term->nauxexprs == 0 )
8343 if(
term->nauxexprs >= conshdlrdata->bilinmaxnauxexprs )
8350 for(
i =
term->nauxexprs;
i > pos; --
i )
8355 ++(
term->nauxexprs);
8360 term->aux.exprs[pos]->underestimate |=
auxexpr->underestimate;
8361 term->aux.exprs[pos]->overestimate |=
auxexpr->overestimate;
8389 if( conshdlrdata->bilinterms !=
NULL )
8398 for(
c = 0;
c < nconss; ++
c )
8479 assert(conshdlrdata->bilinterms[*idx].x ==
x);
8480 assert(conshdlrdata->bilinterms[*idx].y ==
y);
8483 term = &conshdlrdata->bilinterms[*idx];
8485 term->nlockspos += nlockspos;
8486 term->nlocksneg += nlocksneg;
8493 *idx = conshdlrdata->nbilinterms;
8496 term = &conshdlrdata->bilinterms[*idx];
8500 term->nauxexprs = 0;
8501 term->auxexprssize = 0;
8502 term->nlockspos = nlockspos;
8503 term->nlocksneg = nlocksneg;
8504 term->existing = existing;
8511 ++(conshdlrdata->nbilinterms);
8514 if( conshdlrdata->bilinhashtable ==
NULL )
8518 (
void*)conshdlrdata) );
8520 assert(conshdlrdata->bilinhashtable !=
NULL);
8548 if( conshdlrdata->bilinterms ==
NULL )
8551 assert(conshdlrdata->nbilinterms == 0);
8552 assert(conshdlrdata->bilintermssize == 0);
8558 for(
i = 0;
i < conshdlrdata->nbilinterms; ++
i )
8563 for(
j = 0;
j < conshdlrdata->bilinterms[
i].nauxexprs; ++
j )
8565 if( conshdlrdata->bilinterms[
i].aux.exprs[
j]->auxvar !=
NULL )
8572 if( conshdlrdata->bilinterms[
i].nauxexprs > 0 )
8581 if( conshdlrdata->bilinterms[
i].aux.var !=
NULL )
8588 if( conshdlrdata->bilinhashtable !=
NULL )
8595 conshdlrdata->nbilinterms = 0;
8596 conshdlrdata->bilintermssize = 0;
8630 SCIPdebugMsg(
scip,
"Building LP for computing facets of convex envelope of vertex-polyhedral function\n");
8635 nrows = (
unsigned int)
nvars + 1;
8637 nnonz = (ncols * (nrows + 1)) / 2;
8648 for(
i = 0,
k = 0;
i < ncols; ++
i )
8682 ind[
k] = (int)nrows - 1;
8693 (
int)ncols,
obj, lb, ub,
NULL,
8694 (
int)nrows, lb, lb,
NULL,
8695 (
int)nnonz,
beg,
ind, val) );
8698 ind[0] = (int)nrows - 1;
8720 SCIP_Bool overestimate,
8749 for(
i = 0;
i < (
unsigned int) nallvars; ++
i )
8775 while( (
diff >>= 1) != 0 )
8809 SCIP_Bool overestimate,
8816 SCIP_Real targetvalue,
8850 if( conshdlrdata->vp_randnumgen ==
NULL && conshdlrdata->vp_maxperturb > 0.0 )
8856 if( conshdlrdata->vp_lp[
nvars] ==
NULL )
8860 lp = conshdlrdata->vp_lp[
nvars];
8878 for(
i = 0;
i < ncols; ++
i )
8883 for(
i = 0;
i < nrows-1; ++
i )
8893 lb =
box[2 * varpos];
8894 ub =
box[2 * varpos + 1];
8895 solval =
xstar[varpos];
8903 else if( solval >= ub )
8906 aux[
i] = (solval - lb) / (ub - lb);
8909 if( conshdlrdata->vp_maxperturb > 0.0 )
8914 aux[
i] -=
SCIPrandomGetReal(conshdlrdata->vp_randnumgen, 0.0, conshdlrdata->vp_maxperturb);
8915 else if( aux[
i] == 0.0 )
8916 aux[
i] +=
SCIPrandomGetReal(conshdlrdata->vp_randnumgen, 0.0, conshdlrdata->vp_maxperturb);
8925 assert(0.0 < aux[
i] && aux[
i] < 1.0);
8958 if( conshdlrdata->vp_dualsimplex )
8992 for(
i = 0;
i < nallvars; ++
i )
9013 lb =
box[2 * varpos];
9014 ub =
box[2 * varpos + 1];
9040 if( overestimate == (
facetvalue > targetvalue) )
9042 SCIPdebugMsg(
scip,
"missed the target, facetvalue %g targetvalue %g, overestimate=%u\n",
facetvalue, targetvalue, overestimate);
9171 SCIPdebugMsg(
scip,
"numerical troubles - try to solve the linear system via an LU factorization\n");
9211 SCIP_Bool overestimate,
9221 SCIP_Real targetvalue,
9249 targetvalue = -targetvalue;
9272 SCIP_CALL(
computeHyperplaneThreePoints(
scip,
p2[0],
p2[1],
p2val,
p3[0],
p3[1],
p3val,
p4[0],
p4[1],
p4val,
9281 SCIP_CALL(
computeHyperplaneThreePoints(
scip,
p1[0],
p1[1],
p1val,
p3[0],
p3[1],
p3val,
p4[0],
p4[1],
p4val,
9290 SCIP_CALL(
computeHyperplaneThreePoints(
scip,
p1[0],
p1[1],
p1val,
p2[0],
p2[1],
p2val,
p4[0],
p4[1],
p4val,
9299 SCIP_CALL(
computeHyperplaneThreePoints(
scip,
p1[0],
p1[1],
p1val,
p2[0],
p2[1],
p2val,
p3[0],
p3[1],
p3val,
9434 SCIP_Real
val1 = 0.0;
9435 SCIP_Real
val2 = 0.0;
9463 if( nchildren != 2 )
9476 (*consvals)[0] = 1.0;
9493 var1 = (*consvars)[0];
9494 val1 = (*consvals)[0];
9498 var2 = (*consvars)[0];
9499 val2 = (*consvals)[0];
9696 (*consvars)[0] =
var;
9697 (*consvals)[0] = 1.0;
9713 var = (*consvars)[0];
9807 var = (*consvars)[0];
9813 var = (*consvars)[1];
9838 var = (*consvars)[0];
9839 weight = (*consvals)[0];
9860 for(
i = 0;
i < 2; ++
i)
9862 var = (*consvars)[
i];
9898 SCIP_Real val = 0.0;
9990 return (ub + lb) / 2;
10019 SCIP_Real constant;
10060 for(
i = 0;
i < nchildren; ++
i )
10064 SCIP_Real exponent;
10161 (*consvals)[0] = 1.0;
10174 actvar = (*consvars)[0];
10175 val = (*consvals)[0];
10177 (*consvals)[0] = 1.0;
10188 val2 = (*consvals)[0];
10270 SCIP_Real constant;
10410 nconsvars, constant) );
10607 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
10613 conshdlrdata->nlhdlrssize = 0;
10616 for(
i = 0;
i < conshdlrdata->nconsupgrades; ++
i )
10627 if( conshdlrdata->vp_randnumgen !=
NULL )
10633 if( conshdlrdata->vp_lp[
i] !=
NULL )
10639 assert(conshdlrdata->branchrandnumgen ==
NULL);
10662 conshdlrdata->lastboundrelax = ++conshdlrdata->curboundstag;
10664 conshdlrdata->enforound = 1;
10666 conshdlrdata->auxvarid = 0;
10668 for(
i = 0;
i < nconss; ++
i )
10675 if( conshdlrdata->nnlhdlrs > 1 )
10683 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
10689 conshdlrdata->nweaksepa = 0;
10690 conshdlrdata->ntightenlp = 0;
10691 conshdlrdata->ndesperatebranch = 0;
10692 conshdlrdata->ndesperatecutoff = 0;
10693 conshdlrdata->ndesperatetightenlp = 0;
10694 conshdlrdata->nforcelp = 0;
10696 conshdlrdata->ncanonicalizecalls = 0;
10723 for(
i = 0;
i < nconss; ++
i )
10732 conshdlrdata->subnlpheur =
NULL;
10733 conshdlrdata->trysolheur =
NULL;
10735 if( conshdlrdata->vp_randnumgen !=
NULL )
10741 if( conshdlrdata->vp_lp[
i] !=
NULL )
10747 if( conshdlrdata->branchrandnumgen !=
NULL )
10751 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
10768#ifdef SCIP_DISABLED_CODE
10772 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
10778#define consInitpreNonlinear NULL
10786 SCIP_Bool infeasible;
10837 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
10843 if( conshdlrdata->branchpscostweight > 0.0 )
10846 if(
strchr(
"lds", conshdlrdata->branchpscostupdatestrategy) ==
NULL )
10848 SCIPerrorMessage(
"branching/lpgainnormalize strategy %c unknown\n", conshdlrdata->branchpscostupdatestrategy);
10873 conshdlrdata->checkedvarlocks =
FALSE;
10876 if( conshdlrdata->newsoleventfilterpos >= 0 )
10884 conshdlrdata->newsoleventfilterpos = -1;
10900 assert((*consdata)->nlockspos == 0);
10901 assert((*consdata)->nlocksneg == 0);
10909 if( (*consdata)->nlrow !=
NULL )
10966 if( conshdlrdata->linearizeheursol !=
'o' && conshdlrdata->newsoleventfilterpos == -1 )
10974 eventhdlr, (
SCIP_EVENTDATA*)conshdlr, &conshdlrdata->newsoleventfilterpos) );
11041 for(
c = 0;
c < nconss; ++
c )
11073 SCIPdebugMsg(
scip,
"could not find branching candidates, forcing to solve LP\n");
11110 for(
c = 0;
c < nconss; ++
c )
11155 if( !(consdata->linvarincr !=
NULL && consdata->linvarincrcoef > 0.0) &&
11156 !(consdata->linvardecr !=
NULL && consdata->linvardecrcoef < 0.0) )
11165 if( !(consdata->linvarincr !=
NULL && consdata->linvarincrcoef < 0.0) &&
11166 !(consdata->linvardecr !=
NULL && consdata->linvardecrcoef > 0.0) )
11213 SCIP_Bool infeasible;
11273 for(
c = 0;
c < nconss; ++
c )
11275 SCIP_Bool upgraded;
11299 && !conshdlrdata->checkedvarlocks && conshdlrdata->checkvarlocks !=
'd' )
11304 conshdlrdata->checkedvarlocks =
TRUE;
11306 for(
c = 0;
c < nconss; ++
c )
11312 SCIPdebugMsg(
scip,
"presolSingleLockedVars() for %s: nchgvartypes=%d naddconss=%d infeas=%u\n",
11327 if( *ndelconss > 0 || *nchgbds > 0 || *nupgdconss > 0 || *naddconss > 0 || *nchgvartypes > 0 )
11337#ifdef SCIP_DISABLED_CODE
11341 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11347#define consRespropNonlinear NULL
11372 if( ownerdata->nenfos >= 0 )
11374 if( (consdata->nlockspos == 0) != (nlockspos == 0) )
11376 if( (consdata->nlocksneg == 0) != (nlocksneg == 0) )
11402 SCIP_Bool infeasible =
FALSE;
11412 if( !consdata->issimplified )
11422 consdata->issimplified =
TRUE;
11471 assert(consdata->nlockspos == 0);
11472 assert(consdata->nlocksneg == 0);
11558#ifdef SCIP_DISABLED_CODE
11562 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11568#define consDelvarsNonlinear NULL
11632 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
11768 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
11799 for(
i = 0;
i < consdata->nvarexprs; ++
i )
11822 *
nvars = consdata->nvarexprs;
11829#ifdef SCIP_DISABLED_CODE
11833 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11839#define consGetDiveBdChgsNonlinear NULL
11874 SCIPinfoMessage(
scip, file,
"Nonlinear Conshdlr : %10s %10s %10s %10s %10s %10s %10s\n",
"WeakSepa",
"TightenLP",
"DespTghtLP",
"DespBranch",
"DespCutoff",
"ForceLP",
"CanonTime");
11934 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11969 conshdlrdata->curboundstag = 1;
11970 conshdlrdata->lastboundrelax = 1;
11971 conshdlrdata->curpropboundstag = 1;
11972 conshdlrdata->newsoleventfilterpos = -1;
11998 "limit on number of propagation rounds for a set of constraints within one round of SCIP propagation",
12002 "whether to check bounds of all auxiliary variable to seed reverse propagation",
12006 "strategy on how to relax variable bounds during bound tightening: relax (n)ot, relax by (a)bsolute value, relax always by a(b)solute value, relax by (r)relative value",
12007 &conshdlrdata->varboundrelax,
TRUE,
'r',
"nabr",
NULL,
NULL) );
12010 "by how much to relax variable bounds during bound tightening if strategy 'a', 'b', or 'r'",
12014 "by how much to relax constraint sides during bound tightening",
12018 "maximal relative perturbation of reference point when computing facet of envelope of vertex-polyhedral function (dim>2)",
12022 "adjust computed facet of envelope of vertex-polyhedral function up to a violation of this value times LP feasibility tolerance",
12026 "whether to use dual simplex instead of primal simplex for LP that computes facet of vertex-polyhedral function",
12030 "maximal number of auxiliary expressions per bilinear term",
12034 "whether to reformulate products of binary variables during presolving",
12038 "whether to use the AND constraint handler for reformulating binary products",
12042 "minimum number of terms to reformulate bilinear binary products by factorizing variables (<= 1: disabled)",
12046 "whether to forbid multiaggregation of nonlinear variables",
12050 "whether to tighten LP feasibility tolerance during enforcement, if it seems useful",
12054 "whether to (re)run propagation in enforcement",
12058 "threshold for when to regard a cut from an estimator as weak (lower values allow more weak cuts)",
12059 &conshdlrdata->weakcutthreshold,
TRUE, 0.2, 0.0, 1.0,
NULL,
NULL) );
12062 "\"strong\" cuts will be scaled to have their maximal coef in [1/strongcutmaxcoef,strongcutmaxcoef]",
12066 "consider efficacy requirement when deciding whether a cut is \"strong\"",
12070 "whether to force \"strong\" cuts in enforcement",
12074 "an expression will be enforced if the \"auxiliary\" violation is at least this factor times the \"original\" violation",
12075 &conshdlrdata->enfoauxviolfactor,
TRUE, 0.01, 0.0, 1.0,
NULL,
NULL) );
12078 "retry enfo of constraint with weak cuts if violation is least this factor of maximal violated constraints",
12079 &conshdlrdata->weakcutminviolfactor,
TRUE, 0.5, 0.0, 2.0,
NULL,
NULL) );
12082 "whether to make rows to be non-removable in the node where they are added (can prevent some cycling): 'o'ff, in 'e'nforcement only, 'a'lways",
12083 &conshdlrdata->rownotremovable,
TRUE,
'o',
"oea",
NULL,
NULL) );
12086 "method how to scale violations to make them comparable (not used for feasibility check): (n)one, (a)ctivity and side, norm of (g)radient",
12087 &conshdlrdata->violscale,
TRUE,
'n',
"nag",
NULL,
NULL) );
12090 "whether variables contained in a single constraint should be forced to be at their lower or upper bounds ('d'isable, change 't'ype, add 'b'ound disjunction)",
12091 &conshdlrdata->checkvarlocks,
TRUE,
't',
"bdt",
NULL,
NULL) );
12094 "from which depth on in the tree to allow branching on auxiliary variables (variables added for extended formulation)",
12098 "whether to use external branching candidates and branching rules for branching",
12102 "consider a constraint highly violated if its violation is >= this factor * maximal violation among all constraints",
12103 &conshdlrdata->branchhighviolfactor,
FALSE, 0.0, 0.0, 1.0,
NULL,
NULL) );
12106 "consider a variable branching score high if its branching score >= this factor * maximal branching score among all variables",
12107 &conshdlrdata->branchhighscorefactor,
FALSE, 0.9, 0.0, 1.0,
NULL,
NULL) );
12110 "weight by how much to consider the violation assigned to a variable for its branching score",
12114 "weight by how much to consider the dual values of rows that contain a variable for its branching score",
12118 "weight by how much to consider the pseudo cost of a variable for its branching score",
12122 "weight by how much to consider the domain width in branching score",
12126 "weight by how much to consider variable type (continuous: 0, binary: 1, integer: 0.1, impl-integer: 0.01) in branching score",
12130 "how to aggregate several branching scores given for the same expression: 'a'verage, 'm'aximum, 's'um",
12131 &conshdlrdata->branchscoreagg,
FALSE,
's',
"ams",
NULL,
NULL) );
12134 "method used to split violation in expression onto variables: 'u'niform, 'm'idness of solution, 'd'omain width, 'l'ogarithmic domain width",
12135 &conshdlrdata->branchviolsplit,
FALSE,
'm',
"umdl",
NULL,
NULL) );
12138 "minimum pseudo-cost update count required to consider pseudo-costs reliable",
12142 "whether tight linearizations of nonlinear constraints should be added to cutpool when some heuristics finds a new solution ('o'ff, on new 'i'ncumbents, on 'e'very solution)",
12143 &conshdlrdata->linearizeheursol,
FALSE,
'o',
"oie",
NULL,
NULL) );
12146 "whether to assume that any constraint is convex",
12207 if( conshdlr ==
NULL )
12217 for(
i = conshdlrdata->nconsupgrades - 1;
i >= 0; --
i )
12219 if( conshdlrdata->consupgrades[
i]->consupgd ==
nlconsupgd )
12236 assert(conshdlrdata->nconsupgrades+1 <= conshdlrdata->consupgradessize);
12238 for(
i = conshdlrdata->nconsupgrades;
i > 0 && conshdlrdata->consupgrades[
i-1]->priority <
consupgrade->priority; --
i )
12239 conshdlrdata->consupgrades[
i] = conshdlrdata->consupgrades[
i-1];
12242 conshdlrdata->nconsupgrades++;
12267 SCIP_Bool separate,
12277 SCIP_Bool modifiable,
12283 SCIP_Bool removable
12292 if( conshdlr ==
NULL )
12300 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12338 SCIP_Real* lincoefs,
12347 SCIP_Bool separate,
12357 SCIP_Bool modifiable,
12363 SCIP_Bool removable
12375 if( conshdlr ==
NULL )
12382 SCIP_CALL(
SCIPcreateExprQuadratic(
scip, &expr, nlinvars, linvars, lincoefs,
nquadterms,
quadvars1,
quadvars2,
quadcoefs,
exprownerCreate, (
void*)conshdlr) );
12387 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12409 SCIP_Real* lincoefs,
12418 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, nlinvars, linvars, lincoefs,
nquadterms,
quadvars1,
quadvars2,
quadcoefs, lhs, rhs,
12437 SCIP_Real* offsets,
12438 SCIP_Real constant,
12447 SCIP_Real termcoefs[2];
12459 if( offsets !=
NULL && offsets[
i] != 0.0 )
12478 termcoefs[0] = 1.0;
12507 SCIP_Real exponent,
12516 SCIP_Real coefs[2];
12561 return conshdlrdata->curboundstag;
12574 return conshdlrdata->lastboundrelax;
12593 ++conshdlrdata->curboundstag;
12594 assert(conshdlrdata->curboundstag > 0);
12597 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
12617 SCIP_Bool overestimate,
12619 SCIP_Real auxvalue,
12632 SCIP_Real mincutviolation;
12675 ( overestimate && (-
cutviol >= conshdlrdata->weakcutthreshold * (auxvalue -
auxvarvalue))) )
12678 "weak: auxvarvalue %g estimateval %g auxvalue %g (over %d)\n",
12779#ifdef BRSCORE_ABSVIOL
12804 if( conshdlrdata->branchdualweight > 0.0 )
12833 SCIP_Bool infeasible;
12844 if( conshdlrdata->rownotremovable ==
'a' || (conshdlrdata->rownotremovable ==
'e' &&
inenforcement) )
12893 return conshdlrdata->assumeconvex;
12931 return conshdlrdata->nbilinterms;
12950 return conshdlrdata->bilinterms;
12975 if( conshdlrdata->bilinhashtable ==
NULL )
13024 return &conshdlrdata->bilinterms[idx];
13071 term = &conshdlrdata->bilinterms[idx];
13077 if( auxvar !=
NULL )
13079 term->aux.var = auxvar;
13097 SCIP_Bool overestimate
13113 nlockspos = overestimate ? 1 : 0;
13114 nlocksneg = overestimate ? 0 : 1;
13118 term = &conshdlrdata->bilinterms[idx];
13129 if( conshdlrdata->bilinmaxnauxexprs <= 1 )
13152 auxexpr->underestimate = !overestimate;
13153 auxexpr->overestimate = overestimate;
13176 else if( auxvar !=
NULL )
13188 SCIP_Bool overestimate,
13194 SCIP_Real targetvalue,
13223 for(
j = 0;
j < nallvars; ++
j )
13245 for(
j = 0;
j < nallvars; ++
j )
13259 if( (
i >>
j) & 0x1 )
13301 SCIP_Real coefs[2] = { 0.0, 0.0 };
13303 SCIP_CALL(
computeVertexPolyhedralFacetBivariate(
scip, overestimate,
p1,
p2,
p3,
p4,
funvals[0],
funvals[1],
funvals[2],
funvals[3],
xstar2, targetvalue,
success, coefs,
facetconstant) );
13310 SCIP_CALL(
computeVertexPolyhedralFacetLP(
scip, conshdlr, overestimate,
xstar,
box, nallvars,
nonfixedpos,
funvals,
nvars, targetvalue,
success,
facetcoefs,
facetconstant) );
13388 return consdata->expr;
13404 return consdata->lhs;
13420 return consdata->rhs;
13439 if( consdata->nlrow ==
NULL )
13444 *nlrow = consdata->nlrow;
13465 return consdata->curv;
13519 SCIPerrorMessage(
"SCIPchgLhsNonlinear can only be called in problem stage.\n");
13529 if( consdata->lhs == lhs )
13532 consdata->lhs = lhs;
13535 consdata->ispropagated =
FALSE;
13558 SCIPerrorMessage(
"SCIPchgLhsNonlinear can only be called in problem stage.\n");
13568 if( consdata->rhs == rhs )
13571 consdata->rhs = rhs;
13574 consdata->ispropagated =
FALSE;
13598 SCIPerrorMessage(
"SCIPchgExprNonlinear can only be called in problem stage.\n");
13616 assert(consdata->nvarexprs == 0);
13618 assert(!consdata->catchedevents);
13627 consdata->issimplified =
FALSE;
13628 consdata->ispropagated =
FALSE;
13653 SCIPerrorMessage(
"SCIPaddLinearVarNonlinear can only be called in problem stage.\n");
13674 assert(consdata->nvarexprs == 0);
13676 assert(!consdata->catchedevents);
13689 SCIP_Real coefs[2] = { 1.0, coef };
13700 consdata->issimplified =
FALSE;
13701 consdata->ispropagated =
FALSE;
13726 SCIPerrorMessage(
"SCIPaddLinearVarNonlinear can only be called in problem stage.\n");
13747 assert(consdata->nvarexprs == 0);
13749 assert(!consdata->catchedevents);
13763 SCIP_Real coefs[2] = { 1.0, coef };
13774 consdata->issimplified =
FALSE;
13775 consdata->ispropagated =
FALSE;
13845 *
var = consdata->linvardecr;
13846 *coef = consdata->linvardecrcoef;
13869 *
var = consdata->linvarincr;
13870 *coef = consdata->linvarincrcoef;
13915 return ownerdata->filterpos >= -1 ?
SCIPgetVarExprVar(expr) : ownerdata->auxvar;
13936 SCIP_Bool* sepabelowusesactivity,
13937 SCIP_Bool* sepaaboveusesactivity,
13938 SCIP_Real* auxvalue
13952 *nlhdlr = ownerdata->enfos[idx]->nlhdlr;
13954 if( nlhdlrexprdata !=
NULL )
13955 *nlhdlrexprdata = ownerdata->enfos[idx]->nlhdlrexprdata;
13957 if( nlhdlrparticipation !=
NULL )
13958 *nlhdlrparticipation = ownerdata->enfos[idx]->nlhdlrparticipation;
13960 if( sepabelowusesactivity !=
NULL )
13961 *sepabelowusesactivity = ownerdata->enfos[idx]->sepabelowusesactivity;
13963 if( sepaaboveusesactivity !=
NULL )
13964 *sepaaboveusesactivity = ownerdata->enfos[idx]->sepaaboveusesactivity;
13966 if( auxvalue !=
NULL )
13967 *auxvalue = ownerdata->enfos[idx]->auxvalue;
13988 ownerdata->enfos[idx]->auxvalue = auxvalue;
14066 if( ownerdata->nenfos >= 0 &&
14068 (ownerdata->nauxvaruses == 0 &&
useauxvar)
14080 ++ownerdata->nauxvaruses;
14083 ++ownerdata->nactivityusesprop;
14086 ++ownerdata->nactivityusessepa;
14174 SCIP_Real auxvalue,
14206 SCIP_Real auxvalue,
14260 if( ownerdata->propboundstag == conshdlrdata->curpropboundstag )
14262 bounds = ownerdata->propbounds;
14275 if( ownerdata->auxvar !=
NULL )
14280 auxvarbounds = conshdlrdata->intevalvar(
scip, ownerdata->auxvar, conshdlrdata);
14363 if( ownerdata->propboundstag == conshdlrdata->curpropboundstag )
14376 SCIPdebugMsg(
scip,
" applied %s: [%.20g,%.20g]\n", ownerdata->propboundstag == conshdlrdata->curpropboundstag ?
"previous propbounds" :
"activity",
newbounds.inf,
newbounds.sup);
14382 SCIPdebugMsg(
scip,
" cut off due to empty intersection with previous propbounds or activity\n");
14395 ownerdata->propboundstag = conshdlrdata->curpropboundstag;
14409 SCIPdebugMsg(
scip,
" new bounds [%g,%g] for expr %p not sufficiently tighter than activity -- not adding to propqueue or tightening auxvar\n",
newbounds.inf,
newbounds.sup, (
void*)expr);
14414 if(
SCIPexprGetNChildren(expr) > 0 && !ownerdata->inpropqueue && (ownerdata->nactivityusesprop > 0 || ownerdata->nactivityusessepa > 0 || ownerdata->nenfos < 0) )
14423 ownerdata->inpropqueue =
TRUE;
14470 for(
c = 0;
c < ownerdata->nconss; ++
c )
14474 consdata->ispropagated =
FALSE;
14519 if( ownerdata->violscoretag != conshdlrdata->enforound )
14523 ownerdata->nviolscores = 1;
14524 ownerdata->violscoretag = conshdlrdata->enforound;
14529 if(
violscore > ownerdata->violscoremax )
14531 ++ownerdata->nviolscores;
14580 for(
i = 0;
i < nexprs; ++
i )
14589 if( varssize ==
nvars )
14626 if( conshdlrdata->enforound != ownerdata->violscoretag )
14629 if( ownerdata->nviolscores == 0 )
14632 switch( conshdlrdata->branchscoreagg )
14636 return ownerdata->violscoresum / ownerdata->nviolscores;
14640 return ownerdata->violscoremax;
14644 return ownerdata->violscoresum;
14647 SCIPerrorMessage(
"Invalid value %c for branchscoreagg parameter\n", conshdlrdata->branchscoreagg);
14755 SCIP_Real auxvalue;
14757 SCIP_Real* lincoefs;
14769 for(
i = 0;
i < nlinexprs; ++
i )
14776 for(
i = 0;
i < nquadexprs; ++
i )
14788 auxvalue += (lincoef + sqrcoef * solval) * solval;
14818 int detectpriority,
14834 if( conshdlr ==
NULL )
14849 conshdlrdata->nlhdlrs[conshdlrdata->nnlhdlrs] = *nlhdlr;
14850 ++conshdlrdata->nnlhdlrs;
14873 return conshdlrdata->nnlhdlrs;
14888 return conshdlrdata->nlhdlrs;
14906 for(
h = 0;
h < conshdlrdata->nnlhdlrs; ++
h )
14908 return conshdlrdata->nlhdlrs[
h];
14931 for(
e = 0;
e < ownerdata->nenfos; ++
e )
14932 if( ownerdata->enfos[
e]->nlhdlr == nlhdlr )
14933 return ownerdata->enfos[
e]->nlhdlrexprdata;
static GRAPHNODE ** active
Constraint handler for AND constraints, .
constraint handler for bound disjunction constraints
Constraint handler for linear constraints in their most general form, .
static SCIP_Bool isBinaryProduct(SCIP *scip, SCIP_EXPR *expr)
static SCIP_RETCODE createExprVar(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_EXPR **expr, SCIP_VAR *var)
static SCIP_Real computeVertexPolyhedralMaxFacetError(SCIP *scip, SCIP_Bool overestimate, SCIP_Real *funvals, SCIP_Real *box, int nallvars, int nvars, int *nonfixedpos, SCIP_Real *facetcoefs, SCIP_Real facetconstant)
static SCIP_Bool isEvenOperator(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool *hasvalue, SCIP_Real *value)
static SCIP_RETCODE tryAddGadgetEvenOperatorVariable(SCIP *scip, SCIP_EXPR *evenopexpr, SCIP_EXPR *child, SCIP_CONS *cons, SYM_GRAPH *graph, int parentidx, SCIP_Bool hasparentcoef, SCIP_Real parentcoef, SCIP_Bool hassymval, SCIP_Real symval, SCIP_VAR ***consvars, SCIP_Real **consvals, int *maxnconsvars, SCIP_Bool *success)
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
static SCIP_RETCODE analyzeViolation(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_Real *maxabsconsviol, SCIP_Real *maxrelconsviol, SCIP_Real *minauxviol, SCIP_Real *maxauxviol, SCIP_Real *maxvarboundviol)
static SCIP_RETCODE presolveRedundantConss(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_Bool *cutoff, int *ndelconss, int *nchgbds)
static SCIP_RETCODE reversePropQueue(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_Bool *infeasible, int *ntightenings)
#define BRANCH_RANDNUMINITSEED
static SCIP_RETCODE dropVarEvent(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_EXPR *expr, SCIP_CONS *cons)
static SCIP_RETCODE forbidNonlinearVariablesMultiaggration(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
static SCIP_RETCODE computeHyperplaneThreePoints(SCIP *scip, SCIP_Real a1, SCIP_Real a2, SCIP_Real a3, SCIP_Real b1, SCIP_Real b2, SCIP_Real b3, SCIP_Real c1, SCIP_Real c2, SCIP_Real c3, SCIP_Real *alpha, SCIP_Real *beta, SCIP_Real *gamma_, SCIP_Real *delta)
static SCIP_RETCODE propagateLocks(SCIP *scip, SCIP_EXPR *expr, int nlockspos, int nlocksneg)
#define CONSHDLR_CHECKPRIORITY
static SCIP_RETCODE registerBranchingCandidates(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_Bool *success)
static SCIP_RETCODE enforceConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_EXPRITER *it, SCIP_Bool allowweakcuts, SCIP_Bool inenforcement, SCIP_RESULT *result, SCIP_Bool *success)
static SCIP_RETCODE bilinTermAddAuxExpr(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONSNONLINEAR_BILINTERM *term, SCIP_CONSNONLINEAR_AUXEXPR *auxexpr, SCIP_Bool *added)
static SCIP_RETCODE freeVarExprs(SCIP *scip, SCIP_CONSDATA *consdata)
static SCIP_RETCODE proposeFeasibleSolution(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_Bool *success)
#define consRespropNonlinear
static SCIP_RETCODE consSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_RESULT *result)
#define CONSHDLR_PROP_TIMING
static void addExprsViolScore(SCIP *scip, SCIP_EXPR **exprs, int nexprs, SCIP_Real violscore, SCIP_SOL *sol, SCIP_Bool *success)
static SCIP_RETCODE tightenAuxVarBounds(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_EXPR *expr, SCIP_INTERVAL bounds, SCIP_Bool *cutoff, int *ntightenings)
#define TABLE_DESC_NLHDLR
static SCIP_RETCODE replaceBinaryProducts(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_HASHMAP *exprmap, SCIP_EXPRITER *it, int *naddconss, int *nchgcoefs)
static SCIP_RETCODE computeVertexPolyhedralFacetBivariate(SCIP *scip, SCIP_Bool overestimate, SCIP_Real p1[2], SCIP_Real p2[2], SCIP_Real p3[2], SCIP_Real p4[2], SCIP_Real p1val, SCIP_Real p2val, SCIP_Real p3val, SCIP_Real p4val, SCIP_Real xstar[2], SCIP_Real targetvalue, SCIP_Bool *success, SCIP_Real *facetcoefs, SCIP_Real *facetconstant)
static SCIP_RETCODE tryAddGadgetEvenOperator(SCIP *scip, SCIP_EXPR *expr, SCIP_CONS *cons, SYM_GRAPH *graph, int parentidx, SCIP_Bool hasparentcoef, SCIP_Real parentcoef, SCIP_VAR ***consvars, SCIP_Real **consvals, int *maxnconsvars, SCIP_HASHSET *handledexprs, SCIP_Bool *success)
#define consInitpreNonlinear
static SCIP_RETCODE addExprViolScoresAuxVars(SCIP *scip, SCIP_EXPR *expr, SCIP_Real violscore, SCIP_VAR **auxvars, int nauxvars, SCIP_SOL *sol, SCIP_Bool *success)
static SCIP_RETCODE detectNlhdlr(SCIP *scip, SCIP_EXPR *expr, SCIP_CONS *cons)
#define CONSHDLR_MAXPREROUNDS
static SCIP_RETCODE computeVertexPolyhedralFacetLP(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_Bool overestimate, SCIP_Real *xstar, SCIP_Real *box, int nallvars, int *nonfixedpos, SCIP_Real *funvals, int nvars, SCIP_Real targetvalue, SCIP_Bool *success, SCIP_Real *facetcoefs, SCIP_Real *facetconstant)
#define TABLE_EARLIEST_STAGE_NLHDLR
#define VERTEXPOLY_RANDNUMINITSEED
static SCIP_RETCODE getFactorizedBinaryQuadraticExpr(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_EXPR *sumexpr, int minterms, SCIP_EXPR **newexpr, int *naddconss)
#define consDelvarsNonlinear
static SCIP_RETCODE enforceExprNlhdlr(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_NLHDLR *nlhdlr, SCIP_EXPR *expr, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_SOL *sol, SCIP_Real auxvalue, SCIP_Bool overestimate, SCIP_Bool separated, SCIP_Bool allowweakcuts, SCIP_Bool inenforcement, SCIP_RESULT *result)
static SCIP_RETCODE reformulateFactorizedBinaryQuadratic(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_VAR *facvar, SCIP_VAR **vars, SCIP_Real *coefs, int nvars, SCIP_EXPR **newexpr, int *naddconss)
static void scoreBranchingCandidates(SCIP *scip, SCIP_CONSHDLR *conshdlr, BRANCHCAND *cands, int ncands, SCIP_SOL *sol)
#define CONSHDLR_SEPAPRIORITY
static SCIP_RETCODE getConsRelViolation(SCIP *scip, SCIP_CONS *cons, SCIP_Real *viol, SCIP_SOL *sol, SCIP_Longint soltag)
#define consGetDiveBdChgsNonlinear
static SCIP_Bool isConsViolated(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE getBinaryProductExprDo(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_EXPR *prodexpr, SCIP_EXPR **newexpr, int *naddconss, SCIP_Bool empathy4and)
static SCIP_RETCODE registerBranchingCandidatesAllUnfixed(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int *nnotify)
static SCIP_Bool isIntervalBetter(SCIP *scip, SCIP_Bool subsetsufficient, SCIP_INTERVAL newinterval, SCIP_INTERVAL oldinterval)
static SCIP_RETCODE detectNlhdlrs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
static SCIP_RETCODE enforceExpr(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_Bool allowweakcuts, SCIP_Bool inenforcement, SCIP_RESULT *result)
#define TABLE_EARLIEST_STAGE_NONLINEAR
static SCIP_RETCODE getBinaryProductExpr(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_HASHMAP *exprmap, SCIP_EXPR *prodexpr, SCIP_EXPR **newexpr, int *naddconss, int *nchgcoefs)
static SCIP_RETCODE catchVarEvents(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS *cons)
#define TABLE_DESC_NONLINEAR
static SCIP_RETCODE createAuxVar(SCIP *scip, SCIP_EXPR *expr)
static SCIP_Real getViolSplitWeight(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *var, SCIP_SOL *sol)
static SCIP_RETCODE freeEnfoData(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool freeauxvar)
#define infty2infty(infty1, infty2, val)
static SCIP_RETCODE getBilinearBinaryTerms(SCIP *scip, SCIP_EXPR *sumexpr, SCIP_VAR **xs, SCIP_VAR **ys, int *childidxs, int *nterms)
static SCIP_RETCODE storeVarExprs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata)
static SCIP_RETCODE buildVertexPolyhedralSeparationLP(SCIP *scip, int nvars, SCIP_LPI **lp)
static SCIP_RETCODE tryAddGadgetSquaredDifference(SCIP *scip, SCIP_EXPR *sumexpr, SCIP_CONS *cons, SYM_GRAPH *graph, int sumnodeidx, SCIP_VAR ***consvars, SCIP_Real **consvals, int *maxnconsvars, SCIP_HASHSET *handledexprs)
static SCIP_RETCODE tryAddGadgetBilinearProductSignedPerm(SCIP *scip, SCIP_EXPR *expr, SCIP_CONS *cons, SYM_GRAPH *graph, int parentidx, SCIP_Bool hasparentcoef, SCIP_Real parentcoef, SCIP_VAR ***consvars, SCIP_Real **consvals, int *maxnconsvars, SCIP_HASHSET *handledexprs, SCIP_Bool *success)
static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
static SCIP_RETCODE propConss(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_Bool force, SCIP_RESULT *result, int *nchgbds)
static SCIP_RETCODE presolveUpgrade(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_Bool *upgraded, int *nupgdconss, int *naddconss)
static SCIP_RETCODE forwardPropExpr(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_EXPR *rootexpr, SCIP_Bool tightenauxvars, SCIP_Bool *infeasible, int *ntightenings)
static SCIP_RETCODE consEnfo(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_RESULT *result)
static SCIP_Bool isSingleLockedCand(SCIP *scip, SCIP_EXPR *expr)
static SCIP_Bool branchAuxNonlinear(SCIP *scip, SCIP_CONSHDLR *conshdlr)
static SCIP_RETCODE presolveImplint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int *nchgvartypes, SCIP_Bool *infeasible)
#define TABLE_NAME_NONLINEAR
#define TABLE_NAME_NLHDLR
static SCIP_RETCODE tryAddGadgetEvenOperatorSum(SCIP *scip, SCIP_EXPR *evenopexpr, SCIP_EXPR *child, SCIP_CONS *cons, SYM_GRAPH *graph, int parentidx, SCIP_Bool hasparentcoef, SCIP_Real parentcoef, SCIP_Bool hassymval, SCIP_Real symval, SCIP_VAR ***consvars, SCIP_Real **consvals, int *maxnconsvars, SCIP_HASHSET *handledexprs, SCIP_Bool *success)
static SCIP_Real getDualBranchscore(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *var)
static SCIP_RETCODE deinitSolve(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
static SCIP_RETCODE ensureLocVarsArraySize(SCIP *scip, SCIP_VAR ***vars, SCIP_Real **vals, int nelems, int *maxnelems)
static SCIP_RETCODE createNlRow(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE scaleConsSides(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_Bool *changed)
static SCIP_RETCODE computeViolation(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Longint soltag)
#define VERTEXPOLY_MAXPERTURBATION
static SCIP_RETCODE presolveBinaryProducts(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int *naddconss, int *nchgcoefs)
static SCIP_RETCODE catchVarEvent(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_EXPR *expr, SCIP_CONS *cons)
static SCIP_RETCODE presolveSingleLockedVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, int *nchgvartypes, int *naddconss, SCIP_Bool *infeasible)
#define VERTEXPOLY_USEDUALSIMPLEX
#define CONSHDLR_PROPFREQ
static SCIP_Bool varIsCenteredAt0(SCIP *scip, SCIP_VAR *var)
static SCIP_RETCODE initSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_Bool *infeasible)
static SCIP_RETCODE computeVertexPolyhedralFacetUnivariate(SCIP *scip, SCIP_Real left, SCIP_Real right, SCIP_Real funleft, SCIP_Real funright, SCIP_Bool *success, SCIP_Real *facetcoef, SCIP_Real *facetconstant)
#define CONSHDLR_PRESOLTIMING
static SCIP_RETCODE collectBranchingCandidates(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_Real maxrelconsviol, SCIP_SOL *sol, SCIP_Longint soltag, BRANCHCAND *cands, int *ncands)
static SCIP_RETCODE branching(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_Real maxrelconsviol, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_RESULT *result)
static SCIP_RETCODE bilinearTermsInsertAll(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
#define VERTEXPOLY_ADJUSTFACETFACTOR
#define TABLE_POSITION_NONLINEAR
static SCIP_RETCODE initSolve(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
static SCIP_RETCODE removeSingleLockedVars(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPRITER *it, SCIP_HASHMAP *exprcands)
#define CONSHDLR_EAGERFREQ
static void findUnlockedLinearVar(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE addLocks(SCIP *scip, SCIP_CONS *cons, int nlockspos, int nlocksneg)
static SCIP_RETCODE propExprDomains(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_RESULT *result, int *nchgbds)
static SCIP_RETCODE freeAuxVar(SCIP *scip, SCIP_EXPR *expr)
static SCIP_Real getConsAbsViolation(SCIP_CONS *cons)
static SCIP_RETCODE bilinearTermsFree(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)
#define CONSHDLR_ENFOPRIORITY
#define CONSHDLR_DELAYSEPA
static SCIP_RETCODE createCons(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool copyexpr, 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)
static SCIP_RETCODE bilinearTermsInsertEntry(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y, int nlockspos, int nlocksneg, int *idx, SCIP_Bool existing)
static SCIP_RETCODE enforceConstraints(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_Bool inenforcement, SCIP_Real maxrelconsviol, SCIP_RESULT *result)
static SCIP_RETCODE notifyNlhdlrNewsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_Bool solisbest)
static SCIP_Real getExprAbsOrigViolation(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Bool *violunder, SCIP_Bool *violover)
static SCIP_RETCODE presolveMergeConss(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool *success)
static SCIP_Real getDomainCenter(SCIP *scip, SCIP_VAR *var)
#define TABLE_POSITION_NLHDLR
static SCIP_RETCODE ensureOpenArraySizeSymdetect(SCIP *scip, int **openidx, int nelems, int *maxnelems)
static SCIP_RETCODE canonicalizeConstraints(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_PRESOLTIMING presoltiming, SCIP_Bool *infeasible, int *ndelconss, int *naddconss, int *nchgcoefs)
static SCIP_RETCODE dropVarEvents(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS *cons)
static SCIP_Real getExprAbsAuxViolation(SCIP *scip, SCIP_EXPR *expr, SCIP_Real auxvalue, SCIP_SOL *sol, SCIP_Bool *violunder, SCIP_Bool *violover)
#define CONSHDLR_DELAYPROP
#define BILIN_MAXNAUXEXPRS
constraint handler for nonlinear constraints specified by algebraic expressions
Constraint handler for variable bound constraints .
#define SCIPdebugAddSolVal(scip, var, val)
#define SCIP_INTERVAL_INFINITY
#define SCIP_CALL_ABORT(x)
#define SCIP_LONGINT_FORMAT
default user interface dialog
absolute expression handler
power and signed power expression handlers
handler for sin expressions
constant value expression handler
variable expression handler
handler for variable index expressions
SCIP_Real SCIPevalBilinAuxExprNonlinear(SCIP *scip, SCIP_VAR *x, SCIP_VAR *y, SCIP_CONSNONLINEAR_AUXEXPR *auxexpr, SCIP_SOL *sol)
SCIP_RETCODE SCIPcheckQuadraticNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *isquadratic)
SCIP_RETCODE SCIPaddLinearVarNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real coef)
#define SCIP_DECL_NONLINCONSUPGD(x)
SCIP_RETCODE SCIPmarkExprPropagateNonlinear(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateConsBasicSignpowerNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *x, SCIP_VAR *z, SCIP_Real exponent, SCIP_Real xoffset, SCIP_Real zcoef, SCIP_Real lhs, SCIP_Real rhs)
SCIP_Real SCIPgetExprViolScoreNonlinear(SCIP_EXPR *expr)
unsigned int SCIPgetExprNAuxvarUsesNonlinear(SCIP_EXPR *expr)
SCIP_RETCODE SCIPincludeConsUpgradeNonlinear(SCIP *scip, SCIP_DECL_NONLINCONSUPGD((*nlconsupgd)), int priority, SCIP_Bool active, const char *conshdlrname)
void SCIPgetLinvarMayDecreaseNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **var, SCIP_Real *coef)
void SCIPgetExprEnfoDataNonlinear(SCIP_EXPR *expr, int idx, SCIP_NLHDLR **nlhdlr, SCIP_NLHDLREXPRDATA **nlhdlrexprdata, SCIP_NLHDLR_METHOD *nlhdlrparticipation, SCIP_Bool *sepabelowusesactivity, SCIP_Bool *sepaaboveusesactivity, SCIP_Real *auxvalue)
int SCIPgetExprNLocksPosNonlinear(SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateConsBasicSOCNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *coefs, SCIP_Real *offsets, SCIP_Real constant, SCIP_VAR *rhsvar, SCIP_Real rhscoeff, SCIP_Real rhsoffset)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPcreateConsBasicVarbound(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE SCIPchgLhsNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
SCIP_HASHMAP * SCIPgetVarExprHashmapNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPinsertBilinearTermImplicitNonlinear(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y, SCIP_VAR *auxvar, SCIP_Real coefx, SCIP_Real coefy, SCIP_Real coefaux, SCIP_Real cst, SCIP_Bool overestimate)
void SCIPsetExprEnfoAuxValueNonlinear(SCIP_EXPR *expr, int idx, SCIP_Real auxvalue)
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 SCIPgetNlRowNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_NLROW **nlrow)
SCIP_RETCODE SCIPchgRhsNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
SCIP_RETCODE SCIPgetAbsViolationNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Real *viol)
SCIP_RETCODE SCIPgetExprRelAuxViolationNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_Real auxvalue, SCIP_SOL *sol, SCIP_Real *viol, SCIP_Bool *violunder, SCIP_Bool *violover)
SCIP_Longint SCIPgetCurBoundsTagNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPassumeConvexNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_VAR * SCIPgetExprAuxVarNonlinear(SCIP_EXPR *expr)
int SCIPgetBilinTermIdxNonlinear(SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y)
void SCIPgetLinvarMayIncreaseNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **var, SCIP_Real *coef)
SCIP_RETCODE SCIPinsertBilinearTermExistingNonlinear(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y, SCIP_VAR *auxvar, int nlockspos, int nlocksneg)
SCIP_RETCODE SCIPcreateConsBasicLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE SCIPaddExprNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_EXPR *expr, SCIP_Real coef)
SCIP_RETCODE SCIPprocessRowprepNonlinear(SCIP *scip, SCIP_NLHDLR *nlhdlr, SCIP_CONS *cons, SCIP_EXPR *expr, SCIP_ROWPREP *rowprep, SCIP_Bool overestimate, SCIP_VAR *auxvar, SCIP_Real auxvalue, SCIP_Bool allowweakcuts, SCIP_Bool branchscoresuccess, SCIP_Bool inenforcement, SCIP_SOL *sol, SCIP_RESULT *result)
SCIP_EXPR * SCIPgetExprNonlinear(SCIP_CONS *cons)
SCIP_RETCODE SCIPgetExprAbsOrigViolationNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_Real *viol, SCIP_Bool *violunder, SCIP_Bool *violover)
SCIP_Real SCIPgetRhsNonlinear(SCIP_CONS *cons)
unsigned int SCIPgetExprNSepaUsesActivityNonlinear(SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateConsNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, 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_RETCODE SCIPcreateConsBasicNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs)
int SCIPgetExprNEnfosNonlinear(SCIP_EXPR *expr)
int SCIPgetExprNLocksNegNonlinear(SCIP_EXPR *expr)
SCIP_CONSNONLINEAR_BILINTERM * SCIPgetBilinTermsNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPtightenExprIntervalNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_INTERVAL newbounds, SCIP_Bool *cutoff, int *ntightenings)
SCIP_RETCODE SCIPaddExprsViolScoreNonlinear(SCIP *scip, SCIP_EXPR **exprs, int nexprs, SCIP_Real violscore, SCIP_SOL *sol, SCIP_Bool *success)
int SCIPgetNBilinTermsNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPgetExprPartialDiffNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_VAR *var)
SCIP_Longint SCIPgetLastBoundRelaxTagNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPcollectBilinTermsNonlinear(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
SCIP_RETCODE SCIPregisterExprUsageNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool useauxvar, SCIP_Bool useactivityforprop, SCIP_Bool useactivityforsepabelow, SCIP_Bool useactivityforsepaabove)
SCIP_RETCODE SCIPcomputeFacetVertexPolyhedralNonlinear(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_Bool overestimate, SCIP_DECL_VERTEXPOLYFUN((*function)), void *fundata, SCIP_Real *xstar, SCIP_Real *box, int nallvars, SCIP_Real targetvalue, SCIP_Bool *success, SCIP_Real *facetcoefs, SCIP_Real *facetconstant)
SCIP_RETCODE SCIPcreateConsBasicQuadraticNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadterms, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, SCIP_Real lhs, SCIP_Real rhs)
SCIP_CONSNONLINEAR_BILINTERM * SCIPgetBilinTermNonlinear(SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y)
#define SCIP_DECL_VERTEXPOLYFUN(f)
SCIP_RETCODE SCIPgetRelViolationNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Real *viol)
SCIP_INTERVAL SCIPgetExprBoundsNonlinear(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateConsBasicAnd(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, int nvars, SCIP_VAR **vars)
unsigned int SCIPgetExprNPropUsesActivityNonlinear(SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateConsQuadraticNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadterms, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, 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_RETCODE SCIPchgExprNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_EXPR *expr)
SCIP_EXPRCURV SCIPgetCurvatureNonlinear(SCIP_CONS *cons)
SCIP_Real SCIPgetLhsNonlinear(SCIP_CONS *cons)
void SCIPaddExprViolScoreNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_Real violscore)
void SCIPincrementCurBoundsTagNonlinear(SCIP_CONSHDLR *conshdlr, SCIP_Bool boundrelax)
SCIP_RETCODE SCIPgetExprAbsAuxViolationNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_Real auxvalue, SCIP_SOL *sol, SCIP_Real *viol, SCIP_Bool *violunder, SCIP_Bool *violover)
SCIP_Real SCIPevalExprQuadraticAuxNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol)
#define SCIP_MAXVERTEXPOLYDIM
SCIP_Real SCIPgetExprPartialDiffGradientDirNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_VAR *var)
SCIP_RETCODE SCIPincludeConshdlrNonlinear(SCIP *scip)
SCIP_RETCODE SCIPcreateExprVar(SCIP *scip, SCIP_EXPR **expr, SCIP_VAR *var, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_Bool SCIPisExprVaridx(SCIP *scip, SCIP_EXPR *expr)
SCIP_Bool SCIPisExprAbs(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPappendExprSumExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *child, SCIP_Real childcoef)
SCIP_RETCODE SCIPcreateExprSignpower(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_Real exponent, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_Bool SCIPisExprSignpower(SCIP *scip, SCIP_EXPR *expr)
SCIP_Bool SCIPisExprCos(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateExprSum(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real *coefficients, SCIP_Real constant, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPcreateExprValue(SCIP *scip, SCIP_EXPR **expr, SCIP_Real value, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPcreateExprPow(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_Real exponent, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_Bool SCIPisPresolveFinished(SCIP *scip)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNObjVars(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
int SCIPgetNIntVars(SCIP *scip)
int SCIPgetNContVars(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
int SCIPgetNBinVars(SCIP *scip)
int SCIPgetNTotalVars(SCIP *scip)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
int SCIPhashmapGetNElements(SCIP_HASHMAP *hashmap)
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 SCIPhashsetFree(SCIP_HASHSET **hashset, BMS_BLKMEM *blkmem)
SCIP_Bool SCIPhashsetExists(SCIP_HASHSET *hashset, void *element)
SCIP_Bool SCIPhashsetIsEmpty(SCIP_HASHSET *hashset)
SCIP_RETCODE SCIPhashsetInsert(SCIP_HASHSET *hashset, BMS_BLKMEM *blkmem, void *element)
SCIP_RETCODE SCIPhashsetCreate(SCIP_HASHSET **hashset, BMS_BLKMEM *blkmem, int size)
SCIP_RETCODE SCIPhashsetRemove(SCIP_HASHSET *hashset, void *element)
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
#define SCIPhashTwo(a, b)
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)
void * SCIPhashtableRetrieve(SCIP_HASHTABLE *hashtable, void *key)
SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)
SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgObjsen(SCIP_LPI *lpi, SCIP_OBJSEN objsen)
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)
SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)
SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiLoadColLP(SCIP_LPI *lpi, SCIP_OBJSEN objsen, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)
SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)
SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)
SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
#define SCIPdebugMsgPrint
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
void SCIPdialogMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_RETCODE SCIPhasExprCurvature(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPRCURV curv, SCIP_Bool *success, SCIP_HASHMAP *assumevarfixed)
SCIP_RETCODE SCIPheurPassSolTrySol(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL *sol)
SCIP_RETCODE SCIPupdateStartpointHeurSubNlp(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL *solcand, SCIP_Real violation)
SCIP_RETCODE SCIPaddCharParam(SCIP *scip, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, 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 SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_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 SCIPgetCharParam(SCIP *scip, const char *name, char *value)
void SCIPswapPointers(void **pointer1, void **pointer2)
void SCIPswapReals(SCIP_Real *value1, SCIP_Real *value2)
SCIP_RETCODE SCIPaddExternBranchCand(SCIP *scip, SCIP_VAR *var, SCIP_Real score, SCIP_Real solval)
SCIP_Real SCIPgetBranchingPoint(SCIP *scip, SCIP_VAR *var, SCIP_Real suggestion)
SCIP_RETCODE SCIPbranchVarVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
SCIP_Real SCIPgetBranchScore(SCIP *scip, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
int SCIPcolGetNLPNonz(SCIP_COL *col)
SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)
void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
int SCIPconshdlrGetMaxNActiveConss(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPincludeConshdlr(SCIP *scip, const char *name, const char *desc, int sepapriority, int enfopriority, int chckpriority, 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_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsPropagationEnabled(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_Bool SCIPconsIsOriginal(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsSeparationEnabled(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
SCIP_Bool SCIPisCutApplicable(SCIP *scip, SCIP_ROW *cut)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPreleaseDialog(SCIP *scip, SCIP_DIALOG **dialog)
SCIP_DIALOG * SCIPdialoghdlrGetRoot(SCIP_DIALOGHDLR *dialoghdlr)
SCIP_Bool SCIPdialogHasEntry(SCIP_DIALOG *dialog, const char *entryname)
SCIP_RETCODE SCIPdialoghdlrAddHistory(SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG *dialog, const char *command, SCIP_Bool escapecommand)
SCIP_RETCODE SCIPincludeDialog(SCIP *scip, SCIP_DIALOG **dialog, SCIP_DECL_DIALOGCOPY((*dialogcopy)), SCIP_DECL_DIALOGEXEC((*dialogexec)), SCIP_DECL_DIALOGDESC((*dialogdesc)), SCIP_DECL_DIALOGFREE((*dialogfree)), const char *name, const char *desc, SCIP_Bool issubmenu, SCIP_DIALOGDATA *dialogdata)
SCIP_RETCODE SCIPaddDialogEntry(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOG *subdialog)
SCIP_DIALOG * SCIPgetRootDialog(SCIP *scip)
int SCIPdialogFindEntry(SCIP_DIALOG *dialog, const char *entryname, SCIP_DIALOG **subdialog)
int SCIPgetPtrarrayMinIdx(SCIP *scip, SCIP_PTRARRAY *ptrarray)
void * SCIPgetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx)
SCIP_RETCODE SCIPfreePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
int SCIPgetPtrarrayMaxIdx(SCIP *scip, SCIP_PTRARRAY *ptrarray)
SCIP_RETCODE SCIPcreatePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
SCIP_SOL * SCIPeventGetSol(SCIP_EVENT *event)
SCIP_VARTYPE SCIPeventGetNewtype(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)
SCIP_Bool SCIPexprhdlrHasGetSymData(SCIP_EXPRHDLR *exprhdlr)
SCIP_Bool SCIPexprhdlrHasMonotonicity(SCIP_EXPRHDLR *exprhdlr)
SCIP_Bool SCIPexprhdlrHasReverseProp(SCIP_EXPRHDLR *exprhdlr)
void SCIPexprSetActivity(SCIP_EXPR *expr, SCIP_INTERVAL activity, SCIP_Longint activitytag)
SCIP_RETCODE SCIPcreateExprQuadratic(SCIP *scip, SCIP_EXPR **expr, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadterms, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPgetSymDataExpr(SCIP *scip, SCIP_EXPR *expr, SYM_EXPRDATA **symdata)
SCIP_RETCODE SCIPevalExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag)
int SCIPexprGetNChildren(SCIP_EXPR *expr)
void SCIPexprGetQuadraticBilinTerm(SCIP_EXPR *expr, int termidx, SCIP_EXPR **expr1, SCIP_EXPR **expr2, SCIP_Real *coef, int *pos2, SCIP_EXPR **prodexpr)
SCIP_RETCODE SCIPcomputeExprIntegrality(SCIP *scip, SCIP_EXPR *expr)
SCIP_Real SCIPgetExponentExprPow(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprProduct(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPevalExprGradient(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag)
SCIP_Bool SCIPexpriterIsEnd(SCIP_EXPRITER *iterator)
SCIP_Longint SCIPgetExprNewSoltag(SCIP *scip)
SCIP_EXPR * SCIPexpriterSkipDFS(SCIP_EXPRITER *iterator)
SCIP_EXPR_OWNERDATA * SCIPexprGetOwnerData(SCIP_EXPR *expr)
SCIP_Real SCIPexprGetDerivative(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprSum(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPgetExprNVars(SCIP *scip, SCIP_EXPR *expr, int *nvars)
SCIP_Longint SCIPexprGetEvalTag(SCIP_EXPR *expr)
SCIP_Bool SCIPexprIsIntegral(SCIP_EXPR *expr)
SCIP_Bool SCIPexprAreQuadraticExprsVariables(SCIP_EXPR *expr)
void SCIPexprGetQuadraticData(SCIP_EXPR *expr, SCIP_Real *constant, int *nlinexprs, SCIP_EXPR ***linexprs, SCIP_Real **lincoefs, int *nquadexprs, int *nbilinexprs, SCIP_Real **eigenvalues, SCIP_Real **eigenvectors)
SCIP_RETCODE SCIPreplaceExprChild(SCIP *scip, SCIP_EXPR *expr, int childidx, SCIP_EXPR *newchild)
SCIP_Real * SCIPgetCoefsExprSum(SCIP_EXPR *expr)
SCIP_EXPRITER_USERDATA SCIPexpriterGetCurrentUserData(SCIP_EXPRITER *iterator)
SCIP_Bool SCIPisExprValue(SCIP *scip, SCIP_EXPR *expr)
SCIP_Real SCIPgetCoefExprProduct(SCIP_EXPR *expr)
void SCIPfreeExprQuadratic(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)
SCIP_EXPR * SCIPexpriterGetCurrent(SCIP_EXPRITER *iterator)
void SCIPexpriterSetStagesDFS(SCIP_EXPRITER *iterator, SCIP_EXPRITER_STAGE stopstages)
SCIP_Bool SCIPisExprVar(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPparseExpr(SCIP *scip, SCIP_EXPR **expr, const char *exprstr, const char **finalpos, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_EXPR * SCIPexpriterRestartDFS(SCIP_EXPRITER *iterator, SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateExpriter(SCIP *scip, SCIP_EXPRITER **iterator)
void SCIPexprSetIntegrality(SCIP_EXPR *expr, SCIP_Bool isintegral)
SCIP_RETCODE SCIPprintExpr(SCIP *scip, SCIP_EXPR *expr, FILE *file)
SCIP_EXPR * SCIPexpriterGetParentDFS(SCIP_EXPRITER *iterator)
SCIP_Real SCIPgetValueExprValue(SCIP_EXPR *expr)
void SCIPexpriterSetCurrentUserData(SCIP_EXPRITER *iterator, SCIP_EXPRITER_USERDATA userdata)
SCIP_Bool SCIPisExprPower(SCIP *scip, SCIP_EXPR *expr)
SCIP_Real SCIPexprGetEvalValue(SCIP_EXPR *expr)
SCIP_Longint SCIPexprGetActivityTag(SCIP_EXPR *expr)
SCIP_RETCODE SCIPreplaceCommonSubexpressions(SCIP *scip, SCIP_EXPR **exprs, int nexprs, SCIP_Bool *replacedroot)
SCIP_EXPR * SCIPexpriterGetNext(SCIP_EXPRITER *iterator)
SCIP_RETCODE SCIPcheckExprQuadratic(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool *isquadratic)
SCIP_Real SCIPexprGetBardot(SCIP_EXPR *expr)
SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)
SCIP_Real SCIPgetConstantExprSum(SCIP_EXPR *expr)
SCIP_RETCODE SCIPcopyExpr(SCIP *sourcescip, SCIP *targetscip, SCIP_EXPR *expr, SCIP_EXPR **copyexpr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *valid)
SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)
void SCIPexpriterSetChildUserData(SCIP_EXPRITER *iterator, SCIP_EXPRITER_USERDATA userdata)
SCIP_INTERVAL SCIPexprGetActivity(SCIP_EXPR *expr)
void SCIPexprGetQuadraticQuadTerm(SCIP_EXPR *quadexpr, int termidx, SCIP_EXPR **expr, SCIP_Real *lincoef, SCIP_Real *sqrcoef, int *nadjbilin, int **adjbilin, SCIP_EXPR **sqrexpr)
int SCIPexpriterGetChildIdxDFS(SCIP_EXPRITER *iterator)
void SCIPfreeExpriter(SCIP_EXPRITER **iterator)
SCIP_EXPRITER_STAGE SCIPexpriterGetStageDFS(SCIP_EXPRITER *iterator)
SCIP_RETCODE SCIPduplicateExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR **copyexpr, SCIP_DECL_EXPR_MAPEXPR((*mapexpr)), void *mapexprdata, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
void SCIPcaptureExpr(SCIP_EXPR *expr)
SCIP_RETCODE SCIPexpriterInit(SCIP_EXPRITER *iterator, SCIP_EXPR *expr, SCIP_EXPRITER_TYPE type, SCIP_Bool allowrevisit)
int SCIPexprGetNUses(SCIP_EXPR *expr)
SCIP_RETCODE SCIPgetExprVarExprs(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR **varexprs, int *nvarexprs)
SCIP_Longint SCIPexprGetDiffTag(SCIP_EXPR *expr)
SCIP_RETCODE SCIPsimplifyExpr(SCIP *scip, SCIP_EXPR *rootexpr, SCIP_EXPR **simplified, SCIP_Bool *changed, SCIP_Bool *infeasible, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPevalExprActivity(SCIP *scip, SCIP_EXPR *expr)
SCIP_EXPRHDLR * SCIPexprGetHdlr(SCIP_EXPR *expr)
SCIP_EXPR * SCIPexpriterGetChildExprDFS(SCIP_EXPRITER *iterator)
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
const char * SCIPheurGetName(SCIP_HEUR *heur)
void SCIPintervalIntersectEps(SCIP_INTERVAL *resultant, SCIP_Real eps, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
SCIP_Bool SCIPintervalIsEntire(SCIP_Real infinity, SCIP_INTERVAL operand)
void SCIPintervalSetEntire(SCIP_Real infinity, SCIP_INTERVAL *resultant)
SCIP_Bool SCIPintervalIsSubsetEQ(SCIP_Real infinity, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
SCIP_Bool SCIPintervalIsEmpty(SCIP_Real infinity, SCIP_INTERVAL operand)
void SCIPintervalSetBounds(SCIP_INTERVAL *resultant, SCIP_Real inf, SCIP_Real sup)
void SCIPintervalSetEmpty(SCIP_INTERVAL *resultant)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
SCIP_Real SCIPgetLPObjval(SCIP *scip)
void SCIPsetLPFeastol(SCIP *scip, SCIP_Real newfeastol)
SCIP_Real SCIPgetLPFeastol(SCIP *scip)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocClearBlockMemory(scip, ptr)
#define SCIPensureBlockMemoryArray(scip, ptr, arraysizeptr, minsize)
BMS_BUFMEM * SCIPbuffer(SCIP *scip)
#define SCIPallocClearBufferArray(scip, ptr, num)
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 SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_RETCODE SCIPdelNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
void SCIPenableNLP(SCIP *scip)
SCIP_RETCODE SCIPsetNlRowExpr(SCIP *scip, SCIP_NLROW *nlrow, SCIP_EXPR *expr)
SCIP_RETCODE SCIPaddLinearCoefToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
SCIP_RETCODE SCIPchgNlRowConstant(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real constant)
void SCIPsetNlRowCurvature(SCIP *scip, SCIP_NLROW *nlrow, SCIP_EXPRCURV curvature)
SCIP_RETCODE SCIPcreateNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)
const char * SCIPnlhdlrGetDesc(SCIP_NLHDLR *nlhdlr)
SCIP_NLHDLR ** SCIPgetNlhdlrsNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPnlhdlrHasIntEval(SCIP_NLHDLR *nlhdlr)
int SCIPnlhdlrGetDetectPriority(SCIP_NLHDLR *nlhdlr)
SCIP_NLHDLREXPRDATA * SCIPgetNlhdlrExprDataNonlinear(SCIP_NLHDLR *nlhdlr, SCIP_EXPR *expr)
SCIP_Bool SCIPnlhdlrIsEnabled(SCIP_NLHDLR *nlhdlr)
int SCIPgetNNlhdlrsNonlinear(SCIP_CONSHDLR *conshdlr)
const char * SCIPnlhdlrGetName(SCIP_NLHDLR *nlhdlr)
SCIP_NLHDLR * SCIPfindNlhdlrNonlinear(SCIP_CONSHDLR *conshdlr, const char *name)
SCIP_Bool SCIPnlhdlrHasEstimate(SCIP_NLHDLR *nlhdlr)
SCIP_RETCODE SCIPincludeNlhdlrNonlinear(SCIP *scip, SCIP_NLHDLR **nlhdlr, const char *name, const char *desc, int detectpriority, int enfopriority, SCIP_DECL_NLHDLRDETECT((*detect)), SCIP_DECL_NLHDLREVALAUX((*evalaux)), SCIP_NLHDLRDATA *nlhdlrdata)
SCIP_Bool SCIPnlhdlrHasInitSepa(SCIP_NLHDLR *nlhdlr)
int SCIPnlhdlrGetEnfoPriority(SCIP_NLHDLR *nlhdlr)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_CONSHDLR * SCIProwGetOriginConshdlr(SCIP_ROW *row)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
const char * SCIProwGetName(SCIP_ROW *row)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
void SCIPmarkRowNotRemovableLocal(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
SCIP_Real SCIPgetSepaMinEfficacy(SCIP *scip)
SCIP_SOLORIGIN SCIPsolGetOrigin(SCIP_SOL *sol)
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
SCIP_RETCODE SCIPcreateLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPunlinkSol(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPincSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real incval)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
SCIP_RETCODE SCIPaddSymgraphEdge(SCIP *scip, SYM_GRAPH *graph, int first, int second, SCIP_Bool hasval, SCIP_Real val)
SCIP_RETCODE SCIPaddSymgraphOpnode(SCIP *scip, SYM_GRAPH *graph, int op, int *nodeidx)
SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
SCIP_RETCODE SCIPaddSymgraphValnode(SCIP *scip, SYM_GRAPH *graph, SCIP_Real val, int *nodeidx)
int SCIPgetSymgraphVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
SCIP_RETCODE SCIPaddSymgraphConsnode(SCIP *scip, SYM_GRAPH *graph, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, int *nodeidx)
SCIP_RETCODE SCIPaddSymgraphVarAggregation(SCIP *scip, SYM_GRAPH *graph, int rootidx, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real constant)
int SCIPgetSymExprdataNConstants(SYM_EXPRDATA *symdata)
int SCIPgetSymgraphNegatedVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
SCIP_RETCODE SCIPfreeSymDataExpr(SCIP *scip, SYM_EXPRDATA **symdata)
int SCIPgetSymgraphNNodes(SYM_GRAPH *graph)
SCIP_Real * SCIPgetSymExprdataConstants(SYM_EXPRDATA *symdata)
SCIP_RETCODE SCIPgetCoefSymData(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *parentexpr, SCIP_Real *coef, SCIP_Bool *success)
SCIP_TABLE * SCIPfindTable(SCIP *scip, const char *name)
SCIP_RETCODE SCIPincludeTable(SCIP *scip, const char *name, const char *desc, SCIP_Bool active, SCIP_DECL_TABLECOPY((*tablecopy)), SCIP_DECL_TABLEFREE((*tablefree)), SCIP_DECL_TABLEINIT((*tableinit)), SCIP_DECL_TABLEEXIT((*tableexit)), SCIP_DECL_TABLEINITSOL((*tableinitsol)), SCIP_DECL_TABLEEXITSOL((*tableexitsol)), SCIP_DECL_TABLEOUTPUT((*tableoutput)), SCIP_TABLEDATA *tabledata, int position, SCIP_STAGE earlieststage)
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstopClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_Bool SCIPisRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisUbBetter(SCIP *scip, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLbBetter(SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisHugeValue(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisSumLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPround(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Real SCIPgetHugeValue(SCIP *scip)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPepsilon(SCIP *scip)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
int SCIPgetDepth(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPaddVarLocks(SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
void SCIPvarMarkRelaxationOnly(SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetIndex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
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)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
void SCIPqueueFree(SCIP_QUEUE **queue)
SCIP_RETCODE SCIPqueueCreate(SCIP_QUEUE **queue, int initsize, SCIP_Real sizefac)
SCIP_RETCODE SCIPqueueInsert(SCIP_QUEUE *queue, void *elem)
SCIP_Bool SCIPqueueIsEmpty(SCIP_QUEUE *queue)
void * SCIPqueueRemove(SCIP_QUEUE *queue)
SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)
int SCIPrandomGetInt(SCIP_RANDNUMGEN *randnumgen, int minrandval, int maxrandval)
SCIP_VAR ** SCIProwprepGetVars(SCIP_ROWPREP *rowprep)
SCIP_RETCODE SCIPcleanupRowprep2(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Real maxcoefbound, SCIP_Bool *success)
int SCIProwprepGetNModifiedVars(SCIP_ROWPREP *rowprep)
SCIP_Real SCIPgetRowprepViolation(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Bool *reliable)
SCIP_Real * SCIProwprepGetCoefs(SCIP_ROWPREP *rowprep)
SCIP_VAR ** SCIProwprepGetModifiedVars(SCIP_ROWPREP *rowprep)
char * SCIProwprepGetName(SCIP_ROWPREP *rowprep)
SCIP_SIDETYPE SCIProwprepGetSidetype(SCIP_ROWPREP *rowprep)
SCIP_RETCODE SCIPaddRowprepTerm(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_VAR *var, SCIP_Real coef)
SCIP_RETCODE SCIPgetRowprepRowCons(SCIP *scip, SCIP_ROW **row, SCIP_ROWPREP *rowprep, SCIP_CONS *cons)
int SCIProwprepGetNVars(SCIP_ROWPREP *rowprep)
void SCIProwprepRecordModifications(SCIP_ROWPREP *rowprep)
SCIP_RETCODE SCIPcleanupRowprep(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Real minviol, SCIP_Real *viol, SCIP_Bool *success)
void SCIPfreeRowprep(SCIP *scip, SCIP_ROWPREP **rowprep)
void SCIPprintRowprep(SCIP *scip, SCIP_ROWPREP *rowprep, FILE *file)
SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
void SCIPsortDown(int *perm, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownIntPtr(int *intarray, void **ptrarray, int len)
void SCIPsort(int *perm, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPskipSpace(char **s)
SCIPfreeSol(scip, &heurdata->sol))
SCIPfreeRandom(scip, &heurdata->randnumgen)
SCIPcreateRandom(scip, &heurdata->randnumgen, DEFAULT_RANDSEED, TRUE))
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
NLP local search primal heuristic using sub-SCIPs.
primal heuristic that tries a given solution
SCIP_Bool SCIPcliqueHasVar(SCIP_CLIQUE *clique, SCIP_VAR *var, SCIP_Bool value)
static volatile int nterms
SCIP_Bool SCIPlapackIsAvailable(void)
SCIP_RETCODE SCIPlapackSolveLinearEquations(BMS_BUFMEM *bufmem, int n, SCIP_Real *A, SCIP_Real *b, SCIP_Real *x, SCIP_Bool *success)
interface methods for lapack functions
static const char * paramname[]
#define BMSclearMemoryArray(ptr, num)
SCIP_RETCODE SCIPnlhdlrFree(SCIP *scip, SCIP_NLHDLR **nlhdlr)
SCIP_RETCODE SCIPnlhdlrCreate(SCIP *scip, SCIP_NLHDLR **nlhdlr, const char *name, const char *desc, int detectpriority, int enfopriority, SCIP_DECL_NLHDLRDETECT((*detect)), SCIP_DECL_NLHDLREVALAUX((*evalaux)), SCIP_NLHDLRDATA *nlhdlrdata)
void SCIPnlhdlrPrintStatistics(SCIP *scip, SCIP_NLHDLR **nlhdlrs, int nnlhdlrs, FILE *file)
private functions of nonlinear handlers of nonlinear constraints
#define SCIPnlhdlrIncrementNSeparated(nlhdlr)
#define SCIPnlhdlrResetNDetectionslast(nlhdlr)
#define SCIPnlhdlrIncrementNCutoffs(nlhdlr)
nonlinear handlers for convex and concave expressions, respectively
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
SCIP_RETCODE SCIPgetSymOpNodeType(SCIP *scip, const char *opnodename, int *nodetype)
propagator for symmetry handling
#define SCIPdebugPrintCons(x, y, z)
methods for sorting joint arrays of various types
public functions to work with algebraic expressions
SCIP_DECL_NONLINCONSUPGD((*consupgd))
SCIP_NLHDLR_METHOD nlhdlrparticipation
SCIP_Bool sepaaboveusesactivity
SCIP_Bool sepabelowusesactivity
SCIP_NLHDLREXPRDATA * nlhdlrexprdata
structs for symmetry computations
methods for dealing with symmetry detection graphs
#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)
#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_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
#define SCIP_DECL_CONSDELVARS(x)
#define SCIP_DECL_DIALOGEXEC(x)
#define SCIP_EVENTTYPE_BOUNDCHANGED
#define SCIP_EVENTTYPE_TYPECHANGED
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_VARFIXED
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_BESTSOLFOUND
#define SCIP_EVENTTYPE_FORMAT
#define SCIP_EVENTTYPE_BOUNDRELAXED
#define SCIP_EVENTTYPE_SOLFOUND
#define SCIP_EVENTTYPE_BOUNDTIGHTENED
#define SCIP_DECL_EXPR_OWNERCREATE(x)
#define SCIP_EXPRITER_VISITINGCHILD
#define SCIP_DECL_EXPR_OWNERPRINT(x)
struct SCIP_Expr_OwnerData SCIP_EXPR_OWNERDATA
#define SCIP_DECL_EXPR_INTEVALVAR(x)
@ SCIP_EXPRITER_RTOPOLOGIC
#define SCIP_DECL_EXPR_MAPEXPR(x)
#define SCIP_DECL_EXPR_OWNERFREE(x)
#define SCIP_EXPRITER_LEAVEEXPR
#define SCIP_DECL_EXPR_OWNEREVALACTIVITY(x)
#define SCIP_EXPRITER_ENTEREXPR
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_BoundType SCIP_BOUNDTYPE
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_SORTINDCOMP(x)
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
#define SCIP_NLHDLR_METHOD_SEPAABOVE
#define SCIP_DECL_NLHDLREVALAUX(x)
struct SCIP_NlhdlrData SCIP_NLHDLRDATA
#define SCIP_NLHDLR_METHOD_SEPABOTH
#define SCIP_NLHDLR_METHOD_ACTIVITY
unsigned int SCIP_NLHDLR_METHOD
#define SCIP_DECL_NLHDLRDETECT(x)
#define SCIP_NLHDLR_METHOD_NONE
struct SCIP_NlhdlrExprData SCIP_NLHDLREXPRDATA
#define SCIP_NLHDLR_METHOD_ALL
#define SCIP_NLHDLR_METHOD_SEPABELOW
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_INITPRESOLVE
@ SCIP_STAGE_EXITPRESOLVE
enum SYM_Symtype SYM_SYMTYPE
#define SCIP_DECL_TABLEOUTPUT(x)
#define SCIP_PRESOLTIMING_ALWAYS
#define SCIP_PRESOLTIMING_MEDIUM
unsigned int SCIP_PRESOLTIMING
#define SCIP_PRESOLTIMING_EXHAUSTIVE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR
enum SCIP_Vartype SCIP_VARTYPE