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);
818 for(
i = 0;
i < consdata->nvarexprs; ++
i )
827 consdata->varexprs =
NULL;
828 consdata->nvarexprs = 0;
852 if( conshdlrdata->globalbounds )
875 switch( conshdlrdata->varboundrelax )
889 SCIP_Real bnd = floor(lb);
890 lb =
MAX(bnd, lb - conshdlrdata->varboundrelaxamount);
896 SCIP_Real bnd = ceil(ub);
897 ub =
MIN(bnd, ub + conshdlrdata->varboundrelaxamount);
910 lb -= conshdlrdata->varboundrelaxamount;
913 ub += conshdlrdata->varboundrelaxamount;
930 SCIP_Real bnd = floor(lb);
936 SCIP_Real bnd = ceil(ub);
945 SCIPerrorMessage(
"Unsupported value '%c' for varboundrelax option.\n", conshdlrdata->varboundrelax);
974 return consdata1->consindex - consdata2->consindex;
984 SCIP_Bool boundtightened =
FALSE;
1001 assert(ownerdata->nconss > 0);
1005 boundtightened =
TRUE;
1014 boundtightened =
TRUE;
1024 boundtightened =
TRUE;
1031 if( boundtightened )
1036 for(
c = 0;
c < ownerdata->nconss; ++
c )
1046 consdata->ispropagated =
FALSE;
1052 consdata->issimplified =
FALSE;
1068 ++conshdlrdata->curboundstag;
1069 assert(conshdlrdata->curboundstag > 0);
1073 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
1078 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &activity, conshdlrdata->intevalvar, conshdlrdata) );
1116 for(
i = 0;
i < ownerdata->nconss; ++
i )
1117 assert(ownerdata->conss[
i] != cons);
1123 ownerdata->conss[ownerdata->nconss++] = cons;
1127 if( ownerdata->nconss <= 1 )
1128 ownerdata->consssorted =
TRUE;
1129 else if( ownerdata->consssorted )
1130 ownerdata->consssorted = compIndexConsNonlinear(ownerdata->conss[ownerdata->nconss-2], ownerdata->conss[ownerdata->nconss-1]) > 0;
1133 if( ownerdata->filterpos < 0 )
1137 assert(ownerdata->nconss == 1);
1142 assert(ownerdata->filterpos >= 0);
1167 assert(consdata->nvarexprs >= 0);
1170 if( consdata->catchedevents )
1176 assert(conshdlrdata->intevalvar == intEvalVarBoundTightening);
1181 for(
i = 0;
i < consdata->nvarexprs; ++
i )
1183 expr = consdata->varexprs[
i];
1196 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &activity, intEvalVarBoundTightening, conshdlrdata) );
1205 consdata->catchedevents =
TRUE;
1233 assert(ownerdata->nconss > 0);
1235 if( ownerdata->conss[ownerdata->nconss-1] == cons )
1237 pos = ownerdata->nconss-1;
1241 if( !ownerdata->consssorted )
1243 SCIPsortPtr((
void**)ownerdata->conss, compIndexConsNonlinear, ownerdata->nconss);
1244 ownerdata->consssorted =
TRUE;
1247 if( !
SCIPsortedvecFindPtr((
void**)ownerdata->conss, compIndexConsNonlinear, cons, ownerdata->nconss, &pos) )
1252 assert(pos >= 0 && pos < ownerdata->nconss);
1254 assert(ownerdata->conss[pos] == cons);
1257 if( pos < ownerdata->nconss-1 )
1259 ownerdata->conss[pos] = ownerdata->conss[ownerdata->nconss-1];
1260 ownerdata->consssorted =
FALSE;
1262 --ownerdata->nconss;
1265 if( ownerdata->nconss == 0 )
1269 assert(ownerdata->filterpos >= 0);
1274 ownerdata->filterpos = -1;
1298 if( !consdata->catchedevents )
1302 assert(consdata->nvarexprs >= 0);
1306 for(
i = consdata->nvarexprs - 1;
i >= 0; --
i )
1313 consdata->catchedevents =
FALSE;
1344 SCIP_Bool modifiable,
1365 SCIPerrorMessage(
"Locally valid nonlinear constraints are not supported, yet.\n");
1372 SCIPerrorMessage(
"Non-initial nonlinear constraints are not supported, yet.\n");
1386 consdata->expr = expr;
1389 consdata->lhs = lhs;
1390 consdata->rhs = rhs;
1391 consdata->consindex = conshdlrdata->lastconsindex++;
1395 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
1396 local, modifiable, dynamic, removable,
FALSE) );
1418 SCIP_Bool* violunder,
1423 SCIP_Real auxvarvalue;
1433 if( violunder !=
NULL )
1435 if( violover !=
NULL )
1444 if( violunder !=
NULL )
1446 if( violover !=
NULL )
1453 if( violunder !=
NULL )
1455 if( violover !=
NULL )
1460 if( violunder !=
NULL )
1462 if( violover !=
NULL )
1485 SCIP_Bool* violunder,
1490 SCIP_Real auxvarvalue;
1500 if( violunder !=
NULL )
1502 if( violover !=
NULL )
1509 if( ownerdata->nlocksneg > 0 && auxvarvalue > auxvalue )
1511 if( violunder !=
NULL )
1513 if( violover !=
NULL )
1515 return auxvarvalue - auxvalue;
1518 if( ownerdata->nlockspos > 0 && auxvalue > auxvarvalue )
1520 if( violunder !=
NULL )
1522 if( violover !=
NULL )
1524 return auxvalue - auxvarvalue;
1527 if( violunder !=
NULL )
1529 if( violover !=
NULL )
1587 return MAX3(0.0, consdata->lhsviol, consdata->rhsviol);
1619 if( conshdlrdata->violscale ==
'n' )
1628 if( conshdlrdata->violscale ==
'a' )
1633 if( consdata->lhsviol > 0.0 &&
REALABS(consdata->lhs) > scale )
1636 scale =
REALABS(consdata->lhs);
1638 else if( consdata->rhsviol > 0.0 &&
REALABS(consdata->rhs) > scale )
1641 scale =
REALABS(consdata->rhs);
1649 assert(conshdlrdata->violscale ==
'g');
1650 if( soltag == 0L || consdata->gradnormsoltag != soltag )
1656 consdata->gradnorm = 0.0;
1665 for(
i = 0;
i < consdata->nvarexprs; ++
i )
1674 consdata->gradnorm = 0.0;
1678 consdata->gradnorm += deriv*deriv;
1681 consdata->gradnorm = sqrt(consdata->gradnorm);
1682 consdata->gradnormsoltag = soltag;
1685 *viol /=
MAX(1.0, consdata->gradnorm);
1720 consdata->linvarincr =
NULL;
1721 consdata->linvardecr =
NULL;
1722 consdata->linvarincrcoef = 0.0;
1723 consdata->linvardecrcoef = 0.0;
1759 if( (consdata->linvardecr ==
NULL) ||
1762 consdata->linvardecr =
var;
1763 consdata->linvardecrcoef = coef;
1772 if( (consdata->linvarincr ==
NULL) ||
1775 consdata->linvarincr =
var;
1776 consdata->linvarincrcoef = coef;
1782 assert(consdata->linvarincr ==
NULL || consdata->linvarincrcoef != 0.0);
1783 assert(consdata->linvardecr ==
NULL || consdata->linvardecrcoef != 0.0);
1785 if( consdata->linvarincr !=
NULL )
1789 if( consdata->linvardecr !=
NULL )
1837 SCIPdebugMsg(
scip,
"attempt to make solution from <%s> feasible by shifting linear variable\n",
1840 for(
c = 0;
c < nconss; ++
c )
1843 SCIP_Real viol = 0.0;
1851 viol = consdata->lhsviol;
1853 viol = -consdata->rhsviol;
1857 if( consdata->linvarincr !=
NULL &&
1858 ((viol > 0.0 && consdata->linvarincrcoef > 0.0) || (viol < 0.0 && consdata->linvarincrcoef < 0.0)) )
1863 delta = viol / consdata->linvarincrcoef;
1870 delta =
MIN(
MAX(0.0, gap), delta);
1879 SCIPdebugMsg(
scip,
"increase <%s> by %g to %g to remedy lhs-violation %g of cons <%s>\n",
1883 viol -= consdata->linvarincrcoef * delta;
1890 if( consdata->linvardecr !=
NULL &&
1891 ((viol > 0.0 && consdata->linvardecrcoef < 0.0) || (viol < 0.0 && consdata->linvardecrcoef > 0.0)) )
1896 delta = viol / consdata->linvardecrcoef;
1903 delta =
MAX(
MIN(0.0, gap), delta);
1912 SCIPdebugMsg(
scip,
"increase <%s> by %g to %g to remedy rhs-violation %g of cons <%s>\n",
1916 viol -= consdata->linvardecrcoef * delta;
1968 SCIP_Longint soltag;
1988 for(
c = 0;
c < nconss; ++
c )
2004 for(
i = 0;
i < consdata->nvarexprs; ++
i )
2026 if( ownerdata->auxvar !=
NULL )
2032 for( e = 0; e < ownerdata->nenfos; ++e )
2036 ownerdata->enfos[e]->nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata,
sol, solisbest,
2105 SCIP_Bool tightenedlb;
2106 SCIP_Bool tightenedub;
2130 if( ntightenings !=
NULL )
2144 if( ntightenings !=
NULL )
2170 SCIP_Bool tightenauxvars,
2171 SCIP_Bool* infeasible,
2183 if( infeasible !=
NULL )
2184 *infeasible =
FALSE;
2185 if( ntightenings !=
NULL )
2194 SCIPdebugMsg(
scip,
"stored activity of root expr is empty and valid (activitytag >= lastboundrelax (%" SCIP_LONGINT_FORMAT ")), skip forwardPropExpr -> cutoff\n", conshdlrdata->lastboundrelax);
2196 if( infeasible !=
NULL )
2223 if( ownerdata->nenfos >= 0 && ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && !conshdlrdata->indetect)
2226 SCIPdebugMsg(
scip,
"root expr activity is not used but enfo initialized, skip inteval\n");
2274 SCIPexprGetActivityTag(expr) >= conshdlrdata->lastvaractivitymethodchange && !conshdlrdata->globalbounds )
2279 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &exprhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );
2309 if( infeasible !=
NULL )
2311 SCIPdebugMsg(
scip,
"expr %p already has empty activity -> cutoff\n", (
void*)expr);
2321 if( ownerdata->nenfos >= 0 && ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && !conshdlrdata->indetect )
2324 SCIPdebugMsg(
scip,
"expr %p activity is not used but enfo initialized, skip inteval\n", (
void*)expr);
2336 if( ownerdata->nenfos > 0 )
2349 nlhdlr = ownerdata->enfos[e]->nlhdlr;
2357 nlhdlrinterval = activity;
2358 SCIP_CALL( SCIPnlhdlrInteval(
scip, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata,
2359 &nlhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );
2375 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &exprhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );
2419 if( infeasible !=
NULL )
2422 else if( tightenauxvars && ownerdata->auxvar !=
NULL )
2424 SCIP_Bool tighteninfeasible;
2427 if( tighteninfeasible )
2429 if( infeasible !=
NULL )
2466 SCIP_Bool subsetsufficient,
2475 if( subsetsufficient )
2515 SCIP_Bool* infeasible,
2534 while( !
SCIPqueueIsEmpty(conshdlrdata->reversepropqueue) && !(*infeasible) )
2545 assert(ownerdata->inpropqueue);
2547 ownerdata->inpropqueue =
FALSE;
2552 assert(ownerdata->propboundstag == conshdlrdata->curpropboundstag);
2560#ifdef SCIP_DISABLED_CODE
2568 propbounds = ownerdata->propbounds;
2571 if( ownerdata->nenfos > 0 )
2574 for( e = 0; e < ownerdata->nenfos && !*infeasible; ++e )
2583 nlhdlr = ownerdata->enfos[e]->nlhdlr;
2594 SCIP_CALL( SCIPnlhdlrReverseprop(
scip, conshdlr, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, propbounds, infeasible, &nreds) );
2596 *ntightenings += nreds;
2614 assert(ownerdata->nenfos < 0);
2621 SCIP_CALL( SCIPcallExprReverseprop(
scip, expr, propbounds, childrenbounds, infeasible) );
2643 ownerdata->inpropqueue =
FALSE;
2711 assert(conshdlrdata->intevalvar == intEvalVarBoundTightening);
2713 assert(!conshdlrdata->globalbounds);
2719 conshdlrdata->forceboundtightening = force;
2722 ++conshdlrdata->curpropboundstag;
2725 if( conshdlrdata->propauxvars )
2740 for(
i = 0;
i < nconss; ++
i )
2752 if( consdata->ispropagated )
2773 if( !conshdlrdata->propauxvars || ownerdata->auxvar ==
NULL )
2779 if( ownerdata->auxvar ==
NULL )
2788 conssides = intEvalVarBoundTightening(
scip, ownerdata->auxvar, (
void*)conshdlrdata);
2807 if( ownerdata->auxvar ==
NULL )
2810 if( ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 )
2813 conssides = intEvalVarBoundTightening(
scip, ownerdata->auxvar, (
void*)conshdlrdata);
2825 assert(ntightenings >= 0);
2826 if( ntightenings > 0 )
2828 *nchgbds += ntightenings;
2833 consdata->ispropagated =
TRUE;
2838 assert(ntightenings >= 0);
2848 if( ntightenings > 0 )
2850 *nchgbds += ntightenings;
2854 while( ntightenings > 0 && ++roundnr < conshdlrdata->maxproprounds );
2856 if( conshdlrdata->propauxvars )
2861 conshdlrdata->forceboundtightening =
FALSE;
2864 ++conshdlrdata->curpropboundstag;
2914 for(
c = 0;
c < nconss && !
cutoff; ++
c )
2931 for( e = 0; e < ownerdata->nenfos; ++e )
2936 nlhdlr = ownerdata->enfos[e]->nlhdlr;
2941 SCIPdebugMsg(
scip,
"propExprDomains calling reverseprop for expression %p [%g,%g]\n", (
void*)expr,
2944 SCIP_CALL( SCIPnlhdlrReverseprop(
scip, conshdlr, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata,
2955 assert(ntightenings >= 0);
2956 if( ntightenings > 0 )
2958 *nchgbds += ntightenings;
2967 assert(ntightenings >= 0);
2974 else if( ntightenings > 0 )
2976 *nchgbds += ntightenings;
3004 if( nlockspos == 0 && nlocksneg == 0 )
3013 ituserdata.
intvals[0] = nlockspos;
3014 ituserdata.
intvals[1] = nlocksneg;
3021 nlockspos = ituserdata.
intvals[0];
3022 nlocksneg = ituserdata.
intvals[1];
3037 ownerdata->nlockspos += nlockspos;
3038 ownerdata->nlocksneg += nlocksneg;
3041 if( ownerdata->nlockspos == nlockspos && ownerdata->nlocksneg == nlocksneg &&
SCIPexprGetNChildren(expr) > 0
3047 assert(ownerdata->monotonicitysize == 0);
3055 SCIP_CALL( SCIPcallExprMonotonicity(
scip, expr,
i, &ownerdata->monotonicity[
i]) );
3064 if( ownerdata->nlockspos == 0 && ownerdata->nlocksneg == 0 && ownerdata->monotonicity !=
NULL )
3066 assert(ownerdata->monotonicitysize > 0);
3071 ownerdata->monotonicitysize = 0;
3087 switch( monotonicity )
3090 ituserdata.
intvals[0] = nlockspos;
3091 ituserdata.
intvals[1] = nlocksneg;
3094 ituserdata.
intvals[0] = nlocksneg;
3095 ituserdata.
intvals[1] = nlockspos;
3098 ituserdata.
intvals[0] = nlockspos + nlocksneg;
3099 ituserdata.
intvals[1] = nlockspos + nlocksneg;
3154 if( nlockspos == 0 && nlocksneg == 0 )
3165 consdata->nlockspos += nlockspos;
3166 consdata->nlocksneg += nlocksneg;
3168 assert(consdata->nlockspos >= 0);
3169 assert(consdata->nlocksneg >= 0);
3205 if( consdata->nlrow !=
NULL )
3314 assert(conshdlrdata->auxvarid >= 0);
3315 assert(!conshdlrdata->indetect);
3318 assert(ownerdata->nenfos < 0);
3328 if( ownerdata->nauxvaruses == 0 )
3332 if( ownerdata->nlockspos == 0 )
3334 if( ownerdata->nlocksneg == 0 )
3337 if( ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 )
3346 ownerdata->nenfos = 0;
3349 conshdlrdata->indetect =
TRUE;
3351 SCIPdebugMsg(
scip,
"detecting nlhdlrs for %s expression %p (%s); requiring%s%s%s\n",
3357 for(
h = 0;
h < conshdlrdata->nnlhdlrs; ++
h )
3361 nlhdlr = conshdlrdata->nlhdlrs[
h];
3369 nlhdlrexprdata =
NULL;
3370 enforcemethodsnew = enforcemethods;
3372 conshdlrdata->registerusesactivitysepabelow =
FALSE;
3373 conshdlrdata->registerusesactivitysepaabove =
FALSE;
3375 SCIP_CALL( SCIPnlhdlrDetect(
scip, ownerdata->conshdlr, nlhdlr, expr, cons, &enforcemethodsnew, &nlhdlrparticipating, &nlhdlrexprdata) );
3378 nlhdlrparticipating &= enforcemethodsallowed;
3381 assert((enforcemethodsnew & enforcemethods) == enforcemethods);
3386 nlhdlrenforcemethods = (enforcemethodsnew ^ enforcemethods) & enforcemethodsallowed;
3389 assert((nlhdlrparticipating & nlhdlrenforcemethods) == nlhdlrenforcemethods);
3397 if( nlhdlrexprdata !=
NULL )
3399 SCIP_CALL( SCIPnlhdlrFreeexprdata(
scip, nlhdlr, expr, &nlhdlrexprdata) );
3409 SCIPdebugMsg(
scip,
"nlhdlr <%s> detect successful; sepabelow: %s, sepaabove: %s, activity: %s\n",
3418 ownerdata->enfos[ownerdata->nenfos]->nlhdlr = nlhdlr;
3419 ownerdata->enfos[ownerdata->nenfos]->nlhdlrexprdata = nlhdlrexprdata;
3420 ownerdata->enfos[ownerdata->nenfos]->nlhdlrparticipation = nlhdlrparticipating;
3421 ownerdata->enfos[ownerdata->nenfos]->issepainit =
FALSE;
3422 ownerdata->enfos[ownerdata->nenfos]->sepabelowusesactivity = conshdlrdata->registerusesactivitysepabelow;
3423 ownerdata->enfos[ownerdata->nenfos]->sepaaboveusesactivity = conshdlrdata->registerusesactivitysepaabove;
3424 ownerdata->nenfos++;
3427 enforcemethods = enforcemethodsnew;
3430 conshdlrdata->indetect =
FALSE;
3437 SCIPerrorMessage(
"no nonlinear handler provided some of the required enforcement methods\n");
3441 assert(ownerdata->nenfos > 0);
3444 if( ownerdata->nenfos > 1 )
3445 SCIPsortDownPtr((
void**)ownerdata->enfos, enfodataCmp, ownerdata->nenfos);
3485 conshdlrdata->globalbounds =
TRUE;
3486 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
3489 for(
i = 0;
i < nconss; ++
i )
3511 if( ownerdata->nenfos > 0 )
3514 assert(ownerdata->nenfos < 0);
3522 conshdlrdata->indetect =
TRUE;
3527 conshdlrdata->indetect =
FALSE;
3539 if( ownerdata->nenfos >= 0 )
3549 if( ownerdata->nauxvaruses > 0 || ownerdata->nactivityusesprop > 0 || ownerdata->nactivityusessepa > 0 )
3553 assert(ownerdata->nenfos >= 0);
3562 ownerdata->nenfos = 0;
3568 consdata->ispropagated =
FALSE;
3577 conshdlrdata->globalbounds =
FALSE;
3578 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
3614 for(
c = 0;
c < nconss; ++
c )
3622 SCIP_Bool success =
FALSE;
3665 if( consdata->nlrow ==
NULL )
3704 SCIP_Bool rootactivityvalid;
3715 for(
c = 0;
c < nconss; ++
c )
3729 SCIPdebugMsg(
scip,
"exitsepa and free nonlinear handler data for expression %p\n", (
void*)expr);
3737 if( rootactivityvalid )
3748 if( consdata->nlrow !=
NULL )
3762 consdata->linvardecr =
NULL;
3763 consdata->linvarincr =
NULL;
3886 SCIP_Real minact = 0.0;
3887 SCIP_Real maxact = 0.0;
3888 SCIP_Bool integral =
TRUE;
3901 minact +=
MIN(coefs[
i], 0.0);
3902 maxact +=
MAX(coefs[
i], 0.0);
3905 assert(minact <= maxact);
3919 if( naddconss !=
NULL )
3930 if( naddconss !=
NULL )
3944 if( naddconss !=
NULL )
3957 if( naddconss !=
NULL )
3986 SCIP_Real* exprcoefs =
NULL;
3987 SCIP_Real* tmpcoefs =
NULL;
3988 SCIP_Real* sumcoefs;
3989 SCIP_Bool* isused =
NULL;
3990 int* childidxs =
NULL;
4015 if( nchildren < minterms )
4049 assert(xidx < ntotalvars);
4051 assert(yidx < ntotalvars);
4082 for( j = 0; j <
nterms; ++j )
4084 int childidx = childidxs[j];
4085 assert(childidx >= 0 && childidx < nchildren);
4087 if( !isused[childidx] && (xs[j] == facvar || ys[j] == facvar) )
4093 coef = sumcoefs[childidx];
4097 tmpvars[ntmpvars] = (xs[j] == facvar) ? ys[j] : xs[j];
4098 tmpcoefs[ntmpvars] = coef;
4103 assert(xidx < ntotalvars);
4105 assert(yidx < ntotalvars);
4108 assert(count[xidx] >= 0);
4109 assert(count[yidx] >= 0);
4112 isused[childidx] =
TRUE;
4115 assert(ntmpvars >= minterms);
4121 exprcoefs[nexprs] = 1.0;
4128 int nexprsold = nexprs;
4131 for(
i = 0;
i < nchildren; ++
i )
4136 exprcoefs[nexprs] = sumcoefs[
i];
4145 for(
i = 0;
i < nexprsold; ++
i )
4175 SCIP_Bool empathy4and
4201 strcpy(name,
"binreform");
4202 for(
i = 0;
i < nchildren; ++
i )
4207 (void) strcat(name,
"_");
4217 if( nchildren == 2 && !empathy4and )
4247 if( naddconss !=
NULL )
4259 if( naddconss !=
NULL )
4317 SCIPdebugMsg(
scip,
" product expression %p has been considered for the first time\n", (
void*)prodexpr);
4319 if( nchildren == 2 )
4324 SCIP_Bool found_clique =
FALSE;
4345 if( nchgcoefs !=
NULL )
4348 found_clique =
TRUE;
4357 if( nchgcoefs !=
NULL )
4360 found_clique =
TRUE;
4377 if( nchgcoefs !=
NULL )
4380 found_clique =
TRUE;
4388 SCIP_Real sum_coefs[2];
4398 if( nchgcoefs !=
NULL )
4401 found_clique =
TRUE;
4468 if( conshdlrdata->reformbinprodsfac > 1 )
4474 if( newexpr ==
NULL )
4479 if( newexpr !=
NULL )
4481 assert(naddconss ==
NULL || *naddconss > 0 || nchgcoefs ==
NULL || *nchgcoefs > 0);
4490 consdata->issimplified =
FALSE;
4566 for(
c = 0;
c < nconss; ++
c )
4577 if( conshdlrdata->reformbinprodsfac > 1 )
4583 if( newexpr !=
NULL )
4586 consdata->expr = newexpr;
4589 consdata->issimplified =
FALSE;
4638 if( nchildren == 1 && constant == 0.0 && coefs[0] == -1.0 )
4641 expr = consdata->expr;
4649 consdata->lhs = -consdata->lhs;
4650 consdata->rhs = -consdata->rhs;
4658 for(
i = 0;
i < nchildren; ++
i )
4659 counter += coefs[
i] > 0 ? 1 : -1;
4664 SCIP_Real* newcoefs;
4669 for(
i = 0;
i < nchildren; ++
i )
4670 newcoefs[
i] = -coefs[
i];
4677 consdata->expr = expr;
4679 consdata->lhs = -consdata->lhs;
4680 consdata->rhs = -consdata->rhs;
4715 for(
c = 0;
c < nconss; ++
c )
4767 SCIP_Bool* infeasible,
4777 SCIP_Bool havechange;
4790 ++(conshdlrdata->ncanonicalizecalls);
4794 *infeasible =
FALSE;
4797 havechange = conshdlrdata->ncanonicalizecalls == 1;
4807 for(
i = 0;
i < nconss; ++
i )
4815 nlockspos[
i] = consdata->nlockspos;
4816 nlocksneg[
i] = consdata->nlocksneg;
4820 assert(consdata->nlockspos == 0);
4821 assert(consdata->nlocksneg == 0);
4826 for(
i = 0;
i < nconss; ++
i )
4851 int tmpnaddconss = 0;
4852 int tmpnchgcoefs = 0;
4860 if( naddconss !=
NULL )
4861 *naddconss = tmpnaddconss;
4862 if( nchgcoefs !=
NULL )
4863 *nchgcoefs = tmpnchgcoefs;
4866 if( tmpnaddconss + tmpnchgcoefs > 0 )
4870 for(
i = 0;
i < nconss; ++
i )
4876 if( !consdata->issimplified && consdata->expr !=
NULL )
4883 consdata->issimplified =
TRUE;
4891 if( simplified != consdata->expr )
4899 consdata->expr = simplified;
4934 if( ndelconss !=
NULL )
4943 if( havechange && !*infeasible )
4947 SCIP_Bool replacedroot;
4950 for(
i = 0;
i < nconss; ++
i )
4959 for(
i = 0;
i < nconss; ++
i )
4972 SCIPsortPtr((
void**)consssorted, compIndexConsNonlinear, nconss);
4974 for(
i = nconss-1;
i >= 0; --
i )
4976 assert(
i == 0 || compIndexConsNonlinear((
void*)consssorted[
i-1], (
void*)consssorted[
i]) < 0);
4983 for(
i = 0;
i < nconss; ++
i )
5002 for(
i = 0;
i < nconss; ++
i )
5016 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
5041 SCIP_Bool* updatelocks;
5059 for(
c = 0;
c < nconss; ++
c )
5081 assert(idx >= 0 && idx < nconss);
5085 assert(imgconsdata->expr == consdata->expr);
5087 SCIPdebugMsg(
scip,
"merge constraint %g <= %s <= %g with %g <= %s <= %g\n", consdata->lhs,
5094 nlockspos[idx] = imgconsdata->nlockspos;
5095 nlocksneg[idx] = imgconsdata->nlocksneg;
5097 updatelocks[idx] =
TRUE;
5101 imgconsdata->lhs =
MAX(imgconsdata->lhs, consdata->lhs);
5102 imgconsdata->rhs =
MIN(imgconsdata->rhs, consdata->rhs);
5113 for(
c = 0;
c < nconss; ++
c )
5115 if( updatelocks[
c] )
5149 if( conshdlrdata->globalbounds )
5235 ++conshdlrdata->curboundstag;
5236 assert(conshdlrdata->curboundstag > 0);
5237 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
5238 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
5239 conshdlrdata->intevalvar = intEvalVarRedundancyCheck;
5244 for(
i = 0;
i < nconss; ++
i )
5278 SCIP_Bool tightened;
5345 SCIPdebugMsg(
scip,
" -> redundant: activity [%g,%g] within sides [%g,%g]\n", activity.
inf, activity.
sup, consdata->lhs, consdata->rhs);
5353 SCIPdebugMsg(
scip,
" -> not redundant: activity [%g,%g] not within sides [%g,%g]\n", activity.
inf, activity.
sup, consdata->lhs, consdata->rhs);
5358 ++conshdlrdata->curboundstag;
5359 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
5360 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
5361 conshdlrdata->intevalvar = intEvalVarBoundTightening;
5372 SCIP_Bool* upgraded,
5400 if( conshdlrdata->nconsupgrades == 0 )
5414 for(
i = 0;
i < conshdlrdata->nconsupgrades; ++
i )
5416 if( !conshdlrdata->consupgrades[
i]->active )
5419 assert(conshdlrdata->consupgrades[
i]->consupgd !=
NULL);
5421 SCIP_CALL( conshdlrdata->consupgrades[
i]->consupgd(
scip, cons, consdata->nvarexprs, &nupgdconss_, upgdconss, upgdconsssize) );
5423 while( nupgdconss_ < 0 )
5426 assert(-nupgdconss_ > upgdconsssize);
5427 upgdconsssize = -nupgdconss_;
5430 SCIP_CALL( conshdlrdata->consupgrades[
i]->consupgd(
scip, cons, consdata->nvarexprs, &nupgdconss_, upgdconss, upgdconsssize) );
5432 assert(nupgdconss_ != 0);
5435 if( nupgdconss_ > 0 )
5443 for( j = 0; j < nupgdconss_; ++j )
5454 *naddconss += nupgdconss_ - 1;
5539 SCIP_Bool* infeasible
5546 SCIP_Bool hasbounddisj;
5549 int nsinglelocked = 0;
5560 *infeasible =
FALSE;
5584 for(
i = 0;
i < consdata->nvarexprs; ++
i )
5591 singlelocked[nsinglelocked++] = consdata->varexprs[
i];
5596 if( nsinglelocked > 0 )
5610 for(
i = 0;
i < nchildren; ++
i )
5615 child = children[
i];
5651 valid = exponent > 1.0 && fmod(exponent, 2.0) == 0.0;
5675 for(
i = 0;
i < nsinglelocked; ++
i )
5683 SCIP_Real bounds[2];
5689 SCIPdebugMsg(
scip,
"found single locked variable %s in [%g,%g] that can be fixed to one of its bounds\n",
5743 SCIP_Bool* infeasible
5754 *infeasible =
FALSE;
5764 for(
c = 0;
c < nconss; ++
c )
5771 SCIP_Real candcoef = 0.0;
5793 if( nchildren <= 1 )
5799 for(
i = 0;
i < nchildren; ++
i )
5804 candcoef = coefs[
i];
5821 for(
i = 0;
i < nchildren; ++
i )
5823 if( children[
i] == cand )
5844 SCIPdebugMsg(
scip,
"make variable <%s> implicit integer due to constraint <%s>\n",
5882 assert(ownerdata->nauxvaruses > 0);
5885 if( ownerdata->auxvar !=
NULL )
5900 assert(conshdlrdata->auxvarid >= 0);
5910 ++conshdlrdata->auxvarid;
5960#ifdef WITH_DEBUG_SOLUTION
5961 if( SCIPdebugIsMainscip(
scip) )
5994 SCIP_Bool* infeasible
6003 int nreductions = 0;
6016 ++conshdlrdata->curpropboundstag;
6022 *infeasible =
FALSE;
6023 for(
c = 0;
c < nconss; ++
c )
6032#ifdef WITH_DEBUG_SOLUTION
6033 if( SCIPdebugIsMainscip(
scip) )
6039 if( debugsol !=
NULL )
6061 if( auxvar !=
NULL )
6063 SCIPdebugMsg(
scip,
"tighten auxvar <%s> bounds using constraint sides [%g,%g]\n",
6096 for(
c = 0;
c < nconss && !*infeasible; ++
c )
6112 if( ownerdata->nauxvaruses == 0 )
6115 for( e = 0; e < ownerdata->nenfos; ++e )
6118 SCIP_Bool underestimate;
6119 SCIP_Bool overestimate;
6125 if( ownerdata->enfos[e]->issepainit )
6132 nlhdlr = ownerdata->enfos[e]->nlhdlr;
6140 overestimate = ownerdata->nlocksneg > 0;
6141 underestimate = ownerdata->nlockspos > 0;
6142 assert(underestimate || overestimate);
6144 SCIPdebugMsg(
scip,
"initsepa under=%u over=%u for expression %p\n", underestimate, overestimate, (
void*)expr);
6147 SCIP_CALL( SCIPnlhdlrInitsepa(
scip, conshdlr, conss[
c], nlhdlr, expr,
6148 ownerdata->enfos[e]->nlhdlrexprdata, overestimate, underestimate, infeasible) );
6149 ownerdata->enfos[e]->issepainit =
TRUE;
6200 switch( conshdlrdata->branchviolsplit )
6209 return MAX(0.05, weight);
6220 return 10.0*log10(width);
6222 return 0.1/(-log10(width));
6227 SCIPerrorMessage(
"invalid value for parameter constraints/expr/branching/violsplit");
6245 SCIP_Real violscore,
6253 SCIP_Real weightsum = 0.0;
6272 for(
i = 0;
i < nexprs; ++
i )
6284 for(
i = 0;
i < nexprs; ++
i )
6289 if( nunbounded > 0 )
6294 SCIPdebugMsg(
scip,
"add score %g (%g%% of %g) to <%s>[%g,%g]\n", violscore / nunbounded,
6295 100.0/nunbounded, violscore,
6306 SCIPdebugMsg(
scip,
"add score %g (%g%% of %g) to <%s>[%g,%g]\n", violscore * weight / weightsum,
6307 100*weight / weightsum, violscore,
6330 SCIP_Real violscore,
6349 SCIPsortPtr((
void**)auxvars, SCIPvarComp, nauxvars);
6360 if( auxvar ==
NULL )
6366 assert(auxvars[pos] == auxvar);
6369 exprs[nexprs++] = expr;
6371 if( nexprs == nauxvars )
6411 for(
c = 0;
c < nconss; ++
c )
6424 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6466 for(
c = 0;
c < nconss; ++
c )
6485 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6487 SCIP_Real violscore;
6495 if( violscore == 0.0 )
6528 SCIP_Real violscore;
6533 if( violscore == 0.0 )
6582 SCIP_Real maxrelconsviol,
6584 SCIP_Longint soltag,
6611 for( attempt = 0; attempt < 2; ++attempt )
6617 for(
c = 0;
c < nconss; ++
c )
6633 if( attempt == 0 && consviol < conshdlrdata->branchhighviolfactor * maxrelconsviol )
6635 else if( attempt == 1 && consviol >= conshdlrdata->branchhighviolfactor * maxrelconsviol )
6647 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6670 cands[*ncands].
expr = consdata->varexprs[
i];
6671 cands[*ncands].
var =
var;
6708 cands[*ncands].
expr = expr;
6709 cands[*ncands].
var =
var;
6765 SCIP_Real dualscore;
6795 for(
r = 0;
r < nrows; ++
r )
6797 SCIP_Real estimategap;
6798 const char* estimategapstr;
6812 if( estimategapstr ==
NULL )
6814 estimategap = atof(estimategapstr + 13);
6815 assert(estimategap >= 0.0);
6856 SCIP_Bool considerfracnl,
6875 for(
c = 0;
c < ncands; ++
c )
6877 if( conshdlrdata->branchviolweight > 0.0 )
6888 assert(cands[
c].expr !=
NULL || cands[
c].fractionality > 0.0);
6890 if( considerfracnl && cands[
c].fractionality == 0.0 )
6909 if( conshdlrdata->branchdomainweight > 0.0 && cands[
c].
expr !=
NULL )
6911 SCIP_Real domainwidth;
6924 if( domainwidth >= 1.0 )
6934 if( conshdlrdata->branchdualweight > 0.0 && cands[
c].
expr !=
NULL )
6945 cands[
c].
dual = 0.0;
6954 if( cands[
c].expr !=
NULL )
6961 SCIP_Real pscostdown;
6970 strategy = conshdlrdata->branchpscostupdatestrategy;
7048 SCIP_Real pscostdown;
7085 if( conshdlrdata->branchvartypeweight > 0.0 )
7109 for(
c = 0;
c < ncands; ++
c )
7111 SCIP_Real weightsum;
7115 cands[
c].weighted = 0.0;
7121 weightsum += conshdlrdata->branchviolweight;
7129 weightsum += conshdlrdata->branchfracweight;
7134 if( maxscore.
domain > 0.0 )
7137 weightsum += conshdlrdata->branchdomainweight;
7142 if( maxscore.
dual > 0.0 )
7145 weightsum += conshdlrdata->branchdualweight;
7150 if( maxscore.
pscost > 0.0 )
7156 weightsum += conshdlrdata->branchpscostweight;
7170 weightsum += conshdlrdata->branchvartypeweight;
7192 if( cands[ind1].weighted != cands[ind2].weighted )
7195 if( cands[ind1].
var != cands[ind2].
var )
7198 return cands[ind1].
expr !=
NULL ? 1 : -1;
7208 SCIP_Bool considerfracnl,
7217 SCIP_Real threshold;
7239 SCIPsortDown(perm, branchcandCompare, (
void*)cands, ncands);
7243 SCIPvarGetName(cands[perm[ncands - 1]].
var), cands[perm[ncands - 1]].weighted); )
7248 threshold = conshdlrdata->branchhighscorefactor * cands[perm[0]].
weighted;
7249 while( left < right )
7251 int mid = (left + right) / 2;
7252 if( cands[perm[mid]].weighted >= threshold )
7261 if( cands[perm[left]].weighted >= threshold )
7263 assert(left + 1 == ncands || cands[perm[left + 1]].weighted < threshold);
7268 assert(cands[perm[left]].weighted < threshold);
7274 ENFOLOG(
SCIPinfoMessage(
scip, enfologfile,
" %d branching candidates <%s>(%g)...<%s>(%g) after removing low scores\n", ncands,
7276 SCIPvarGetName(cands[perm[ncands - 1]].
var), cands[perm[ncands - 1]].weighted); )
7281 if( conshdlrdata->branchrandnumgen ==
NULL )
7286 *selected = &cands[perm[
c]];
7289 *selected = &cands[perm[0]];
7303 SCIP_Real maxrelconsviol,
7305 SCIP_Longint soltag,
7325 if( conshdlrdata->branchexternal )
7359 if( downchild !=
NULL || eqchild !=
NULL || upchild !=
NULL )
7388 SCIP_Bool overestimate,
7389 SCIP_Bool separated,
7390 SCIP_Bool allowweakcuts,
7391 SCIP_Bool inenforcement,
7392 SCIP_Bool branchcandonly,
7399 SCIP_CALL( SCIPnlhdlrEnfo(
scip, conshdlr, cons, nlhdlr, expr, nlhdlrexprdata,
sol, auxvalue, overestimate,
7400 allowweakcuts, separated, inenforcement, branchcandonly,
result) );
7420 SCIP_Bool sepasuccess =
FALSE;
7421 SCIP_Bool branchscoresuccess =
FALSE;
7433 SCIP_CALL( SCIPnlhdlrEstimate(
scip, conshdlr, nlhdlr, expr, nlhdlrexprdata,
sol, auxvalue, overestimate,
7434 SCIPgetSolVal(
scip,
sol, auxvar), inenforcement, rowpreps, &sepasuccess, &branchscoresuccess) );
7439 assert((sepasuccess && minidx <= maxidx) || (!sepasuccess && minidx > maxidx));
7447 for(
r = minidx;
r <= maxidx; ++
r )
7454 if( !branchcandonly )
7463 auxvalue, allowweakcuts, branchscoresuccess, inenforcement,
sol,
result) );
7469 if( branchcandonly && branchscoresuccess )
7492 SCIP_Longint soltag,
7493 SCIP_Bool allowweakcuts,
7494 SCIP_Bool inenforcement,
7495 SCIP_Bool branchcandonly,
7502 SCIP_Bool underestimate;
7503 SCIP_Bool overestimate;
7505 SCIP_Bool auxunderestimate;
7506 SCIP_Bool auxoverestimate;
7530 if( !overestimate && !underestimate )
7536 for( e = 0; e < ownerdata->nenfos; ++e )
7545 if( branchcandonly && !ownerdata->enfos[e]->sepaaboveusesactivity && !ownerdata->enfos[e]->sepabelowusesactivity )
7548 nlhdlr = ownerdata->enfos[e]->nlhdlr;
7552 SCIP_CALL( SCIPnlhdlrEvalaux(
scip, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, &ownerdata->enfos[e]->auxvalue,
sol) );
7556 SCIPinfoMessage(
scip, enfologfile,
" (%p): evalvalue %.15g auxvarvalue %.15g [%.15g,%.15g], nlhdlr <%s> " \
7573 if( !
SCIPisInfinity(
scip, auxviol) && auxviol < conshdlrdata->enfoauxviolfactor * origviol )
7576 "auxviolation %g << origviolation %g under:%d over:%d\n",
SCIPnlhdlrGetName(nlhdlr), (
void*)expr,
7588 underestimate, overestimate); )
7596 auxviol, origviol, underestimate, overestimate, allowweakcuts); )
7601 if( overestimate && auxoverestimate && (ownerdata->enfos[e]->nlhdlrparticipation &
SCIP_NLHDLR_METHOD_SEPAABOVE) != 0 && (!branchcandonly || ownerdata->enfos[e]->sepaaboveusesactivity) )
7606 ownerdata->enfos[e]->auxvalue,
TRUE, *
result ==
SCIP_SEPARATED, allowweakcuts, inenforcement, branchcandonly, &hdlrresult) );
7612 ownerdata->lastenforced = conshdlrdata->enforound;
7620 ownerdata->lastenforced = conshdlrdata->enforound;
7629 ownerdata->lastenforced = conshdlrdata->enforound;
7642 ownerdata->lastenforced = conshdlrdata->enforound;
7649 if( underestimate && auxunderestimate && (ownerdata->enfos[e]->nlhdlrparticipation &
SCIP_NLHDLR_METHOD_SEPABELOW) != 0 && (!branchcandonly || ownerdata->enfos[e]->sepabelowusesactivity) )
7654 ownerdata->enfos[e]->auxvalue,
FALSE, *
result ==
SCIP_SEPARATED, allowweakcuts, inenforcement, branchcandonly, &hdlrresult) );
7660 ownerdata->lastenforced = conshdlrdata->enforound;
7668 ownerdata->lastenforced = conshdlrdata->enforound;
7677 ownerdata->lastenforced = conshdlrdata->enforound;
7690 ownerdata->lastenforced = conshdlrdata->enforound;
7705 SCIP_Longint soltag,
7707 SCIP_Bool allowweakcuts,
7708 SCIP_Bool inenforcement,
7709 SCIP_Bool branchcandonly,
7733 if( inenforcement && !branchcandonly && !consdata->ispropagated )
7743 SCIP_Bool infeasible;
7753 if( ntightenings > 0 )
7766 if( ownerdata->auxvar ==
NULL )
7769 assert(ownerdata->lastenforced <= conshdlrdata->enforound);
7770 if( ownerdata->lastenforced == conshdlrdata->enforound )
7785 if( ownerdata->lastenforced == conshdlrdata->enforound )
7826 SCIP_Longint soltag,
7827 SCIP_Bool inenforcement,
7828 SCIP_Bool branchcandonly,
7829 SCIP_Real maxrelconsviol,
7835 SCIP_Bool consenforced;
7849 ++(conshdlrdata->enforound);
7856 for(
c = 0;
c < nconss; ++
c )
7882 for(
i = 0;
i < consdata->nvarexprs; ++
i )
7891 SCIP_CALL(
enforceConstraint(
scip, conshdlr, conss[
c],
sol, soltag, it,
FALSE, inenforcement, branchcandonly,
result, &consenforced) );
7896 if( !consenforced && inenforcement && !branchcandonly )
7901 if( viol > conshdlrdata->weakcutminviolfactor * maxrelconsviol )
7906 SCIP_CALL(
enforceConstraint(
scip, conshdlr, conss[
c],
sol, soltag, it,
TRUE, inenforcement, branchcandonly,
result, &consenforced) );
7909 ++conshdlrdata->nweaksepa;
7919 ENFOLOG(
if( enfologfile !=
NULL ) fflush( enfologfile); )
7936 ENFOLOG(
if( enfologfile !=
NULL ) fflush( enfologfile); )
7956 SCIP_Longint soltag,
7957 SCIP_Real maxrelconsviol,
7958 SCIP_Bool* branchintegral,
7978 *branchintegral =
FALSE;
7989 *branchintegral =
TRUE;
8000 SCIPerrorMessage(
"Unexpected separation or propagation from enforceConstraints(branchcandonly = TRUE)\n");
8012 SCIPerrorMessage(
"Unexpected return from enforceConstraints(branchcandonly = TRUE)\n");
8047 *branchintegral =
TRUE;
8086 if( conshdlrdata->branchmixfractional == 0.0 )
8112 SCIP_Longint soltag,
8113 SCIP_Real* maxabsconsviol,
8114 SCIP_Real* maxrelconsviol,
8115 SCIP_Real* minauxviol,
8116 SCIP_Real* maxauxviol,
8117 SCIP_Real* maxvarboundviol
8135 *maxabsconsviol = 0.0;
8136 *maxrelconsviol = 0.0;
8139 *maxvarboundviol = 0.0;
8141 for(
c = 0;
c < nconss; ++
c )
8154 *maxabsconsviol =
MAX(*maxabsconsviol, v);
8161 *maxrelconsviol =
MAX(*maxrelconsviol, v);
8166 SCIP_Real auxvarvalue;
8169 SCIP_Bool violunder;
8178 if( ownerdata->auxvar ==
NULL )
8191 origviol = auxvarlb - auxvarvalue;
8193 origviol = auxvarvalue - auxvarub;
8194 if( origviol <= 0.0 )
8197 *maxvarboundviol =
MAX(*maxvarboundviol, origviol);
8218 *maxvarboundviol = auxvarlb - auxvarvalue;
8219 else if( auxvarvalue - auxvarub > *maxvarboundviol && !
SCIPisInfinity(
scip, auxvarub) )
8220 *maxvarboundviol = auxvarvalue - auxvarub;
8225 if( origviol > 0.0 || auxvarlb > auxvarvalue || auxvarub < auxvarvalue )
8232 if( origviol > 0.0 )
8233 SCIPinfoMessage(
scip, enfologfile,
" auxvar %s expr violated by %g", violunder ?
">=" :
"<=", origviol);
8235 SCIPinfoMessage(
scip, enfologfile,
" auxvar >= auxvar's lb violated by %g", auxvarlb - auxvarvalue);
8237 SCIPinfoMessage(
scip, enfologfile,
" auxvar <= auxvar's ub violated by %g", auxvarvalue - auxvarub);
8243 if( origviol == 0.0 )
8247 for( e = 0; e < ownerdata->nenfos; ++e )
8255 nlhdlr = ownerdata->enfos[e]->nlhdlr;
8259 SCIP_CALL( SCIPnlhdlrEvalaux(
scip, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, &ownerdata->enfos[e]->auxvalue,
sol) );
8268 *maxauxviol =
MAX(*maxauxviol, auxviol);
8269 *minauxviol =
MIN(*minauxviol, auxviol);
8293 SCIP_Real maxabsconsviol;
8294 SCIP_Real maxrelconsviol;
8295 SCIP_Real minauxviol;
8296 SCIP_Real maxauxviol;
8297 SCIP_Real maxvarboundviol;
8298 SCIP_Longint soltag;
8299 SCIP_Bool branchintegral;
8316 for(
c = 0;
c < nconss; ++
c )
8332 &minauxviol, &maxauxviol, &maxvarboundviol) );
8335 "auxviolations in %g..%g, variable bounds violated by at most %g, LP feastol=%e\n",
8352 if( branchintegral )
8361 if( conshdlrdata->propinenforce )
8382 ++conshdlrdata->ntightenlp;
8398 ++conshdlrdata->ntightenlp;
8428 ++conshdlrdata->ntightenlp;
8450 ++conshdlrdata->ndesperatetightenlp;
8460 if( !conshdlrdata->propinenforce )
8482 ++conshdlrdata->ndesperatebranch;
8497 ENFOLOG(
SCIPinfoMessage(
scip, enfologfile,
" enforcement with max. violation %g failed; cutting off node\n", maxabsconsviol); )
8502 ++conshdlrdata->ndesperatecutoff;
8518 SCIP_Longint soltag;
8519 SCIP_Bool haveviol =
FALSE;
8527 for(
c = 0;
c < nconss; ++
c )
8567 idx = ((int)(
size_t)elem) - 1;
8568 assert(idx >= 0 && idx < conshdlrdata->nbilinterms);
8570 return (
void*)&conshdlrdata->bilinterms[idx];
8588 return entry1->
x == entry2->
x && entry1->
y == entry2->
y;
8623 for(
i = 0;
i < 3; ++
i )
8626 return auxexpr1->
coefs[
i] < auxexpr2->
coefs[
i] ? -1 : 1;
8629 return auxexpr1->
cst < auxexpr2->
cst ? -1 : auxexpr1->
cst == auxexpr2->
cst ? 0 : 1;
8661 if( term->
nauxexprs >= conshdlrdata->bilinmaxnauxexprs )
8707 if( conshdlrdata->bilinterms !=
NULL )
8716 for(
c = 0;
c < nconss; ++
c )
8797 assert(conshdlrdata->bilinterms[*idx].x ==
x);
8798 assert(conshdlrdata->bilinterms[*idx].y ==
y);
8801 term = &conshdlrdata->bilinterms[*idx];
8802 assert(existing <= term->existing);
8811 *idx = conshdlrdata->nbilinterms;
8814 term = &conshdlrdata->bilinterms[*idx];
8829 ++(conshdlrdata->nbilinterms);
8832 if( conshdlrdata->bilinhashtable ==
NULL )
8835 bilinearTermsGetHashkey, bilinearTermsIsHashkeyEq, bilinearTermsGetHashkeyVal,
8836 (
void*)conshdlrdata) );
8838 assert(conshdlrdata->bilinhashtable !=
NULL);
8866 if( conshdlrdata->bilinterms ==
NULL )
8869 assert(conshdlrdata->nbilinterms == 0);
8870 assert(conshdlrdata->bilintermssize == 0);
8876 for(
i = 0;
i < conshdlrdata->nbilinterms; ++
i )
8881 for( j = 0; j < conshdlrdata->bilinterms[
i].nauxexprs; ++j )
8883 if( conshdlrdata->bilinterms[
i].aux.exprs[j]->auxvar !=
NULL )
8890 if( conshdlrdata->bilinterms[
i].nauxexprs > 0 )
8899 if( conshdlrdata->bilinterms[
i].aux.var !=
NULL )
8906 if( conshdlrdata->bilinhashtable !=
NULL )
8913 conshdlrdata->nbilinterms = 0;
8914 conshdlrdata->bilintermssize = 0;
8948 SCIPdebugMsg(
scip,
"Building LP for computing facets of convex envelope of vertex-polyhedral function\n");
8953 nrows = (
unsigned int)
nvars + 1;
8955 nnonz = (ncols * (nrows + 1)) / 2;
8966 for(
i = 0, k = 0;
i < ncols; ++
i )
9000 ind[k] = (int)nrows - 1;
9011 (
int)ncols,
obj, lb, ub,
NULL,
9012 (
int)nrows, lb, lb,
NULL,
9013 (
int)nnonz, beg, ind, val) );
9016 ind[0] = (int)nrows - 1;
9038 SCIP_Bool overestimate,
9044 SCIP_Real* facetcoefs,
9045 SCIP_Real facetconstant
9053 unsigned int ncorners;
9066 facetval = facetconstant;
9067 for(
i = 0;
i < (
unsigned int) nallvars; ++
i )
9068 facetval += facetcoefs[
i] * box[2*
i];
9071 funval = funvals[0];
9073 error = funval - facetval;
9075 error = facetval - funval;
9078 maxerror =
MAX(error, maxerror);
9081 for(
i = 1;
i < ncorners; ++
i )
9088 gray =
i ^ (
i >> 1);
9093 while( (diff >>= 1) != 0 )
9097 origpos = nonfixedpos[pos];
9100 facetval += facetcoefs[origpos] * (box[2*origpos+1] - box[2*origpos]);
9102 facetval -= facetcoefs[origpos] * (box[2*origpos+1] - box[2*origpos]);
9105 funval = funvals[gray];
9107 error = funval - facetval;
9109 error = facetval - funval;
9112 maxerror =
MAX(error, maxerror);
9127 SCIP_Bool overestimate,
9134 SCIP_Real targetvalue,
9136 SCIP_Real* facetcoefs,
9137 SCIP_Real* facetconstant
9147 SCIP_Real facetvalue;
9148 SCIP_Real mindomwidth;
9168 if( conshdlrdata->vp_randnumgen ==
NULL && conshdlrdata->vp_maxperturb > 0.0 )
9174 if( conshdlrdata->vp_lp[
nvars] ==
NULL )
9178 lp = conshdlrdata->vp_lp[
nvars];
9196 for(
i = 0;
i < ncols; ++
i )
9201 for(
i = 0;
i < nrows-1; ++
i )
9210 varpos = nonfixedpos[
i];
9211 lb = box[2 * varpos];
9212 ub = box[2 * varpos + 1];
9213 solval = xstar[varpos];
9215 if( ub - lb < mindomwidth )
9216 mindomwidth = ub - lb;
9221 else if( solval >= ub )
9224 aux[
i] = (solval - lb) / (ub - lb);
9227 if( conshdlrdata->vp_maxperturb > 0.0 )
9232 aux[
i] -=
SCIPrandomGetReal(conshdlrdata->vp_randnumgen, 0.0, conshdlrdata->vp_maxperturb);
9233 else if( aux[
i] == 0.0 )
9234 aux[
i] +=
SCIPrandomGetReal(conshdlrdata->vp_randnumgen, 0.0, conshdlrdata->vp_maxperturb);
9237 SCIP_Real perturbation;
9239 perturbation =
MIN( aux[
i], 1.0 - aux[
i] ) / 2.0;
9240 perturbation =
MIN( perturbation, conshdlrdata->vp_maxperturb );
9241 aux[
i] +=
SCIPrandomGetReal(conshdlrdata->vp_randnumgen, -perturbation, perturbation);
9243 assert(0.0 < aux[
i] && aux[
i] < 1.0);
9276 if( conshdlrdata->vp_dualsimplex )
9304 facetcoefs[nonfixedpos[
i]] = aux[
i];
9306 *facetconstant = aux[nrows - 1];
9310 for(
i = 0;
i < nallvars; ++
i )
9330 varpos = nonfixedpos[
i];
9331 lb = box[2 * varpos];
9332 ub = box[2 * varpos + 1];
9336 facetcoefs[varpos] = facetcoefs[varpos] / (ub - lb);
9339 *facetconstant -= facetcoefs[varpos] * lb;
9342 facetvalue += facetcoefs[varpos] * xstar[varpos];
9349 facetvalue += *facetconstant;
9358 if( overestimate == (facetvalue > targetvalue) )
9360 SCIPdebugMsg(
scip,
"missed the target, facetvalue %g targetvalue %g, overestimate=%u\n", facetvalue, targetvalue, overestimate);
9387 SCIP_Real* facetcoef,
9388 SCIP_Real* facetconstant
9401 *facetcoef = (funright - funleft) / (right - left);
9402 *facetconstant = funleft - *facetcoef * left;
9439 *
alpha = -b3*c2 + a3*(-b2+c2) + a2*(b3-c3) + b2*c3;
9440 *beta = -(-b3*c1 + a3*(-b1+c1) + a1*(b3-c3) + b1*c3);
9441 *gamma_ = -a2*b1 + a1*b2 + a2*c1 - b2*c1 - a1*c2 + b1*c2;
9442 *delta = -a3*b2*c1 + a2*b3*c1 + a3*b1*c2 - a1*b3*c2 - a2*b1*c3 + a1*b2*c3;
9489 SCIPdebugMsg(
scip,
"numerical troubles - try to solve the linear system via an LU factorization\n");
9529 SCIP_Bool overestimate,
9539 SCIP_Real targetvalue,
9541 SCIP_Real* facetcoefs,
9542 SCIP_Real* facetconstant
9545 SCIP_Real
alpha, beta, gamma_, delta;
9546 SCIP_Real xstarval, candxstarval = 0.0;
9567 targetvalue = -targetvalue;
9584 for( leaveout = 1; leaveout <= 4; ++leaveout )
9590 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p2[0], p2[1], p2val, p3[0], p3[1], p3val, p4[0], p4[1], p4val,
9591 &
alpha, &beta, &gamma_, &delta) );
9593 if(
alpha * p1[0] + beta * p1[1] + gamma_ * p1val - delta > 0.0 )
9599 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p1[0], p1[1], p1val, p3[0], p3[1], p3val, p4[0], p4[1], p4val,
9600 &
alpha, &beta, &gamma_, &delta) );
9602 if(
alpha * p2[0] + beta * p2[1] + gamma_ * p2val - delta > 0.0 )
9608 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p1[0], p1[1], p1val, p2[0], p2[1], p2val, p4[0], p4[1], p4val,
9609 &
alpha, &beta, &gamma_, &delta) );
9611 if(
alpha * p3[0] + beta * p3[1] + gamma_ * p3val - delta > 0.0 )
9617 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p1[0], p1[1], p1val, p2[0], p2[1], p2val, p3[0], p3[1], p3val,
9618 &
alpha, &beta, &gamma_, &delta) );
9620 if(
alpha * p4[0] + beta * p4[1] + gamma_ * p4val - delta > 0.0 )
9645 xstarval = -
alpha/gamma_ * xstar[0] -beta/gamma_ * xstar[1] + delta/gamma_;
9648 if( xstarval <= targetvalue && (!*success || xstarval < candxstarval) )
9654 facetcoefs[0] = -
alpha/gamma_;
9655 facetcoefs[1] = -beta/gamma_;
9656 *facetconstant = delta/gamma_;
9659 candxstarval = xstarval;
9681 if( nelems > *maxnelems )
9686 assert(newsize >= nelems);
9690 *maxnelems = newsize;
9711 if( nelems > *maxnelems )
9716 assert(newsize > *maxnelems);
9721 *maxnelems = newsize;
9739 SCIP_Bool hasparentcoef,
9740 SCIP_Real parentcoef,
9742 SCIP_Real** consvals,
9752 SCIP_Real val1 = 0.0;
9753 SCIP_Real val2 = 0.0;
9773 assert(*maxnconsvars > 0);
9781 if( nchildren != 2 )
9791 for( childidx = 0; childidx < 2; ++childidx )
9794 (*consvals)[0] = 1.0;
9811 var1 = (*consvars)[0];
9812 val1 = (*consvals)[0];
9816 var2 = (*consvars)[0];
9817 val2 = (*consvals)[0];
9846 prodval = coef * val1 * val2;
9877 SCIP_Bool* hasvalue,
9930 safeexponent = (int) (exponent + 0.5);
9931 if( safeexponent % 2 != 0 )
9980 SCIP_Bool hasparentcoef,
9981 SCIP_Real parentcoef,
9982 SCIP_Bool hassymval,
9985 SCIP_Real** consvals,
9992 SCIP_Real edgeweight;
10014 (*consvars)[0] =
var;
10015 (*consvals)[0] = 1.0;
10031 var = (*consvars)[0];
10032 edgeweight = (*consvals)[0];
10043 TRUE, edgeweight) );
10045 TRUE, edgeweight) );
10065 SCIP_Bool hasparentcoef,
10066 SCIP_Real parentcoef,
10067 SCIP_Bool hassymval,
10070 SCIP_Real** consvals,
10077 SCIP_Real constant;
10105 for(
i = 0;
i < nlocvars; ++
i)
10125 var = (*consvars)[0];
10129 if( nlocvars == 2 )
10131 var = (*consvars)[1];
10154 if( nlocvars == 1 )
10156 var = (*consvars)[0];
10157 weight = (*consvals)[0];
10178 for(
i = 0;
i < 2; ++
i)
10180 var = (*consvars)[
i];
10181 weight =
ABS((*consvals)[
i]);
10206 SCIP_Bool hasparentcoef,
10207 SCIP_Real parentcoef,
10209 SCIP_Real** consvals,
10216 SCIP_Real val = 0.0;
10217 SCIP_Bool hasval =
FALSE;
10226 assert(*maxnconsvars > 0);
10250 hasval, val, consvars, consvals, maxnconsvars, success) );
10255 hasval, val, consvars, consvals, maxnconsvars, handledexprs, success) );
10308 return (ub + lb) / 2;
10320 SCIP_Real** consvals,
10336 SCIP_Real* sumcoefs;
10337 SCIP_Real constant;
10338 SCIP_Real constant2;
10341 SCIP_Bool* powexprused =
NULL;
10342 int* powperm =
NULL;
10343 int* prodperm =
NULL;
10354 int nprodexprs = 0;
10364 assert(*maxnconsvars > 0);
10378 for(
i = 0;
i < nchildren; ++
i )
10382 SCIP_Real exponent;
10390 else if( !
SCIPisEQ(
scip, (SCIP_Real) powcoef, sumcoefs[
i]) )
10414 powexprs[npowexprs] = children[
i];
10415 powvars[npowexprs++] =
var;
10426 else if( !
SCIPisEQ(
scip, (SCIP_Real) 2 * powcoef, -sumcoefs[
i]) )
10443 prodexprs[nprodexprs] = children[
i];
10444 prodvars[nprodexprs++] =
var;
10445 prodexprs[nprodexprs] = children[
i];
10446 prodvars[nprodexprs++] = var2;
10451 if( npowexprs == 0 || nprodexprs != npowexprs )
10458 SCIPsort(powperm, SCIPsortVarPtr, (
void*) powvars, npowexprs);
10459 SCIPsort(prodperm, SCIPsortVarPtr, (
void*) prodvars, npowexprs);
10461 for(
i = 0;
i < npowexprs; ++
i )
10468 assert(npowexprs % 2 == 0);
10476 SCIP_Bool var1found =
FALSE;
10477 SCIP_Bool var2found =
FALSE;
10479 (*consvals)[0] = 1.0;
10480 (*consvars)[0] = prodvars[cnt++];
10487 if( nlocvars != 1 )
10492 actvar = (*consvars)[0];
10493 val = (*consvals)[0];
10495 (*consvals)[0] = 1.0;
10496 (*consvars)[0] = prodvars[cnt++];
10503 if( nlocvars != 1 )
10505 actvar2 = (*consvars)[0];
10506 val2 = (*consvals)[0];
10539 for( j = 0; j < npowexprs && !(var1found && var2found); ++j )
10541 if( powexprused[j] )
10545 if( !var1found && powvars[j] == prodvars[cnt - 2] )
10548 powexprused[j] =
TRUE;
10551 else if( !var2found && powvars[j] == prodvars[cnt - 1] )
10554 powexprused[j] =
TRUE;
10587 SCIP_Real* consvals;
10588 SCIP_Real constant;
10589 SCIP_Real parentcoef = 0.0;
10600 SCIP_Bool iscolored;
10601 SCIP_Bool hasparentcoef;
10673 if( expr == rootexpr )
10674 parentidx = consnodeidx;
10678 parentidx = openidx[nopenidx - 1];
10682 hasparentcoef =
FALSE;
10683 if ( expr != rootexpr )
10694 openidx[nopenidx++] = -1;
10696 assert(maxnconsvars > 0);
10700 if( hasparentcoef )
10705 parentidx = nodeidx;
10725 parentidx = thisidx;
10728 nconsvars, constant) );
10741 openidx[nopenidx++] = -1;
10745 SCIP_Bool usedefaultgadget =
TRUE;
10747 assert(expr == rootexpr || parentidx > 0);
10759 usedefaultgadget =
FALSE;
10798 &consvars, &consvals, &maxnconsvars, handledexprs) );
10802 openidx[nopenidx++] = sumidx;
10809 parentcoef, &consvars, &consvals, &maxnconsvars, handledexprs, &succ) );
10813 usedefaultgadget =
FALSE;
10823 &consvars, &consvals, &maxnconsvars, handledexprs, &succ) );
10827 usedefaultgadget =
FALSE;
10832 if( usedefaultgadget )
10862 openidx[nopenidx++] = opidx;
10900 assert(targetconshdlr != conshdlr);
10906 for(
i = 0;
i < sourceconshdlrdata->nnlhdlrs; ++
i )
10908 SCIP_CALL( SCIPnlhdlrCopyhdlr(
scip, targetconshdlr, conshdlr, sourceconshdlrdata->nlhdlrs[
i]) );
10927 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
10933 conshdlrdata->nlhdlrssize = 0;
10936 for(
i = 0;
i < conshdlrdata->nconsupgrades; ++
i )
10947 if( conshdlrdata->vp_randnumgen !=
NULL )
10953 if( conshdlrdata->vp_lp[
i] !=
NULL )
10959 assert(conshdlrdata->branchrandnumgen ==
NULL);
10982 conshdlrdata->lastboundrelax = ++conshdlrdata->curboundstag;
10984 conshdlrdata->enforound = 1;
10986 conshdlrdata->auxvarid = 0;
10988 for(
i = 0;
i < nconss; ++
i )
10995 if( conshdlrdata->nnlhdlrs > 1 )
10996 SCIPsortDownPtr((
void**)conshdlrdata->nlhdlrs, SCIPnlhdlrComp, conshdlrdata->nnlhdlrs);
11003 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11009 conshdlrdata->nweaksepa = 0;
11010 conshdlrdata->ntightenlp = 0;
11011 conshdlrdata->ndesperatebranch = 0;
11012 conshdlrdata->ndesperatecutoff = 0;
11013 conshdlrdata->ndesperatetightenlp = 0;
11014 conshdlrdata->nforcelp = 0;
11016 conshdlrdata->ncanonicalizecalls = 0;
11019 ENFOLOG( enfologfile = fopen(ENFOLOGFILE,
"w"); )
11041 SCIPsortDownPtr((
void**)consssorted, compIndexConsNonlinear, nconss);
11043 for(
i = 0;
i < nconss; ++
i )
11052 conshdlrdata->subnlpheur =
NULL;
11053 conshdlrdata->trysolheur =
NULL;
11055 if( conshdlrdata->vp_randnumgen !=
NULL )
11061 if( conshdlrdata->vp_lp[
i] !=
NULL )
11067 if( conshdlrdata->branchrandnumgen !=
NULL )
11071 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11077 if( enfologfile !=
NULL )
11079 fclose(enfologfile);
11080 enfologfile =
NULL;
11088#ifdef SCIP_DISABLED_CODE
11092 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11098#define consInitpreNonlinear NULL
11106 SCIP_Bool infeasible;
11157 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11163 if( conshdlrdata->branchpscostweight > 0.0 )
11166 if( strchr(
"lds", conshdlrdata->branchpscostupdatestrategy) ==
NULL )
11168 SCIPerrorMessage(
"branching/lpgainnormalize strategy %c unknown\n", conshdlrdata->branchpscostupdatestrategy);
11193 conshdlrdata->checkedvarlocks =
FALSE;
11196 if( conshdlrdata->newsoleventfilterpos >= 0 )
11204 conshdlrdata->newsoleventfilterpos = -1;
11220 assert((*consdata)->nlockspos == 0);
11221 assert((*consdata)->nlocksneg == 0);
11229 if( (*consdata)->nlrow !=
NULL )
11256 targetexpr, sourcedata->lhs, sourcedata->rhs,
FALSE,
11286 if( conshdlrdata->linearizeheursol !=
'o' && conshdlrdata->newsoleventfilterpos == -1 )
11294 eventhdlr, (
SCIP_EVENTDATA*)conshdlr, &conshdlrdata->newsoleventfilterpos) );
11353 SCIP_Longint soltag;
11361 for(
c = 0;
c < nconss; ++
c )
11388 SCIPdebugMsg(
scip,
"registered %d external branching candidates\n", nnotify);
11393 SCIPdebugMsg(
scip,
"could not find branching candidates, forcing to solve LP\n");
11408 SCIP_Bool maypropfeasible;
11409 SCIP_Longint soltag;
11427 maypropfeasible =
FALSE;
11430 for(
c = 0;
c < nconss; ++
c )
11458 else if( (conshdlrdata->subnlpheur ==
NULL ||
sol ==
NULL) && !maypropfeasible && !completely )
11466 maypropfeasible =
FALSE;
11468 if( maypropfeasible )
11475 if( !(consdata->linvarincr !=
NULL && consdata->linvarincrcoef > 0.0) &&
11476 !(consdata->linvardecr !=
NULL && consdata->linvardecrcoef < 0.0) )
11477 maypropfeasible =
FALSE;
11485 if( !(consdata->linvarincr !=
NULL && consdata->linvarincrcoef < 0.0) &&
11486 !(consdata->linvardecr !=
NULL && consdata->linvardecrcoef > 0.0) )
11487 maypropfeasible =
FALSE;
11533 SCIP_Bool infeasible;
11593 for(
c = 0;
c < nconss; ++
c )
11595 SCIP_Bool upgraded;
11619 && !conshdlrdata->checkedvarlocks && conshdlrdata->checkvarlocks !=
'd' )
11624 conshdlrdata->checkedvarlocks =
TRUE;
11626 for(
c = 0;
c < nconss; ++
c )
11628 int tmpnchgvartypes = 0;
11629 int tmpnaddconss = 0;
11632 SCIPdebugMsg(
scip,
"presolSingleLockedVars() for %s: nchgvartypes=%d naddconss=%d infeas=%u\n",
11642 (*nchgvartypes) += tmpnchgvartypes;
11643 (*naddconss) += tmpnaddconss;
11647 if( *ndelconss > 0 || *nchgbds > 0 || *nupgdconss > 0 || *naddconss > 0 || *nchgvartypes > 0 )
11657#ifdef SCIP_DISABLED_CODE
11661 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11667#define consRespropNonlinear NULL
11677 SCIP_Bool reinitsolve =
FALSE;
11692 if( ownerdata->nenfos >= 0 )
11694 if( (consdata->nlockspos == 0) != (nlockspos == 0) )
11695 reinitsolve =
TRUE;
11696 if( (consdata->nlocksneg == 0) != (nlocksneg == 0) )
11697 reinitsolve =
TRUE;
11722 SCIP_Bool infeasible =
FALSE;
11730 SCIP_Bool replacedroot;
11732 if( !consdata->issimplified )
11741 consdata->expr = simplified;
11742 consdata->issimplified =
TRUE;
11773 if( hashmapexpr !=
NULL && hashmapexpr != child )
11791 assert(consdata->nlockspos == 0);
11792 assert(consdata->nlocksneg == 0);
11878#ifdef SCIP_DISABLED_CODE
11882 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11888#define consDelvarsNonlinear NULL
11941 SCIP_CALL(
SCIPcopyExpr(sourcescip,
scip, sourcedata->expr, &targetexpr, exprownerCreate, (
void*)targetconshdlr, varmap, consmap, global,
valid) );
11943 if( targetexpr ==
NULL )
11951 targetexpr, sourcedata->lhs, sourcedata->rhs,
FALSE,
11952 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
11955 if( targetexpr !=
NULL )
11988 endptr = (
char*)str;
11997 if( isdigit((
unsigned char)str[0]) || ((str[0] ==
'-' || str[0] ==
'+') && isdigit((
unsigned char)str[1])) )
12009 if( endptr[0] !=
'<' || endptr[1] !=
'=' )
12033 if( strncmp(str,
"[free]", 6) == 0 )
12087 consexprtree, lhs, rhs,
FALSE,
12088 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12113 if( varssize < consdata->nvarexprs )
12119 for(
i = 0;
i < consdata->nvarexprs; ++
i )
12142 *
nvars = consdata->nvarexprs;
12149#ifdef SCIP_DISABLED_CODE
12153 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
12159#define consGetDiveBdChgsNonlinear NULL
12194 SCIPinfoMessage(
scip, file,
"Nonlinear Conshdlr : %10s %10s %10s %10s %10s %10s %10s\n",
"WeakSepa",
"TightenLP",
"DespTghtLP",
"DespBranch",
"DespCutoff",
"ForceLP",
"CanonTime");
12254 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
12288 conshdlrdata->intevalvar = intEvalVarBoundTightening;
12289 conshdlrdata->curboundstag = 1;
12290 conshdlrdata->lastboundrelax = 1;
12291 conshdlrdata->curpropboundstag = 1;
12292 conshdlrdata->newsoleventfilterpos = -1;
12303 conshdlrCopyNonlinear,
12304 consFreeNonlinear, consInitNonlinear, consExitNonlinear,
12306 consDeleteNonlinear, consTransNonlinear, consInitlpNonlinear,
12307 consSepalpNonlinear, consSepasolNonlinear, consEnfolpNonlinear, consEnforelaxNonlinear, consEnfopsNonlinear, consCheckNonlinear,
12309 consActiveNonlinear, consDeactiveNonlinear,
12311 consPrintNonlinear, consCopyNonlinear, consParseNonlinear,
12313 consGetSignedPermsymGraphNonlinear, conshdlrdata) );
12318 "limit on number of propagation rounds for a set of constraints within one round of SCIP propagation",
12319 &conshdlrdata->maxproprounds,
FALSE, 10, 0, INT_MAX,
NULL,
NULL) );
12322 "whether to check bounds of all auxiliary variable to seed reverse propagation",
12326 "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",
12327 &conshdlrdata->varboundrelax,
TRUE,
'r',
"nabr",
NULL,
NULL) );
12330 "by how much to relax variable bounds during bound tightening if strategy 'a', 'b', or 'r'",
12334 "by how much to relax constraint sides during bound tightening",
12338 "maximal relative perturbation of reference point when computing facet of envelope of vertex-polyhedral function (dim>2)",
12342 "adjust computed facet of envelope of vertex-polyhedral function up to a violation of this value times LP feasibility tolerance",
12346 "whether to use dual simplex instead of primal simplex for LP that computes facet of vertex-polyhedral function",
12350 "maximal number of auxiliary expressions per bilinear term",
12354 "whether to reformulate products of binary variables during presolving",
12358 "whether to use the AND constraint handler for reformulating binary products",
12362 "minimum number of terms to reformulate bilinear binary products by factorizing variables (<= 1: disabled)",
12363 &conshdlrdata->reformbinprodsfac,
FALSE, 50, 1, INT_MAX,
NULL,
NULL) );
12366 "whether to forbid multiaggregation of nonlinear variables",
12370 "whether to tighten LP feasibility tolerance during enforcement, if it seems useful",
12374 "whether to (re)run propagation in enforcement",
12378 "threshold for when to regard a cut from an estimator as weak (lower values allow more weak cuts)",
12379 &conshdlrdata->weakcutthreshold,
TRUE, 0.2, 0.0, 1.0,
NULL,
NULL) );
12382 "\"strong\" cuts will be scaled to have their maximal coef in [1/strongcutmaxcoef,strongcutmaxcoef]",
12386 "consider efficacy requirement when deciding whether a cut is \"strong\"",
12390 "whether to force \"strong\" cuts in enforcement",
12394 "an expression will be enforced if the \"auxiliary\" violation is at least this factor times the \"original\" violation",
12395 &conshdlrdata->enfoauxviolfactor,
TRUE, 0.01, 0.0, 1.0,
NULL,
NULL) );
12398 "retry enfo of constraint with weak cuts if violation is least this factor of maximal violated constraints",
12399 &conshdlrdata->weakcutminviolfactor,
TRUE, 0.5, 0.0, 2.0,
NULL,
NULL) );
12402 "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",
12403 &conshdlrdata->rownotremovable,
TRUE,
'o',
"oea",
NULL,
NULL) );
12406 "method how to scale violations to make them comparable (not used for feasibility check): (n)one, (a)ctivity and side, norm of (g)radient",
12407 &conshdlrdata->violscale,
TRUE,
'n',
"nag",
NULL,
NULL) );
12410 "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)",
12411 &conshdlrdata->checkvarlocks,
TRUE,
't',
"bdt",
NULL,
NULL) );
12414 "from which depth on in the tree to allow branching on auxiliary variables (variables added for extended formulation)",
12415 &conshdlrdata->branchauxmindepth,
FALSE, INT_MAX, 0, INT_MAX,
NULL,
NULL) );
12418 "whether to use external branching candidates and branching rules for branching",
12422 "consider a constraint highly violated if its violation is >= this factor * maximal violation among all constraints",
12423 &conshdlrdata->branchhighviolfactor,
FALSE, 0.0, 0.0, 1.0,
NULL,
NULL) );
12426 "consider a variable branching score high if its branching score >= this factor * maximal branching score among all variables",
12427 &conshdlrdata->branchhighscorefactor,
FALSE, 0.9, 0.0, 1.0,
NULL,
NULL) );
12430 "weight by how much to consider the violation assigned to a variable for its branching score",
12434 "weight by how much to consider fractionality of integer variables in branching score for spatial branching",
12438 "weight by how much to consider the dual values of rows that contain a variable for its branching score",
12442 "weight by how much to consider the pseudo cost of a variable for its branching score",
12446 "weight by how much to consider the domain width in branching score",
12450 "weight by how much to consider variable type (continuous: 0, binary: 1, integer: 0.1, impl-integer: 0.01) in branching score",
12454 "how to aggregate several branching scores given for the same expression: 'a'verage, 'm'aximum, 's'um",
12455 &conshdlrdata->branchscoreagg,
FALSE,
's',
"ams",
NULL,
NULL) );
12458 "method used to split violation in expression onto variables: 'u'niform, 'm'idness of solution, 'd'omain width, 'l'ogarithmic domain width",
12459 &conshdlrdata->branchviolsplit,
FALSE,
'm',
"umdl",
NULL,
NULL) );
12462 "minimum pseudo-cost update count required to consider pseudo-costs reliable",
12466 "minimal average pseudo cost count for discrete variables at which to start considering spatial branching before branching on fractional integer variables",
12470 "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)",
12471 &conshdlrdata->linearizeheursol,
FALSE,
'o',
"oie",
NULL,
NULL) );
12474 "whether to assume that any constraint is convex",
12479 "signals a bound change to a nonlinear constraint", processVarEvent,
NULL) );
12509 processNewSolutionEvent,
NULL) );
12520 const char* conshdlrname
12535 if( conshdlr ==
NULL )
12545 for(
i = conshdlrdata->nconsupgrades - 1;
i >= 0; --
i )
12547 if( conshdlrdata->consupgrades[
i]->consupgd == nlconsupgd )
12550 SCIPwarningMessage(
scip,
"Try to add already known upgrade method for constraint handler <%s>.\n", conshdlrname);
12558 consupgrade->consupgd = nlconsupgd;
12564 assert(conshdlrdata->nconsupgrades+1 <= conshdlrdata->consupgradessize);
12566 for(
i = conshdlrdata->nconsupgrades;
i > 0 && conshdlrdata->consupgrades[
i-1]->priority < consupgrade->
priority; --
i )
12567 conshdlrdata->consupgrades[
i] = conshdlrdata->consupgrades[
i-1];
12569 conshdlrdata->consupgrades[
i] = consupgrade;
12570 conshdlrdata->nconsupgrades++;
12595 SCIP_Bool separate,
12605 SCIP_Bool modifiable,
12611 SCIP_Bool removable
12620 if( conshdlr ==
NULL )
12628 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12666 SCIP_Real* lincoefs,
12670 SCIP_Real* quadcoefs,
12675 SCIP_Bool separate,
12685 SCIP_Bool modifiable,
12691 SCIP_Bool removable
12699 assert(nquadterms == 0 || (quadvars1 !=
NULL && quadvars2 !=
NULL && quadcoefs !=
NULL));
12703 if( conshdlr ==
NULL )
12710 SCIP_CALL(
SCIPcreateExprQuadratic(
scip, &expr, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, exprownerCreate, (
void*)conshdlr) );
12715 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12737 SCIP_Real* lincoefs,
12741 SCIP_Real* quadcoefs,
12746 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs,
12765 SCIP_Real* offsets,
12766 SCIP_Real constant,
12768 SCIP_Real rhscoeff,
12769 SCIP_Real rhsoffset
12775 SCIP_Real termcoefs[2];
12787 if( offsets !=
NULL && offsets[
i] != 0.0 )
12806 termcoefs[0] = 1.0;
12809 termcoefs[1] = -rhscoeff;
12835 SCIP_Real exponent,
12844 SCIP_Real coefs[2];
12851 if( xoffset != 0.0 )
12889 return conshdlrdata->curboundstag;
12902 return conshdlrdata->lastboundrelax;
12913 SCIP_Bool boundrelax
12921 ++conshdlrdata->curboundstag;
12922 assert(conshdlrdata->curboundstag > 0);
12925 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
12945 SCIP_Bool overestimate,
12947 SCIP_Real auxvalue,
12948 SCIP_Bool allowweakcuts,
12949 SCIP_Bool branchscoresuccess,
12950 SCIP_Bool inenforcement,
12958 SCIP_Bool sepasuccess;
12960 SCIP_Real mincutviolation;
12978 sepasuccess =
TRUE;
12981 if( cutviol > 0.0 )
13002 if( (!overestimate && ( cutviol <= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) ||
13003 ( overestimate && (-cutviol >= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) )
13006 "weak: auxvarvalue %g estimateval %g auxvalue %g (over %d)\n",
13008 auxvarvalue + (overestimate ? -cutviol : cutviol), auxvalue, overestimate); )
13009 sepasuccess =
FALSE;
13014 estimateval = auxvarvalue + (!overestimate ? cutviol : -cutviol);
13018 sepasuccess =
FALSE;
13027 "estimateval %g auxvalue %g (over %d)\n ",
SCIPnlhdlrGetName(nlhdlr), auxvarvalue,
13028 auxvarvalue + (overestimate ? -cutviol : cutviol), auxvalue, overestimate);
13034 if( !allowweakcuts )
13046 "min requ viol = %g\n", cutviol, sepasuccess ?
"" :
"not ", mincutviolation); )
13048 sepasuccess = cutviol > mincutviolation;
13057 SCIP_Real auxvarcoef = 0.0;
13072 if( auxvarcoef == 0.0 ||
13073 (!overestimate && ( cutviol / auxvarcoef <= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) ||
13074 ( overestimate && (-cutviol / auxvarcoef >= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) )
13076 ENFOLOG(
SCIPinfoMessage(
scip, enfologfile,
" cut is too weak after cleanup: auxvarvalue %g estimateval %g auxvalue %g (over %d)\n",
13077 auxvarvalue, auxvarvalue + (overestimate ? -cutviol : cutviol) / auxvarcoef, auxvalue, overestimate); )
13078 sepasuccess =
FALSE;
13089 if( !branchscoresuccess )
13105 SCIP_Real violscore;
13107#ifdef BRSCORE_ABSVIOL
13132 if( conshdlrdata->branchdualweight > 0.0 )
13143 (void) sprintf(gap,
"_estimategap=%g",
REALABS(auxvalue - estimateval));
13161 SCIP_Bool infeasible;
13169 SCIP_CALL(
SCIPaddRow(
scip, row, conshdlrdata->forcestrongcut && !allowweakcuts && inenforcement, &infeasible) );
13172 if( conshdlrdata->rownotremovable ==
'a' || (conshdlrdata->rownotremovable ==
'e' && inenforcement) )
13189 else if( branchscoresuccess )
13202 "branching candidates%s\n",
SCIPnlhdlrGetName(nlhdlr), (allowweakcuts && inenforcement) ?
13221 return conshdlrdata->assumeconvex;
13259 return conshdlrdata->nbilinterms;
13278 return conshdlrdata->bilinterms;
13303 if( conshdlrdata->bilinhashtable ==
NULL )
13319 assert(idx >= -1 && idx < conshdlrdata->nbilinterms);
13320 assert(idx < 0 || conshdlrdata->bilinterms[idx].
x ==
x);
13321 assert(idx < 0 || conshdlrdata->bilinterms[idx].
y ==
y);
13348 assert(idx >= -1 && idx < conshdlrdata->nbilinterms);
13352 return &conshdlrdata->bilinterms[idx];
13399 term = &conshdlrdata->bilinterms[idx];
13405 if( auxvar !=
NULL )
13425 SCIP_Bool overestimate
13441 nlockspos = overestimate ? 1 : 0;
13442 nlocksneg = overestimate ? 0 : 1;
13446 term = &conshdlrdata->bilinterms[idx];
13457 if( conshdlrdata->bilinmaxnauxexprs <= 1 )
13461 auxvarexpr->
cst = 0.0;
13462 auxvarexpr->
coefs[0] = 1.0;
13463 auxvarexpr->
coefs[1] = 0.0;
13464 auxvarexpr->
coefs[2] = 0.0;
13482 auxexpr->
auxvar = auxvar;
13483 auxexpr->
coefs[0] = coefaux;
13487 auxexpr->
coefs[1] = coefx;
13488 auxexpr->
coefs[2] = coefy;
13494 auxexpr->
coefs[1] = coefy;
13495 auxexpr->
coefs[2] = coefx;
13497 auxexpr->
cst = cst;
13504 else if( auxvar !=
NULL )
13516 SCIP_Bool overestimate,
13522 SCIP_Real targetvalue,
13523 SCIP_Bool* success,
13524 SCIP_Real* facetcoefs,
13525 SCIP_Real* facetconstant
13529 SCIP_Real* funvals;
13531 SCIP_Real maxfaceterror;
13533 unsigned int ncorners;
13551 for( j = 0; j < nallvars; ++j )
13555 nonfixedpos[
nvars] = j;
13573 for( j = 0; j < nallvars; ++j )
13576 corner[j] = (box[2 * j] + box[2 * j + 1]) / 2.0;
13578 for(
i = 0;
i < ncorners; ++
i )
13581 for( j = 0; j <
nvars; ++j )
13583 int varpos = nonfixedpos[j];
13587 if( (
i >> j) & 0x1 )
13588 corner[varpos] = box[2 * varpos + 1];
13590 corner[varpos] = box[2 * varpos ];
13595 funvals[
i] = function(corner, nallvars, fundata);
13601 SCIPdebugMsg(
scip,
"cannot compute underestimator; function value at corner is too large %g\n", funvals[
i]);
13614 if( *success && overestimate == (*facetconstant + facetcoefs[nonfixedpos[0]] * xstar[nonfixedpos[0]] > targetvalue) )
13616 SCIPdebugMsg(
scip,
"computed secant, but missed target %g (facetvalue=%g, overestimate=%u)\n", targetvalue, *facetconstant + facetcoefs[nonfixedpos[0]] * xstar[nonfixedpos[0]], overestimate);
13622 int idx1 = nonfixedpos[0];
13623 int idx2 = nonfixedpos[1];
13624 SCIP_Real p1[2] = { box[2*idx1], box[2*idx2] };
13625 SCIP_Real p2[2] = { box[2*idx1+1], box[2*idx2] };
13626 SCIP_Real p3[2] = { box[2*idx1], box[2*idx2+1] };
13627 SCIP_Real p4[2] = { box[2*idx1+1], box[2*idx2+1] };
13628 SCIP_Real xstar2[2] = { xstar[idx1], xstar[idx2] };
13629 SCIP_Real coefs[2] = { 0.0, 0.0 };
13631 SCIP_CALL(
computeVertexPolyhedralFacetBivariate(
scip, overestimate, p1, p2, p3, p4, funvals[0], funvals[1], funvals[2], funvals[3], xstar2, targetvalue, success, coefs, facetconstant) );
13633 facetcoefs[idx1] = coefs[0];
13634 facetcoefs[idx2] = coefs[1];
13638 SCIP_CALL(
computeVertexPolyhedralFacetLP(
scip, conshdlr, overestimate, xstar, box, nallvars, nonfixedpos, funvals,
nvars, targetvalue, success, facetcoefs, facetconstant) );
13653 if( maxfaceterror > 0.0 )
13662 for( j = 0; j <
nvars; ++j )
13663 corner[nonfixedpos[j]] = (box[2 * nonfixedpos[j]] + box[2 * nonfixedpos[j] + 1]) / 2.0;
13664 midval = function(corner, nallvars, fundata);
13672 if( maxfaceterror > conshdlrdata->vp_adjfacetthreshold * feastol * fabs(midval) )
13674 SCIPdebugMsg(
scip,
"ignoring facet due to instability, it cuts off a vertex by %g (midval=%g).\n", maxfaceterror, midval);
13679 SCIPdebugMsg(
scip,
"maximum facet error %g (midval=%g), adjust constant to make cut valid!\n", maxfaceterror, midval);
13682 *facetconstant += maxfaceterror;
13684 *facetconstant -= maxfaceterror;
13716 return consdata->expr;
13732 return consdata->lhs;
13748 return consdata->rhs;
13767 if( consdata->nlrow ==
NULL )
13772 *nlrow = consdata->nlrow;
13793 return consdata->curv;
13805 SCIP_Bool* isquadratic
13847 SCIPerrorMessage(
"SCIPchgLhsNonlinear can only be called in problem stage.\n");
13857 if( consdata->lhs == lhs )
13860 consdata->lhs = lhs;
13863 consdata->ispropagated =
FALSE;
13886 SCIPerrorMessage(
"SCIPchgLhsNonlinear can only be called in problem stage.\n");
13896 if( consdata->rhs == rhs )
13899 consdata->rhs = rhs;
13902 consdata->ispropagated =
FALSE;
13926 SCIPerrorMessage(
"SCIPchgExprNonlinear can only be called in problem stage.\n");
13944 assert(consdata->nvarexprs == 0);
13946 assert(!consdata->catchedevents);
13955 consdata->issimplified =
FALSE;
13956 consdata->ispropagated =
FALSE;
13981 SCIPerrorMessage(
"SCIPaddLinearVarNonlinear can only be called in problem stage.\n");
14002 assert(consdata->nvarexprs == 0);
14004 assert(!consdata->catchedevents);
14016 SCIP_EXPR* children[2] = { consdata->expr, varexpr };
14017 SCIP_Real coefs[2] = { 1.0, coef };
14028 consdata->issimplified =
FALSE;
14029 consdata->ispropagated =
FALSE;
14054 SCIPerrorMessage(
"SCIPaddLinearVarNonlinear can only be called in problem stage.\n");
14075 assert(consdata->nvarexprs == 0);
14077 assert(!consdata->catchedevents);
14090 SCIP_EXPR* children[2] = { consdata->expr, exprowned };
14091 SCIP_Real coefs[2] = { 1.0, coef };
14102 consdata->issimplified =
FALSE;
14103 consdata->ispropagated =
FALSE;
14117 SCIP_Real* activity
14199 *
var = consdata->linvardecr;
14200 *coef = consdata->linvardecrcoef;
14223 *
var = consdata->linvarincr;
14224 *coef = consdata->linvarincrcoef;
14269 return ownerdata->filterpos >= -1 ?
SCIPgetVarExprVar(expr) : ownerdata->auxvar;
14290 SCIP_Bool* sepabelowusesactivity,
14291 SCIP_Bool* sepaaboveusesactivity,
14292 SCIP_Real* auxvalue
14302 assert(idx < ownerdata->nenfos);
14306 *nlhdlr = ownerdata->enfos[idx]->nlhdlr;
14308 if( nlhdlrexprdata !=
NULL )
14309 *nlhdlrexprdata = ownerdata->enfos[idx]->nlhdlrexprdata;
14311 if( nlhdlrparticipation !=
NULL )
14312 *nlhdlrparticipation = ownerdata->enfos[idx]->nlhdlrparticipation;
14314 if( sepabelowusesactivity !=
NULL )
14315 *sepabelowusesactivity = ownerdata->enfos[idx]->sepabelowusesactivity;
14317 if( sepaaboveusesactivity !=
NULL )
14318 *sepaaboveusesactivity = ownerdata->enfos[idx]->sepaaboveusesactivity;
14320 if( auxvalue !=
NULL )
14321 *auxvalue = ownerdata->enfos[idx]->auxvalue;
14339 assert(idx < ownerdata->nenfos);
14342 ownerdata->enfos[idx]->auxvalue = auxvalue;
14403 SCIP_Bool useauxvar,
14404 SCIP_Bool useactivityforprop,
14405 SCIP_Bool useactivityforsepabelow,
14406 SCIP_Bool useactivityforsepaabove
14420 if( ownerdata->nenfos >= 0 &&
14421 ( (ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && (useactivityforprop || useactivityforsepabelow || useactivityforsepaabove)) ||
14422 (ownerdata->nauxvaruses == 0 && useauxvar)
14434 ++ownerdata->nauxvaruses;
14436 if( useactivityforprop )
14437 ++ownerdata->nactivityusesprop;
14439 if( useactivityforsepabelow || useactivityforsepaabove )
14440 ++ownerdata->nactivityusessepa;
14445 if( useactivityforsepabelow )
14447 if( useactivityforsepaabove )
14450 if( useactivityforprop )
14494 SCIP_Longint soltag,
14496 SCIP_Bool* violunder,
14497 SCIP_Bool* violover
14528 SCIP_Real auxvalue,
14531 SCIP_Bool* violunder,
14532 SCIP_Bool* violover
14560 SCIP_Real auxvalue,
14563 SCIP_Bool* violunder,
14564 SCIP_Bool* violover
14614 if( ownerdata->propboundstag == conshdlrdata->curpropboundstag )
14616 bounds = ownerdata->propbounds;
14629 if( ownerdata->auxvar !=
NULL )
14634 auxvarbounds = conshdlrdata->intevalvar(
scip, ownerdata->auxvar, conshdlrdata);
14717 if( ownerdata->propboundstag == conshdlrdata->curpropboundstag )
14730 SCIPdebugMsg(
scip,
" applied %s: [%.20g,%.20g]\n", ownerdata->propboundstag == conshdlrdata->curpropboundstag ?
"previous propbounds" :
"activity", newbounds.
inf, newbounds.
sup);
14736 SCIPdebugMsg(
scip,
" cut off due to empty intersection with previous propbounds or activity\n");
14748 ownerdata->propbounds = newbounds;
14749 ownerdata->propboundstag = conshdlrdata->curpropboundstag;
14763 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);
14768 if(
SCIPexprGetNChildren(expr) > 0 && !ownerdata->inpropqueue && (ownerdata->nactivityusesprop > 0 || ownerdata->nactivityusessepa > 0 || ownerdata->nenfos < 0) )
14777 ownerdata->inpropqueue =
TRUE;
14824 for(
c = 0;
c < ownerdata->nconss; ++
c )
14828 consdata->ispropagated =
FALSE;
14851 SCIP_Real violscore
14859 assert(violscore >= 0.0);
14873 if( ownerdata->violscoretag != conshdlrdata->enforound )
14875 ownerdata->violscoresum = violscore;
14876 ownerdata->violscoremax = violscore;
14877 ownerdata->nviolscores = 1;
14878 ownerdata->violscoretag = conshdlrdata->enforound;
14882 ownerdata->violscoresum += violscore;
14883 if( violscore > ownerdata->violscoremax )
14884 ownerdata->violscoremax = violscore;
14885 ++ownerdata->nviolscores;
14898 SCIP_Real violscore,
14934 for(
i = 0;
i < nexprs; ++
i )
14943 if( varssize ==
nvars )
14950 varexprs[
nvars++] = e;
14980 if( conshdlrdata->enforound != ownerdata->violscoretag )
14983 if( ownerdata->nviolscores == 0 )
14986 switch( conshdlrdata->branchscoreagg )
14990 return ownerdata->violscoresum / ownerdata->nviolscores;
14994 return ownerdata->violscoremax;
14998 return ownerdata->violscoresum;
15001 SCIPerrorMessage(
"Invalid value %c for branchscoreagg parameter\n", conshdlrdata->branchscoreagg);
15109 SCIP_Real auxvalue;
15111 SCIP_Real* lincoefs;
15123 for(
i = 0;
i < nlinexprs; ++
i )
15130 for(
i = 0;
i < nquadexprs; ++
i )
15142 auxvalue += (lincoef + sqrcoef * solval) * solval;
15146 for(
i = 0;
i < nbilinexprs; ++
i )
15172 int detectpriority,
15188 if( conshdlr ==
NULL )
15203 conshdlrdata->nlhdlrs[conshdlrdata->nnlhdlrs] = *nlhdlr;
15204 ++conshdlrdata->nnlhdlrs;
15210 SCIPsortDownPtr((
void**)conshdlrdata->nlhdlrs, SCIPnlhdlrComp, conshdlrdata->nnlhdlrs);
15227 return conshdlrdata->nnlhdlrs;
15242 return conshdlrdata->nlhdlrs;
15260 for(
h = 0;
h < conshdlrdata->nnlhdlrs; ++
h )
15262 return conshdlrdata->nlhdlrs[
h];
15285 for( e = 0; e < ownerdata->nenfos; ++e )
15286 if( ownerdata->enfos[e]->nlhdlr == nlhdlr )
15287 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_Bool branchingIntegralFirst(SCIP *scip, SCIP_CONSHDLR *conshdlr)
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 selectBranchingCandidate(SCIP *scip, SCIP_CONSHDLR *conshdlr, BRANCHCAND *cands, int ncands, SCIP_Bool considerfracnl, BRANCHCAND **selected)
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 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_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 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_RETCODE SCIPaddSymgraphEdge(SCIP *scip, SYM_GRAPH *graph, int first, int second, SCIP_Bool hasval, SCIP_Real val)
SCIP_RETCODE SCIPaddSymgraphOpnode(SCIP *scip, SYM_GRAPH *graph, int op, int *nodeidx)
SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
SCIP_RETCODE SCIPaddSymgraphValnode(SCIP *scip, SYM_GRAPH *graph, SCIP_Real val, int *nodeidx)
int SCIPgetSymgraphVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
SCIP_RETCODE SCIPaddSymgraphConsnode(SCIP *scip, SYM_GRAPH *graph, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, int *nodeidx)
SCIP_RETCODE SCIPaddSymgraphVarAggregation(SCIP *scip, SYM_GRAPH *graph, int rootidx, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real constant)
int SCIPgetSymExprdataNConstants(SYM_EXPRDATA *symdata)
int SCIPgetSymgraphNegatedVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
SCIP_RETCODE SCIPfreeSymDataExpr(SCIP *scip, SYM_EXPRDATA **symdata)
int SCIPgetSymgraphNNodes(SYM_GRAPH *graph)
SCIP_Real * SCIPgetSymExprdataConstants(SYM_EXPRDATA *symdata)
SCIP_RETCODE SCIPgetCoefSymData(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *parentexpr, SCIP_Real *coef, SCIP_Bool *success)
SCIP_TABLE * SCIPfindTable(SCIP *scip, const char *name)
SCIP_RETCODE SCIPincludeTable(SCIP *scip, const char *name, const char *desc, SCIP_Bool active, SCIP_DECL_TABLECOPY((*tablecopy)), SCIP_DECL_TABLEFREE((*tablefree)), SCIP_DECL_TABLEINIT((*tableinit)), SCIP_DECL_TABLEEXIT((*tableexit)), SCIP_DECL_TABLEINITSOL((*tableinitsol)), SCIP_DECL_TABLEEXITSOL((*tableexitsol)), SCIP_DECL_TABLEOUTPUT((*tableoutput)), SCIP_TABLEDATA *tabledata, int position, SCIP_STAGE earlieststage)
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstopClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_Bool SCIPisRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisUbBetter(SCIP *scip, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLbBetter(SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_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_Real SCIPfeastol(SCIP *scip)
SCIP_Real SCIPgetHugeValue(SCIP *scip)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPepsilon(SCIP *scip)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
int SCIPgetDepth(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPaddVarLocks(SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
void SCIPvarMarkRelaxationOnly(SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetIndex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
void SCIPqueueFree(SCIP_QUEUE **queue)
SCIP_RETCODE SCIPqueueCreate(SCIP_QUEUE **queue, int initsize, SCIP_Real sizefac)
SCIP_RETCODE SCIPqueueInsert(SCIP_QUEUE *queue, void *elem)
SCIP_Bool SCIPqueueIsEmpty(SCIP_QUEUE *queue)
void * SCIPqueueRemove(SCIP_QUEUE *queue)
SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)
int SCIPrandomGetInt(SCIP_RANDNUMGEN *randnumgen, int minrandval, int maxrandval)
SCIP_VAR ** SCIProwprepGetVars(SCIP_ROWPREP *rowprep)
SCIP_RETCODE SCIPcleanupRowprep2(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Real maxcoefbound, SCIP_Bool *success)
int SCIProwprepGetNModifiedVars(SCIP_ROWPREP *rowprep)
SCIP_Real SCIPgetRowprepViolation(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Bool *reliable)
SCIP_Real * SCIProwprepGetCoefs(SCIP_ROWPREP *rowprep)
SCIP_VAR ** SCIProwprepGetModifiedVars(SCIP_ROWPREP *rowprep)
char * SCIProwprepGetName(SCIP_ROWPREP *rowprep)
SCIP_SIDETYPE SCIProwprepGetSidetype(SCIP_ROWPREP *rowprep)
SCIP_RETCODE SCIPaddRowprepTerm(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_VAR *var, SCIP_Real coef)
SCIP_RETCODE SCIPgetRowprepRowCons(SCIP *scip, SCIP_ROW **row, SCIP_ROWPREP *rowprep, SCIP_CONS *cons)
int SCIProwprepGetNVars(SCIP_ROWPREP *rowprep)
void SCIProwprepRecordModifications(SCIP_ROWPREP *rowprep)
SCIP_RETCODE SCIPcleanupRowprep(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Real minviol, SCIP_Real *viol, SCIP_Bool *success)
void SCIPfreeRowprep(SCIP *scip, SCIP_ROWPREP **rowprep)
void SCIPprintRowprep(SCIP *scip, SCIP_ROWPREP *rowprep, FILE *file)
SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
void SCIPsortDown(int *perm, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownIntPtr(int *intarray, void **ptrarray, int len)
void SCIPsort(int *perm, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPskipSpace(char **s)
SCIPfreeSol(scip, &heurdata->sol))
SCIPfreeRandom(scip, &heurdata->randnumgen)
SCIPcreateRandom(scip, &heurdata->randnumgen, DEFAULT_RANDSEED, TRUE))
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
NLP local search primal heuristic using sub-SCIPs.
primal heuristic that tries a given solution
SCIP_Bool SCIPcliqueHasVar(SCIP_CLIQUE *clique, SCIP_VAR *var, SCIP_Bool value)
static volatile int nterms
SCIP_Bool SCIPlapackIsAvailable(void)
SCIP_RETCODE SCIPlapackSolveLinearEquations(BMS_BUFMEM *bufmem, int n, SCIP_Real *A, SCIP_Real *b, SCIP_Real *x, SCIP_Bool *success)
interface methods for lapack functions
static const char * paramname[]
#define BMSclearMemoryArray(ptr, num)
SCIP_RETCODE SCIPnlhdlrFree(SCIP *scip, SCIP_NLHDLR **nlhdlr)
SCIP_RETCODE SCIPnlhdlrCreate(SCIP *scip, SCIP_NLHDLR **nlhdlr, const char *name, const char *desc, int detectpriority, int enfopriority, SCIP_DECL_NLHDLRDETECT((*detect)), SCIP_DECL_NLHDLREVALAUX((*evalaux)), SCIP_NLHDLRDATA *nlhdlrdata)
void SCIPnlhdlrPrintStatistics(SCIP *scip, SCIP_NLHDLR **nlhdlrs, int nnlhdlrs, FILE *file)
private functions of nonlinear handlers of nonlinear constraints
#define SCIPnlhdlrIncrementNSeparated(nlhdlr)
#define SCIPnlhdlrResetNDetectionslast(nlhdlr)
#define SCIPnlhdlrIncrementNCutoffs(nlhdlr)
nonlinear handlers for convex and concave expressions, respectively
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
SCIP_RETCODE SCIPgetSymOpNodeType(SCIP *scip, const char *opnodename, int *nodetype)
propagator for symmetry handling
#define SCIPdebugPrintCons(x, y, z)
methods for sorting joint arrays of various types
public functions to work with algebraic expressions
SCIP_DECL_NONLINCONSUPGD((*consupgd))
SCIP_NLHDLR_METHOD nlhdlrparticipation
SCIP_Bool sepaaboveusesactivity
SCIP_Bool sepabelowusesactivity
SCIP_NLHDLREXPRDATA * nlhdlrexprdata
SCIP_CONSNONLINEAR_AUXEXPR ** exprs
union SCIP_ConsNonlinear_BilinTerm::@4 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