83#define CONSHDLR_NAME "nonlinear"
84#define CONSHDLR_DESC "handler for nonlinear constraints specified by algebraic expressions"
85#define CONSHDLR_ENFOPRIORITY 50
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 }
139FILE* enfologfile =
NULL;
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 branchfracweight;
313 SCIP_Real branchdualweight;
314 SCIP_Real branchpscostweight;
315 SCIP_Real branchdomainweight;
316 SCIP_Real branchvartypeweight;
318 char branchviolsplit;
319 SCIP_Real branchpscostreliable;
320 SCIP_Real branchmixfractional;
321 char linearizeheursol;
322 SCIP_Bool assumeconvex;
325 SCIP_Longint nweaksepa;
326 SCIP_Longint ntightenlp;
327 SCIP_Longint ndesperatetightenlp;
328 SCIP_Longint ndesperatebranch;
329 SCIP_Longint ndesperatecutoff;
330 SCIP_Longint nforcelp;
332 SCIP_Longint ncanonicalizecalls;
343 int bilinmaxnauxexprs;
347 char branchpscostupdatestrategy;
350 SCIP_Bool checkedvarlocks;
352 int newsoleventfilterpos;
379 SCIP_Bool tightenauxvars,
380 SCIP_Bool* infeasible,
399 if( mydata->auxvar ==
NULL )
441 mydata->nactivityusesprop = 0;
442 mydata->nactivityusessepa = 0;
443 mydata->nauxvaruses = 0;
447 for( e = 0; e < mydata->nenfos; ++e )
453 nlhdlr = mydata->enfos[e]->nlhdlr;
456 if( mydata->enfos[e]->issepainit )
459 SCIP_CALL( SCIPnlhdlrExitsepa(
scip, nlhdlr, expr, mydata->enfos[e]->nlhdlrexprdata) );
460 mydata->enfos[e]->issepainit =
FALSE;
464 if( mydata->enfos[e]->nlhdlrexprdata !=
NULL )
466 SCIP_CALL( SCIPnlhdlrFreeexprdata(
scip, nlhdlr, expr, &mydata->enfos[e]->nlhdlrexprdata) );
467 assert(mydata->enfos[e]->nlhdlrexprdata ==
NULL);
493 assert((*ownerdata)->nlockspos == 0);
494 assert((*ownerdata)->nlocksneg == 0);
499 assert((*ownerdata)->nenfos <= 0);
508 assert((*ownerdata)->nconss == 0);
510 assert((*ownerdata)->filterpos == -1);
542 if( ownerdata->nenfos > 0 )
547 for(
i = 0;
i < ownerdata->nenfos; ++
i )
564 if( ownerdata->auxvar !=
NULL )
609 (*ownerdata)->nenfos = -1;
617 (*ownerdata)->filterpos = -1;
640 (*ownerdata)->filterpos = -2;
643 *ownerfree = exprownerFree;
644 *ownerprint = exprownerPrint;
645 *ownerevalactivity = exprownerEvalactivity;
750 if( consdata->varexprs !=
NULL )
754 assert(consdata->nvarexprs == 0);
757 if( consdata->issimplified )
773 assert(varexprssize >= consdata->nvarexprs);
776 if( varexprssize > consdata->nvarexprs )
788 for(
i = 0;
i < consdata->nvarexprs; ++
i )
811 if( consdata->varexprs ==
NULL )
815 assert(consdata->nvarexprs >= 0);
816 assert(!consdata->catchedevents);
819 for(
i = 0;
i < consdata->nvarexprs; ++
i )
828 consdata->varexprs =
NULL;
829 consdata->nvarexprs = 0;
853 if( conshdlrdata->globalbounds )
876 switch( conshdlrdata->varboundrelax )
890 SCIP_Real bnd = floor(lb);
891 lb =
MAX(bnd, lb - conshdlrdata->varboundrelaxamount);
897 SCIP_Real bnd = ceil(ub);
898 ub =
MIN(bnd, ub + conshdlrdata->varboundrelaxamount);
911 lb -= conshdlrdata->varboundrelaxamount;
914 ub += conshdlrdata->varboundrelaxamount;
931 SCIP_Real bnd = floor(lb);
937 SCIP_Real bnd = ceil(ub);
946 SCIPerrorMessage(
"Unsupported value '%c' for varboundrelax option.\n", conshdlrdata->varboundrelax);
975 return consdata1->consindex - consdata2->consindex;
985 SCIP_Bool boundtightened =
FALSE;
1002 assert(ownerdata->nconss > 0);
1006 boundtightened =
TRUE;
1015 boundtightened =
TRUE;
1025 boundtightened =
TRUE;
1032 if( boundtightened )
1037 for(
c = 0;
c < ownerdata->nconss; ++
c )
1047 consdata->ispropagated =
FALSE;
1053 consdata->issimplified =
FALSE;
1069 ++conshdlrdata->curboundstag;
1070 assert(conshdlrdata->curboundstag > 0);
1074 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
1079 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &activity, conshdlrdata->intevalvar, conshdlrdata) );
1117 for(
i = 0;
i < ownerdata->nconss; ++
i )
1118 assert(ownerdata->conss[
i] != cons);
1124 ownerdata->conss[ownerdata->nconss++] = cons;
1128 if( ownerdata->nconss <= 1 )
1129 ownerdata->consssorted =
TRUE;
1130 else if( ownerdata->consssorted )
1131 ownerdata->consssorted = compIndexConsNonlinear(ownerdata->conss[ownerdata->nconss-2], ownerdata->conss[ownerdata->nconss-1]) > 0;
1134 if( ownerdata->filterpos < 0 )
1138 assert(ownerdata->nconss == 1);
1143 assert(ownerdata->filterpos >= 0);
1168 assert(consdata->nvarexprs >= 0);
1171 if( consdata->catchedevents )
1177 assert(conshdlrdata->intevalvar == intEvalVarBoundTightening);
1182 for(
i = 0;
i < consdata->nvarexprs; ++
i )
1184 expr = consdata->varexprs[
i];
1197 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &activity, intEvalVarBoundTightening, conshdlrdata) );
1206 consdata->catchedevents =
TRUE;
1234 assert(ownerdata->nconss > 0);
1236 if( ownerdata->conss[ownerdata->nconss-1] == cons )
1238 pos = ownerdata->nconss-1;
1242 if( !ownerdata->consssorted )
1244 SCIPsortPtr((
void**)ownerdata->conss, compIndexConsNonlinear, ownerdata->nconss);
1245 ownerdata->consssorted =
TRUE;
1248 if( !
SCIPsortedvecFindPtr((
void**)ownerdata->conss, compIndexConsNonlinear, cons, ownerdata->nconss, &pos) )
1253 assert(pos >= 0 && pos < ownerdata->nconss);
1255 assert(ownerdata->conss[pos] == cons);
1258 if( pos < ownerdata->nconss-1 )
1260 ownerdata->conss[pos] = ownerdata->conss[ownerdata->nconss-1];
1261 ownerdata->consssorted =
FALSE;
1263 --ownerdata->nconss;
1266 if( ownerdata->nconss == 0 )
1270 assert(ownerdata->filterpos >= 0);
1275 ownerdata->filterpos = -1;
1299 if( !consdata->catchedevents )
1303 assert(consdata->nvarexprs >= 0);
1307 for(
i = consdata->nvarexprs - 1;
i >= 0; --
i )
1314 consdata->catchedevents =
FALSE;
1345 SCIP_Bool modifiable,
1366 SCIPerrorMessage(
"Locally valid nonlinear constraints are not supported, yet.\n");
1373 SCIPerrorMessage(
"Non-initial nonlinear constraints are not supported, yet.\n");
1387 consdata->expr = expr;
1390 consdata->lhs = lhs;
1391 consdata->rhs = rhs;
1392 consdata->consindex = conshdlrdata->lastconsindex++;
1396 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
1397 local, modifiable, dynamic, removable,
FALSE) );
1419 SCIP_Bool* violunder,
1424 SCIP_Real auxvarvalue;
1434 if( violunder !=
NULL )
1436 if( violover !=
NULL )
1445 if( violunder !=
NULL )
1447 if( violover !=
NULL )
1454 if( violunder !=
NULL )
1456 if( violover !=
NULL )
1461 if( violunder !=
NULL )
1463 if( violover !=
NULL )
1486 SCIP_Bool* violunder,
1491 SCIP_Real auxvarvalue;
1501 if( violunder !=
NULL )
1503 if( violover !=
NULL )
1510 if( ownerdata->nlocksneg > 0 && auxvarvalue > auxvalue )
1512 if( violunder !=
NULL )
1514 if( violover !=
NULL )
1516 return auxvarvalue - auxvalue;
1519 if( ownerdata->nlockspos > 0 && auxvalue > auxvarvalue )
1521 if( violunder !=
NULL )
1523 if( violover !=
NULL )
1525 return auxvalue - auxvarvalue;
1528 if( violunder !=
NULL )
1530 if( violover !=
NULL )
1588 return MAX3(0.0, consdata->lhsviol, consdata->rhsviol);
1620 if( conshdlrdata->violscale ==
'n' )
1629 if( conshdlrdata->violscale ==
'a' )
1634 if( consdata->lhsviol > 0.0 &&
REALABS(consdata->lhs) > scale )
1637 scale =
REALABS(consdata->lhs);
1639 else if( consdata->rhsviol > 0.0 &&
REALABS(consdata->rhs) > scale )
1642 scale =
REALABS(consdata->rhs);
1650 assert(conshdlrdata->violscale ==
'g');
1651 if( soltag == 0L || consdata->gradnormsoltag != soltag )
1657 consdata->gradnorm = 0.0;
1666 for(
i = 0;
i < consdata->nvarexprs; ++
i )
1675 consdata->gradnorm = 0.0;
1679 consdata->gradnorm += deriv*deriv;
1682 consdata->gradnorm = sqrt(consdata->gradnorm);
1683 consdata->gradnormsoltag = soltag;
1686 *viol /=
MAX(1.0, consdata->gradnorm);
1721 consdata->linvarincr =
NULL;
1722 consdata->linvardecr =
NULL;
1723 consdata->linvarincrcoef = 0.0;
1724 consdata->linvardecrcoef = 0.0;
1760 if( (consdata->linvardecr ==
NULL) ||
1763 consdata->linvardecr =
var;
1764 consdata->linvardecrcoef = coef;
1773 if( (consdata->linvarincr ==
NULL) ||
1776 consdata->linvarincr =
var;
1777 consdata->linvarincrcoef = coef;
1783 assert(consdata->linvarincr ==
NULL || consdata->linvarincrcoef != 0.0);
1784 assert(consdata->linvardecr ==
NULL || consdata->linvardecrcoef != 0.0);
1786 if( consdata->linvarincr !=
NULL )
1790 if( consdata->linvardecr !=
NULL )
1838 SCIPdebugMsg(
scip,
"attempt to make solution from <%s> feasible by shifting linear variable\n",
1841 for(
c = 0;
c < nconss; ++
c )
1844 SCIP_Real viol = 0.0;
1852 viol = consdata->lhsviol;
1854 viol = -consdata->rhsviol;
1858 if( consdata->linvarincr !=
NULL &&
1859 ((viol > 0.0 && consdata->linvarincrcoef > 0.0) || (viol < 0.0 && consdata->linvarincrcoef < 0.0)) )
1864 delta = viol / consdata->linvarincrcoef;
1871 delta =
MIN(
MAX(0.0, gap), delta);
1880 SCIPdebugMsg(
scip,
"increase <%s> by %g to %g to remedy lhs-violation %g of cons <%s>\n",
1884 viol -= consdata->linvarincrcoef * delta;
1891 if( consdata->linvardecr !=
NULL &&
1892 ((viol > 0.0 && consdata->linvardecrcoef < 0.0) || (viol < 0.0 && consdata->linvardecrcoef > 0.0)) )
1897 delta = viol / consdata->linvardecrcoef;
1904 delta =
MAX(
MIN(0.0, gap), delta);
1913 SCIPdebugMsg(
scip,
"increase <%s> by %g to %g to remedy rhs-violation %g of cons <%s>\n",
1917 viol -= consdata->linvardecrcoef * delta;
1969 SCIP_Longint soltag;
1989 for(
c = 0;
c < nconss; ++
c )
2005 for(
i = 0;
i < consdata->nvarexprs; ++
i )
2027 if( ownerdata->auxvar !=
NULL )
2033 for( e = 0; e < ownerdata->nenfos; ++e )
2037 ownerdata->enfos[e]->nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata,
sol, solisbest,
2106 SCIP_Bool tightenedlb;
2107 SCIP_Bool tightenedub;
2131 if( ntightenings !=
NULL )
2145 if( ntightenings !=
NULL )
2171 SCIP_Bool tightenauxvars,
2172 SCIP_Bool* infeasible,
2184 if( infeasible !=
NULL )
2185 *infeasible =
FALSE;
2186 if( ntightenings !=
NULL )
2195 SCIPdebugMsg(
scip,
"stored activity of root expr is empty and valid (activitytag >= lastboundrelax (%" SCIP_LONGINT_FORMAT ")), skip forwardPropExpr -> cutoff\n", conshdlrdata->lastboundrelax);
2197 if( infeasible !=
NULL )
2224 if( ownerdata->nenfos >= 0 && ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && !conshdlrdata->indetect)
2227 SCIPdebugMsg(
scip,
"root expr activity is not used but enfo initialized, skip inteval\n");
2275 SCIPexprGetActivityTag(expr) >= conshdlrdata->lastvaractivitymethodchange && !conshdlrdata->globalbounds )
2280 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &exprhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );
2310 if( infeasible !=
NULL )
2312 SCIPdebugMsg(
scip,
"expr %p already has empty activity -> cutoff\n", (
void*)expr);
2322 if( ownerdata->nenfos >= 0 && ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && !conshdlrdata->indetect )
2325 SCIPdebugMsg(
scip,
"expr %p activity is not used but enfo initialized, skip inteval\n", (
void*)expr);
2337 if( ownerdata->nenfos > 0 )
2350 nlhdlr = ownerdata->enfos[e]->nlhdlr;
2358 nlhdlrinterval = activity;
2359 SCIP_CALL( SCIPnlhdlrInteval(
scip, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata,
2360 &nlhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );
2376 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &exprhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );
2420 if( infeasible !=
NULL )
2423 else if( tightenauxvars && ownerdata->auxvar !=
NULL )
2425 SCIP_Bool tighteninfeasible;
2428 if( tighteninfeasible )
2430 if( infeasible !=
NULL )
2467 SCIP_Bool subsetsufficient,
2476 if( subsetsufficient )
2516 SCIP_Bool* infeasible,
2535 while( !
SCIPqueueIsEmpty(conshdlrdata->reversepropqueue) && !(*infeasible) )
2546 assert(ownerdata->inpropqueue);
2548 ownerdata->inpropqueue =
FALSE;
2553 assert(ownerdata->propboundstag == conshdlrdata->curpropboundstag);
2561#ifdef SCIP_DISABLED_CODE
2569 propbounds = ownerdata->propbounds;
2572 if( ownerdata->nenfos > 0 )
2575 for( e = 0; e < ownerdata->nenfos && !*infeasible; ++e )
2584 nlhdlr = ownerdata->enfos[e]->nlhdlr;
2595 SCIP_CALL( SCIPnlhdlrReverseprop(
scip, conshdlr, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, propbounds, infeasible, &nreds) );
2597 *ntightenings += nreds;
2615 assert(ownerdata->nenfos < 0);
2622 SCIP_CALL( SCIPcallExprReverseprop(
scip, expr, propbounds, childrenbounds, infeasible) );
2644 ownerdata->inpropqueue =
FALSE;
2712 assert(conshdlrdata->intevalvar == intEvalVarBoundTightening);
2714 assert(!conshdlrdata->globalbounds);
2720 conshdlrdata->forceboundtightening = force;
2723 ++conshdlrdata->curpropboundstag;
2726 if( conshdlrdata->propauxvars )
2741 for(
i = 0;
i < nconss; ++
i )
2753 if( consdata->ispropagated )
2774 if( !conshdlrdata->propauxvars || ownerdata->auxvar ==
NULL )
2780 if( ownerdata->auxvar ==
NULL )
2789 conssides = intEvalVarBoundTightening(
scip, ownerdata->auxvar, (
void*)conshdlrdata);
2808 if( ownerdata->auxvar ==
NULL )
2811 if( ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 )
2814 conssides = intEvalVarBoundTightening(
scip, ownerdata->auxvar, (
void*)conshdlrdata);
2826 assert(ntightenings >= 0);
2827 if( ntightenings > 0 )
2829 *nchgbds += ntightenings;
2834 consdata->ispropagated =
TRUE;
2839 assert(ntightenings >= 0);
2849 if( ntightenings > 0 )
2851 *nchgbds += ntightenings;
2855 while( ntightenings > 0 && ++roundnr < conshdlrdata->maxproprounds );
2857 if( conshdlrdata->propauxvars )
2862 conshdlrdata->forceboundtightening =
FALSE;
2865 ++conshdlrdata->curpropboundstag;
2915 for(
c = 0;
c < nconss && !
cutoff; ++
c )
2932 for( e = 0; e < ownerdata->nenfos; ++e )
2937 nlhdlr = ownerdata->enfos[e]->nlhdlr;
2942 SCIPdebugMsg(
scip,
"propExprDomains calling reverseprop for expression %p [%g,%g]\n", (
void*)expr,
2945 SCIP_CALL( SCIPnlhdlrReverseprop(
scip, conshdlr, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata,
2956 assert(ntightenings >= 0);
2957 if( ntightenings > 0 )
2959 *nchgbds += ntightenings;
2968 assert(ntightenings >= 0);
2975 else if( ntightenings > 0 )
2977 *nchgbds += ntightenings;
3005 if( nlockspos == 0 && nlocksneg == 0 )
3014 ituserdata.
intvals[0] = nlockspos;
3015 ituserdata.
intvals[1] = nlocksneg;
3022 nlockspos = ituserdata.
intvals[0];
3023 nlocksneg = ituserdata.
intvals[1];
3038 ownerdata->nlockspos += nlockspos;
3039 ownerdata->nlocksneg += nlocksneg;
3042 if( ownerdata->nlockspos == nlockspos && ownerdata->nlocksneg == nlocksneg &&
SCIPexprGetNChildren(expr) > 0
3048 assert(ownerdata->monotonicitysize == 0);
3056 SCIP_CALL( SCIPcallExprMonotonicity(
scip, expr,
i, &ownerdata->monotonicity[
i]) );
3065 if( ownerdata->nlockspos == 0 && ownerdata->nlocksneg == 0 && ownerdata->monotonicity !=
NULL )
3067 assert(ownerdata->monotonicitysize > 0);
3072 ownerdata->monotonicitysize = 0;
3088 switch( monotonicity )
3091 ituserdata.
intvals[0] = nlockspos;
3092 ituserdata.
intvals[1] = nlocksneg;
3095 ituserdata.
intvals[0] = nlocksneg;
3096 ituserdata.
intvals[1] = nlockspos;
3099 ituserdata.
intvals[0] = nlockspos + nlocksneg;
3100 ituserdata.
intvals[1] = nlockspos + nlocksneg;
3155 if( nlockspos == 0 && nlocksneg == 0 )
3166 consdata->nlockspos += nlockspos;
3167 consdata->nlocksneg += nlocksneg;
3169 assert(consdata->nlockspos >= 0);
3170 assert(consdata->nlocksneg >= 0);
3206 if( consdata->nlrow !=
NULL )
3315 assert(conshdlrdata->auxvarid >= 0);
3316 assert(!conshdlrdata->indetect);
3319 assert(ownerdata->nenfos < 0);
3329 if( ownerdata->nauxvaruses == 0 )
3333 if( ownerdata->nlockspos == 0 )
3335 if( ownerdata->nlocksneg == 0 )
3338 if( ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 )
3347 ownerdata->nenfos = 0;
3350 conshdlrdata->indetect =
TRUE;
3352 SCIPdebugMsg(
scip,
"detecting nlhdlrs for %s expression %p (%s); requiring%s%s%s\n",
3358 for(
h = 0;
h < conshdlrdata->nnlhdlrs; ++
h )
3362 nlhdlr = conshdlrdata->nlhdlrs[
h];
3370 nlhdlrexprdata =
NULL;
3371 enforcemethodsnew = enforcemethods;
3373 conshdlrdata->registerusesactivitysepabelow =
FALSE;
3374 conshdlrdata->registerusesactivitysepaabove =
FALSE;
3376 SCIP_CALL( SCIPnlhdlrDetect(
scip, ownerdata->conshdlr, nlhdlr, expr, cons, &enforcemethodsnew, &nlhdlrparticipating, &nlhdlrexprdata) );
3379 nlhdlrparticipating &= enforcemethodsallowed;
3382 assert((enforcemethodsnew & enforcemethods) == enforcemethods);
3387 nlhdlrenforcemethods = (enforcemethodsnew ^ enforcemethods) & enforcemethodsallowed;
3390 assert((nlhdlrparticipating & nlhdlrenforcemethods) == nlhdlrenforcemethods);
3398 if( nlhdlrexprdata !=
NULL )
3400 SCIP_CALL( SCIPnlhdlrFreeexprdata(
scip, nlhdlr, expr, &nlhdlrexprdata) );
3410 SCIPdebugMsg(
scip,
"nlhdlr <%s> detect successful; sepabelow: %s, sepaabove: %s, activity: %s\n",
3419 ownerdata->enfos[ownerdata->nenfos]->nlhdlr = nlhdlr;
3420 ownerdata->enfos[ownerdata->nenfos]->nlhdlrexprdata = nlhdlrexprdata;
3421 ownerdata->enfos[ownerdata->nenfos]->nlhdlrparticipation = nlhdlrparticipating;
3422 ownerdata->enfos[ownerdata->nenfos]->issepainit =
FALSE;
3423 ownerdata->enfos[ownerdata->nenfos]->sepabelowusesactivity = conshdlrdata->registerusesactivitysepabelow;
3424 ownerdata->enfos[ownerdata->nenfos]->sepaaboveusesactivity = conshdlrdata->registerusesactivitysepaabove;
3425 ownerdata->nenfos++;
3428 enforcemethods = enforcemethodsnew;
3431 conshdlrdata->indetect =
FALSE;
3438 SCIPerrorMessage(
"no nonlinear handler provided some of the required enforcement methods\n");
3442 assert(ownerdata->nenfos > 0);
3445 if( ownerdata->nenfos > 1 )
3446 SCIPsortDownPtr((
void**)ownerdata->enfos, enfodataCmp, ownerdata->nenfos);
3486 conshdlrdata->globalbounds =
TRUE;
3487 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
3490 for(
i = 0;
i < nconss; ++
i )
3512 if( ownerdata->nenfos > 0 )
3515 assert(ownerdata->nenfos < 0);
3523 conshdlrdata->indetect =
TRUE;
3528 conshdlrdata->indetect =
FALSE;
3540 if( ownerdata->nenfos >= 0 )
3550 if( ownerdata->nauxvaruses > 0 || ownerdata->nactivityusesprop > 0 || ownerdata->nactivityusessepa > 0 )
3554 assert(ownerdata->nenfos >= 0);
3563 ownerdata->nenfos = 0;
3569 consdata->ispropagated =
FALSE;
3578 conshdlrdata->globalbounds =
FALSE;
3579 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
3615 for(
c = 0;
c < nconss; ++
c )
3623 SCIP_Bool success =
FALSE;
3666 if( consdata->nlrow ==
NULL )
3705 SCIP_Bool rootactivityvalid;
3716 for(
c = 0;
c < nconss; ++
c )
3730 SCIPdebugMsg(
scip,
"exitsepa and free nonlinear handler data for expression %p\n", (
void*)expr);
3738 if( rootactivityvalid )
3749 if( consdata->nlrow !=
NULL )
3763 consdata->linvardecr =
NULL;
3764 consdata->linvarincr =
NULL;
3887 SCIP_Real minact = 0.0;
3888 SCIP_Real maxact = 0.0;
3889 SCIP_Bool integral =
TRUE;
3902 minact +=
MIN(coefs[
i], 0.0);
3903 maxact +=
MAX(coefs[
i], 0.0);
3906 assert(minact <= maxact);
3913#ifdef WITH_DEBUG_SOLUTION
3914 if( SCIPdebugIsMainscip(
scip) )
3916 SCIP_Real debugsolval;
3925 debugsolval += coefs[
i] * val;
3944 if( naddconss !=
NULL )
3955 if( naddconss !=
NULL )
3969 if( naddconss !=
NULL )
3982 if( naddconss !=
NULL )
4011 SCIP_Real* exprcoefs =
NULL;
4012 SCIP_Real* tmpcoefs =
NULL;
4013 SCIP_Real* sumcoefs;
4014 SCIP_Bool* isused =
NULL;
4015 int* childidxs =
NULL;
4040 if( nchildren < minterms )
4074 assert(xidx < ntotalvars);
4076 assert(yidx < ntotalvars);
4107 for( j = 0; j <
nterms; ++j )
4109 int childidx = childidxs[j];
4110 assert(childidx >= 0 && childidx < nchildren);
4112 if( !isused[childidx] && (xs[j] == facvar || ys[j] == facvar) )
4118 coef = sumcoefs[childidx];
4122 tmpvars[ntmpvars] = (xs[j] == facvar) ? ys[j] : xs[j];
4123 tmpcoefs[ntmpvars] = coef;
4128 assert(xidx < ntotalvars);
4130 assert(yidx < ntotalvars);
4133 assert(count[xidx] >= 0);
4134 assert(count[yidx] >= 0);
4137 isused[childidx] =
TRUE;
4140 assert(ntmpvars >= minterms);
4146 exprcoefs[nexprs] = 1.0;
4153 int nexprsold = nexprs;
4156 for(
i = 0;
i < nchildren; ++
i )
4161 exprcoefs[nexprs] = sumcoefs[
i];
4170 for(
i = 0;
i < nexprsold; ++
i )
4200 SCIP_Bool empathy4and
4226 strcpy(name,
"binreform");
4227 for(
i = 0;
i < nchildren; ++
i )
4232 (void) strcat(name,
"_");
4241#ifdef WITH_DEBUG_SOLUTION
4242 if( SCIPdebugIsMainscip(
scip) )
4244 SCIP_Real debugsolval;
4249 for(
i = 0;
i < nchildren; ++
i )
4261 if( nchildren == 2 && !empathy4and )
4291 if( naddconss !=
NULL )
4303 if( naddconss !=
NULL )
4361 SCIPdebugMsg(
scip,
" product expression %p has been considered for the first time\n", (
void*)prodexpr);
4363 if( nchildren == 2 )
4368 SCIP_Bool found_clique =
FALSE;
4389 if( nchgcoefs !=
NULL )
4392 found_clique =
TRUE;
4401 if( nchgcoefs !=
NULL )
4404 found_clique =
TRUE;
4421 if( nchgcoefs !=
NULL )
4424 found_clique =
TRUE;
4432 SCIP_Real sum_coefs[2];
4442 if( nchgcoefs !=
NULL )
4445 found_clique =
TRUE;
4512 if( conshdlrdata->reformbinprodsfac > 1 )
4518 if( newexpr ==
NULL )
4523 if( newexpr !=
NULL )
4525 assert(naddconss ==
NULL || *naddconss > 0 || nchgcoefs ==
NULL || *nchgcoefs > 0);
4534 consdata->issimplified =
FALSE;
4610 for(
c = 0;
c < nconss; ++
c )
4621 if( conshdlrdata->reformbinprodsfac > 1 )
4627 if( newexpr !=
NULL )
4630 consdata->expr = newexpr;
4633 consdata->issimplified =
FALSE;
4682 if( nchildren == 1 && constant == 0.0 && coefs[0] == -1.0 )
4685 expr = consdata->expr;
4693 consdata->lhs = -consdata->lhs;
4694 consdata->rhs = -consdata->rhs;
4702 for(
i = 0;
i < nchildren; ++
i )
4703 counter += coefs[
i] > 0 ? 1 : -1;
4708 SCIP_Real* newcoefs;
4713 for(
i = 0;
i < nchildren; ++
i )
4714 newcoefs[
i] = -coefs[
i];
4721 consdata->expr = expr;
4723 consdata->lhs = -consdata->lhs;
4724 consdata->rhs = -consdata->rhs;
4759 for(
c = 0;
c < nconss; ++
c )
4811 SCIP_Bool* infeasible,
4821 SCIP_Bool havechange;
4834 ++(conshdlrdata->ncanonicalizecalls);
4838 *infeasible =
FALSE;
4841 havechange = conshdlrdata->ncanonicalizecalls == 1;
4851 for(
i = 0;
i < nconss; ++
i )
4859 nlockspos[
i] = consdata->nlockspos;
4860 nlocksneg[
i] = consdata->nlocksneg;
4864 assert(consdata->nlockspos == 0);
4865 assert(consdata->nlocksneg == 0);
4870 for(
i = 0;
i < nconss; ++
i )
4895 int tmpnaddconss = 0;
4896 int tmpnchgcoefs = 0;
4904 if( naddconss !=
NULL )
4905 *naddconss = tmpnaddconss;
4906 if( nchgcoefs !=
NULL )
4907 *nchgcoefs = tmpnchgcoefs;
4910 if( tmpnaddconss + tmpnchgcoefs > 0 )
4914 for(
i = 0;
i < nconss; ++
i )
4920 if( !consdata->issimplified && consdata->expr !=
NULL )
4927 consdata->issimplified =
TRUE;
4935 if( simplified != consdata->expr )
4943 consdata->expr = simplified;
4978 if( ndelconss !=
NULL )
4987 if( havechange && !*infeasible )
4991 SCIP_Bool replacedroot;
4994 for(
i = 0;
i < nconss; ++
i )
5003 for(
i = 0;
i < nconss; ++
i )
5016 SCIPsortPtr((
void**)consssorted, compIndexConsNonlinear, nconss);
5018 for(
i = nconss-1;
i >= 0; --
i )
5020 assert(
i == 0 || compIndexConsNonlinear((
void*)consssorted[
i-1], (
void*)consssorted[
i]) < 0);
5027 for(
i = 0;
i < nconss; ++
i )
5046 for(
i = 0;
i < nconss; ++
i )
5060 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
5085 SCIP_Bool* updatelocks;
5103 for(
c = 0;
c < nconss; ++
c )
5125 assert(idx >= 0 && idx < nconss);
5129 assert(imgconsdata->expr == consdata->expr);
5131 SCIPdebugMsg(
scip,
"merge constraint %g <= %s <= %g with %g <= %s <= %g\n", consdata->lhs,
5138 nlockspos[idx] = imgconsdata->nlockspos;
5139 nlocksneg[idx] = imgconsdata->nlocksneg;
5141 updatelocks[idx] =
TRUE;
5145 imgconsdata->lhs =
MAX(imgconsdata->lhs, consdata->lhs);
5146 imgconsdata->rhs =
MIN(imgconsdata->rhs, consdata->rhs);
5157 for(
c = 0;
c < nconss; ++
c )
5159 if( updatelocks[
c] )
5193 if( conshdlrdata->globalbounds )
5279 ++conshdlrdata->curboundstag;
5280 assert(conshdlrdata->curboundstag > 0);
5281 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
5282 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
5283 conshdlrdata->intevalvar = intEvalVarRedundancyCheck;
5288 for(
i = 0;
i < nconss; ++
i )
5322 SCIP_Bool tightened;
5389 SCIPdebugMsg(
scip,
" -> redundant: activity [%g,%g] within sides [%g,%g]\n", activity.
inf, activity.
sup, consdata->lhs, consdata->rhs);
5397 SCIPdebugMsg(
scip,
" -> not redundant: activity [%g,%g] not within sides [%g,%g]\n", activity.
inf, activity.
sup, consdata->lhs, consdata->rhs);
5402 ++conshdlrdata->curboundstag;
5403 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
5404 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
5405 conshdlrdata->intevalvar = intEvalVarBoundTightening;
5416 SCIP_Bool* upgraded,
5444 if( conshdlrdata->nconsupgrades == 0 )
5458 for(
i = 0;
i < conshdlrdata->nconsupgrades; ++
i )
5460 if( !conshdlrdata->consupgrades[
i]->active )
5463 assert(conshdlrdata->consupgrades[
i]->consupgd !=
NULL);
5465 SCIP_CALL( conshdlrdata->consupgrades[
i]->consupgd(
scip, cons, consdata->nvarexprs, &nupgdconss_, upgdconss, upgdconsssize) );
5467 while( nupgdconss_ < 0 )
5470 assert(-nupgdconss_ > upgdconsssize);
5471 upgdconsssize = -nupgdconss_;
5474 SCIP_CALL( conshdlrdata->consupgrades[
i]->consupgd(
scip, cons, consdata->nvarexprs, &nupgdconss_, upgdconss, upgdconsssize) );
5476 assert(nupgdconss_ != 0);
5479 if( nupgdconss_ > 0 )
5487 for( j = 0; j < nupgdconss_; ++j )
5498 *naddconss += nupgdconss_ - 1;
5583 SCIP_Bool* infeasible
5590 SCIP_Bool hasbounddisj;
5593 int nsinglelocked = 0;
5604 *infeasible =
FALSE;
5628 for(
i = 0;
i < consdata->nvarexprs; ++
i )
5635 singlelocked[nsinglelocked++] = consdata->varexprs[
i];
5640 if( nsinglelocked > 0 )
5654 for(
i = 0;
i < nchildren; ++
i )
5659 child = children[
i];
5695 valid = exponent > 1.0 && fmod(exponent, 2.0) == 0.0;
5719 for(
i = 0;
i < nsinglelocked; ++
i )
5727 SCIP_Real bounds[2];
5733 SCIPdebugMsg(
scip,
"found single locked variable %s in [%g,%g] that can be fixed to one of its bounds\n",
5787 SCIP_Bool* infeasible
5798 *infeasible =
FALSE;
5808 for(
c = 0;
c < nconss; ++
c )
5815 SCIP_Real candcoef = 0.0;
5837 if( nchildren <= 1 )
5843 for(
i = 0;
i < nchildren; ++
i )
5848 candcoef = coefs[
i];
5865 for(
i = 0;
i < nchildren; ++
i )
5867 if( children[
i] == cand )
5888 SCIPdebugMsg(
scip,
"make variable <%s> implicit integer due to constraint <%s>\n",
5926 assert(ownerdata->nauxvaruses > 0);
5929 if( ownerdata->auxvar !=
NULL )
5944 assert(conshdlrdata->auxvarid >= 0);
5954 ++conshdlrdata->auxvarid;
6004#ifdef WITH_DEBUG_SOLUTION
6005 if( SCIPdebugIsMainscip(
scip) )
6038 SCIP_Bool* infeasible
6047 int nreductions = 0;
6060 ++conshdlrdata->curpropboundstag;
6066 *infeasible =
FALSE;
6067 for(
c = 0;
c < nconss; ++
c )
6076#ifdef WITH_DEBUG_SOLUTION
6077 if( SCIPdebugIsMainscip(
scip) )
6083 if( debugsol !=
NULL )
6105 if( auxvar !=
NULL )
6107 SCIPdebugMsg(
scip,
"tighten auxvar <%s> bounds using constraint sides [%g,%g]\n",
6140 for(
c = 0;
c < nconss && !*infeasible; ++
c )
6156 if( ownerdata->nauxvaruses == 0 )
6159 for( e = 0; e < ownerdata->nenfos; ++e )
6162 SCIP_Bool underestimate;
6163 SCIP_Bool overestimate;
6169 if( ownerdata->enfos[e]->issepainit )
6176 nlhdlr = ownerdata->enfos[e]->nlhdlr;
6184 overestimate = ownerdata->nlocksneg > 0;
6185 underestimate = ownerdata->nlockspos > 0;
6186 assert(underestimate || overestimate);
6188 SCIPdebugMsg(
scip,
"initsepa under=%u over=%u for expression %p\n", underestimate, overestimate, (
void*)expr);
6191 SCIP_CALL( SCIPnlhdlrInitsepa(
scip, conshdlr, conss[
c], nlhdlr, expr,
6192 ownerdata->enfos[e]->nlhdlrexprdata, overestimate, underestimate, infeasible) );
6193 ownerdata->enfos[e]->issepainit =
TRUE;
6244 switch( conshdlrdata->branchviolsplit )
6253 return MAX(0.05, weight);
6264 return 10.0*log10(width);
6266 return 0.1/(-log10(width));
6271 SCIPerrorMessage(
"invalid value for parameter constraints/expr/branching/violsplit");
6289 SCIP_Real violscore,
6297 SCIP_Real weightsum = 0.0;
6316 for(
i = 0;
i < nexprs; ++
i )
6328 for(
i = 0;
i < nexprs; ++
i )
6333 if( nunbounded > 0 )
6338 SCIPdebugMsg(
scip,
"add score %g (%g%% of %g) to <%s>[%g,%g]\n", violscore / nunbounded,
6339 100.0/nunbounded, violscore,
6350 SCIPdebugMsg(
scip,
"add score %g (%g%% of %g) to <%s>[%g,%g]\n", violscore * weight / weightsum,
6351 100*weight / weightsum, violscore,
6374 SCIP_Real violscore,
6393 SCIPsortPtr((
void**)auxvars, SCIPvarComp, nauxvars);
6404 if( auxvar ==
NULL )
6410 assert(auxvars[pos] == auxvar);
6413 exprs[nexprs++] = expr;
6415 if( nexprs == nauxvars )
6455 for(
c = 0;
c < nconss; ++
c )
6468 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6510 for(
c = 0;
c < nconss; ++
c )
6529 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6531 SCIP_Real violscore;
6539 if( violscore == 0.0 )
6572 SCIP_Real violscore;
6577 if( violscore == 0.0 )
6626 SCIP_Real maxrelconsviol,
6628 SCIP_Longint soltag,
6655 for( attempt = 0; attempt < 2; ++attempt )
6661 for(
c = 0;
c < nconss; ++
c )
6677 if( attempt == 0 && consviol < conshdlrdata->branchhighviolfactor * maxrelconsviol )
6679 else if( attempt == 1 && consviol >= conshdlrdata->branchhighviolfactor * maxrelconsviol )
6691 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6714 cands[*ncands].
expr = consdata->varexprs[
i];
6715 cands[*ncands].
var =
var;
6752 cands[*ncands].
expr = expr;
6753 cands[*ncands].
var =
var;
6809 SCIP_Real dualscore;
6839 for(
r = 0;
r < nrows; ++
r )
6841 SCIP_Real estimategap;
6842 const char* estimategapstr;
6856 if( estimategapstr ==
NULL )
6858 estimategap = atof(estimategapstr + 13);
6859 assert(estimategap >= 0.0);
6900 SCIP_Bool considerfracnl,
6919 for(
c = 0;
c < ncands; ++
c )
6921 if( conshdlrdata->branchviolweight > 0.0 )
6932 assert(cands[
c].expr !=
NULL || cands[
c].fractionality > 0.0);
6934 if( considerfracnl && cands[
c].fractionality == 0.0 )
6953 if( conshdlrdata->branchdomainweight > 0.0 && cands[
c].
expr !=
NULL )
6955 SCIP_Real domainwidth;
6968 if( domainwidth >= 1.0 )
6978 if( conshdlrdata->branchdualweight > 0.0 && cands[
c].
expr !=
NULL )
6989 cands[
c].
dual = 0.0;
6998 if( cands[
c].expr !=
NULL )
7005 SCIP_Real pscostdown;
7014 strategy = conshdlrdata->branchpscostupdatestrategy;
7092 SCIP_Real pscostdown;
7129 if( conshdlrdata->branchvartypeweight > 0.0 )
7153 for(
c = 0;
c < ncands; ++
c )
7155 SCIP_Real weightsum;
7159 cands[
c].weighted = 0.0;
7165 weightsum += conshdlrdata->branchviolweight;
7173 weightsum += conshdlrdata->branchfracweight;
7178 if( maxscore.
domain > 0.0 )
7181 weightsum += conshdlrdata->branchdomainweight;
7186 if( maxscore.
dual > 0.0 )
7189 weightsum += conshdlrdata->branchdualweight;
7194 if( maxscore.
pscost > 0.0 )
7200 weightsum += conshdlrdata->branchpscostweight;
7214 weightsum += conshdlrdata->branchvartypeweight;
7236 if( cands[ind1].weighted != cands[ind2].weighted )
7239 if( cands[ind1].
var != cands[ind2].
var )
7242 return cands[ind1].
expr !=
NULL ? 1 : -1;
7252 SCIP_Bool considerfracnl,
7262 SCIP_Real threshold;
7284 SCIPsortDown(perm, branchcandCompare, (
void*)cands, ncands);
7288 SCIPvarGetName(cands[perm[ncands - 1]].
var), cands[perm[ncands - 1]].weighted); )
7293 threshold = conshdlrdata->branchhighscorefactor * cands[perm[0]].
weighted;
7294 while( left < right )
7296 int mid = (left + right) / 2;
7297 if( cands[perm[mid]].weighted >= threshold )
7306 if( cands[perm[left]].weighted >= threshold )
7308 assert(left + 1 == ncands || cands[perm[left + 1]].weighted < threshold);
7313 assert(cands[perm[left]].weighted < threshold);
7319 ENFOLOG(
SCIPinfoMessage(
scip, enfologfile,
" %d branching candidates <%s>(%g)...<%s>(%g) after removing low scores\n", ncands,
7321 SCIPvarGetName(cands[perm[ncands - 1]].
var), cands[perm[ncands - 1]].weighted); )
7326 if( conshdlrdata->branchrandnumgen ==
NULL )
7331 *selected = &cands[perm[
c]];
7334 *selected = &cands[perm[0]];
7348 SCIP_Real maxrelconsviol,
7350 SCIP_Longint soltag,
7370 if( conshdlrdata->branchexternal )
7404 if( downchild !=
NULL || eqchild !=
NULL || upchild !=
NULL )
7433 SCIP_Bool overestimate,
7434 SCIP_Bool separated,
7435 SCIP_Bool allowweakcuts,
7436 SCIP_Bool inenforcement,
7437 SCIP_Bool branchcandonly,
7444 SCIP_CALL( SCIPnlhdlrEnfo(
scip, conshdlr, cons, nlhdlr, expr, nlhdlrexprdata,
sol, auxvalue, overestimate,
7445 allowweakcuts, separated, inenforcement, branchcandonly,
result) );
7465 SCIP_Bool sepasuccess =
FALSE;
7466 SCIP_Bool branchscoresuccess =
FALSE;
7478 SCIP_CALL( SCIPnlhdlrEstimate(
scip, conshdlr, nlhdlr, expr, nlhdlrexprdata,
sol, auxvalue, overestimate,
7479 SCIPgetSolVal(
scip,
sol, auxvar), inenforcement, rowpreps, &sepasuccess, &branchscoresuccess) );
7484 assert((sepasuccess && minidx <= maxidx) || (!sepasuccess && minidx > maxidx));
7492 for(
r = minidx;
r <= maxidx; ++
r )
7499 if( !branchcandonly )
7508 auxvalue, allowweakcuts, branchscoresuccess, inenforcement,
sol,
result) );
7514 if( branchcandonly && branchscoresuccess )
7537 SCIP_Longint soltag,
7538 SCIP_Bool allowweakcuts,
7539 SCIP_Bool inenforcement,
7540 SCIP_Bool branchcandonly,
7547 SCIP_Bool underestimate;
7548 SCIP_Bool overestimate;
7550 SCIP_Bool auxunderestimate;
7551 SCIP_Bool auxoverestimate;
7575 if( !overestimate && !underestimate )
7581 for( e = 0; e < ownerdata->nenfos; ++e )
7590 if( branchcandonly && !ownerdata->enfos[e]->sepaaboveusesactivity && !ownerdata->enfos[e]->sepabelowusesactivity )
7593 nlhdlr = ownerdata->enfos[e]->nlhdlr;
7597 SCIP_CALL( SCIPnlhdlrEvalaux(
scip, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, &ownerdata->enfos[e]->auxvalue,
sol) );
7601 SCIPinfoMessage(
scip, enfologfile,
" (%p): evalvalue %.15g auxvarvalue %.15g [%.15g,%.15g], nlhdlr <%s> " \
7618 if( !
SCIPisInfinity(
scip, auxviol) && auxviol < conshdlrdata->enfoauxviolfactor * origviol )
7621 "auxviolation %g << origviolation %g under:%d over:%d\n",
SCIPnlhdlrGetName(nlhdlr), (
void*)expr,
7633 underestimate, overestimate); )
7641 auxviol, origviol, underestimate, overestimate, allowweakcuts); )
7646 if( overestimate && auxoverestimate && (ownerdata->enfos[e]->nlhdlrparticipation &
SCIP_NLHDLR_METHOD_SEPAABOVE) != 0 && (!branchcandonly || ownerdata->enfos[e]->sepaaboveusesactivity) )
7651 ownerdata->enfos[e]->auxvalue,
TRUE, *
result ==
SCIP_SEPARATED, allowweakcuts, inenforcement, branchcandonly, &hdlrresult) );
7657 ownerdata->lastenforced = conshdlrdata->enforound;
7665 ownerdata->lastenforced = conshdlrdata->enforound;
7674 ownerdata->lastenforced = conshdlrdata->enforound;
7687 ownerdata->lastenforced = conshdlrdata->enforound;
7694 if( underestimate && auxunderestimate && (ownerdata->enfos[e]->nlhdlrparticipation &
SCIP_NLHDLR_METHOD_SEPABELOW) != 0 && (!branchcandonly || ownerdata->enfos[e]->sepabelowusesactivity) )
7699 ownerdata->enfos[e]->auxvalue,
FALSE, *
result ==
SCIP_SEPARATED, allowweakcuts, inenforcement, branchcandonly, &hdlrresult) );
7705 ownerdata->lastenforced = conshdlrdata->enforound;
7713 ownerdata->lastenforced = conshdlrdata->enforound;
7722 ownerdata->lastenforced = conshdlrdata->enforound;
7735 ownerdata->lastenforced = conshdlrdata->enforound;
7750 SCIP_Longint soltag,
7752 SCIP_Bool allowweakcuts,
7753 SCIP_Bool inenforcement,
7754 SCIP_Bool branchcandonly,
7778 if( inenforcement && !branchcandonly && !consdata->ispropagated )
7788 SCIP_Bool infeasible;
7798 if( ntightenings > 0 )
7811 if( ownerdata->auxvar ==
NULL )
7814 assert(ownerdata->lastenforced <= conshdlrdata->enforound);
7815 if( ownerdata->lastenforced == conshdlrdata->enforound )
7830 if( ownerdata->lastenforced == conshdlrdata->enforound )
7871 SCIP_Longint soltag,
7872 SCIP_Bool inenforcement,
7873 SCIP_Bool branchcandonly,
7874 SCIP_Real maxrelconsviol,
7880 SCIP_Bool consenforced;
7894 ++(conshdlrdata->enforound);
7901 for(
c = 0;
c < nconss; ++
c )
7927 for(
i = 0;
i < consdata->nvarexprs; ++
i )
7936 SCIP_CALL(
enforceConstraint(
scip, conshdlr, conss[
c],
sol, soltag, it,
FALSE, inenforcement, branchcandonly,
result, &consenforced) );
7941 if( !consenforced && inenforcement && !branchcandonly )
7946 if( viol > conshdlrdata->weakcutminviolfactor * maxrelconsviol )
7951 SCIP_CALL(
enforceConstraint(
scip, conshdlr, conss[
c],
sol, soltag, it,
TRUE, inenforcement, branchcandonly,
result, &consenforced) );
7954 ++conshdlrdata->nweaksepa;
7964 ENFOLOG(
if( enfologfile !=
NULL ) fflush( enfologfile); )
7981 ENFOLOG(
if( enfologfile !=
NULL ) fflush( enfologfile); )
8001 SCIP_Longint soltag,
8002 SCIP_Real maxrelconsviol,
8003 SCIP_Bool* branchintegral,
8023 *branchintegral =
FALSE;
8034 *branchintegral =
TRUE;
8045 SCIPerrorMessage(
"Unexpected separation or propagation from enforceConstraints(branchcandonly = TRUE)\n");
8057 SCIPerrorMessage(
"Unexpected return from enforceConstraints(branchcandonly = TRUE)\n");
8092 *branchintegral =
TRUE;
8134 SCIP_Bool isfractional =
FALSE;
8150 isfractional =
TRUE;
8162 if( conshdlrdata->branchmixfractional == 0.0 )
8188 SCIP_Longint soltag,
8189 SCIP_Real* maxabsconsviol,
8190 SCIP_Real* maxrelconsviol,
8191 SCIP_Real* minauxviol,
8192 SCIP_Real* maxauxviol,
8193 SCIP_Real* maxvarboundviol
8211 *maxabsconsviol = 0.0;
8212 *maxrelconsviol = 0.0;
8215 *maxvarboundviol = 0.0;
8217 for(
c = 0;
c < nconss; ++
c )
8230 *maxabsconsviol =
MAX(*maxabsconsviol, v);
8237 *maxrelconsviol =
MAX(*maxrelconsviol, v);
8242 SCIP_Real auxvarvalue;
8245 SCIP_Bool violunder;
8254 if( ownerdata->auxvar ==
NULL )
8267 origviol = auxvarlb - auxvarvalue;
8269 origviol = auxvarvalue - auxvarub;
8270 if( origviol <= 0.0 )
8273 *maxvarboundviol =
MAX(*maxvarboundviol, origviol);
8294 *maxvarboundviol = auxvarlb - auxvarvalue;
8295 else if( auxvarvalue - auxvarub > *maxvarboundviol && !
SCIPisInfinity(
scip, auxvarub) )
8296 *maxvarboundviol = auxvarvalue - auxvarub;
8301 if( origviol > 0.0 || auxvarlb > auxvarvalue || auxvarub < auxvarvalue )
8308 if( origviol > 0.0 )
8309 SCIPinfoMessage(
scip, enfologfile,
" auxvar %s expr violated by %g", violunder ?
">=" :
"<=", origviol);
8311 SCIPinfoMessage(
scip, enfologfile,
" auxvar >= auxvar's lb violated by %g", auxvarlb - auxvarvalue);
8313 SCIPinfoMessage(
scip, enfologfile,
" auxvar <= auxvar's ub violated by %g", auxvarvalue - auxvarub);
8319 if( origviol == 0.0 )
8323 for( e = 0; e < ownerdata->nenfos; ++e )
8331 nlhdlr = ownerdata->enfos[e]->nlhdlr;
8335 SCIP_CALL( SCIPnlhdlrEvalaux(
scip, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, &ownerdata->enfos[e]->auxvalue,
sol) );
8344 *maxauxviol =
MAX(*maxauxviol, auxviol);
8345 *minauxviol =
MIN(*minauxviol, auxviol);
8369 SCIP_Real maxabsconsviol;
8370 SCIP_Real maxrelconsviol;
8371 SCIP_Real minauxviol;
8372 SCIP_Real maxauxviol;
8373 SCIP_Real maxvarboundviol;
8374 SCIP_Longint soltag;
8375 SCIP_Bool branchintegral;
8392 for(
c = 0;
c < nconss; ++
c )
8408 &minauxviol, &maxauxviol, &maxvarboundviol) );
8411 "auxviolations in %g..%g, variable bounds violated by at most %g, LP feastol=%e\n",
8428 if( branchintegral )
8437 if( conshdlrdata->propinenforce )
8458 ++conshdlrdata->ntightenlp;
8474 ++conshdlrdata->ntightenlp;
8504 ++conshdlrdata->ntightenlp;
8526 ++conshdlrdata->ndesperatetightenlp;
8536 if( !conshdlrdata->propinenforce )
8558 ++conshdlrdata->ndesperatebranch;
8573 ENFOLOG(
SCIPinfoMessage(
scip, enfologfile,
" enforcement with max. violation %g failed; cutting off node\n", maxabsconsviol); )
8578 ++conshdlrdata->ndesperatecutoff;
8594 SCIP_Longint soltag;
8595 SCIP_Bool haveviol =
FALSE;
8603 for(
c = 0;
c < nconss; ++
c )
8643 idx = ((int)(size_t)elem) - 1;
8644 assert(idx >= 0 && idx < conshdlrdata->nbilinterms);
8646 return (
void*)&conshdlrdata->bilinterms[idx];
8664 return entry1->
x == entry2->
x && entry1->
y == entry2->
y;
8699 for(
i = 0;
i < 3; ++
i )
8702 return auxexpr1->
coefs[
i] < auxexpr2->
coefs[
i] ? -1 : 1;
8705 return auxexpr1->
cst < auxexpr2->
cst ? -1 : auxexpr1->
cst == auxexpr2->
cst ? 0 : 1;
8737 if( term->
nauxexprs >= conshdlrdata->bilinmaxnauxexprs )
8784 if( conshdlrdata->bilinterms !=
NULL )
8793 for(
c = 0;
c < nconss; ++
c )
8874 assert(conshdlrdata->bilinterms[*idx].x ==
x);
8875 assert(conshdlrdata->bilinterms[*idx].y ==
y);
8878 term = &conshdlrdata->bilinterms[*idx];
8879 assert(existing <= term->existing);
8888 *idx = conshdlrdata->nbilinterms;
8891 term = &conshdlrdata->bilinterms[*idx];
8906 ++(conshdlrdata->nbilinterms);
8909 if( conshdlrdata->bilinhashtable ==
NULL )
8912 bilinearTermsGetHashkey, bilinearTermsIsHashkeyEq, bilinearTermsGetHashkeyVal,
8913 (
void*)conshdlrdata) );
8915 assert(conshdlrdata->bilinhashtable !=
NULL);
8943 if( conshdlrdata->bilinterms ==
NULL )
8946 assert(conshdlrdata->nbilinterms == 0);
8947 assert(conshdlrdata->bilintermssize == 0);
8953 for(
i = 0;
i < conshdlrdata->nbilinterms; ++
i )
8958 for( j = 0; j < conshdlrdata->bilinterms[
i].nauxexprs; ++j )
8960 if( conshdlrdata->bilinterms[
i].aux.exprs[j]->auxvar !=
NULL )
8967 if( conshdlrdata->bilinterms[
i].nauxexprs > 0 )
8976 if( conshdlrdata->bilinterms[
i].aux.var !=
NULL )
8983 if( conshdlrdata->bilinhashtable !=
NULL )
8990 conshdlrdata->nbilinterms = 0;
8991 conshdlrdata->bilintermssize = 0;
9025 SCIPdebugMsg(
scip,
"Building LP for computing facets of convex envelope of vertex-polyhedral function\n");
9030 nrows = (
unsigned int)
nvars + 1;
9032 nnonz = (ncols * (nrows + 1)) / 2;
9043 for(
i = 0, k = 0;
i < ncols; ++
i )
9077 ind[k] = (int)nrows - 1;
9088 (
int)ncols,
obj, lb, ub,
NULL,
9089 (
int)nrows, lb, lb,
NULL,
9090 (
int)nnonz, beg, ind, val) );
9093 ind[0] = (int)nrows - 1;
9115 SCIP_Bool overestimate,
9121 SCIP_Real* facetcoefs,
9122 SCIP_Real facetconstant
9130 unsigned int ncorners;
9143 facetval = facetconstant;
9144 for(
i = 0;
i < (
unsigned int) nallvars; ++
i )
9145 facetval += facetcoefs[
i] * box[2*
i];
9148 funval = funvals[0];
9150 error = funval - facetval;
9152 error = facetval - funval;
9155 maxerror =
MAX(error, maxerror);
9158 for(
i = 1;
i < ncorners; ++
i )
9165 gray =
i ^ (
i >> 1);
9170 while( (diff >>= 1) != 0 )
9174 origpos = nonfixedpos[pos];
9177 facetval += facetcoefs[origpos] * (box[2*origpos+1] - box[2*origpos]);
9179 facetval -= facetcoefs[origpos] * (box[2*origpos+1] - box[2*origpos]);
9182 funval = funvals[gray];
9184 error = funval - facetval;
9186 error = facetval - funval;
9189 maxerror =
MAX(error, maxerror);
9204 SCIP_Bool overestimate,
9211 SCIP_Real targetvalue,
9213 SCIP_Real* facetcoefs,
9214 SCIP_Real* facetconstant
9224 SCIP_Real facetvalue;
9225 SCIP_Real mindomwidth;
9245 if( conshdlrdata->vp_randnumgen ==
NULL && conshdlrdata->vp_maxperturb > 0.0 )
9251 if( conshdlrdata->vp_lp[
nvars] ==
NULL )
9255 lp = conshdlrdata->vp_lp[
nvars];
9273 for(
i = 0;
i < ncols; ++
i )
9278 for(
i = 0;
i < nrows-1; ++
i )
9287 varpos = nonfixedpos[
i];
9288 lb = box[2 * varpos];
9289 ub = box[2 * varpos + 1];
9290 solval = xstar[varpos];
9292 if( ub - lb < mindomwidth )
9293 mindomwidth = ub - lb;
9298 else if( solval >= ub )
9301 aux[
i] = (solval - lb) / (ub - lb);
9304 if( conshdlrdata->vp_maxperturb > 0.0 )
9309 aux[
i] -=
SCIPrandomGetReal(conshdlrdata->vp_randnumgen, 0.0, conshdlrdata->vp_maxperturb);
9310 else if( aux[
i] == 0.0 )
9311 aux[
i] +=
SCIPrandomGetReal(conshdlrdata->vp_randnumgen, 0.0, conshdlrdata->vp_maxperturb);
9314 SCIP_Real perturbation;
9316 perturbation =
MIN( aux[
i], 1.0 - aux[
i] ) / 2.0;
9317 perturbation =
MIN( perturbation, conshdlrdata->vp_maxperturb );
9318 aux[
i] +=
SCIPrandomGetReal(conshdlrdata->vp_randnumgen, -perturbation, perturbation);
9320 assert(0.0 < aux[
i] && aux[
i] < 1.0);
9353 if( conshdlrdata->vp_dualsimplex )
9381 facetcoefs[nonfixedpos[
i]] = aux[
i];
9383 *facetconstant = aux[nrows - 1];
9387 for(
i = 0;
i < nallvars; ++
i )
9407 varpos = nonfixedpos[
i];
9408 lb = box[2 * varpos];
9409 ub = box[2 * varpos + 1];
9413 facetcoefs[varpos] = facetcoefs[varpos] / (ub - lb);
9416 *facetconstant -= facetcoefs[varpos] * lb;
9419 facetvalue += facetcoefs[varpos] * xstar[varpos];
9426 facetvalue += *facetconstant;
9435 if( overestimate == (facetvalue > targetvalue) )
9437 SCIPdebugMsg(
scip,
"missed the target, facetvalue %g targetvalue %g, overestimate=%u\n", facetvalue, targetvalue, overestimate);
9464 SCIP_Real* facetcoef,
9465 SCIP_Real* facetconstant
9478 *facetcoef = (funright - funleft) / (right - left);
9479 *facetconstant = funleft - *facetcoef * left;
9516 *
alpha = -b3*c2 + a3*(-b2+c2) + a2*(b3-c3) + b2*c3;
9517 *beta = -(-b3*c1 + a3*(-b1+c1) + a1*(b3-c3) + b1*c3);
9518 *gamma_ = -a2*b1 + a1*b2 + a2*c1 - b2*c1 - a1*c2 + b1*c2;
9519 *delta = -a3*b2*c1 + a2*b3*c1 + a3*b1*c2 - a1*b3*c2 - a2*b1*c3 + a1*b2*c3;
9566 SCIPdebugMsg(
scip,
"numerical troubles - try to solve the linear system via an LU factorization\n");
9606 SCIP_Bool overestimate,
9616 SCIP_Real targetvalue,
9618 SCIP_Real* facetcoefs,
9619 SCIP_Real* facetconstant
9622 SCIP_Real
alpha, beta, gamma_, delta;
9623 SCIP_Real xstarval, candxstarval = 0.0;
9644 targetvalue = -targetvalue;
9661 for( leaveout = 1; leaveout <= 4; ++leaveout )
9667 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p2[0], p2[1], p2val, p3[0], p3[1], p3val, p4[0], p4[1], p4val,
9668 &
alpha, &beta, &gamma_, &delta) );
9670 if(
alpha * p1[0] + beta * p1[1] + gamma_ * p1val - delta > 0.0 )
9676 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p1[0], p1[1], p1val, p3[0], p3[1], p3val, p4[0], p4[1], p4val,
9677 &
alpha, &beta, &gamma_, &delta) );
9679 if(
alpha * p2[0] + beta * p2[1] + gamma_ * p2val - delta > 0.0 )
9685 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p1[0], p1[1], p1val, p2[0], p2[1], p2val, p4[0], p4[1], p4val,
9686 &
alpha, &beta, &gamma_, &delta) );
9688 if(
alpha * p3[0] + beta * p3[1] + gamma_ * p3val - delta > 0.0 )
9694 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p1[0], p1[1], p1val, p2[0], p2[1], p2val, p3[0], p3[1], p3val,
9695 &
alpha, &beta, &gamma_, &delta) );
9697 if(
alpha * p4[0] + beta * p4[1] + gamma_ * p4val - delta > 0.0 )
9722 xstarval = -
alpha/gamma_ * xstar[0] -beta/gamma_ * xstar[1] + delta/gamma_;
9725 if( xstarval <= targetvalue && (!*success || xstarval < candxstarval) )
9731 facetcoefs[0] = -
alpha/gamma_;
9732 facetcoefs[1] = -beta/gamma_;
9733 *facetconstant = delta/gamma_;
9736 candxstarval = xstarval;
9758 if( nelems > *maxnelems )
9763 assert(newsize >= nelems);
9767 *maxnelems = newsize;
9788 if( nelems > *maxnelems )
9793 assert(newsize > *maxnelems);
9798 *maxnelems = newsize;
9816 SCIP_Bool hasparentcoef,
9817 SCIP_Real parentcoef,
9819 SCIP_Real** consvals,
9829 SCIP_Real val1 = 0.0;
9830 SCIP_Real val2 = 0.0;
9850 assert(*maxnconsvars > 0);
9858 if( nchildren != 2 )
9868 for( childidx = 0; childidx < 2; ++childidx )
9871 (*consvals)[0] = 1.0;
9888 var1 = (*consvars)[0];
9889 val1 = (*consvals)[0];
9893 var2 = (*consvars)[0];
9894 val2 = (*consvals)[0];
9923 prodval = coef * val1 * val2;
9954 SCIP_Bool* hasvalue,
10007 safeexponent = (int) (exponent + 0.5);
10008 if( safeexponent % 2 != 0 )
10057 SCIP_Bool hasparentcoef,
10058 SCIP_Real parentcoef,
10059 SCIP_Bool hassymval,
10062 SCIP_Real** consvals,
10068 SCIP_Real constant;
10069 SCIP_Real edgeweight;
10091 (*consvars)[0] =
var;
10092 (*consvals)[0] = 1.0;
10108 var = (*consvars)[0];
10109 edgeweight = (*consvals)[0];
10120 TRUE, edgeweight) );
10122 TRUE, edgeweight) );
10142 SCIP_Bool hasparentcoef,
10143 SCIP_Real parentcoef,
10144 SCIP_Bool hassymval,
10147 SCIP_Real** consvals,
10154 SCIP_Real constant;
10182 for(
i = 0;
i < nlocvars; ++
i)
10202 var = (*consvars)[0];
10206 if( nlocvars == 2 )
10208 var = (*consvars)[1];
10231 if( nlocvars == 1 )
10233 var = (*consvars)[0];
10234 weight = (*consvals)[0];
10255 for(
i = 0;
i < 2; ++
i)
10257 var = (*consvars)[
i];
10258 weight =
ABS((*consvals)[
i]);
10283 SCIP_Bool hasparentcoef,
10284 SCIP_Real parentcoef,
10286 SCIP_Real** consvals,
10293 SCIP_Real val = 0.0;
10294 SCIP_Bool hasval =
FALSE;
10303 assert(*maxnconsvars > 0);
10327 hasval, val, consvars, consvals, maxnconsvars, success) );
10332 hasval, val, consvars, consvals, maxnconsvars, handledexprs, success) );
10385 return (ub + lb) / 2;
10397 SCIP_Real** consvals,
10413 SCIP_Real* sumcoefs;
10414 SCIP_Real constant;
10415 SCIP_Real constant2;
10418 SCIP_Bool* powexprused =
NULL;
10419 int* powperm =
NULL;
10420 int* prodperm =
NULL;
10431 int nprodexprs = 0;
10441 assert(*maxnconsvars > 0);
10455 for(
i = 0;
i < nchildren; ++
i )
10459 SCIP_Real exponent;
10467 else if( !
SCIPisEQ(
scip, (SCIP_Real) powcoef, sumcoefs[
i]) )
10491 powexprs[npowexprs] = children[
i];
10492 powvars[npowexprs++] =
var;
10503 else if( !
SCIPisEQ(
scip, (SCIP_Real) 2 * powcoef, -sumcoefs[
i]) )
10520 prodexprs[nprodexprs] = children[
i];
10521 prodvars[nprodexprs++] =
var;
10522 prodexprs[nprodexprs] = children[
i];
10523 prodvars[nprodexprs++] = var2;
10528 if( npowexprs == 0 || nprodexprs != npowexprs )
10535 SCIPsort(powperm, SCIPsortVarPtr, (
void*) powvars, npowexprs);
10536 SCIPsort(prodperm, SCIPsortVarPtr, (
void*) prodvars, npowexprs);
10538 for(
i = 0;
i < npowexprs; ++
i )
10545 assert(npowexprs % 2 == 0);
10553 SCIP_Bool var1found =
FALSE;
10554 SCIP_Bool var2found =
FALSE;
10556 (*consvals)[0] = 1.0;
10557 (*consvars)[0] = prodvars[cnt++];
10564 if( nlocvars != 1 )
10569 actvar = (*consvars)[0];
10570 val = (*consvals)[0];
10572 (*consvals)[0] = 1.0;
10573 (*consvars)[0] = prodvars[cnt++];
10580 if( nlocvars != 1 )
10582 actvar2 = (*consvars)[0];
10583 val2 = (*consvals)[0];
10616 for( j = 0; j < npowexprs && !(var1found && var2found); ++j )
10618 if( powexprused[j] )
10622 if( !var1found && powvars[j] == prodvars[cnt - 2] )
10625 powexprused[j] =
TRUE;
10628 else if( !var2found && powvars[j] == prodvars[cnt - 1] )
10631 powexprused[j] =
TRUE;
10664 SCIP_Real* consvals;
10665 SCIP_Real constant;
10666 SCIP_Real parentcoef = 0.0;
10677 SCIP_Bool iscolored;
10678 SCIP_Bool hasparentcoef;
10750 if( expr == rootexpr )
10751 parentidx = consnodeidx;
10755 parentidx = openidx[nopenidx - 1];
10759 hasparentcoef =
FALSE;
10760 if ( expr != rootexpr )
10771 openidx[nopenidx++] = -1;
10773 assert(maxnconsvars > 0);
10777 if( hasparentcoef )
10782 parentidx = nodeidx;
10802 parentidx = thisidx;
10805 nconsvars, constant) );
10818 openidx[nopenidx++] = -1;
10822 SCIP_Bool usedefaultgadget =
TRUE;
10824 assert(expr == rootexpr || parentidx > 0);
10836 usedefaultgadget =
FALSE;
10875 &consvars, &consvals, &maxnconsvars, handledexprs) );
10879 openidx[nopenidx++] = sumidx;
10886 parentcoef, &consvars, &consvals, &maxnconsvars, handledexprs, &succ) );
10890 usedefaultgadget =
FALSE;
10900 &consvars, &consvals, &maxnconsvars, handledexprs, &succ) );
10904 usedefaultgadget =
FALSE;
10909 if( usedefaultgadget )
10939 openidx[nopenidx++] = opidx;
10977 assert(targetconshdlr != conshdlr);
10983 for(
i = 0;
i < sourceconshdlrdata->nnlhdlrs; ++
i )
10985 SCIP_CALL( SCIPnlhdlrCopyhdlr(
scip, targetconshdlr, conshdlr, sourceconshdlrdata->nlhdlrs[
i]) );
11004 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11010 conshdlrdata->nlhdlrssize = 0;
11013 for(
i = 0;
i < conshdlrdata->nconsupgrades; ++
i )
11024 if( conshdlrdata->vp_randnumgen !=
NULL )
11030 if( conshdlrdata->vp_lp[
i] !=
NULL )
11036 assert(conshdlrdata->branchrandnumgen ==
NULL);
11059 conshdlrdata->lastboundrelax = ++conshdlrdata->curboundstag;
11061 conshdlrdata->enforound = 1;
11063 conshdlrdata->auxvarid = 0;
11065 for(
i = 0;
i < nconss; ++
i )
11072 if( conshdlrdata->nnlhdlrs > 1 )
11073 SCIPsortDownPtr((
void**)conshdlrdata->nlhdlrs, SCIPnlhdlrComp, conshdlrdata->nnlhdlrs);
11080 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11086 conshdlrdata->nweaksepa = 0;
11087 conshdlrdata->ntightenlp = 0;
11088 conshdlrdata->ndesperatebranch = 0;
11089 conshdlrdata->ndesperatecutoff = 0;
11090 conshdlrdata->ndesperatetightenlp = 0;
11091 conshdlrdata->nforcelp = 0;
11093 conshdlrdata->ncanonicalizecalls = 0;
11096 ENFOLOG( enfologfile = fopen(ENFOLOGFILE,
"w"); )
11118 SCIPsortDownPtr((
void**)consssorted, compIndexConsNonlinear, nconss);
11120 for(
i = 0;
i < nconss; ++
i )
11129 conshdlrdata->subnlpheur =
NULL;
11130 conshdlrdata->trysolheur =
NULL;
11132 if( conshdlrdata->vp_randnumgen !=
NULL )
11138 if( conshdlrdata->vp_lp[
i] !=
NULL )
11144 if( conshdlrdata->branchrandnumgen !=
NULL )
11148 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11154 if( enfologfile !=
NULL )
11156 fclose(enfologfile);
11157 enfologfile =
NULL;
11165#ifdef SCIP_DISABLED_CODE
11169 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11175#define consInitpreNonlinear NULL
11183 SCIP_Bool infeasible;
11234 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11240 if( conshdlrdata->branchpscostweight > 0.0 )
11243 if( strchr(
"lds", conshdlrdata->branchpscostupdatestrategy) ==
NULL )
11245 SCIPerrorMessage(
"branching/lpgainnormalize strategy %c unknown\n", conshdlrdata->branchpscostupdatestrategy);
11270 conshdlrdata->checkedvarlocks =
FALSE;
11273 if( conshdlrdata->newsoleventfilterpos >= 0 )
11281 conshdlrdata->newsoleventfilterpos = -1;
11297 assert((*consdata)->nlockspos == 0);
11298 assert((*consdata)->nlocksneg == 0);
11306 if( (*consdata)->nlrow !=
NULL )
11333 targetexpr, sourcedata->lhs, sourcedata->rhs,
FALSE,
11363 if( conshdlrdata->linearizeheursol !=
'o' && conshdlrdata->newsoleventfilterpos == -1 )
11371 eventhdlr, (
SCIP_EVENTDATA*)conshdlr, &conshdlrdata->newsoleventfilterpos) );
11430 SCIP_Longint soltag;
11438 for(
c = 0;
c < nconss; ++
c )
11465 SCIPdebugMsg(
scip,
"registered %d external branching candidates\n", nnotify);
11470 SCIPdebugMsg(
scip,
"could not find branching candidates, forcing to solve LP\n");
11485 SCIP_Bool maypropfeasible;
11486 SCIP_Longint soltag;
11504 maypropfeasible =
FALSE;
11507 for(
c = 0;
c < nconss; ++
c )
11535 else if( (conshdlrdata->subnlpheur ==
NULL ||
sol ==
NULL) && !maypropfeasible && !completely )
11543 maypropfeasible =
FALSE;
11545 if( maypropfeasible )
11552 if( !(consdata->linvarincr !=
NULL && consdata->linvarincrcoef > 0.0) &&
11553 !(consdata->linvardecr !=
NULL && consdata->linvardecrcoef < 0.0) )
11554 maypropfeasible =
FALSE;
11562 if( !(consdata->linvarincr !=
NULL && consdata->linvarincrcoef < 0.0) &&
11563 !(consdata->linvardecr !=
NULL && consdata->linvardecrcoef > 0.0) )
11564 maypropfeasible =
FALSE;
11610 SCIP_Bool infeasible;
11670 for(
c = 0;
c < nconss; ++
c )
11672 SCIP_Bool upgraded;
11696 && !conshdlrdata->checkedvarlocks && conshdlrdata->checkvarlocks !=
'd' )
11701 conshdlrdata->checkedvarlocks =
TRUE;
11703 for(
c = 0;
c < nconss; ++
c )
11705 int tmpnchgvartypes = 0;
11706 int tmpnaddconss = 0;
11709 SCIPdebugMsg(
scip,
"presolSingleLockedVars() for %s: nchgvartypes=%d naddconss=%d infeas=%u\n",
11719 (*nchgvartypes) += tmpnchgvartypes;
11720 (*naddconss) += tmpnaddconss;
11724 if( *ndelconss > 0 || *nchgbds > 0 || *nupgdconss > 0 || *naddconss > 0 || *nchgvartypes > 0 )
11734#ifdef SCIP_DISABLED_CODE
11738 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11744#define consRespropNonlinear NULL
11754 SCIP_Bool reinitsolve =
FALSE;
11769 if( ownerdata->nenfos >= 0 )
11771 if( (consdata->nlockspos == 0) != (nlockspos == 0) )
11772 reinitsolve =
TRUE;
11773 if( (consdata->nlocksneg == 0) != (nlocksneg == 0) )
11774 reinitsolve =
TRUE;
11799 SCIP_Bool infeasible =
FALSE;
11807 SCIP_Bool replacedroot;
11809 if( !consdata->issimplified )
11818 consdata->expr = simplified;
11819 consdata->issimplified =
TRUE;
11850 if( hashmapexpr !=
NULL && hashmapexpr != child )
11868 assert(consdata->nlockspos == 0);
11869 assert(consdata->nlocksneg == 0);
11955#ifdef SCIP_DISABLED_CODE
11959 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11965#define consDelvarsNonlinear NULL
12018 SCIP_CALL(
SCIPcopyExpr(sourcescip,
scip, sourcedata->expr, &targetexpr, exprownerCreate, (
void*)targetconshdlr, varmap, consmap, global,
valid) );
12020 if( targetexpr ==
NULL )
12028 targetexpr, sourcedata->lhs, sourcedata->rhs,
FALSE,
12029 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12032 if( targetexpr !=
NULL )
12065 endptr = (
char*)str;
12074 if( isdigit((
unsigned char)str[0]) || ((str[0] ==
'-' || str[0] ==
'+') && isdigit((
unsigned char)str[1])) )
12086 if( endptr[0] !=
'<' || endptr[1] !=
'=' )
12110 if( strncmp(str,
"[free]", 6) == 0 )
12164 consexprtree, lhs, rhs,
FALSE,
12165 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12190 if( varssize < consdata->nvarexprs )
12196 for(
i = 0;
i < consdata->nvarexprs; ++
i )
12219 *
nvars = consdata->nvarexprs;
12226#ifdef SCIP_DISABLED_CODE
12230 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
12236#define consGetDiveBdChgsNonlinear NULL
12271 SCIPinfoMessage(
scip, file,
"Nonlinear Conshdlr : %10s %10s %10s %10s %10s %10s %10s\n",
"WeakSepa",
"TightenLP",
"DespTghtLP",
"DespBranch",
"DespCutoff",
"ForceLP",
"CanonTime");
12331 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
12365 conshdlrdata->intevalvar = intEvalVarBoundTightening;
12366 conshdlrdata->curboundstag = 1;
12367 conshdlrdata->lastboundrelax = 1;
12368 conshdlrdata->curpropboundstag = 1;
12369 conshdlrdata->newsoleventfilterpos = -1;
12380 conshdlrCopyNonlinear,
12381 consFreeNonlinear, consInitNonlinear, consExitNonlinear,
12383 consDeleteNonlinear, consTransNonlinear, consInitlpNonlinear,
12384 consSepalpNonlinear, consSepasolNonlinear, consEnfolpNonlinear, consEnforelaxNonlinear, consEnfopsNonlinear, consCheckNonlinear,
12386 consActiveNonlinear, consDeactiveNonlinear,
12388 consPrintNonlinear, consCopyNonlinear, consParseNonlinear,
12390 consGetSignedPermsymGraphNonlinear, conshdlrdata) );
12395 "limit on number of propagation rounds for a set of constraints within one round of SCIP propagation",
12396 &conshdlrdata->maxproprounds,
FALSE, 10, 0, INT_MAX,
NULL,
NULL) );
12399 "whether to check bounds of all auxiliary variable to seed reverse propagation",
12403 "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",
12404 &conshdlrdata->varboundrelax,
TRUE,
'r',
"nabr",
NULL,
NULL) );
12407 "by how much to relax variable bounds during bound tightening if strategy 'a', 'b', or 'r'",
12411 "by how much to relax constraint sides during bound tightening",
12415 "maximal relative perturbation of reference point when computing facet of envelope of vertex-polyhedral function (dim>2)",
12419 "adjust computed facet of envelope of vertex-polyhedral function up to a violation of this value times LP feasibility tolerance",
12423 "whether to use dual simplex instead of primal simplex for LP that computes facet of vertex-polyhedral function",
12427 "maximal number of auxiliary expressions per bilinear term",
12431 "whether to reformulate products of binary variables during presolving",
12435 "whether to use the AND constraint handler for reformulating binary products",
12439 "minimum number of terms to reformulate bilinear binary products by factorizing variables (<= 1: disabled)",
12440 &conshdlrdata->reformbinprodsfac,
FALSE, 50, 1, INT_MAX,
NULL,
NULL) );
12443 "whether to forbid multiaggregation of nonlinear variables",
12447 "whether to tighten LP feasibility tolerance during enforcement, if it seems useful",
12451 "whether to (re)run propagation in enforcement",
12455 "threshold for when to regard a cut from an estimator as weak (lower values allow more weak cuts)",
12456 &conshdlrdata->weakcutthreshold,
TRUE, 0.2, 0.0, 1.0,
NULL,
NULL) );
12459 "\"strong\" cuts will be scaled to have their maximal coef in [1/strongcutmaxcoef,strongcutmaxcoef]",
12463 "consider efficacy requirement when deciding whether a cut is \"strong\"",
12467 "whether to force \"strong\" cuts in enforcement",
12471 "an expression will be enforced if the \"auxiliary\" violation is at least this factor times the \"original\" violation",
12472 &conshdlrdata->enfoauxviolfactor,
TRUE, 0.01, 0.0, 1.0,
NULL,
NULL) );
12475 "retry enfo of constraint with weak cuts if violation is least this factor of maximal violated constraints",
12476 &conshdlrdata->weakcutminviolfactor,
TRUE, 0.5, 0.0, 2.0,
NULL,
NULL) );
12479 "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",
12480 &conshdlrdata->rownotremovable,
TRUE,
'o',
"oea",
NULL,
NULL) );
12483 "method how to scale violations to make them comparable (not used for feasibility check): (n)one, (a)ctivity and side, norm of (g)radient",
12484 &conshdlrdata->violscale,
TRUE,
'n',
"nag",
NULL,
NULL) );
12487 "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)",
12488 &conshdlrdata->checkvarlocks,
TRUE,
't',
"bdt",
NULL,
NULL) );
12491 "from which depth on in the tree to allow branching on auxiliary variables (variables added for extended formulation)",
12492 &conshdlrdata->branchauxmindepth,
FALSE, INT_MAX, 0, INT_MAX,
NULL,
NULL) );
12495 "whether to use external branching candidates and branching rules for branching",
12499 "consider a constraint highly violated if its violation is >= this factor * maximal violation among all constraints",
12500 &conshdlrdata->branchhighviolfactor,
FALSE, 0.0, 0.0, 1.0,
NULL,
NULL) );
12503 "consider a variable branching score high if its branching score >= this factor * maximal branching score among all variables",
12504 &conshdlrdata->branchhighscorefactor,
FALSE, 0.9, 0.0, 1.0,
NULL,
NULL) );
12507 "weight by how much to consider the violation assigned to a variable for its branching score",
12511 "weight by how much to consider fractionality of integer variables in branching score for spatial branching",
12515 "weight by how much to consider the dual values of rows that contain a variable for its branching score",
12519 "weight by how much to consider the pseudo cost of a variable for its branching score",
12523 "weight by how much to consider the domain width in branching score",
12527 "weight by how much to consider variable type (continuous: 0, binary: 1, integer: 0.1, impl-integer: 0.01) in branching score",
12531 "how to aggregate several branching scores given for the same expression: 'a'verage, 'm'aximum, 's'um",
12532 &conshdlrdata->branchscoreagg,
FALSE,
's',
"ams",
NULL,
NULL) );
12535 "method used to split violation in expression onto variables: 'u'niform, 'm'idness of solution, 'd'omain width, 'l'ogarithmic domain width",
12536 &conshdlrdata->branchviolsplit,
FALSE,
'm',
"umdl",
NULL,
NULL) );
12539 "minimum pseudo-cost update count required to consider pseudo-costs reliable",
12543 "minimal average pseudo cost count for discrete variables at which to start considering spatial branching before branching on fractional integer variables",
12547 "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)",
12548 &conshdlrdata->linearizeheursol,
FALSE,
'o',
"oie",
NULL,
NULL) );
12551 "whether to assume that any constraint is convex",
12556 "signals a bound change to a nonlinear constraint", processVarEvent,
NULL) );
12586 processNewSolutionEvent,
NULL) );
12597 const char* conshdlrname
12612 if( conshdlr ==
NULL )
12622 for(
i = conshdlrdata->nconsupgrades - 1;
i >= 0; --
i )
12624 if( conshdlrdata->consupgrades[
i]->consupgd == nlconsupgd )
12627 SCIPwarningMessage(
scip,
"Try to add already known upgrade method for constraint handler <%s>.\n", conshdlrname);
12635 consupgrade->consupgd = nlconsupgd;
12641 assert(conshdlrdata->nconsupgrades+1 <= conshdlrdata->consupgradessize);
12643 for(
i = conshdlrdata->nconsupgrades;
i > 0 && conshdlrdata->consupgrades[
i-1]->priority < consupgrade->
priority; --
i )
12644 conshdlrdata->consupgrades[
i] = conshdlrdata->consupgrades[
i-1];
12646 conshdlrdata->consupgrades[
i] = consupgrade;
12647 conshdlrdata->nconsupgrades++;
12672 SCIP_Bool separate,
12682 SCIP_Bool modifiable,
12688 SCIP_Bool removable
12697 if( conshdlr ==
NULL )
12705 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12743 SCIP_Real* lincoefs,
12747 SCIP_Real* quadcoefs,
12752 SCIP_Bool separate,
12762 SCIP_Bool modifiable,
12768 SCIP_Bool removable
12776 assert(nquadterms == 0 || (quadvars1 !=
NULL && quadvars2 !=
NULL && quadcoefs !=
NULL));
12780 if( conshdlr ==
NULL )
12787 SCIP_CALL(
SCIPcreateExprQuadratic(
scip, &expr, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, exprownerCreate, (
void*)conshdlr) );
12792 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12814 SCIP_Real* lincoefs,
12818 SCIP_Real* quadcoefs,
12823 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs,
12842 SCIP_Real* offsets,
12843 SCIP_Real constant,
12845 SCIP_Real rhscoeff,
12846 SCIP_Real rhsoffset
12852 SCIP_Real termcoefs[2];
12864 if( offsets !=
NULL && offsets[
i] != 0.0 )
12883 termcoefs[0] = 1.0;
12886 termcoefs[1] = -rhscoeff;
12912 SCIP_Real exponent,
12921 SCIP_Real coefs[2];
12928 if( xoffset != 0.0 )
12966 return conshdlrdata->curboundstag;
12979 return conshdlrdata->lastboundrelax;
12990 SCIP_Bool boundrelax
12998 ++conshdlrdata->curboundstag;
12999 assert(conshdlrdata->curboundstag > 0);
13002 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
13022 SCIP_Bool overestimate,
13024 SCIP_Real auxvalue,
13025 SCIP_Bool allowweakcuts,
13026 SCIP_Bool branchscoresuccess,
13027 SCIP_Bool inenforcement,
13035 SCIP_Bool sepasuccess;
13037 SCIP_Real mincutviolation;
13055 sepasuccess =
TRUE;
13058 if( cutviol > 0.0 )
13079 if( (!overestimate && ( cutviol <= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) ||
13080 ( overestimate && (-cutviol >= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) )
13083 "weak: auxvarvalue %g estimateval %g auxvalue %g (over %d)\n",
13085 auxvarvalue + (overestimate ? -cutviol : cutviol), auxvalue, overestimate); )
13086 sepasuccess =
FALSE;
13091 estimateval = auxvarvalue + (!overestimate ? cutviol : -cutviol);
13095 sepasuccess =
FALSE;
13104 "estimateval %g auxvalue %g (over %d)\n ",
SCIPnlhdlrGetName(nlhdlr), auxvarvalue,
13105 auxvarvalue + (overestimate ? -cutviol : cutviol), auxvalue, overestimate);
13111 if( !allowweakcuts )
13123 "min requ viol = %g\n", cutviol, sepasuccess ?
"" :
"not ", mincutviolation); )
13125 sepasuccess = cutviol > mincutviolation;
13134 SCIP_Real auxvarcoef = 0.0;
13149 if( auxvarcoef == 0.0 ||
13150 (!overestimate && ( cutviol / auxvarcoef <= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) ||
13151 ( overestimate && (-cutviol / auxvarcoef >= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) )
13153 ENFOLOG(
SCIPinfoMessage(
scip, enfologfile,
" cut is too weak after cleanup: auxvarvalue %g estimateval %g auxvalue %g (over %d)\n",
13154 auxvarvalue, auxvarvalue + (overestimate ? -cutviol : cutviol) / auxvarcoef, auxvalue, overestimate); )
13155 sepasuccess =
FALSE;
13166 if( !branchscoresuccess )
13182 SCIP_Real violscore;
13184#ifdef BRSCORE_ABSVIOL
13209 if( conshdlrdata->branchdualweight > 0.0 )
13220 (void) sprintf(gap,
"_estimategap=%g",
REALABS(auxvalue - estimateval));
13238 SCIP_Bool infeasible;
13246 SCIP_CALL(
SCIPaddRow(
scip, row, conshdlrdata->forcestrongcut && !allowweakcuts && inenforcement, &infeasible) );
13249 if( conshdlrdata->rownotremovable ==
'a' || (conshdlrdata->rownotremovable ==
'e' && inenforcement) )
13266 else if( branchscoresuccess )
13279 "branching candidates%s\n",
SCIPnlhdlrGetName(nlhdlr), (allowweakcuts && inenforcement) ?
13298 return conshdlrdata->assumeconvex;
13336 return conshdlrdata->nbilinterms;
13355 return conshdlrdata->bilinterms;
13380 if( conshdlrdata->bilinhashtable ==
NULL )
13396 assert(idx >= -1 && idx < conshdlrdata->nbilinterms);
13397 assert(idx < 0 || conshdlrdata->bilinterms[idx].
x ==
x);
13398 assert(idx < 0 || conshdlrdata->bilinterms[idx].
y ==
y);
13425 assert(idx >= -1 && idx < conshdlrdata->nbilinterms);
13429 return &conshdlrdata->bilinterms[idx];
13476 term = &conshdlrdata->bilinterms[idx];
13482 if( auxvar !=
NULL )
13502 SCIP_Bool overestimate
13518 nlockspos = overestimate ? 1 : 0;
13519 nlocksneg = overestimate ? 0 : 1;
13523 term = &conshdlrdata->bilinterms[idx];
13534 if( conshdlrdata->bilinmaxnauxexprs <= 1 )
13538 auxvarexpr->
cst = 0.0;
13539 auxvarexpr->
coefs[0] = 1.0;
13540 auxvarexpr->
coefs[1] = 0.0;
13541 auxvarexpr->
coefs[2] = 0.0;
13559 auxexpr->
auxvar = auxvar;
13560 auxexpr->
coefs[0] = coefaux;
13564 auxexpr->
coefs[1] = coefx;
13565 auxexpr->
coefs[2] = coefy;
13571 auxexpr->
coefs[1] = coefy;
13572 auxexpr->
coefs[2] = coefx;
13574 auxexpr->
cst = cst;
13581 else if( auxvar !=
NULL )
13593 SCIP_Bool overestimate,
13599 SCIP_Real targetvalue,
13600 SCIP_Bool* success,
13601 SCIP_Real* facetcoefs,
13602 SCIP_Real* facetconstant
13606 SCIP_Real* funvals;
13608 SCIP_Real maxfaceterror;
13610 unsigned int ncorners;
13628 for( j = 0; j < nallvars; ++j )
13632 nonfixedpos[
nvars] = j;
13650 for( j = 0; j < nallvars; ++j )
13653 corner[j] = (box[2 * j] + box[2 * j + 1]) / 2.0;
13655 for(
i = 0;
i < ncorners; ++
i )
13658 for( j = 0; j <
nvars; ++j )
13660 int varpos = nonfixedpos[j];
13664 if( (
i >> j) & 0x1 )
13665 corner[varpos] = box[2 * varpos + 1];
13667 corner[varpos] = box[2 * varpos ];
13672 funvals[
i] = function(corner, nallvars, fundata);
13678 SCIPdebugMsg(
scip,
"cannot compute underestimator; function value at corner is too large %g\n", funvals[
i]);
13691 if( *success && overestimate == (*facetconstant + facetcoefs[nonfixedpos[0]] * xstar[nonfixedpos[0]] > targetvalue) )
13693 SCIPdebugMsg(
scip,
"computed secant, but missed target %g (facetvalue=%g, overestimate=%u)\n", targetvalue, *facetconstant + facetcoefs[nonfixedpos[0]] * xstar[nonfixedpos[0]], overestimate);
13699 int idx1 = nonfixedpos[0];
13700 int idx2 = nonfixedpos[1];
13701 SCIP_Real p1[2] = { box[2*idx1], box[2*idx2] };
13702 SCIP_Real p2[2] = { box[2*idx1+1], box[2*idx2] };
13703 SCIP_Real p3[2] = { box[2*idx1], box[2*idx2+1] };
13704 SCIP_Real p4[2] = { box[2*idx1+1], box[2*idx2+1] };
13705 SCIP_Real xstar2[2] = { xstar[idx1], xstar[idx2] };
13706 SCIP_Real coefs[2] = { 0.0, 0.0 };
13708 SCIP_CALL(
computeVertexPolyhedralFacetBivariate(
scip, overestimate, p1, p2, p3, p4, funvals[0], funvals[1], funvals[2], funvals[3], xstar2, targetvalue, success, coefs, facetconstant) );
13710 facetcoefs[idx1] = coefs[0];
13711 facetcoefs[idx2] = coefs[1];
13715 SCIP_CALL(
computeVertexPolyhedralFacetLP(
scip, conshdlr, overestimate, xstar, box, nallvars, nonfixedpos, funvals,
nvars, targetvalue, success, facetcoefs, facetconstant) );
13730 if( maxfaceterror > 0.0 )
13739 for( j = 0; j <
nvars; ++j )
13740 corner[nonfixedpos[j]] = (box[2 * nonfixedpos[j]] + box[2 * nonfixedpos[j] + 1]) / 2.0;
13741 midval = function(corner, nallvars, fundata);
13749 if( maxfaceterror > conshdlrdata->vp_adjfacetthreshold * feastol * fabs(midval) )
13751 SCIPdebugMsg(
scip,
"ignoring facet due to instability, it cuts off a vertex by %g (midval=%g).\n", maxfaceterror, midval);
13756 SCIPdebugMsg(
scip,
"maximum facet error %g (midval=%g), adjust constant to make cut valid!\n", maxfaceterror, midval);
13759 *facetconstant += maxfaceterror;
13761 *facetconstant -= maxfaceterror;
13793 return consdata->expr;
13809 return consdata->lhs;
13825 return consdata->rhs;
13844 if( consdata->nlrow ==
NULL )
13849 *nlrow = consdata->nlrow;
13870 return consdata->curv;
13882 SCIP_Bool* isquadratic
13924 SCIPerrorMessage(
"SCIPchgLhsNonlinear can only be called in problem stage.\n");
13934 if( consdata->lhs == lhs )
13937 consdata->lhs = lhs;
13940 consdata->ispropagated =
FALSE;
13963 SCIPerrorMessage(
"SCIPchgLhsNonlinear can only be called in problem stage.\n");
13973 if( consdata->rhs == rhs )
13976 consdata->rhs = rhs;
13979 consdata->ispropagated =
FALSE;
14003 SCIPerrorMessage(
"SCIPchgExprNonlinear can only be called in problem stage.\n");
14021 assert(consdata->nvarexprs == 0);
14023 assert(!consdata->catchedevents);
14032 consdata->issimplified =
FALSE;
14033 consdata->ispropagated =
FALSE;
14058 SCIPerrorMessage(
"SCIPaddLinearVarNonlinear can only be called in problem stage.\n");
14079 assert(consdata->nvarexprs == 0);
14081 assert(!consdata->catchedevents);
14093 SCIP_EXPR* children[2] = { consdata->expr, varexpr };
14094 SCIP_Real coefs[2] = { 1.0, coef };
14105 consdata->issimplified =
FALSE;
14106 consdata->ispropagated =
FALSE;
14131 SCIPerrorMessage(
"SCIPaddExprNonlinear can only be called in problem stage.\n");
14168 SCIP_EXPR* children[2] = { consdata->expr, exprowned };
14169 SCIP_Real coefs[2] = { 1.0, coef };
14180 consdata->issimplified =
FALSE;
14181 consdata->ispropagated =
FALSE;
14195 SCIP_Real* activity
14277 *
var = consdata->linvardecr;
14278 *coef = consdata->linvardecrcoef;
14301 *
var = consdata->linvarincr;
14302 *coef = consdata->linvarincrcoef;
14347 return ownerdata->filterpos >= -1 ?
SCIPgetVarExprVar(expr) : ownerdata->auxvar;
14368 SCIP_Bool* sepabelowusesactivity,
14369 SCIP_Bool* sepaaboveusesactivity,
14370 SCIP_Real* auxvalue
14380 assert(idx < ownerdata->nenfos);
14384 *nlhdlr = ownerdata->enfos[idx]->nlhdlr;
14386 if( nlhdlrexprdata !=
NULL )
14387 *nlhdlrexprdata = ownerdata->enfos[idx]->nlhdlrexprdata;
14389 if( nlhdlrparticipation !=
NULL )
14390 *nlhdlrparticipation = ownerdata->enfos[idx]->nlhdlrparticipation;
14392 if( sepabelowusesactivity !=
NULL )
14393 *sepabelowusesactivity = ownerdata->enfos[idx]->sepabelowusesactivity;
14395 if( sepaaboveusesactivity !=
NULL )
14396 *sepaaboveusesactivity = ownerdata->enfos[idx]->sepaaboveusesactivity;
14398 if( auxvalue !=
NULL )
14399 *auxvalue = ownerdata->enfos[idx]->auxvalue;
14417 assert(idx < ownerdata->nenfos);
14420 ownerdata->enfos[idx]->auxvalue = auxvalue;
14481 SCIP_Bool useauxvar,
14482 SCIP_Bool useactivityforprop,
14483 SCIP_Bool useactivityforsepabelow,
14484 SCIP_Bool useactivityforsepaabove
14498 if( ownerdata->nenfos >= 0 &&
14499 ( (ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && (useactivityforprop || useactivityforsepabelow || useactivityforsepaabove)) ||
14500 (ownerdata->nauxvaruses == 0 && useauxvar)
14512 ++ownerdata->nauxvaruses;
14514 if( useactivityforprop )
14515 ++ownerdata->nactivityusesprop;
14517 if( useactivityforsepabelow || useactivityforsepaabove )
14518 ++ownerdata->nactivityusessepa;
14523 if( useactivityforsepabelow )
14525 if( useactivityforsepaabove )
14528 if( useactivityforprop )
14572 SCIP_Longint soltag,
14574 SCIP_Bool* violunder,
14575 SCIP_Bool* violover
14606 SCIP_Real auxvalue,
14609 SCIP_Bool* violunder,
14610 SCIP_Bool* violover
14638 SCIP_Real auxvalue,
14641 SCIP_Bool* violunder,
14642 SCIP_Bool* violover
14692 if( ownerdata->propboundstag == conshdlrdata->curpropboundstag )
14694 bounds = ownerdata->propbounds;
14707 if( ownerdata->auxvar !=
NULL )
14712 auxvarbounds = conshdlrdata->intevalvar(
scip, ownerdata->auxvar, conshdlrdata);
14795 if( ownerdata->propboundstag == conshdlrdata->curpropboundstag )
14808 SCIPdebugMsg(
scip,
" applied %s: [%.20g,%.20g]\n", ownerdata->propboundstag == conshdlrdata->curpropboundstag ?
"previous propbounds" :
"activity", newbounds.
inf, newbounds.
sup);
14814 SCIPdebugMsg(
scip,
" cut off due to empty intersection with previous propbounds or activity\n");
14826 ownerdata->propbounds = newbounds;
14827 ownerdata->propboundstag = conshdlrdata->curpropboundstag;
14841 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);
14846 if(
SCIPexprGetNChildren(expr) > 0 && !ownerdata->inpropqueue && (ownerdata->nactivityusesprop > 0 || ownerdata->nactivityusessepa > 0 || ownerdata->nenfos < 0) )
14855 ownerdata->inpropqueue =
TRUE;
14902 for(
c = 0;
c < ownerdata->nconss; ++
c )
14906 consdata->ispropagated =
FALSE;
14929 SCIP_Real violscore
14937 assert(violscore >= 0.0);
14951 if( ownerdata->violscoretag != conshdlrdata->enforound )
14953 ownerdata->violscoresum = violscore;
14954 ownerdata->violscoremax = violscore;
14955 ownerdata->nviolscores = 1;
14956 ownerdata->violscoretag = conshdlrdata->enforound;
14960 ownerdata->violscoresum += violscore;
14961 if( violscore > ownerdata->violscoremax )
14962 ownerdata->violscoremax = violscore;
14963 ++ownerdata->nviolscores;
14976 SCIP_Real violscore,
15012 for(
i = 0;
i < nexprs; ++
i )
15021 if( varssize ==
nvars )
15028 varexprs[
nvars++] = e;
15058 if( conshdlrdata->enforound != ownerdata->violscoretag )
15061 if( ownerdata->nviolscores == 0 )
15064 switch( conshdlrdata->branchscoreagg )
15068 return ownerdata->violscoresum / ownerdata->nviolscores;
15072 return ownerdata->violscoremax;
15076 return ownerdata->violscoresum;
15079 SCIPerrorMessage(
"Invalid value %c for branchscoreagg parameter\n", conshdlrdata->branchscoreagg);
15187 SCIP_Real auxvalue;
15189 SCIP_Real* lincoefs;
15201 for(
i = 0;
i < nlinexprs; ++
i )
15208 for(
i = 0;
i < nquadexprs; ++
i )
15220 auxvalue += (lincoef + sqrcoef * solval) * solval;
15224 for(
i = 0;
i < nbilinexprs; ++
i )
15250 int detectpriority,
15266 if( conshdlr ==
NULL )
15281 conshdlrdata->nlhdlrs[conshdlrdata->nnlhdlrs] = *nlhdlr;
15282 ++conshdlrdata->nnlhdlrs;
15288 SCIPsortDownPtr((
void**)conshdlrdata->nlhdlrs, SCIPnlhdlrComp, conshdlrdata->nnlhdlrs);
15305 return conshdlrdata->nnlhdlrs;
15320 return conshdlrdata->nlhdlrs;
15338 for(
h = 0;
h < conshdlrdata->nnlhdlrs; ++
h )
15340 return conshdlrdata->nlhdlrs[
h];
15363 for( e = 0; e < ownerdata->nenfos; ++e )
15364 if( ownerdata->enfos[e]->nlhdlr == nlhdlr )
15365 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 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_Bool branchcandonly, SCIP_RESULT *result, SCIP_Bool *success)
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 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_Bool branchcandonly, SCIP_RESULT *result)
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 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)
static void scoreBranchingCandidates(SCIP *scip, SCIP_CONSHDLR *conshdlr, BRANCHCAND *cands, int ncands, SCIP_Bool considerfracnl, SCIP_SOL *sol)
#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 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)
#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)
#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 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_Bool branchcandonly, SCIP_RESULT *result)
static SCIP_RETCODE selectBranchingCandidate(SCIP *scip, SCIP_CONSHDLR *conshdlr, BRANCHCAND *cands, int ncands, SCIP_Bool considerfracnl, SCIP_SOL *sol, BRANCHCAND **selected)
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 enforceConstraints(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_Bool inenforcement, SCIP_Bool branchcandonly, SCIP_Real maxrelconsviol, SCIP_RESULT *result)
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 SCIP_RETCODE branchingIntegralOrNonlinear(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_Longint soltag, SCIP_Real maxrelconsviol, SCIP_Bool *branchintegral, SCIP_Bool *cutoff)
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_Bool branchingIntegralFirst(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol)
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 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 SCIPdebugGetSolVal(scip, var, val)
#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)
SCIP_RETCODE SCIPgetExprActivityNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Real *activity)
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_RETCODE SCIPgetLPBranchCands(SCIP *scip, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)
int SCIPgetNLPBranchCands(SCIP *scip)
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_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)
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_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
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_Real SCIPfeasFloor(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_Bool SCIPisFeasIntegral(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)
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)
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
SCIP_CONSNONLINEAR_AUXEXPR ** exprs
union SCIP_ConsNonlinear_BilinTerm::@055261256347130033265073212045155110332303333345 aux
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