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;
179 unsigned int lastenforced;
180 unsigned int nactivityusesprop;
181 unsigned int nactivityusessepa;
182 unsigned int nauxvaruses;
189 unsigned int violscoretag;
220 unsigned int ispropagated:1;
221 unsigned int issimplified:1;
248struct SCIP_ConshdlrData
260 int consupgradessize;
273 unsigned int enforound;
281 unsigned int curpropboundstag;
294 int reformbinprodsfac;
304 char rownotremovable;
307 int branchauxmindepth;
318 char branchviolsplit;
321 char linearizeheursol;
343 int bilinmaxnauxexprs;
347 char branchpscostupdatestrategy;
352 int newsoleventfilterpos;
399 if( mydata->auxvar ==
NULL )
441 mydata->nactivityusesprop = 0;
442 mydata->nactivityusessepa = 0;
443 mydata->nauxvaruses = 0;
447 for( e = 0; e < mydata->nenfos; ++e )
453 nlhdlr = mydata->enfos[e]->nlhdlr;
456 if( mydata->enfos[e]->issepainit )
459 SCIP_CALL( SCIPnlhdlrExitsepa(
scip, nlhdlr, expr, mydata->enfos[e]->nlhdlrexprdata) );
460 mydata->enfos[e]->issepainit =
FALSE;
464 if( mydata->enfos[e]->nlhdlrexprdata !=
NULL )
466 SCIP_CALL( SCIPnlhdlrFreeexprdata(
scip, nlhdlr, expr, &mydata->enfos[e]->nlhdlrexprdata) );
467 assert(mydata->enfos[e]->nlhdlrexprdata ==
NULL);
493 assert((*ownerdata)->nlockspos == 0);
494 assert((*ownerdata)->nlocksneg == 0);
499 assert((*ownerdata)->nenfos <= 0);
508 assert((*ownerdata)->nconss == 0);
510 assert((*ownerdata)->filterpos == -1);
542 if( ownerdata->nenfos > 0 )
547 for(
i = 0;
i < ownerdata->nenfos; ++
i )
564 if( ownerdata->auxvar !=
NULL )
609 (*ownerdata)->nenfos = -1;
617 (*ownerdata)->filterpos = -1;
640 (*ownerdata)->filterpos = -2;
643 *ownerfree = exprownerFree;
644 *ownerprint = exprownerPrint;
645 *ownerevalactivity = exprownerEvalactivity;
750 if( consdata->varexprs !=
NULL )
754 assert(consdata->nvarexprs == 0);
757 if( consdata->issimplified )
773 assert(varexprssize >= consdata->nvarexprs);
776 if( varexprssize > consdata->nvarexprs )
788 for(
i = 0;
i < consdata->nvarexprs; ++
i )
811 if( consdata->varexprs ==
NULL )
815 assert(consdata->nvarexprs >= 0);
816 assert(!consdata->catchedevents);
819 for(
i = 0;
i < consdata->nvarexprs; ++
i )
828 consdata->varexprs =
NULL;
829 consdata->nvarexprs = 0;
853 if( conshdlrdata->globalbounds )
876 switch( conshdlrdata->varboundrelax )
891 lb =
MAX(bnd, lb - conshdlrdata->varboundrelaxamount);
898 ub =
MIN(bnd, ub + conshdlrdata->varboundrelaxamount);
911 lb -= conshdlrdata->varboundrelaxamount;
914 ub += conshdlrdata->varboundrelaxamount;
946 SCIPerrorMessage(
"Unsupported value '%c' for varboundrelax option.\n", conshdlrdata->varboundrelax);
975 return consdata1->consindex - consdata2->consindex;
1002 assert(ownerdata->nconss > 0);
1006 boundtightened =
TRUE;
1015 boundtightened =
TRUE;
1025 boundtightened =
TRUE;
1032 if( boundtightened )
1037 for(
c = 0;
c < ownerdata->nconss; ++
c )
1047 consdata->ispropagated =
FALSE;
1053 consdata->issimplified =
FALSE;
1069 ++conshdlrdata->curboundstag;
1070 assert(conshdlrdata->curboundstag > 0);
1074 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
1079 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &activity, conshdlrdata->intevalvar, conshdlrdata) );
1117 for(
i = 0;
i < ownerdata->nconss; ++
i )
1118 assert(ownerdata->conss[
i] != cons);
1124 ownerdata->conss[ownerdata->nconss++] = cons;
1128 if( ownerdata->nconss <= 1 )
1129 ownerdata->consssorted =
TRUE;
1130 else if( ownerdata->consssorted )
1131 ownerdata->consssorted = compIndexConsNonlinear(ownerdata->conss[ownerdata->nconss-2], ownerdata->conss[ownerdata->nconss-1]) > 0;
1134 if( ownerdata->filterpos < 0 )
1138 assert(ownerdata->nconss == 1);
1143 assert(ownerdata->filterpos >= 0);
1168 assert(consdata->nvarexprs >= 0);
1171 if( consdata->catchedevents )
1177 assert(conshdlrdata->intevalvar == intEvalVarBoundTightening);
1182 for(
i = 0;
i < consdata->nvarexprs; ++
i )
1184 expr = consdata->varexprs[
i];
1197 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &activity, intEvalVarBoundTightening, conshdlrdata) );
1206 consdata->catchedevents =
TRUE;
1234 assert(ownerdata->nconss > 0);
1236 if( ownerdata->conss[ownerdata->nconss-1] == cons )
1238 pos = ownerdata->nconss-1;
1242 if( !ownerdata->consssorted )
1244 SCIPsortPtr((
void**)ownerdata->conss, compIndexConsNonlinear, ownerdata->nconss);
1245 ownerdata->consssorted =
TRUE;
1248 if( !
SCIPsortedvecFindPtr((
void**)ownerdata->conss, compIndexConsNonlinear, cons, ownerdata->nconss, &pos) )
1253 assert(pos >= 0 && pos < ownerdata->nconss);
1255 assert(ownerdata->conss[pos] == cons);
1258 if( pos < ownerdata->nconss-1 )
1260 ownerdata->conss[pos] = ownerdata->conss[ownerdata->nconss-1];
1261 ownerdata->consssorted =
FALSE;
1263 --ownerdata->nconss;
1266 if( ownerdata->nconss == 0 )
1270 assert(ownerdata->filterpos >= 0);
1275 ownerdata->filterpos = -1;
1299 if( !consdata->catchedevents )
1303 assert(consdata->nvarexprs >= 0);
1307 for(
i = consdata->nvarexprs - 1;
i >= 0; --
i )
1314 consdata->catchedevents =
FALSE;
1366 SCIPerrorMessage(
"Locally valid nonlinear constraints are not supported, yet.\n");
1373 SCIPerrorMessage(
"Non-initial nonlinear constraints are not supported, yet.\n");
1387 consdata->expr = expr;
1390 consdata->lhs = lhs;
1391 consdata->rhs = rhs;
1392 consdata->consindex = conshdlrdata->lastconsindex++;
1396 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
1397 local, modifiable, dynamic, removable,
FALSE) );
1434 if( violunder !=
NULL )
1436 if( violover !=
NULL )
1445 if( violunder !=
NULL )
1447 if( violover !=
NULL )
1454 if( violunder !=
NULL )
1456 if( violover !=
NULL )
1461 if( violunder !=
NULL )
1463 if( violover !=
NULL )
1501 if( violunder !=
NULL )
1503 if( violover !=
NULL )
1510 if( ownerdata->nlocksneg > 0 && auxvarvalue > auxvalue )
1512 if( violunder !=
NULL )
1514 if( violover !=
NULL )
1516 return auxvarvalue - auxvalue;
1519 if( ownerdata->nlockspos > 0 && auxvalue > auxvarvalue )
1521 if( violunder !=
NULL )
1523 if( violover !=
NULL )
1525 return auxvalue - auxvarvalue;
1528 if( violunder !=
NULL )
1530 if( violover !=
NULL )
1588 return MAX3(0.0, consdata->lhsviol, consdata->rhsviol);
1620 if( conshdlrdata->violscale ==
'n' )
1629 if( conshdlrdata->violscale ==
'a' )
1634 if( consdata->lhsviol > 0.0 &&
REALABS(consdata->lhs) > scale )
1637 scale =
REALABS(consdata->lhs);
1639 else if( consdata->rhsviol > 0.0 &&
REALABS(consdata->rhs) > scale )
1642 scale =
REALABS(consdata->rhs);
1650 assert(conshdlrdata->violscale ==
'g');
1651 if( soltag == 0L || consdata->gradnormsoltag != soltag )
1657 consdata->gradnorm = 0.0;
1666 for(
i = 0;
i < consdata->nvarexprs; ++
i )
1675 consdata->gradnorm = 0.0;
1679 consdata->gradnorm += deriv*deriv;
1682 consdata->gradnorm = sqrt(consdata->gradnorm);
1683 consdata->gradnormsoltag = soltag;
1686 *viol /=
MAX(1.0, consdata->gradnorm);
1721 consdata->linvarincr =
NULL;
1722 consdata->linvardecr =
NULL;
1723 consdata->linvarincrcoef = 0.0;
1724 consdata->linvardecrcoef = 0.0;
1760 if( (consdata->linvardecr ==
NULL) ||
1763 consdata->linvardecr =
var;
1764 consdata->linvardecrcoef = coef;
1773 if( (consdata->linvarincr ==
NULL) ||
1776 consdata->linvarincr =
var;
1777 consdata->linvarincrcoef = coef;
1783 assert(consdata->linvarincr ==
NULL || consdata->linvarincrcoef != 0.0);
1784 assert(consdata->linvardecr ==
NULL || consdata->linvardecrcoef != 0.0);
1786 if( consdata->linvarincr !=
NULL )
1790 if( consdata->linvardecr !=
NULL )
1838 SCIPdebugMsg(
scip,
"attempt to make solution from <%s> feasible by shifting linear variable\n",
1841 for(
c = 0;
c < nconss; ++
c )
1852 viol = consdata->lhsviol;
1854 viol = -consdata->rhsviol;
1858 if( consdata->linvarincr !=
NULL &&
1859 ((viol > 0.0 && consdata->linvarincrcoef > 0.0) || (viol < 0.0 && consdata->linvarincrcoef < 0.0)) )
1864 delta = viol / consdata->linvarincrcoef;
1871 delta =
MIN(
MAX(0.0, gap), delta);
1880 SCIPdebugMsg(
scip,
"increase <%s> by %g to %g to remedy lhs-violation %g of cons <%s>\n",
1884 viol -= consdata->linvarincrcoef * delta;
1891 if( consdata->linvardecr !=
NULL &&
1892 ((viol > 0.0 && consdata->linvardecrcoef < 0.0) || (viol < 0.0 && consdata->linvardecrcoef > 0.0)) )
1897 delta = viol / consdata->linvardecrcoef;
1904 delta =
MAX(
MIN(0.0, gap), delta);
1913 SCIPdebugMsg(
scip,
"increase <%s> by %g to %g to remedy rhs-violation %g of cons <%s>\n",
1917 viol -= consdata->linvardecrcoef * delta;
1989 for(
c = 0;
c < nconss; ++
c )
2005 for(
i = 0;
i < consdata->nvarexprs; ++
i )
2027 if( ownerdata->auxvar !=
NULL )
2033 for( e = 0; e < ownerdata->nenfos; ++e )
2037 ownerdata->enfos[e]->nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata,
sol, solisbest,
2131 if( ntightenings !=
NULL )
2145 if( ntightenings !=
NULL )
2184 if( infeasible !=
NULL )
2185 *infeasible =
FALSE;
2186 if( ntightenings !=
NULL )
2195 SCIPdebugMsg(
scip,
"stored activity of root expr is empty and valid (activitytag >= lastboundrelax (%" SCIP_LONGINT_FORMAT ")), skip forwardPropExpr -> cutoff\n", conshdlrdata->lastboundrelax);
2197 if( infeasible !=
NULL )
2224 if( ownerdata->nenfos >= 0 && ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && !conshdlrdata->indetect)
2227 SCIPdebugMsg(
scip,
"root expr activity is not used but enfo initialized, skip inteval\n");
2275 SCIPexprGetActivityTag(expr) >= conshdlrdata->lastvaractivitymethodchange && !conshdlrdata->globalbounds )
2280 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &exprhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );
2310 if( infeasible !=
NULL )
2312 SCIPdebugMsg(
scip,
"expr %p already has empty activity -> cutoff\n", (
void*)expr);
2322 if( ownerdata->nenfos >= 0 && ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && !conshdlrdata->indetect )
2325 SCIPdebugMsg(
scip,
"expr %p activity is not used but enfo initialized, skip inteval\n", (
void*)expr);
2337 if( ownerdata->nenfos > 0 )
2350 nlhdlr = ownerdata->enfos[e]->nlhdlr;
2358 nlhdlrinterval = activity;
2359 SCIP_CALL( SCIPnlhdlrInteval(
scip, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata,
2360 &nlhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );
2376 SCIP_CALL( SCIPcallExprInteval(
scip, expr, &exprhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );
2420 if( infeasible !=
NULL )
2423 else if( tightenauxvars && ownerdata->auxvar !=
NULL )
2428 if( tighteninfeasible )
2430 if( infeasible !=
NULL )
2476 if( subsetsufficient )
2535 while( !
SCIPqueueIsEmpty(conshdlrdata->reversepropqueue) && !(*infeasible) )
2546 assert(ownerdata->inpropqueue);
2548 ownerdata->inpropqueue =
FALSE;
2553 assert(ownerdata->propboundstag == conshdlrdata->curpropboundstag);
2561#ifdef SCIP_DISABLED_CODE
2569 propbounds = ownerdata->propbounds;
2572 if( ownerdata->nenfos > 0 )
2575 for( e = 0; e < ownerdata->nenfos && !*infeasible; ++e )
2584 nlhdlr = ownerdata->enfos[e]->nlhdlr;
2595 SCIP_CALL( SCIPnlhdlrReverseprop(
scip, conshdlr, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, propbounds, infeasible, &nreds) );
2597 *ntightenings += nreds;
2615 assert(ownerdata->nenfos < 0);
2622 SCIP_CALL( SCIPcallExprReverseprop(
scip, expr, propbounds, childrenbounds, infeasible) );
2644 ownerdata->inpropqueue =
FALSE;
2712 assert(conshdlrdata->intevalvar == intEvalVarBoundTightening);
2714 assert(!conshdlrdata->globalbounds);
2720 conshdlrdata->forceboundtightening = force;
2723 ++conshdlrdata->curpropboundstag;
2726 if( conshdlrdata->propauxvars )
2741 for(
i = 0;
i < nconss; ++
i )
2753 if( consdata->ispropagated )
2774 if( !conshdlrdata->propauxvars || ownerdata->auxvar ==
NULL )
2780 if( ownerdata->auxvar ==
NULL )
2789 conssides = intEvalVarBoundTightening(
scip, ownerdata->auxvar, (
void*)conshdlrdata);
2808 if( ownerdata->auxvar ==
NULL )
2811 if( ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 )
2814 conssides = intEvalVarBoundTightening(
scip, ownerdata->auxvar, (
void*)conshdlrdata);
2826 assert(ntightenings >= 0);
2827 if( ntightenings > 0 )
2829 *nchgbds += ntightenings;
2834 consdata->ispropagated =
TRUE;
2839 assert(ntightenings >= 0);
2849 if( ntightenings > 0 )
2851 *nchgbds += ntightenings;
2855 while( ntightenings > 0 && ++roundnr < conshdlrdata->maxproprounds );
2857 if( conshdlrdata->propauxvars )
2862 conshdlrdata->forceboundtightening =
FALSE;
2865 ++conshdlrdata->curpropboundstag;
2915 for(
c = 0;
c < nconss && !
cutoff; ++
c )
2932 for( e = 0; e < ownerdata->nenfos; ++e )
2937 nlhdlr = ownerdata->enfos[e]->nlhdlr;
2942 SCIPdebugMsg(
scip,
"propExprDomains calling reverseprop for expression %p [%g,%g]\n", (
void*)expr,
2945 SCIP_CALL( SCIPnlhdlrReverseprop(
scip, conshdlr, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata,
2956 assert(ntightenings >= 0);
2957 if( ntightenings > 0 )
2959 *nchgbds += ntightenings;
2968 assert(ntightenings >= 0);
2975 else if( ntightenings > 0 )
2977 *nchgbds += ntightenings;
3005 if( nlockspos == 0 && nlocksneg == 0 )
3014 ituserdata.
intvals[0] = nlockspos;
3015 ituserdata.
intvals[1] = nlocksneg;
3022 nlockspos = ituserdata.
intvals[0];
3023 nlocksneg = ituserdata.
intvals[1];
3038 ownerdata->nlockspos += nlockspos;
3039 ownerdata->nlocksneg += nlocksneg;
3042 if( ownerdata->nlockspos == nlockspos && ownerdata->nlocksneg == nlocksneg &&
SCIPexprGetNChildren(expr) > 0
3048 assert(ownerdata->monotonicitysize == 0);
3056 SCIP_CALL( SCIPcallExprMonotonicity(
scip, expr,
i, &ownerdata->monotonicity[
i]) );
3065 if( ownerdata->nlockspos == 0 && ownerdata->nlocksneg == 0 && ownerdata->monotonicity !=
NULL )
3067 assert(ownerdata->monotonicitysize > 0);
3072 ownerdata->monotonicitysize = 0;
3088 switch( monotonicity )
3091 ituserdata.
intvals[0] = nlockspos;
3092 ituserdata.
intvals[1] = nlocksneg;
3095 ituserdata.
intvals[0] = nlocksneg;
3096 ituserdata.
intvals[1] = nlockspos;
3099 ituserdata.
intvals[0] = nlockspos + nlocksneg;
3100 ituserdata.
intvals[1] = nlockspos + nlocksneg;
3155 if( nlockspos == 0 && nlocksneg == 0 )
3166 consdata->nlockspos += nlockspos;
3167 consdata->nlocksneg += nlocksneg;
3169 assert(consdata->nlockspos >= 0);
3170 assert(consdata->nlocksneg >= 0);
3206 if( consdata->nlrow !=
NULL )
3315 assert(conshdlrdata->auxvarid >= 0);
3316 assert(!conshdlrdata->indetect);
3319 assert(ownerdata->nenfos < 0);
3329 if( ownerdata->nauxvaruses == 0 )
3333 if( ownerdata->nlockspos == 0 )
3335 if( ownerdata->nlocksneg == 0 )
3338 if( ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 )
3347 ownerdata->nenfos = 0;
3350 conshdlrdata->indetect =
TRUE;
3352 SCIPdebugMsg(
scip,
"detecting nlhdlrs for %s expression %p (%s); requiring%s%s%s\n",
3358 for(
h = 0;
h < conshdlrdata->nnlhdlrs; ++
h )
3362 nlhdlr = conshdlrdata->nlhdlrs[
h];
3370 nlhdlrexprdata =
NULL;
3371 enforcemethodsnew = enforcemethods;
3373 conshdlrdata->registerusesactivitysepabelow =
FALSE;
3374 conshdlrdata->registerusesactivitysepaabove =
FALSE;
3376 SCIP_CALL( SCIPnlhdlrDetect(
scip, ownerdata->conshdlr, nlhdlr, expr, cons, &enforcemethodsnew, &nlhdlrparticipating, &nlhdlrexprdata) );
3379 nlhdlrparticipating &= enforcemethodsallowed;
3382 assert((enforcemethodsnew & enforcemethods) == enforcemethods);
3387 nlhdlrenforcemethods = (enforcemethodsnew ^ enforcemethods) & enforcemethodsallowed;
3390 assert((nlhdlrparticipating & nlhdlrenforcemethods) == nlhdlrenforcemethods);
3398 if( nlhdlrexprdata !=
NULL )
3400 SCIP_CALL( SCIPnlhdlrFreeexprdata(
scip, nlhdlr, expr, &nlhdlrexprdata) );
3410 SCIPdebugMsg(
scip,
"nlhdlr <%s> detect successful; sepabelow: %s, sepaabove: %s, activity: %s\n",
3419 ownerdata->enfos[ownerdata->nenfos]->nlhdlr = nlhdlr;
3420 ownerdata->enfos[ownerdata->nenfos]->nlhdlrexprdata = nlhdlrexprdata;
3421 ownerdata->enfos[ownerdata->nenfos]->nlhdlrparticipation = nlhdlrparticipating;
3422 ownerdata->enfos[ownerdata->nenfos]->issepainit =
FALSE;
3423 ownerdata->enfos[ownerdata->nenfos]->sepabelowusesactivity = conshdlrdata->registerusesactivitysepabelow;
3424 ownerdata->enfos[ownerdata->nenfos]->sepaaboveusesactivity = conshdlrdata->registerusesactivitysepaabove;
3425 ownerdata->nenfos++;
3428 enforcemethods = enforcemethodsnew;
3431 conshdlrdata->indetect =
FALSE;
3438 SCIPerrorMessage(
"no nonlinear handler provided some of the required enforcement methods\n");
3442 assert(ownerdata->nenfos > 0);
3445 if( ownerdata->nenfos > 1 )
3446 SCIPsortDownPtr((
void**)ownerdata->enfos, enfodataCmp, ownerdata->nenfos);
3486 conshdlrdata->globalbounds =
TRUE;
3487 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
3490 for(
i = 0;
i < nconss; ++
i )
3512 if( ownerdata->nenfos > 0 )
3515 assert(ownerdata->nenfos < 0);
3523 conshdlrdata->indetect =
TRUE;
3528 conshdlrdata->indetect =
FALSE;
3540 if( ownerdata->nenfos >= 0 )
3550 if( ownerdata->nauxvaruses > 0 || ownerdata->nactivityusesprop > 0 || ownerdata->nactivityusessepa > 0 )
3554 assert(ownerdata->nenfos >= 0);
3563 ownerdata->nenfos = 0;
3569 consdata->ispropagated =
FALSE;
3578 conshdlrdata->globalbounds =
FALSE;
3579 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
3615 for(
c = 0;
c < nconss; ++
c )
3666 if( consdata->nlrow ==
NULL )
3716 for(
c = 0;
c < nconss; ++
c )
3730 SCIPdebugMsg(
scip,
"exitsepa and free nonlinear handler data for expression %p\n", (
void*)expr);
3738 if( rootactivityvalid )
3749 if( consdata->nlrow !=
NULL )
3763 consdata->linvardecr =
NULL;
3764 consdata->linvarincr =
NULL;
3902 minact +=
MIN(coefs[
i], 0.0);
3903 maxact +=
MAX(coefs[
i], 0.0);
3906 assert(minact <= maxact);
3913#ifdef WITH_DEBUG_SOLUTION
3914 if( SCIPdebugIsMainscip(
scip) )
3925 debugsolval += coefs[
i] * val;
3944 if( naddconss !=
NULL )
3955 if( naddconss !=
NULL )
3969 if( naddconss !=
NULL )
3982 if( naddconss !=
NULL )
4015 int* childidxs =
NULL;
4040 if( nchildren < minterms )
4074 assert(xidx < ntotalvars);
4076 assert(yidx < ntotalvars);
4107 for( j = 0; j <
nterms; ++j )
4109 int childidx = childidxs[j];
4110 assert(childidx >= 0 && childidx < nchildren);
4112 if( !isused[childidx] && (xs[j] == facvar || ys[j] == facvar) )
4118 coef = sumcoefs[childidx];
4122 tmpvars[ntmpvars] = (xs[j] == facvar) ? ys[j] : xs[j];
4123 tmpcoefs[ntmpvars] = coef;
4128 assert(xidx < ntotalvars);
4130 assert(yidx < ntotalvars);
4133 assert(count[xidx] >= 0);
4134 assert(count[yidx] >= 0);
4137 isused[childidx] =
TRUE;
4140 assert(ntmpvars >= minterms);
4146 exprcoefs[nexprs] = 1.0;
4153 int nexprsold = nexprs;
4156 for(
i = 0;
i < nchildren; ++
i )
4161 exprcoefs[nexprs] = sumcoefs[
i];
4170 for(
i = 0;
i < nexprsold; ++
i )
4226 strcpy(name,
"binreform");
4227 for(
i = 0;
i < nchildren; ++
i )
4232 (void) strcat(name,
"_");
4241#ifdef WITH_DEBUG_SOLUTION
4242 if( SCIPdebugIsMainscip(
scip) )
4249 for(
i = 0;
i < nchildren; ++
i )
4261 if( nchildren == 2 && !empathy4and )
4291 if( naddconss !=
NULL )
4303 if( naddconss !=
NULL )
4361 SCIPdebugMsg(
scip,
" product expression %p has been considered for the first time\n", (
void*)prodexpr);
4363 if( nchildren == 2 )
4389 if( nchgcoefs !=
NULL )
4392 found_clique =
TRUE;
4401 if( nchgcoefs !=
NULL )
4404 found_clique =
TRUE;
4421 if( nchgcoefs !=
NULL )
4424 found_clique =
TRUE;
4442 if( nchgcoefs !=
NULL )
4445 found_clique =
TRUE;
4512 if( conshdlrdata->reformbinprodsfac > 1 )
4518 if( newexpr ==
NULL )
4523 if( newexpr !=
NULL )
4525 assert(naddconss ==
NULL || *naddconss > 0 || nchgcoefs ==
NULL || *nchgcoefs > 0);
4534 consdata->issimplified =
FALSE;
4610 for(
c = 0;
c < nconss; ++
c )
4621 if( conshdlrdata->reformbinprodsfac > 1 )
4627 if( newexpr !=
NULL )
4630 consdata->expr = newexpr;
4633 consdata->issimplified =
FALSE;
4682 if( nchildren == 1 && constant == 0.0 && coefs[0] == -1.0 )
4685 expr = consdata->expr;
4693 consdata->lhs = -consdata->lhs;
4694 consdata->rhs = -consdata->rhs;
4702 for(
i = 0;
i < nchildren; ++
i )
4703 counter += coefs[
i] > 0 ? 1 : -1;
4713 for(
i = 0;
i < nchildren; ++
i )
4714 newcoefs[
i] = -coefs[
i];
4721 consdata->expr = expr;
4723 consdata->lhs = -consdata->lhs;
4724 consdata->rhs = -consdata->rhs;
4759 for(
c = 0;
c < nconss; ++
c )
4834 ++(conshdlrdata->ncanonicalizecalls);
4838 *infeasible =
FALSE;
4841 havechange = conshdlrdata->ncanonicalizecalls == 1;
4851 for(
i = 0;
i < nconss; ++
i )
4859 nlockspos[
i] = consdata->nlockspos;
4860 nlocksneg[
i] = consdata->nlocksneg;
4864 assert(consdata->nlockspos == 0);
4865 assert(consdata->nlocksneg == 0);
4870 for(
i = 0;
i < nconss; ++
i )
4895 int tmpnaddconss = 0;
4896 int tmpnchgcoefs = 0;
4904 if( naddconss !=
NULL )
4905 *naddconss = tmpnaddconss;
4906 if( nchgcoefs !=
NULL )
4907 *nchgcoefs = tmpnchgcoefs;
4910 if( tmpnaddconss + tmpnchgcoefs > 0 )
4914 for(
i = 0;
i < nconss; ++
i )
4920 if( !consdata->issimplified && consdata->expr !=
NULL )
4927 consdata->issimplified =
TRUE;
4935 if( simplified != consdata->expr )
4943 consdata->expr = simplified;
4978 if( ndelconss !=
NULL )
4987 if( havechange && !*infeasible )
4994 for(
i = 0;
i < nconss; ++
i )
5003 for(
i = 0;
i < nconss; ++
i )
5016 SCIPsortPtr((
void**)consssorted, compIndexConsNonlinear, nconss);
5018 for(
i = nconss-1;
i >= 0; --
i )
5020 assert(
i == 0 || compIndexConsNonlinear((
void*)consssorted[
i-1], (
void*)consssorted[
i]) < 0);
5027 for(
i = 0;
i < nconss; ++
i )
5046 for(
i = 0;
i < nconss; ++
i )
5060 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
5103 for(
c = 0;
c < nconss; ++
c )
5125 assert(idx >= 0 && idx < nconss);
5129 assert(imgconsdata->expr == consdata->expr);
5131 SCIPdebugMsg(
scip,
"merge constraint %g <= %s <= %g with %g <= %s <= %g\n", consdata->lhs,
5138 nlockspos[idx] = imgconsdata->nlockspos;
5139 nlocksneg[idx] = imgconsdata->nlocksneg;
5141 updatelocks[idx] =
TRUE;
5145 imgconsdata->lhs =
MAX(imgconsdata->lhs, consdata->lhs);
5146 imgconsdata->rhs =
MIN(imgconsdata->rhs, consdata->rhs);
5157 for(
c = 0;
c < nconss; ++
c )
5159 if( updatelocks[
c] )
5193 if( conshdlrdata->globalbounds )
5279 ++conshdlrdata->curboundstag;
5280 assert(conshdlrdata->curboundstag > 0);
5281 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
5282 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
5283 conshdlrdata->intevalvar = intEvalVarRedundancyCheck;
5288 for(
i = 0;
i < nconss; ++
i )
5389 SCIPdebugMsg(
scip,
" -> redundant: activity [%g,%g] within sides [%g,%g]\n", activity.
inf, activity.
sup, consdata->lhs, consdata->rhs);
5397 SCIPdebugMsg(
scip,
" -> not redundant: activity [%g,%g] not within sides [%g,%g]\n", activity.
inf, activity.
sup, consdata->lhs, consdata->rhs);
5402 ++conshdlrdata->curboundstag;
5403 conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;
5404 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
5405 conshdlrdata->intevalvar = intEvalVarBoundTightening;
5444 if( conshdlrdata->nconsupgrades == 0 )
5458 for(
i = 0;
i < conshdlrdata->nconsupgrades; ++
i )
5460 if( !conshdlrdata->consupgrades[
i]->active )
5463 assert(conshdlrdata->consupgrades[
i]->consupgd !=
NULL);
5465 SCIP_CALL( conshdlrdata->consupgrades[
i]->consupgd(
scip, cons, consdata->nvarexprs, &nupgdconss_, upgdconss, upgdconsssize) );
5467 while( nupgdconss_ < 0 )
5470 assert(-nupgdconss_ > upgdconsssize);
5471 upgdconsssize = -nupgdconss_;
5474 SCIP_CALL( conshdlrdata->consupgrades[
i]->consupgd(
scip, cons, consdata->nvarexprs, &nupgdconss_, upgdconss, upgdconsssize) );
5476 assert(nupgdconss_ != 0);
5479 if( nupgdconss_ > 0 )
5487 for( j = 0; j < nupgdconss_; ++j )
5498 *naddconss += nupgdconss_ - 1;
5593 int nsinglelocked = 0;
5604 *infeasible =
FALSE;
5628 for(
i = 0;
i < consdata->nvarexprs; ++
i )
5635 singlelocked[nsinglelocked++] = consdata->varexprs[
i];
5640 if( nsinglelocked > 0 )
5654 for(
i = 0;
i < nchildren; ++
i )
5659 child = children[
i];
5695 valid = exponent > 1.0 && fmod(exponent, 2.0) == 0.0;
5719 for(
i = 0;
i < nsinglelocked; ++
i )
5733 SCIPdebugMsg(
scip,
"found single locked variable %s in [%g,%g] that can be fixed to one of its bounds\n",
5798 *infeasible =
FALSE;
5808 for(
c = 0;
c < nconss; ++
c )
5837 if( nchildren <= 1 )
5843 for(
i = 0;
i < nchildren; ++
i )
5848 candcoef = coefs[
i];
5865 for(
i = 0;
i < nchildren; ++
i )
5867 if( children[
i] == cand )
5888 SCIPdebugMsg(
scip,
"make variable <%s> implicit integer due to constraint <%s>\n",
5926 assert(ownerdata->nauxvaruses > 0);
5929 if( ownerdata->auxvar !=
NULL )
5944 assert(conshdlrdata->auxvarid >= 0);
5954 ++conshdlrdata->auxvarid;
6004#ifdef WITH_DEBUG_SOLUTION
6005 if( SCIPdebugIsMainscip(
scip) )
6047 int nreductions = 0;
6060 ++conshdlrdata->curpropboundstag;
6066 *infeasible =
FALSE;
6067 for(
c = 0;
c < nconss; ++
c )
6076#ifdef WITH_DEBUG_SOLUTION
6077 if( SCIPdebugIsMainscip(
scip) )
6083 if( debugsol !=
NULL )
6105 if( auxvar !=
NULL )
6107 SCIPdebugMsg(
scip,
"tighten auxvar <%s> bounds using constraint sides [%g,%g]\n",
6140 for(
c = 0;
c < nconss && !*infeasible; ++
c )
6156 if( ownerdata->nauxvaruses == 0 )
6159 for( e = 0; e < ownerdata->nenfos; ++e )
6169 if( ownerdata->enfos[e]->issepainit )
6176 nlhdlr = ownerdata->enfos[e]->nlhdlr;
6184 overestimate = ownerdata->nlocksneg > 0;
6185 underestimate = ownerdata->nlockspos > 0;
6186 assert(underestimate || overestimate);
6188 SCIPdebugMsg(
scip,
"initsepa under=%u over=%u for expression %p\n", underestimate, overestimate, (
void*)expr);
6191 SCIP_CALL( SCIPnlhdlrInitsepa(
scip, conshdlr, conss[
c], nlhdlr, expr,
6192 ownerdata->enfos[e]->nlhdlrexprdata, overestimate, underestimate, infeasible) );
6193 ownerdata->enfos[e]->issepainit =
TRUE;
6244 switch( conshdlrdata->branchviolsplit )
6253 return MAX(0.05, weight);
6264 return 10.0*log10(width);
6266 return 0.1/(-log10(width));
6271 SCIPerrorMessage(
"invalid value for parameter constraints/expr/branching/violsplit");
6316 for(
i = 0;
i < nexprs; ++
i )
6328 for(
i = 0;
i < nexprs; ++
i )
6333 if( nunbounded > 0 )
6338 SCIPdebugMsg(
scip,
"add score %g (%g%% of %g) to <%s>[%g,%g]\n", violscore / nunbounded,
6339 100.0/nunbounded, violscore,
6350 SCIPdebugMsg(
scip,
"add score %g (%g%% of %g) to <%s>[%g,%g]\n", violscore * weight / weightsum,
6351 100*weight / weightsum, violscore,
6393 SCIPsortPtr((
void**)auxvars, SCIPvarComp, nauxvars);
6404 if( auxvar ==
NULL )
6410 assert(auxvars[pos] == auxvar);
6413 exprs[nexprs++] = expr;
6415 if( nexprs == nauxvars )
6455 for(
c = 0;
c < nconss; ++
c )
6468 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6510 for(
c = 0;
c < nconss; ++
c )
6529 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6539 if( violscore == 0.0 )
6577 if( violscore == 0.0 )
6655 for( attempt = 0; attempt < 2; ++attempt )
6661 for(
c = 0;
c < nconss; ++
c )
6677 if( attempt == 0 && consviol < conshdlrdata->branchhighviolfactor * maxrelconsviol )
6679 else if( attempt == 1 && consviol >= conshdlrdata->branchhighviolfactor * maxrelconsviol )
6691 for(
i = 0;
i < consdata->nvarexprs; ++
i )
6714 cands[*ncands].
expr = consdata->varexprs[
i];
6715 cands[*ncands].
var =
var;
6753 cands[*ncands].
expr = expr;
6754 cands[*ncands].
var =
var;
6841 for(
r = 0;
r < nrows; ++
r )
6844 const char* estimategapstr;
6858 if( estimategapstr ==
NULL )
6860 estimategap = atof(estimategapstr + 13);
6861 assert(estimategap >= 0.0);
6921 for(
c = 0;
c < ncands; ++
c )
6923 if( conshdlrdata->branchviolweight > 0.0 )
6934 assert(cands[
c].expr !=
NULL || cands[
c].fractionality > 0.0);
6936 if( considerfracnl && cands[
c].fractionality == 0.0 )
6955 if( conshdlrdata->branchdomainweight > 0.0 && cands[
c].
expr !=
NULL )
6970 if( domainwidth >= 1.0 )
6980 if( conshdlrdata->branchdualweight > 0.0 && cands[
c].
expr !=
NULL )
6991 cands[
c].
dual = 0.0;
7000 if( cands[
c].expr !=
NULL )
7016 strategy = conshdlrdata->branchpscostupdatestrategy;
7131 if( conshdlrdata->branchvartypeweight > 0.0 )
7155 for(
c = 0;
c < ncands; ++
c )
7161 cands[
c].weighted = 0.0;
7167 weightsum += conshdlrdata->branchviolweight;
7175 weightsum += conshdlrdata->branchfracweight;
7180 if( maxscore.
domain > 0.0 )
7183 weightsum += conshdlrdata->branchdomainweight;
7188 if( maxscore.
dual > 0.0 )
7191 weightsum += conshdlrdata->branchdualweight;
7196 if( maxscore.
pscost > 0.0 )
7202 weightsum += conshdlrdata->branchpscostweight;
7216 weightsum += conshdlrdata->branchvartypeweight;
7238 if( cands[ind1].weighted != cands[ind2].weighted )
7241 if( cands[ind1].
var != cands[ind2].
var )
7244 return cands[ind1].
expr !=
NULL ? 1 : -1;
7286 SCIPsortDown(perm, branchcandCompare, (
void*)cands, ncands);
7290 SCIPvarGetName(cands[perm[ncands - 1]].
var), cands[perm[ncands - 1]].weighted); )
7295 threshold = conshdlrdata->branchhighscorefactor * cands[perm[0]].
weighted;
7296 while( left < right )
7298 int mid = (left + right) / 2;
7299 if( cands[perm[mid]].weighted >= threshold )
7308 if( cands[perm[left]].weighted >= threshold )
7310 assert(left + 1 == ncands || cands[perm[left + 1]].weighted < threshold);
7315 assert(cands[perm[left]].weighted < threshold);
7321 ENFOLOG(
SCIPinfoMessage(
scip, enfologfile,
" %d branching candidates <%s>(%g)...<%s>(%g) after removing low scores\n", ncands,
7323 SCIPvarGetName(cands[perm[ncands - 1]].
var), cands[perm[ncands - 1]].weighted); )
7328 if( conshdlrdata->branchrandnumgen ==
NULL )
7333 *selected = &cands[perm[
c]];
7336 *selected = &cands[perm[0]];
7372 if( conshdlrdata->branchexternal )
7406 if( downchild !=
NULL || eqchild !=
NULL || upchild !=
NULL )
7446 SCIP_CALL( SCIPnlhdlrEnfo(
scip, conshdlr, cons, nlhdlr, expr, nlhdlrexprdata,
sol, auxvalue, overestimate,
7447 allowweakcuts, separated, inenforcement, branchcandonly,
result) );
7480 SCIP_CALL( SCIPnlhdlrEstimate(
scip, conshdlr, nlhdlr, expr, nlhdlrexprdata,
sol, auxvalue, overestimate,
7481 SCIPgetSolVal(
scip,
sol, auxvar), inenforcement, rowpreps, &sepasuccess, &branchscoresuccess) );
7486 assert((sepasuccess && minidx <= maxidx) || (!sepasuccess && minidx > maxidx));
7494 for(
r = minidx;
r <= maxidx; ++
r )
7501 if( !branchcandonly )
7510 auxvalue, allowweakcuts, branchscoresuccess, inenforcement,
sol,
result) );
7516 if( branchcandonly && branchscoresuccess )
7577 if( !overestimate && !underestimate )
7583 for( e = 0; e < ownerdata->nenfos; ++e )
7592 if( branchcandonly && !ownerdata->enfos[e]->sepaaboveusesactivity && !ownerdata->enfos[e]->sepabelowusesactivity )
7595 nlhdlr = ownerdata->enfos[e]->nlhdlr;
7599 SCIP_CALL( SCIPnlhdlrEvalaux(
scip, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, &ownerdata->enfos[e]->auxvalue,
sol) );
7603 SCIPinfoMessage(
scip, enfologfile,
" (%p): evalvalue %.15g auxvarvalue %.15g [%.15g,%.15g], nlhdlr <%s> " \
7620 if( !
SCIPisInfinity(
scip, auxviol) && auxviol < conshdlrdata->enfoauxviolfactor * origviol )
7623 "auxviolation %g << origviolation %g under:%d over:%d\n",
SCIPnlhdlrGetName(nlhdlr), (
void*)expr,
7635 underestimate, overestimate); )
7643 auxviol, origviol, underestimate, overestimate, allowweakcuts); )
7648 if( overestimate && auxoverestimate && (ownerdata->enfos[e]->nlhdlrparticipation &
SCIP_NLHDLR_METHOD_SEPAABOVE) != 0 && (!branchcandonly || ownerdata->enfos[e]->sepaaboveusesactivity) )
7653 ownerdata->enfos[e]->auxvalue,
TRUE, *
result ==
SCIP_SEPARATED, allowweakcuts, inenforcement, branchcandonly, &hdlrresult) );
7659 ownerdata->lastenforced = conshdlrdata->enforound;
7667 ownerdata->lastenforced = conshdlrdata->enforound;
7676 ownerdata->lastenforced = conshdlrdata->enforound;
7689 ownerdata->lastenforced = conshdlrdata->enforound;
7696 if( underestimate && auxunderestimate && (ownerdata->enfos[e]->nlhdlrparticipation &
SCIP_NLHDLR_METHOD_SEPABELOW) != 0 && (!branchcandonly || ownerdata->enfos[e]->sepabelowusesactivity) )
7701 ownerdata->enfos[e]->auxvalue,
FALSE, *
result ==
SCIP_SEPARATED, allowweakcuts, inenforcement, branchcandonly, &hdlrresult) );
7707 ownerdata->lastenforced = conshdlrdata->enforound;
7715 ownerdata->lastenforced = conshdlrdata->enforound;
7724 ownerdata->lastenforced = conshdlrdata->enforound;
7737 ownerdata->lastenforced = conshdlrdata->enforound;
7780 if( inenforcement && !branchcandonly && !consdata->ispropagated )
7800 if( ntightenings > 0 )
7813 if( ownerdata->auxvar ==
NULL )
7816 assert(ownerdata->lastenforced <= conshdlrdata->enforound);
7817 if( ownerdata->lastenforced == conshdlrdata->enforound )
7832 if( ownerdata->lastenforced == conshdlrdata->enforound )
7896 ++(conshdlrdata->enforound);
7903 for(
c = 0;
c < nconss; ++
c )
7929 for(
i = 0;
i < consdata->nvarexprs; ++
i )
7938 SCIP_CALL(
enforceConstraint(
scip, conshdlr, conss[
c],
sol, soltag, it,
FALSE, inenforcement, branchcandonly,
result, &consenforced) );
7943 if( !consenforced && inenforcement && !branchcandonly )
7948 if( viol > conshdlrdata->weakcutminviolfactor * maxrelconsviol )
7953 SCIP_CALL(
enforceConstraint(
scip, conshdlr, conss[
c],
sol, soltag, it,
TRUE, inenforcement, branchcandonly,
result, &consenforced) );
7956 ++conshdlrdata->nweaksepa;
7966 ENFOLOG(
if( enfologfile !=
NULL ) fflush( enfologfile); )
7983 ENFOLOG(
if( enfologfile !=
NULL ) fflush( enfologfile); )
8025 *branchintegral =
FALSE;
8036 *branchintegral =
TRUE;
8047 SCIPerrorMessage(
"Unexpected separation or propagation from enforceConstraints(branchcandonly = TRUE)\n");
8059 SCIPerrorMessage(
"Unexpected return from enforceConstraints(branchcandonly = TRUE)\n");
8094 *branchintegral =
TRUE;
8152 isfractional =
TRUE;
8164 if( conshdlrdata->branchmixfractional == 0.0 )
8213 *maxabsconsviol = 0.0;
8214 *maxrelconsviol = 0.0;
8217 *maxvarboundviol = 0.0;
8219 for(
c = 0;
c < nconss; ++
c )
8232 *maxabsconsviol =
MAX(*maxabsconsviol, v);
8239 *maxrelconsviol =
MAX(*maxrelconsviol, v);
8256 if( ownerdata->auxvar ==
NULL )
8269 origviol = auxvarlb - auxvarvalue;
8271 origviol = auxvarvalue - auxvarub;
8272 if( origviol <= 0.0 )
8275 *maxvarboundviol =
MAX(*maxvarboundviol, origviol);
8296 *maxvarboundviol = auxvarlb - auxvarvalue;
8297 else if( auxvarvalue - auxvarub > *maxvarboundviol && !
SCIPisInfinity(
scip, auxvarub) )
8298 *maxvarboundviol = auxvarvalue - auxvarub;
8303 if( origviol > 0.0 || auxvarlb > auxvarvalue || auxvarub < auxvarvalue )
8310 if( origviol > 0.0 )
8311 SCIPinfoMessage(
scip, enfologfile,
" auxvar %s expr violated by %g", violunder ?
">=" :
"<=", origviol);
8313 SCIPinfoMessage(
scip, enfologfile,
" auxvar >= auxvar's lb violated by %g", auxvarlb - auxvarvalue);
8315 SCIPinfoMessage(
scip, enfologfile,
" auxvar <= auxvar's ub violated by %g", auxvarvalue - auxvarub);
8321 if( origviol == 0.0 )
8325 for( e = 0; e < ownerdata->nenfos; ++e )
8333 nlhdlr = ownerdata->enfos[e]->nlhdlr;
8337 SCIP_CALL( SCIPnlhdlrEvalaux(
scip, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, &ownerdata->enfos[e]->auxvalue,
sol) );
8346 *maxauxviol =
MAX(*maxauxviol, auxviol);
8347 *minauxviol =
MIN(*minauxviol, auxviol);
8394 for(
c = 0;
c < nconss; ++
c )
8410 &minauxviol, &maxauxviol, &maxvarboundviol) );
8413 "auxviolations in %g..%g, variable bounds violated by at most %g, LP feastol=%e\n",
8430 if( branchintegral )
8439 if( conshdlrdata->propinenforce )
8460 ++conshdlrdata->ntightenlp;
8476 ++conshdlrdata->ntightenlp;
8506 ++conshdlrdata->ntightenlp;
8528 ++conshdlrdata->ndesperatetightenlp;
8538 if( !conshdlrdata->propinenforce )
8560 ++conshdlrdata->ndesperatebranch;
8575 ENFOLOG(
SCIPinfoMessage(
scip, enfologfile,
" enforcement with max. violation %g failed; cutting off node\n", maxabsconsviol); )
8580 ++conshdlrdata->ndesperatecutoff;
8605 for(
c = 0;
c < nconss; ++
c )
8645 idx = ((int)(size_t)elem) - 1;
8646 assert(idx >= 0 && idx < conshdlrdata->nbilinterms);
8648 return (
void*)&conshdlrdata->bilinterms[idx];
8666 return entry1->
x == entry2->
x && entry1->
y == entry2->
y;
8701 for(
i = 0;
i < 3; ++
i )
8704 return auxexpr1->
coefs[
i] < auxexpr2->
coefs[
i] ? -1 : 1;
8707 return auxexpr1->
cst < auxexpr2->
cst ? -1 : auxexpr1->
cst == auxexpr2->
cst ? 0 : 1;
8739 if( term->
nauxexprs >= conshdlrdata->bilinmaxnauxexprs )
8786 if( conshdlrdata->bilinterms !=
NULL )
8795 for(
c = 0;
c < nconss; ++
c )
8876 assert(conshdlrdata->bilinterms[*idx].x ==
x);
8877 assert(conshdlrdata->bilinterms[*idx].y ==
y);
8880 term = &conshdlrdata->bilinterms[*idx];
8881 assert(existing <= term->existing);
8890 *idx = conshdlrdata->nbilinterms;
8893 term = &conshdlrdata->bilinterms[*idx];
8908 ++(conshdlrdata->nbilinterms);
8911 if( conshdlrdata->bilinhashtable ==
NULL )
8914 bilinearTermsGetHashkey, bilinearTermsIsHashkeyEq, bilinearTermsGetHashkeyVal,
8915 (
void*)conshdlrdata) );
8917 assert(conshdlrdata->bilinhashtable !=
NULL);
8945 if( conshdlrdata->bilinterms ==
NULL )
8948 assert(conshdlrdata->nbilinterms == 0);
8949 assert(conshdlrdata->bilintermssize == 0);
8955 for(
i = 0;
i < conshdlrdata->nbilinterms; ++
i )
8960 for( j = 0; j < conshdlrdata->bilinterms[
i].nauxexprs; ++j )
8962 if( conshdlrdata->bilinterms[
i].aux.exprs[j]->auxvar !=
NULL )
8969 if( conshdlrdata->bilinterms[
i].nauxexprs > 0 )
8978 if( conshdlrdata->bilinterms[
i].aux.var !=
NULL )
8985 if( conshdlrdata->bilinhashtable !=
NULL )
8992 conshdlrdata->nbilinterms = 0;
8993 conshdlrdata->bilintermssize = 0;
9027 SCIPdebugMsg(
scip,
"Building LP for computing facets of convex envelope of vertex-polyhedral function\n");
9032 nrows = (
unsigned int)
nvars + 1;
9034 nnonz = (ncols * (nrows + 1)) / 2;
9045 for(
i = 0, k = 0;
i < ncols; ++
i )
9079 ind[k] = (int)nrows - 1;
9090 (
int)ncols,
obj, lb, ub,
NULL,
9091 (
int)nrows, lb, lb,
NULL,
9092 (
int)nnonz, beg, ind, val) );
9095 ind[0] = (int)nrows - 1;
9132 unsigned int ncorners;
9145 facetval = facetconstant;
9146 for(
i = 0;
i < (
unsigned int) nallvars; ++
i )
9147 facetval += facetcoefs[
i] * box[2*
i];
9150 funval = funvals[0];
9152 error = funval - facetval;
9154 error = facetval - funval;
9157 maxerror =
MAX(error, maxerror);
9160 for(
i = 1;
i < ncorners; ++
i )
9167 gray =
i ^ (
i >> 1);
9172 while( (diff >>= 1) != 0 )
9176 origpos = nonfixedpos[pos];
9179 facetval += facetcoefs[origpos] * (box[2*origpos+1] - box[2*origpos]);
9181 facetval -= facetcoefs[origpos] * (box[2*origpos+1] - box[2*origpos]);
9184 funval = funvals[gray];
9186 error = funval - facetval;
9188 error = facetval - funval;
9191 maxerror =
MAX(error, maxerror);
9247 if( conshdlrdata->vp_randnumgen ==
NULL && conshdlrdata->vp_maxperturb > 0.0 )
9253 if( conshdlrdata->vp_lp[
nvars] ==
NULL )
9257 lp = conshdlrdata->vp_lp[
nvars];
9275 for(
i = 0;
i < ncols; ++
i )
9280 for(
i = 0;
i < nrows-1; ++
i )
9289 varpos = nonfixedpos[
i];
9290 lb = box[2 * varpos];
9291 ub = box[2 * varpos + 1];
9292 solval = xstar[varpos];
9294 if( ub - lb < mindomwidth )
9295 mindomwidth = ub - lb;
9300 else if( solval >= ub )
9303 aux[
i] = (solval - lb) / (ub - lb);
9306 if( conshdlrdata->vp_maxperturb > 0.0 )
9311 aux[
i] -=
SCIPrandomGetReal(conshdlrdata->vp_randnumgen, 0.0, conshdlrdata->vp_maxperturb);
9312 else if( aux[
i] == 0.0 )
9313 aux[
i] +=
SCIPrandomGetReal(conshdlrdata->vp_randnumgen, 0.0, conshdlrdata->vp_maxperturb);
9318 perturbation =
MIN( aux[
i], 1.0 - aux[
i] ) / 2.0;
9319 perturbation =
MIN( perturbation, conshdlrdata->vp_maxperturb );
9320 aux[
i] +=
SCIPrandomGetReal(conshdlrdata->vp_randnumgen, -perturbation, perturbation);
9322 assert(0.0 < aux[
i] && aux[
i] < 1.0);
9355 if( conshdlrdata->vp_dualsimplex )
9383 facetcoefs[nonfixedpos[
i]] = aux[
i];
9385 *facetconstant = aux[nrows - 1];
9389 for(
i = 0;
i < nallvars; ++
i )
9409 varpos = nonfixedpos[
i];
9410 lb = box[2 * varpos];
9411 ub = box[2 * varpos + 1];
9415 facetcoefs[varpos] = facetcoefs[varpos] / (ub - lb);
9418 *facetconstant -= facetcoefs[varpos] * lb;
9421 facetvalue += facetcoefs[varpos] * xstar[varpos];
9428 facetvalue += *facetconstant;
9437 if( overestimate == (facetvalue > targetvalue) )
9439 SCIPdebugMsg(
scip,
"missed the target, facetvalue %g targetvalue %g, overestimate=%u\n", facetvalue, targetvalue, overestimate);
9480 *facetcoef = (funright - funleft) / (right - left);
9481 *facetconstant = funleft - *facetcoef * left;
9518 *
alpha = -b3*c2 + a3*(-b2+c2) + a2*(b3-c3) + b2*c3;
9519 *beta = -(-b3*c1 + a3*(-b1+c1) + a1*(b3-c3) + b1*c3);
9520 *gamma_ = -a2*b1 + a1*b2 + a2*c1 - b2*c1 - a1*c2 + b1*c2;
9521 *delta = -a3*b2*c1 + a2*b3*c1 + a3*b1*c2 - a1*b3*c2 - a2*b1*c3 + a1*b2*c3;
9568 SCIPdebugMsg(
scip,
"numerical troubles - try to solve the linear system via an LU factorization\n");
9646 targetvalue = -targetvalue;
9663 for( leaveout = 1; leaveout <= 4; ++leaveout )
9669 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p2[0], p2[1], p2val, p3[0], p3[1], p3val, p4[0], p4[1], p4val,
9670 &
alpha, &beta, &gamma_, &delta) );
9672 if(
alpha * p1[0] + beta * p1[1] + gamma_ * p1val - delta > 0.0 )
9678 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p1[0], p1[1], p1val, p3[0], p3[1], p3val, p4[0], p4[1], p4val,
9679 &
alpha, &beta, &gamma_, &delta) );
9681 if(
alpha * p2[0] + beta * p2[1] + gamma_ * p2val - delta > 0.0 )
9687 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p1[0], p1[1], p1val, p2[0], p2[1], p2val, p4[0], p4[1], p4val,
9688 &
alpha, &beta, &gamma_, &delta) );
9690 if(
alpha * p3[0] + beta * p3[1] + gamma_ * p3val - delta > 0.0 )
9696 SCIP_CALL(
computeHyperplaneThreePoints(
scip, p1[0], p1[1], p1val, p2[0], p2[1], p2val, p3[0], p3[1], p3val,
9697 &
alpha, &beta, &gamma_, &delta) );
9699 if(
alpha * p4[0] + beta * p4[1] + gamma_ * p4val - delta > 0.0 )
9724 xstarval = -
alpha/gamma_ * xstar[0] -beta/gamma_ * xstar[1] + delta/gamma_;
9727 if( xstarval <= targetvalue && (!*success || xstarval < candxstarval) )
9733 facetcoefs[0] = -
alpha/gamma_;
9734 facetcoefs[1] = -beta/gamma_;
9735 *facetconstant = delta/gamma_;
9738 candxstarval = xstarval;
9760 if( nelems > *maxnelems )
9765 assert(newsize >= nelems);
9769 *maxnelems = newsize;
9790 if( nelems > *maxnelems )
9795 assert(newsize > *maxnelems);
9800 *maxnelems = newsize;
9852 assert(*maxnconsvars > 0);
9860 if( nchildren != 2 )
9870 for( childidx = 0; childidx < 2; ++childidx )
9873 (*consvals)[0] = 1.0;
9890 var1 = (*consvars)[0];
9891 val1 = (*consvals)[0];
9895 var2 = (*consvars)[0];
9896 val2 = (*consvals)[0];
9925 prodval = coef * val1 * val2;
10009 safeexponent = (int) (exponent + 0.5);
10010 if( safeexponent % 2 != 0 )
10093 (*consvars)[0] =
var;
10094 (*consvals)[0] = 1.0;
10110 var = (*consvars)[0];
10111 edgeweight = (*consvals)[0];
10122 TRUE, edgeweight) );
10124 TRUE, edgeweight) );
10184 for(
i = 0;
i < nlocvars; ++
i)
10204 var = (*consvars)[0];
10208 if( nlocvars == 2 )
10210 var = (*consvars)[1];
10233 if( nlocvars == 1 )
10235 var = (*consvars)[0];
10236 weight = (*consvals)[0];
10257 for(
i = 0;
i < 2; ++
i)
10259 var = (*consvars)[
i];
10260 weight =
ABS((*consvals)[
i]);
10305 assert(*maxnconsvars > 0);
10329 hasval, val, consvars, consvals, maxnconsvars, success) );
10334 hasval, val, consvars, consvals, maxnconsvars, handledexprs, success) );
10387 return (ub + lb) / 2;
10421 int* powperm =
NULL;
10422 int* prodperm =
NULL;
10433 int nprodexprs = 0;
10443 assert(*maxnconsvars > 0);
10457 for(
i = 0;
i < nchildren; ++
i )
10493 powexprs[npowexprs] = children[
i];
10494 powvars[npowexprs++] =
var;
10522 prodexprs[nprodexprs] = children[
i];
10523 prodvars[nprodexprs++] =
var;
10524 prodexprs[nprodexprs] = children[
i];
10525 prodvars[nprodexprs++] = var2;
10530 if( npowexprs == 0 || nprodexprs != npowexprs )
10537 SCIPsort(powperm, SCIPsortVarPtr, (
void*) powvars, npowexprs);
10538 SCIPsort(prodperm, SCIPsortVarPtr, (
void*) prodvars, npowexprs);
10540 for(
i = 0;
i < npowexprs; ++
i )
10547 assert(npowexprs % 2 == 0);
10558 (*consvals)[0] = 1.0;
10559 (*consvars)[0] = prodvars[cnt++];
10566 if( nlocvars != 1 )
10571 actvar = (*consvars)[0];
10572 val = (*consvals)[0];
10574 (*consvals)[0] = 1.0;
10575 (*consvars)[0] = prodvars[cnt++];
10582 if( nlocvars != 1 )
10584 actvar2 = (*consvars)[0];
10585 val2 = (*consvals)[0];
10618 for( j = 0; j < npowexprs && !(var1found && var2found); ++j )
10620 if( powexprused[j] )
10624 if( !var1found && powvars[j] == prodvars[cnt - 2] )
10627 powexprused[j] =
TRUE;
10630 else if( !var2found && powvars[j] == prodvars[cnt - 1] )
10633 powexprused[j] =
TRUE;
10752 if( expr == rootexpr )
10753 parentidx = consnodeidx;
10757 parentidx = openidx[nopenidx - 1];
10761 hasparentcoef =
FALSE;
10762 if ( expr != rootexpr )
10773 openidx[nopenidx++] = -1;
10775 assert(maxnconsvars > 0);
10779 if( hasparentcoef )
10784 parentidx = nodeidx;
10804 parentidx = thisidx;
10807 nconsvars, constant) );
10820 openidx[nopenidx++] = -1;
10826 assert(expr == rootexpr || parentidx > 0);
10838 usedefaultgadget =
FALSE;
10877 &consvars, &consvals, &maxnconsvars, handledexprs) );
10881 openidx[nopenidx++] = sumidx;
10888 parentcoef, &consvars, &consvals, &maxnconsvars, handledexprs, &succ) );
10892 usedefaultgadget =
FALSE;
10902 &consvars, &consvals, &maxnconsvars, handledexprs, &succ) );
10906 usedefaultgadget =
FALSE;
10911 if( usedefaultgadget )
10941 openidx[nopenidx++] = opidx;
10979 assert(targetconshdlr != conshdlr);
10985 for(
i = 0;
i < sourceconshdlrdata->nnlhdlrs; ++
i )
10987 SCIP_CALL( SCIPnlhdlrCopyhdlr(
scip, targetconshdlr, conshdlr, sourceconshdlrdata->nlhdlrs[
i]) );
11006 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11012 conshdlrdata->nlhdlrssize = 0;
11015 for(
i = 0;
i < conshdlrdata->nconsupgrades; ++
i )
11026 if( conshdlrdata->vp_randnumgen !=
NULL )
11032 if( conshdlrdata->vp_lp[
i] !=
NULL )
11038 assert(conshdlrdata->branchrandnumgen ==
NULL);
11061 conshdlrdata->lastboundrelax = ++conshdlrdata->curboundstag;
11063 conshdlrdata->enforound = 1;
11065 conshdlrdata->auxvarid = 0;
11067 for(
i = 0;
i < nconss; ++
i )
11074 if( conshdlrdata->nnlhdlrs > 1 )
11075 SCIPsortDownPtr((
void**)conshdlrdata->nlhdlrs, SCIPnlhdlrComp, conshdlrdata->nnlhdlrs);
11082 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11088 conshdlrdata->nweaksepa = 0;
11089 conshdlrdata->ntightenlp = 0;
11090 conshdlrdata->ndesperatebranch = 0;
11091 conshdlrdata->ndesperatecutoff = 0;
11092 conshdlrdata->ndesperatetightenlp = 0;
11093 conshdlrdata->nforcelp = 0;
11095 conshdlrdata->ncanonicalizecalls = 0;
11098 ENFOLOG( enfologfile = fopen(ENFOLOGFILE,
"w"); )
11120 SCIPsortDownPtr((
void**)consssorted, compIndexConsNonlinear, nconss);
11122 for(
i = 0;
i < nconss; ++
i )
11131 conshdlrdata->subnlpheur =
NULL;
11132 conshdlrdata->trysolheur =
NULL;
11134 if( conshdlrdata->vp_randnumgen !=
NULL )
11140 if( conshdlrdata->vp_lp[
i] !=
NULL )
11146 if( conshdlrdata->branchrandnumgen !=
NULL )
11150 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11156 if( enfologfile !=
NULL )
11158 fclose(enfologfile);
11159 enfologfile =
NULL;
11167#ifdef SCIP_DISABLED_CODE
11171 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11177#define consInitpreNonlinear NULL
11236 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
11242 if( conshdlrdata->branchpscostweight > 0.0 )
11245 if( strchr(
"lds", conshdlrdata->branchpscostupdatestrategy) ==
NULL )
11247 SCIPerrorMessage(
"branching/lpgainnormalize strategy %c unknown\n", conshdlrdata->branchpscostupdatestrategy);
11272 conshdlrdata->checkedvarlocks =
FALSE;
11275 if( conshdlrdata->newsoleventfilterpos >= 0 )
11283 conshdlrdata->newsoleventfilterpos = -1;
11299 assert((*consdata)->nlockspos == 0);
11300 assert((*consdata)->nlocksneg == 0);
11308 if( (*consdata)->nlrow !=
NULL )
11335 targetexpr, sourcedata->lhs, sourcedata->rhs,
FALSE,
11365 if( conshdlrdata->linearizeheursol !=
'o' && conshdlrdata->newsoleventfilterpos == -1 )
11373 eventhdlr, (
SCIP_EVENTDATA*)conshdlr, &conshdlrdata->newsoleventfilterpos) );
11440 for(
c = 0;
c < nconss; ++
c )
11467 SCIPdebugMsg(
scip,
"registered %d external branching candidates\n", nnotify);
11472 SCIPdebugMsg(
scip,
"could not find branching candidates, forcing to solve LP\n");
11506 maypropfeasible =
FALSE;
11509 for(
c = 0;
c < nconss; ++
c )
11537 else if( (conshdlrdata->subnlpheur ==
NULL ||
sol ==
NULL) && !maypropfeasible && !completely )
11545 maypropfeasible =
FALSE;
11547 if( maypropfeasible )
11554 if( !(consdata->linvarincr !=
NULL && consdata->linvarincrcoef > 0.0) &&
11555 !(consdata->linvardecr !=
NULL && consdata->linvardecrcoef < 0.0) )
11556 maypropfeasible =
FALSE;
11564 if( !(consdata->linvarincr !=
NULL && consdata->linvarincrcoef < 0.0) &&
11565 !(consdata->linvardecr !=
NULL && consdata->linvardecrcoef > 0.0) )
11566 maypropfeasible =
FALSE;
11672 for(
c = 0;
c < nconss; ++
c )
11698 && !conshdlrdata->checkedvarlocks && conshdlrdata->checkvarlocks !=
'd' )
11703 conshdlrdata->checkedvarlocks =
TRUE;
11705 for(
c = 0;
c < nconss; ++
c )
11707 int tmpnchgvartypes = 0;
11708 int tmpnaddconss = 0;
11711 SCIPdebugMsg(
scip,
"presolSingleLockedVars() for %s: nchgvartypes=%d naddconss=%d infeas=%u\n",
11721 (*nchgvartypes) += tmpnchgvartypes;
11722 (*naddconss) += tmpnaddconss;
11726 if( *ndelconss > 0 || *nchgbds > 0 || *nupgdconss > 0 || *naddconss > 0 || *nchgvartypes > 0 )
11736#ifdef SCIP_DISABLED_CODE
11740 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11746#define consRespropNonlinear NULL
11771 if( ownerdata->nenfos >= 0 )
11773 if( (consdata->nlockspos == 0) != (nlockspos == 0) )
11774 reinitsolve =
TRUE;
11775 if( (consdata->nlocksneg == 0) != (nlocksneg == 0) )
11776 reinitsolve =
TRUE;
11811 if( !consdata->issimplified )
11820 consdata->expr = simplified;
11821 consdata->issimplified =
TRUE;
11852 if( hashmapexpr !=
NULL && hashmapexpr != child )
11870 assert(consdata->nlockspos == 0);
11871 assert(consdata->nlocksneg == 0);
11957#ifdef SCIP_DISABLED_CODE
11961 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
11967#define consDelvarsNonlinear NULL
12020 SCIP_CALL(
SCIPcopyExpr(sourcescip,
scip, sourcedata->expr, &targetexpr, exprownerCreate, (
void*)targetconshdlr, varmap, consmap, global,
valid) );
12022 if( targetexpr ==
NULL )
12030 targetexpr, sourcedata->lhs, sourcedata->rhs,
FALSE,
12031 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12034 if( targetexpr !=
NULL )
12067 endptr = (
char*)str;
12076 if( isdigit((
unsigned char)str[0]) || ((str[0] ==
'-' || str[0] ==
'+') && isdigit((
unsigned char)str[1])) )
12088 if( endptr[0] !=
'<' || endptr[1] !=
'=' )
12112 if( strncmp(str,
"[free]", 6) == 0 )
12166 consexprtree, lhs, rhs,
FALSE,
12167 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12192 if( varssize < consdata->nvarexprs )
12198 for(
i = 0;
i < consdata->nvarexprs; ++
i )
12221 *
nvars = consdata->nvarexprs;
12228#ifdef SCIP_DISABLED_CODE
12232 SCIPerrorMessage(
"method of nonlinear constraint handler not implemented yet\n");
12238#define consGetDiveBdChgsNonlinear NULL
12273 SCIPinfoMessage(
scip, file,
"Nonlinear Conshdlr : %10s %10s %10s %10s %10s %10s %10s\n",
"WeakSepa",
"TightenLP",
"DespTghtLP",
"DespBranch",
"DespCutoff",
"ForceLP",
"CanonTime");
12333 for(
i = 0;
i < conshdlrdata->nnlhdlrs; ++
i )
12367 conshdlrdata->intevalvar = intEvalVarBoundTightening;
12368 conshdlrdata->curboundstag = 1;
12369 conshdlrdata->lastboundrelax = 1;
12370 conshdlrdata->curpropboundstag = 1;
12371 conshdlrdata->newsoleventfilterpos = -1;
12382 conshdlrCopyNonlinear,
12383 consFreeNonlinear, consInitNonlinear, consExitNonlinear,
12385 consDeleteNonlinear, consTransNonlinear, consInitlpNonlinear,
12386 consSepalpNonlinear, consSepasolNonlinear, consEnfolpNonlinear, consEnforelaxNonlinear, consEnfopsNonlinear, consCheckNonlinear,
12388 consActiveNonlinear, consDeactiveNonlinear,
12390 consPrintNonlinear, consCopyNonlinear, consParseNonlinear,
12392 consGetSignedPermsymGraphNonlinear, conshdlrdata) );
12397 "limit on number of propagation rounds for a set of constraints within one round of SCIP propagation",
12398 &conshdlrdata->maxproprounds,
FALSE, 10, 0, INT_MAX,
NULL,
NULL) );
12401 "whether to check bounds of all auxiliary variable to seed reverse propagation",
12405 "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",
12406 &conshdlrdata->varboundrelax,
TRUE,
'r',
"nabr",
NULL,
NULL) );
12409 "by how much to relax variable bounds during bound tightening if strategy 'a', 'b', or 'r'",
12413 "by how much to relax constraint sides during bound tightening",
12417 "maximal relative perturbation of reference point when computing facet of envelope of vertex-polyhedral function (dim>2)",
12421 "adjust computed facet of envelope of vertex-polyhedral function up to a violation of this value times LP feasibility tolerance",
12425 "whether to use dual simplex instead of primal simplex for LP that computes facet of vertex-polyhedral function",
12429 "maximal number of auxiliary expressions per bilinear term",
12433 "whether to reformulate products of binary variables during presolving",
12437 "whether to use the AND constraint handler for reformulating binary products",
12441 "minimum number of terms to reformulate bilinear binary products by factorizing variables (<= 1: disabled)",
12442 &conshdlrdata->reformbinprodsfac,
FALSE, 50, 1, INT_MAX,
NULL,
NULL) );
12445 "whether to forbid multiaggregation of nonlinear variables",
12449 "whether to tighten LP feasibility tolerance during enforcement, if it seems useful",
12453 "whether to (re)run propagation in enforcement",
12457 "threshold for when to regard a cut from an estimator as weak (lower values allow more weak cuts)",
12458 &conshdlrdata->weakcutthreshold,
TRUE, 0.2, 0.0, 1.0,
NULL,
NULL) );
12461 "\"strong\" cuts will be scaled to have their maximal coef in [1/strongcutmaxcoef,strongcutmaxcoef]",
12465 "consider efficacy requirement when deciding whether a cut is \"strong\"",
12469 "whether to force \"strong\" cuts in enforcement",
12473 "an expression will be enforced if the \"auxiliary\" violation is at least this factor times the \"original\" violation",
12474 &conshdlrdata->enfoauxviolfactor,
TRUE, 0.01, 0.0, 1.0,
NULL,
NULL) );
12477 "retry enfo of constraint with weak cuts if violation is least this factor of maximal violated constraints",
12478 &conshdlrdata->weakcutminviolfactor,
TRUE, 0.5, 0.0, 2.0,
NULL,
NULL) );
12481 "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",
12482 &conshdlrdata->rownotremovable,
TRUE,
'o',
"oea",
NULL,
NULL) );
12485 "method how to scale violations to make them comparable (not used for feasibility check): (n)one, (a)ctivity and side, norm of (g)radient",
12486 &conshdlrdata->violscale,
TRUE,
'n',
"nag",
NULL,
NULL) );
12489 "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)",
12490 &conshdlrdata->checkvarlocks,
TRUE,
't',
"bdt",
NULL,
NULL) );
12493 "from which depth on in the tree to allow branching on auxiliary variables (variables added for extended formulation)",
12494 &conshdlrdata->branchauxmindepth,
FALSE, INT_MAX, 0, INT_MAX,
NULL,
NULL) );
12497 "whether to use external branching candidates and branching rules for branching",
12501 "consider a constraint highly violated if its violation is >= this factor * maximal violation among all constraints",
12502 &conshdlrdata->branchhighviolfactor,
FALSE, 0.0, 0.0, 1.0,
NULL,
NULL) );
12505 "consider a variable branching score high if its branching score >= this factor * maximal branching score among all variables",
12506 &conshdlrdata->branchhighscorefactor,
FALSE, 0.9, 0.0, 1.0,
NULL,
NULL) );
12509 "weight by how much to consider the violation assigned to a variable for its branching score",
12513 "weight by how much to consider fractionality of integer variables in branching score for spatial branching",
12517 "weight by how much to consider the dual values of rows that contain a variable for its branching score",
12521 "weight by how much to consider the pseudo cost of a variable for its branching score",
12525 "weight by how much to consider the domain width in branching score",
12529 "weight by how much to consider variable type (continuous: 0, binary: 1, integer: 0.1, impl-integer: 0.01) in branching score",
12533 "how to aggregate several branching scores given for the same expression: 'a'verage, 'm'aximum, 's'um",
12534 &conshdlrdata->branchscoreagg,
FALSE,
's',
"ams",
NULL,
NULL) );
12537 "method used to split violation in expression onto variables: 'u'niform, 'm'idness of solution, 'd'omain width, 'l'ogarithmic domain width",
12538 &conshdlrdata->branchviolsplit,
FALSE,
'm',
"umdl",
NULL,
NULL) );
12541 "minimum pseudo-cost update count required to consider pseudo-costs reliable",
12545 "minimal average pseudo cost count for discrete variables at which to start considering spatial branching before branching on fractional integer variables",
12549 "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)",
12550 &conshdlrdata->linearizeheursol,
FALSE,
'o',
"oie",
NULL,
NULL) );
12553 "whether to assume that any constraint is convex",
12558 "signals a bound change to a nonlinear constraint", processVarEvent,
NULL) );
12588 processNewSolutionEvent,
NULL) );
12599 const char* conshdlrname
12614 if( conshdlr ==
NULL )
12624 for(
i = conshdlrdata->nconsupgrades - 1;
i >= 0; --
i )
12626 if( conshdlrdata->consupgrades[
i]->consupgd == nlconsupgd )
12629 SCIPwarningMessage(
scip,
"Try to add already known upgrade method for constraint handler <%s>.\n", conshdlrname);
12637 consupgrade->consupgd = nlconsupgd;
12643 assert(conshdlrdata->nconsupgrades+1 <= conshdlrdata->consupgradessize);
12645 for(
i = conshdlrdata->nconsupgrades;
i > 0 && conshdlrdata->consupgrades[
i-1]->priority < consupgrade->
priority; --
i )
12646 conshdlrdata->consupgrades[
i] = conshdlrdata->consupgrades[
i-1];
12648 conshdlrdata->consupgrades[
i] = consupgrade;
12649 conshdlrdata->nconsupgrades++;
12699 if( conshdlr ==
NULL )
12707 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12778 assert(nquadterms == 0 || (quadvars1 !=
NULL && quadvars2 !=
NULL && quadcoefs !=
NULL));
12782 if( conshdlr ==
NULL )
12789 SCIP_CALL(
SCIPcreateExprQuadratic(
scip, &expr, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, exprownerCreate, (
void*)conshdlr) );
12794 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
12825 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs,
12866 if( offsets !=
NULL && offsets[
i] != 0.0 )
12885 termcoefs[0] = 1.0;
12888 termcoefs[1] = -rhscoeff;
12930 if( xoffset != 0.0 )
12968 return conshdlrdata->curboundstag;
12981 return conshdlrdata->lastboundrelax;
13000 ++conshdlrdata->curboundstag;
13001 assert(conshdlrdata->curboundstag > 0);
13004 conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;
13057 sepasuccess =
TRUE;
13060 if( cutviol > 0.0 )
13081 if( (!overestimate && ( cutviol <= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) ||
13082 ( overestimate && (-cutviol >= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) )
13085 "weak: auxvarvalue %g estimateval %g auxvalue %g (over %d)\n",
13087 auxvarvalue + (overestimate ? -cutviol : cutviol), auxvalue, overestimate); )
13088 sepasuccess =
FALSE;
13093 estimateval = auxvarvalue + (!overestimate ? cutviol : -cutviol);
13097 sepasuccess =
FALSE;
13106 "estimateval %g auxvalue %g (over %d)\n ",
SCIPnlhdlrGetName(nlhdlr), auxvarvalue,
13107 auxvarvalue + (overestimate ? -cutviol : cutviol), auxvalue, overestimate);
13113 if( !allowweakcuts )
13125 "min requ viol = %g\n", cutviol, sepasuccess ?
"" :
"not ", mincutviolation); )
13127 sepasuccess = cutviol > mincutviolation;
13151 if( auxvarcoef == 0.0 ||
13152 (!overestimate && ( cutviol / auxvarcoef <= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) ||
13153 ( overestimate && (-cutviol / auxvarcoef >= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) )
13155 ENFOLOG(
SCIPinfoMessage(
scip, enfologfile,
" cut is too weak after cleanup: auxvarvalue %g estimateval %g auxvalue %g (over %d)\n",
13156 auxvarvalue, auxvarvalue + (overestimate ? -cutviol : cutviol) / auxvarcoef, auxvalue, overestimate); )
13157 sepasuccess =
FALSE;
13168 if( !branchscoresuccess )
13186#ifdef BRSCORE_ABSVIOL
13211 if( conshdlrdata->branchdualweight > 0.0 )
13222 (void) sprintf(gap,
"_estimategap=%g",
REALABS(auxvalue - estimateval));
13248 SCIP_CALL(
SCIPaddRow(
scip, row, conshdlrdata->forcestrongcut && !allowweakcuts && inenforcement, &infeasible) );
13251 if( conshdlrdata->rownotremovable ==
'a' || (conshdlrdata->rownotremovable ==
'e' && inenforcement) )
13268 else if( branchscoresuccess )
13281 "branching candidates%s\n",
SCIPnlhdlrGetName(nlhdlr), (allowweakcuts && inenforcement) ?
13300 return conshdlrdata->assumeconvex;
13338 return conshdlrdata->nbilinterms;
13357 return conshdlrdata->bilinterms;
13382 if( conshdlrdata->bilinhashtable ==
NULL )
13398 assert(idx >= -1 && idx < conshdlrdata->nbilinterms);
13399 assert(idx < 0 || conshdlrdata->bilinterms[idx].
x ==
x);
13400 assert(idx < 0 || conshdlrdata->bilinterms[idx].
y ==
y);
13427 assert(idx >= -1 && idx < conshdlrdata->nbilinterms);
13431 return &conshdlrdata->bilinterms[idx];
13478 term = &conshdlrdata->bilinterms[idx];
13484 if( auxvar !=
NULL )
13520 nlockspos = overestimate ? 1 : 0;
13521 nlocksneg = overestimate ? 0 : 1;
13525 term = &conshdlrdata->bilinterms[idx];
13536 if( conshdlrdata->bilinmaxnauxexprs <= 1 )
13540 auxvarexpr->
cst = 0.0;
13541 auxvarexpr->
coefs[0] = 1.0;
13542 auxvarexpr->
coefs[1] = 0.0;
13543 auxvarexpr->
coefs[2] = 0.0;
13561 auxexpr->
auxvar = auxvar;
13562 auxexpr->
coefs[0] = coefaux;
13566 auxexpr->
coefs[1] = coefx;
13567 auxexpr->
coefs[2] = coefy;
13573 auxexpr->
coefs[1] = coefy;
13574 auxexpr->
coefs[2] = coefx;
13576 auxexpr->
cst = cst;
13583 else if( auxvar !=
NULL )
13612 unsigned int ncorners;
13630 for( j = 0; j < nallvars; ++j )
13634 nonfixedpos[
nvars] = j;
13652 for( j = 0; j < nallvars; ++j )
13655 corner[j] = (box[2 * j] + box[2 * j + 1]) / 2.0;
13657 for(
i = 0;
i < ncorners; ++
i )
13660 for( j = 0; j <
nvars; ++j )
13662 int varpos = nonfixedpos[j];
13666 if( (
i >> j) & 0x1 )
13667 corner[varpos] = box[2 * varpos + 1];
13669 corner[varpos] = box[2 * varpos ];
13674 funvals[
i] = function(corner, nallvars, fundata);
13680 SCIPdebugMsg(
scip,
"cannot compute underestimator; function value at corner is too large %g\n", funvals[
i]);
13693 if( *success && overestimate == (*facetconstant + facetcoefs[nonfixedpos[0]] * xstar[nonfixedpos[0]] > targetvalue) )
13695 SCIPdebugMsg(
scip,
"computed secant, but missed target %g (facetvalue=%g, overestimate=%u)\n", targetvalue, *facetconstant + facetcoefs[nonfixedpos[0]] * xstar[nonfixedpos[0]], overestimate);
13701 int idx1 = nonfixedpos[0];
13702 int idx2 = nonfixedpos[1];
13703 SCIP_Real p1[2] = { box[2*idx1], box[2*idx2] };
13704 SCIP_Real p2[2] = { box[2*idx1+1], box[2*idx2] };
13705 SCIP_Real p3[2] = { box[2*idx1], box[2*idx2+1] };
13706 SCIP_Real p4[2] = { box[2*idx1+1], box[2*idx2+1] };
13707 SCIP_Real xstar2[2] = { xstar[idx1], xstar[idx2] };
13710 SCIP_CALL(
computeVertexPolyhedralFacetBivariate(
scip, overestimate, p1, p2, p3, p4, funvals[0], funvals[1], funvals[2], funvals[3], xstar2, targetvalue, success, coefs, facetconstant) );
13712 facetcoefs[idx1] = coefs[0];
13713 facetcoefs[idx2] = coefs[1];
13717 SCIP_CALL(
computeVertexPolyhedralFacetLP(
scip, conshdlr, overestimate, xstar, box, nallvars, nonfixedpos, funvals,
nvars, targetvalue, success, facetcoefs, facetconstant) );
13732 if( maxfaceterror > 0.0 )
13741 for( j = 0; j <
nvars; ++j )
13742 corner[nonfixedpos[j]] = (box[2 * nonfixedpos[j]] + box[2 * nonfixedpos[j] + 1]) / 2.0;
13743 midval = function(corner, nallvars, fundata);
13751 if( maxfaceterror > conshdlrdata->vp_adjfacetthreshold * feastol * fabs(midval) )
13753 SCIPdebugMsg(
scip,
"ignoring facet due to instability, it cuts off a vertex by %g (midval=%g).\n", maxfaceterror, midval);
13758 SCIPdebugMsg(
scip,
"maximum facet error %g (midval=%g), adjust constant to make cut valid!\n", maxfaceterror, midval);
13761 *facetconstant += maxfaceterror;
13763 *facetconstant -= maxfaceterror;
13795 return consdata->expr;
13811 return consdata->lhs;
13827 return consdata->rhs;
13846 if( consdata->nlrow ==
NULL )
13851 *nlrow = consdata->nlrow;
13872 return consdata->curv;
13926 SCIPerrorMessage(
"SCIPchgLhsNonlinear can only be called in problem stage.\n");
13936 if( consdata->lhs == lhs )
13939 consdata->lhs = lhs;
13942 consdata->ispropagated =
FALSE;
13965 SCIPerrorMessage(
"SCIPchgLhsNonlinear can only be called in problem stage.\n");
13975 if( consdata->rhs == rhs )
13978 consdata->rhs = rhs;
13981 consdata->ispropagated =
FALSE;
14005 SCIPerrorMessage(
"SCIPchgExprNonlinear can only be called in problem stage.\n");
14023 assert(consdata->nvarexprs == 0);
14025 assert(!consdata->catchedevents);
14034 consdata->issimplified =
FALSE;
14035 consdata->ispropagated =
FALSE;
14060 SCIPerrorMessage(
"SCIPaddLinearVarNonlinear can only be called in problem stage.\n");
14081 assert(consdata->nvarexprs == 0);
14083 assert(!consdata->catchedevents);
14095 SCIP_EXPR* children[2] = { consdata->expr, varexpr };
14107 consdata->issimplified =
FALSE;
14108 consdata->ispropagated =
FALSE;
14133 SCIPerrorMessage(
"SCIPaddExprNonlinear can only be called in problem stage.\n");
14170 SCIP_EXPR* children[2] = { consdata->expr, exprowned };
14182 consdata->issimplified =
FALSE;
14183 consdata->ispropagated =
FALSE;
14279 *
var = consdata->linvardecr;
14280 *coef = consdata->linvardecrcoef;
14303 *
var = consdata->linvarincr;
14304 *coef = consdata->linvarincrcoef;
14349 return ownerdata->filterpos >= -1 ?
SCIPgetVarExprVar(expr) : ownerdata->auxvar;
14382 assert(idx < ownerdata->nenfos);
14386 *nlhdlr = ownerdata->enfos[idx]->nlhdlr;
14388 if( nlhdlrexprdata !=
NULL )
14389 *nlhdlrexprdata = ownerdata->enfos[idx]->nlhdlrexprdata;
14391 if( nlhdlrparticipation !=
NULL )
14392 *nlhdlrparticipation = ownerdata->enfos[idx]->nlhdlrparticipation;
14394 if( sepabelowusesactivity !=
NULL )
14395 *sepabelowusesactivity = ownerdata->enfos[idx]->sepabelowusesactivity;
14397 if( sepaaboveusesactivity !=
NULL )
14398 *sepaaboveusesactivity = ownerdata->enfos[idx]->sepaaboveusesactivity;
14400 if( auxvalue !=
NULL )
14401 *auxvalue = ownerdata->enfos[idx]->auxvalue;
14419 assert(idx < ownerdata->nenfos);
14422 ownerdata->enfos[idx]->auxvalue = auxvalue;
14500 if( ownerdata->nenfos >= 0 &&
14501 ( (ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && (useactivityforprop || useactivityforsepabelow || useactivityforsepaabove)) ||
14502 (ownerdata->nauxvaruses == 0 && useauxvar)
14514 ++ownerdata->nauxvaruses;
14516 if( useactivityforprop )
14517 ++ownerdata->nactivityusesprop;
14519 if( useactivityforsepabelow || useactivityforsepaabove )
14520 ++ownerdata->nactivityusessepa;
14525 if( useactivityforsepabelow )
14527 if( useactivityforsepaabove )
14530 if( useactivityforprop )
14694 if( ownerdata->propboundstag == conshdlrdata->curpropboundstag )
14696 bounds = ownerdata->propbounds;
14709 if( ownerdata->auxvar !=
NULL )
14714 auxvarbounds = conshdlrdata->intevalvar(
scip, ownerdata->auxvar, conshdlrdata);
14797 if( ownerdata->propboundstag == conshdlrdata->curpropboundstag )
14810 SCIPdebugMsg(
scip,
" applied %s: [%.20g,%.20g]\n", ownerdata->propboundstag == conshdlrdata->curpropboundstag ?
"previous propbounds" :
"activity", newbounds.
inf, newbounds.
sup);
14816 SCIPdebugMsg(
scip,
" cut off due to empty intersection with previous propbounds or activity\n");
14828 ownerdata->propbounds = newbounds;
14829 ownerdata->propboundstag = conshdlrdata->curpropboundstag;
14843 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);
14848 if(
SCIPexprGetNChildren(expr) > 0 && !ownerdata->inpropqueue && (ownerdata->nactivityusesprop > 0 || ownerdata->nactivityusessepa > 0 || ownerdata->nenfos < 0) )
14857 ownerdata->inpropqueue =
TRUE;
14904 for(
c = 0;
c < ownerdata->nconss; ++
c )
14908 consdata->ispropagated =
FALSE;
14939 assert(violscore >= 0.0);
14953 if( ownerdata->violscoretag != conshdlrdata->enforound )
14955 ownerdata->violscoresum = violscore;
14956 ownerdata->violscoremax = violscore;
14957 ownerdata->nviolscores = 1;
14958 ownerdata->violscoretag = conshdlrdata->enforound;
14962 ownerdata->violscoresum += violscore;
14963 if( violscore > ownerdata->violscoremax )
14964 ownerdata->violscoremax = violscore;
14965 ++ownerdata->nviolscores;
15014 for(
i = 0;
i < nexprs; ++
i )
15023 if( varssize ==
nvars )
15030 varexprs[
nvars++] = e;
15060 if( conshdlrdata->enforound != ownerdata->violscoretag )
15063 if( ownerdata->nviolscores == 0 )
15066 switch( conshdlrdata->branchscoreagg )
15070 return ownerdata->violscoresum / ownerdata->nviolscores;
15074 return ownerdata->violscoremax;
15078 return ownerdata->violscoresum;
15081 SCIPerrorMessage(
"Invalid value %c for branchscoreagg parameter\n", conshdlrdata->branchscoreagg);
15203 for(
i = 0;
i < nlinexprs; ++
i )
15210 for(
i = 0;
i < nquadexprs; ++
i )
15222 auxvalue += (lincoef + sqrcoef * solval) * solval;
15226 for(
i = 0;
i < nbilinexprs; ++
i )
15252 int detectpriority,
15268 if( conshdlr ==
NULL )
15283 conshdlrdata->nlhdlrs[conshdlrdata->nnlhdlrs] = *nlhdlr;
15284 ++conshdlrdata->nnlhdlrs;
15290 SCIPsortDownPtr((
void**)conshdlrdata->nlhdlrs, SCIPnlhdlrComp, conshdlrdata->nnlhdlrs);
15307 return conshdlrdata->nnlhdlrs;
15322 return conshdlrdata->nlhdlrs;
15340 for(
h = 0;
h < conshdlrdata->nnlhdlrs; ++
h )
15342 return conshdlrdata->nlhdlrs[
h];
15365 for( e = 0; e < ownerdata->nenfos; ++e )
15366 if( ownerdata->enfos[e]->nlhdlr == nlhdlr )
15367 return ownerdata->enfos[e]->nlhdlrexprdata;
static GRAPHNODE ** active
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
#define CONSHDLR_PROP_TIMING
#define CONSHDLR_MAXPREROUNDS
#define CONSHDLR_SEPAPRIORITY
#define CONSHDLR_PROPFREQ
#define CONSHDLR_PRESOLTIMING
#define CONSHDLR_EAGERFREQ
#define CONSHDLR_ENFOPRIORITY
#define CONSHDLR_DELAYSEPA
#define CONSHDLR_DELAYPROP
Constraint handler for AND constraints, .
constraint handler for bound disjunction constraints
Constraint handler for linear constraints in their most general form, .
static SCIP_Bool isBinaryProduct(SCIP *scip, SCIP_EXPR *expr)
static SCIP_RETCODE createExprVar(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_EXPR **expr, SCIP_VAR *var)
static SCIP_Real computeVertexPolyhedralMaxFacetError(SCIP *scip, SCIP_Bool overestimate, SCIP_Real *funvals, SCIP_Real *box, int nallvars, int nvars, int *nonfixedpos, SCIP_Real *facetcoefs, SCIP_Real facetconstant)
static SCIP_Bool isEvenOperator(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool *hasvalue, SCIP_Real *value)
static SCIP_RETCODE enforceConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_EXPRITER *it, SCIP_Bool allowweakcuts, SCIP_Bool inenforcement, SCIP_Bool branchcandonly, SCIP_RESULT *result, SCIP_Bool *success)
static SCIP_RETCODE tryAddGadgetEvenOperatorVariable(SCIP *scip, SCIP_EXPR *evenopexpr, SCIP_EXPR *child, SCIP_CONS *cons, SYM_GRAPH *graph, int parentidx, SCIP_Bool hasparentcoef, SCIP_Real parentcoef, SCIP_Bool hassymval, SCIP_Real symval, SCIP_VAR ***consvars, SCIP_Real **consvals, int *maxnconsvars, SCIP_Bool *success)
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)
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)
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)
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)
static SCIP_RETCODE getConsRelViolation(SCIP *scip, SCIP_CONS *cons, SCIP_Real *viol, SCIP_SOL *sol, SCIP_Longint soltag)
#define consGetDiveBdChgsNonlinear
static SCIP_Bool isConsViolated(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE getBinaryProductExprDo(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_EXPR *prodexpr, SCIP_EXPR **newexpr, int *naddconss, SCIP_Bool empathy4and)
static SCIP_RETCODE registerBranchingCandidatesAllUnfixed(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int *nnotify)
static SCIP_Bool isIntervalBetter(SCIP *scip, SCIP_Bool subsetsufficient, SCIP_INTERVAL newinterval, SCIP_INTERVAL oldinterval)
static SCIP_RETCODE detectNlhdlrs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
#define TABLE_EARLIEST_STAGE_NONLINEAR
static SCIP_RETCODE getBinaryProductExpr(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_HASHMAP *exprmap, SCIP_EXPR *prodexpr, SCIP_EXPR **newexpr, int *naddconss, int *nchgcoefs)
static SCIP_RETCODE catchVarEvents(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS *cons)
#define TABLE_DESC_NONLINEAR
static SCIP_RETCODE createAuxVar(SCIP *scip, SCIP_EXPR *expr)
static SCIP_Real getViolSplitWeight(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *var, SCIP_SOL *sol)
static SCIP_RETCODE freeEnfoData(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool freeauxvar)
#define infty2infty(infty1, infty2, val)
static SCIP_RETCODE getBilinearBinaryTerms(SCIP *scip, SCIP_EXPR *sumexpr, SCIP_VAR **xs, SCIP_VAR **ys, int *childidxs, int *nterms)
static SCIP_RETCODE storeVarExprs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata)
static SCIP_RETCODE buildVertexPolyhedralSeparationLP(SCIP *scip, int nvars, SCIP_LPI **lp)
static SCIP_RETCODE tryAddGadgetSquaredDifference(SCIP *scip, SCIP_EXPR *sumexpr, SCIP_CONS *cons, SYM_GRAPH *graph, int sumnodeidx, SCIP_VAR ***consvars, SCIP_Real **consvals, int *maxnconsvars, SCIP_HASHSET *handledexprs)
static SCIP_RETCODE tryAddGadgetBilinearProductSignedPerm(SCIP *scip, SCIP_EXPR *expr, SCIP_CONS *cons, SYM_GRAPH *graph, int parentidx, SCIP_Bool hasparentcoef, SCIP_Real parentcoef, SCIP_VAR ***consvars, SCIP_Real **consvals, int *maxnconsvars, SCIP_HASHSET *handledexprs, SCIP_Bool *success)
static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
static SCIP_RETCODE propConss(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_Bool force, SCIP_RESULT *result, int *nchgbds)
static SCIP_RETCODE presolveUpgrade(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_Bool *upgraded, int *nupgdconss, int *naddconss)
static SCIP_RETCODE forwardPropExpr(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_EXPR *rootexpr, SCIP_Bool tightenauxvars, SCIP_Bool *infeasible, int *ntightenings)
static SCIP_RETCODE consEnfo(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_RESULT *result)
static SCIP_Bool isSingleLockedCand(SCIP *scip, SCIP_EXPR *expr)
static SCIP_Bool branchAuxNonlinear(SCIP *scip, SCIP_CONSHDLR *conshdlr)
static SCIP_RETCODE presolveImplint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int *nchgvartypes, SCIP_Bool *infeasible)
#define TABLE_NAME_NONLINEAR
#define TABLE_NAME_NLHDLR
static SCIP_RETCODE tryAddGadgetEvenOperatorSum(SCIP *scip, SCIP_EXPR *evenopexpr, SCIP_EXPR *child, SCIP_CONS *cons, SYM_GRAPH *graph, int parentidx, SCIP_Bool hasparentcoef, SCIP_Real parentcoef, SCIP_Bool hassymval, SCIP_Real symval, SCIP_VAR ***consvars, SCIP_Real **consvals, int *maxnconsvars, SCIP_HASHSET *handledexprs, SCIP_Bool *success)
static SCIP_Real getDualBranchscore(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *var)
static SCIP_RETCODE deinitSolve(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
static SCIP_RETCODE ensureLocVarsArraySize(SCIP *scip, SCIP_VAR ***vars, SCIP_Real **vals, int nelems, int *maxnelems)
static SCIP_RETCODE createNlRow(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE enforceExprNlhdlr(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_NLHDLR *nlhdlr, SCIP_EXPR *expr, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_SOL *sol, SCIP_Real auxvalue, SCIP_Bool overestimate, SCIP_Bool separated, SCIP_Bool allowweakcuts, SCIP_Bool inenforcement, SCIP_Bool branchcandonly, SCIP_RESULT *result)
static SCIP_RETCODE selectBranchingCandidate(SCIP *scip, SCIP_CONSHDLR *conshdlr, BRANCHCAND *cands, int ncands, SCIP_Bool considerfracnl, SCIP_SOL *sol, BRANCHCAND **selected)
static SCIP_RETCODE scaleConsSides(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_Bool *changed)
static SCIP_RETCODE computeViolation(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Longint soltag)
#define VERTEXPOLY_MAXPERTURBATION
static SCIP_RETCODE presolveBinaryProducts(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int *naddconss, int *nchgcoefs)
static SCIP_RETCODE catchVarEvent(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_EXPR *expr, SCIP_CONS *cons)
static SCIP_RETCODE enforceConstraints(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_Bool inenforcement, SCIP_Bool branchcandonly, SCIP_Real maxrelconsviol, SCIP_RESULT *result)
static SCIP_RETCODE presolveSingleLockedVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, int *nchgvartypes, int *naddconss, SCIP_Bool *infeasible)
#define VERTEXPOLY_USEDUALSIMPLEX
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)
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)
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)
static SCIP_Bool branchingIntegralFirst(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol)
static SCIP_RETCODE createCons(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool copyexpr, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable)
static SCIP_RETCODE bilinearTermsInsertEntry(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y, int nlockspos, int nlocksneg, int *idx, SCIP_Bool existing)
static SCIP_RETCODE notifyNlhdlrNewsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_Bool solisbest)
static SCIP_Real getExprAbsOrigViolation(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Bool *violunder, SCIP_Bool *violover)
static SCIP_RETCODE presolveMergeConss(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool *success)
static SCIP_Real getDomainCenter(SCIP *scip, SCIP_VAR *var)
#define TABLE_POSITION_NLHDLR
static SCIP_RETCODE ensureOpenArraySizeSymdetect(SCIP *scip, int **openidx, int nelems, int *maxnelems)
static SCIP_RETCODE canonicalizeConstraints(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_PRESOLTIMING presoltiming, SCIP_Bool *infeasible, int *ndelconss, int *naddconss, int *nchgcoefs)
static SCIP_RETCODE dropVarEvents(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS *cons)
static SCIP_Real getExprAbsAuxViolation(SCIP *scip, SCIP_EXPR *expr, SCIP_Real auxvalue, SCIP_SOL *sol, SCIP_Bool *violunder, SCIP_Bool *violover)
#define BILIN_MAXNAUXEXPRS
constraint handler for nonlinear constraints specified by algebraic expressions
Constraint handler for variable bound constraints .
#define SCIPdebugGetSolVal(scip, var, val)
#define SCIPdebugAddSolVal(scip, var, val)
#define SCIP_INTERVAL_INFINITY
#define SCIP_CALL_ABORT(x)
#define SCIP_LONGINT_FORMAT
default user interface dialog
absolute expression handler
power and signed power expression handlers
handler for sin expressions
constant value expression handler
variable expression handler
handler for variable index expressions
SCIP_Real SCIPevalBilinAuxExprNonlinear(SCIP *scip, SCIP_VAR *x, SCIP_VAR *y, SCIP_CONSNONLINEAR_AUXEXPR *auxexpr, SCIP_SOL *sol)
SCIP_RETCODE SCIPcheckQuadraticNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *isquadratic)
SCIP_RETCODE SCIPaddLinearVarNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real coef)
#define SCIP_DECL_NONLINCONSUPGD(x)
SCIP_RETCODE SCIPmarkExprPropagateNonlinear(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateConsBasicSignpowerNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *x, SCIP_VAR *z, SCIP_Real exponent, SCIP_Real xoffset, SCIP_Real zcoef, SCIP_Real lhs, SCIP_Real rhs)
SCIP_Real SCIPgetExprViolScoreNonlinear(SCIP_EXPR *expr)
unsigned int SCIPgetExprNAuxvarUsesNonlinear(SCIP_EXPR *expr)
SCIP_RETCODE SCIPincludeConsUpgradeNonlinear(SCIP *scip, SCIP_DECL_NONLINCONSUPGD((*nlconsupgd)), int priority, SCIP_Bool active, const char *conshdlrname)
void SCIPgetLinvarMayDecreaseNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **var, SCIP_Real *coef)
void SCIPgetExprEnfoDataNonlinear(SCIP_EXPR *expr, int idx, SCIP_NLHDLR **nlhdlr, SCIP_NLHDLREXPRDATA **nlhdlrexprdata, SCIP_NLHDLR_METHOD *nlhdlrparticipation, SCIP_Bool *sepabelowusesactivity, SCIP_Bool *sepaaboveusesactivity, SCIP_Real *auxvalue)
int SCIPgetExprNLocksPosNonlinear(SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateConsBasicSOCNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *coefs, SCIP_Real *offsets, SCIP_Real constant, SCIP_VAR *rhsvar, SCIP_Real rhscoeff, SCIP_Real rhsoffset)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPcreateConsBasicVarbound(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE SCIPchgLhsNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
SCIP_HASHMAP * SCIPgetVarExprHashmapNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPinsertBilinearTermImplicitNonlinear(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y, SCIP_VAR *auxvar, SCIP_Real coefx, SCIP_Real coefy, SCIP_Real coefaux, SCIP_Real cst, SCIP_Bool overestimate)
void SCIPsetExprEnfoAuxValueNonlinear(SCIP_EXPR *expr, int idx, SCIP_Real auxvalue)
SCIP_RETCODE SCIPcreateConsBounddisjunction(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPgetNlRowNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_NLROW **nlrow)
SCIP_RETCODE SCIPchgRhsNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
SCIP_RETCODE SCIPgetAbsViolationNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Real *viol)
SCIP_RETCODE SCIPgetExprRelAuxViolationNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_Real auxvalue, SCIP_SOL *sol, SCIP_Real *viol, SCIP_Bool *violunder, SCIP_Bool *violover)
SCIP_Longint SCIPgetCurBoundsTagNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPassumeConvexNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_VAR * SCIPgetExprAuxVarNonlinear(SCIP_EXPR *expr)
int SCIPgetBilinTermIdxNonlinear(SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y)
void SCIPgetLinvarMayIncreaseNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **var, SCIP_Real *coef)
SCIP_RETCODE SCIPinsertBilinearTermExistingNonlinear(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y, SCIP_VAR *auxvar, int nlockspos, int nlocksneg)
SCIP_RETCODE SCIPcreateConsBasicLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE SCIPaddExprNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_EXPR *expr, SCIP_Real coef)
SCIP_RETCODE SCIPprocessRowprepNonlinear(SCIP *scip, SCIP_NLHDLR *nlhdlr, SCIP_CONS *cons, SCIP_EXPR *expr, SCIP_ROWPREP *rowprep, SCIP_Bool overestimate, SCIP_VAR *auxvar, SCIP_Real auxvalue, SCIP_Bool allowweakcuts, SCIP_Bool branchscoresuccess, SCIP_Bool inenforcement, SCIP_SOL *sol, SCIP_RESULT *result)
SCIP_EXPR * SCIPgetExprNonlinear(SCIP_CONS *cons)
SCIP_RETCODE SCIPgetExprAbsOrigViolationNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_Real *viol, SCIP_Bool *violunder, SCIP_Bool *violover)
SCIP_Real SCIPgetRhsNonlinear(SCIP_CONS *cons)
unsigned int SCIPgetExprNSepaUsesActivityNonlinear(SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateConsNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable)
SCIP_RETCODE SCIPcreateConsBasicNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE SCIPgetExprActivityNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Real *activity)
int SCIPgetExprNEnfosNonlinear(SCIP_EXPR *expr)
int SCIPgetExprNLocksNegNonlinear(SCIP_EXPR *expr)
SCIP_CONSNONLINEAR_BILINTERM * SCIPgetBilinTermsNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPtightenExprIntervalNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_INTERVAL newbounds, SCIP_Bool *cutoff, int *ntightenings)
SCIP_RETCODE SCIPaddExprsViolScoreNonlinear(SCIP *scip, SCIP_EXPR **exprs, int nexprs, SCIP_Real violscore, SCIP_SOL *sol, SCIP_Bool *success)
int SCIPgetNBilinTermsNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPgetExprPartialDiffNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_VAR *var)
SCIP_Longint SCIPgetLastBoundRelaxTagNonlinear(SCIP_CONSHDLR *conshdlr)
struct SCIP_ConsNonlinear_BilinTerm SCIP_CONSNONLINEAR_BILINTERM
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)
struct SCIP_ConsNonlinear_Auxexpr SCIP_CONSNONLINEAR_AUXEXPR
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)
struct SCIP_Interval SCIP_INTERVAL
void SCIPintervalSetEmpty(SCIP_INTERVAL *resultant)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
SCIP_Real SCIPgetLPObjval(SCIP *scip)
void SCIPsetLPFeastol(SCIP *scip, SCIP_Real newfeastol)
SCIP_Real SCIPgetLPFeastol(SCIP *scip)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocClearBlockMemory(scip, ptr)
#define SCIPensureBlockMemoryArray(scip, ptr, arraysizeptr, minsize)
BMS_BUFMEM * SCIPbuffer(SCIP *scip)
#define SCIPallocClearBufferArray(scip, ptr, num)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_RETCODE SCIPdelNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
void SCIPenableNLP(SCIP *scip)
SCIP_RETCODE SCIPsetNlRowExpr(SCIP *scip, SCIP_NLROW *nlrow, SCIP_EXPR *expr)
SCIP_RETCODE SCIPaddLinearCoefToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
SCIP_RETCODE SCIPchgNlRowConstant(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real constant)
void SCIPsetNlRowCurvature(SCIP *scip, SCIP_NLROW *nlrow, SCIP_EXPRCURV curvature)
SCIP_RETCODE SCIPcreateNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)
const char * SCIPnlhdlrGetDesc(SCIP_NLHDLR *nlhdlr)
SCIP_NLHDLR ** SCIPgetNlhdlrsNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPnlhdlrHasIntEval(SCIP_NLHDLR *nlhdlr)
int SCIPnlhdlrGetDetectPriority(SCIP_NLHDLR *nlhdlr)
SCIP_NLHDLREXPRDATA * SCIPgetNlhdlrExprDataNonlinear(SCIP_NLHDLR *nlhdlr, SCIP_EXPR *expr)
SCIP_Bool SCIPnlhdlrIsEnabled(SCIP_NLHDLR *nlhdlr)
int SCIPgetNNlhdlrsNonlinear(SCIP_CONSHDLR *conshdlr)
const char * SCIPnlhdlrGetName(SCIP_NLHDLR *nlhdlr)
SCIP_NLHDLR * SCIPfindNlhdlrNonlinear(SCIP_CONSHDLR *conshdlr, const char *name)
SCIP_Bool SCIPnlhdlrHasEstimate(SCIP_NLHDLR *nlhdlr)
SCIP_RETCODE SCIPincludeNlhdlrNonlinear(SCIP *scip, SCIP_NLHDLR **nlhdlr, const char *name, const char *desc, int detectpriority, int enfopriority, SCIP_DECL_NLHDLRDETECT((*detect)), SCIP_DECL_NLHDLREVALAUX((*evalaux)), SCIP_NLHDLRDATA *nlhdlrdata)
SCIP_Bool SCIPnlhdlrHasInitSepa(SCIP_NLHDLR *nlhdlr)
int SCIPnlhdlrGetEnfoPriority(SCIP_NLHDLR *nlhdlr)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_CONSHDLR * SCIProwGetOriginConshdlr(SCIP_ROW *row)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
const char * SCIProwGetName(SCIP_ROW *row)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
void SCIPmarkRowNotRemovableLocal(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
SCIP_Real SCIPgetSepaMinEfficacy(SCIP *scip)
SCIP_SOLORIGIN SCIPsolGetOrigin(SCIP_SOL *sol)
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
SCIP_RETCODE SCIPcreateLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPunlinkSol(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPincSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real incval)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
SCIP_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_TABLE * SCIPfindTable(SCIP *scip, const char *name)
SCIP_RETCODE SCIPincludeTable(SCIP *scip, const char *name, const char *desc, SCIP_Bool active, SCIP_DECL_TABLECOPY((*tablecopy)), SCIP_DECL_TABLEFREE((*tablefree)), SCIP_DECL_TABLEINIT((*tableinit)), SCIP_DECL_TABLEEXIT((*tableexit)), SCIP_DECL_TABLEINITSOL((*tableinitsol)), SCIP_DECL_TABLEEXITSOL((*tableexitsol)), SCIP_DECL_TABLEOUTPUT((*tableoutput)), SCIP_TABLEDATA *tabledata, int position, SCIP_STAGE earlieststage)
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstopClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_Bool SCIPisRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisUbBetter(SCIP *scip, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLbBetter(SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisHugeValue(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisSumLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPround(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Real SCIPgetHugeValue(SCIP *scip)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPepsilon(SCIP *scip)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
int SCIPgetDepth(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPaddVarLocks(SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
void SCIPvarMarkRelaxationOnly(SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetIndex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
void SCIPqueueFree(SCIP_QUEUE **queue)
SCIP_RETCODE SCIPqueueCreate(SCIP_QUEUE **queue, int initsize, SCIP_Real sizefac)
SCIP_RETCODE SCIPqueueInsert(SCIP_QUEUE *queue, void *elem)
SCIP_Bool SCIPqueueIsEmpty(SCIP_QUEUE *queue)
void * SCIPqueueRemove(SCIP_QUEUE *queue)
SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)
int SCIPrandomGetInt(SCIP_RANDNUMGEN *randnumgen, int minrandval, int maxrandval)
SCIP_VAR ** SCIProwprepGetVars(SCIP_ROWPREP *rowprep)
SCIP_RETCODE SCIPcleanupRowprep2(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Real maxcoefbound, SCIP_Bool *success)
int SCIProwprepGetNModifiedVars(SCIP_ROWPREP *rowprep)
SCIP_Real SCIPgetRowprepViolation(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Bool *reliable)
SCIP_Real * SCIProwprepGetCoefs(SCIP_ROWPREP *rowprep)
SCIP_VAR ** SCIProwprepGetModifiedVars(SCIP_ROWPREP *rowprep)
char * SCIProwprepGetName(SCIP_ROWPREP *rowprep)
SCIP_SIDETYPE SCIProwprepGetSidetype(SCIP_ROWPREP *rowprep)
SCIP_RETCODE SCIPaddRowprepTerm(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_VAR *var, SCIP_Real coef)
SCIP_RETCODE SCIPgetRowprepRowCons(SCIP *scip, SCIP_ROW **row, SCIP_ROWPREP *rowprep, SCIP_CONS *cons)
int SCIProwprepGetNVars(SCIP_ROWPREP *rowprep)
void SCIProwprepRecordModifications(SCIP_ROWPREP *rowprep)
SCIP_RETCODE SCIPcleanupRowprep(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Real minviol, SCIP_Real *viol, SCIP_Bool *success)
void SCIPfreeRowprep(SCIP *scip, SCIP_ROWPREP **rowprep)
void SCIPprintRowprep(SCIP *scip, SCIP_ROWPREP *rowprep, FILE *file)
SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
void SCIPsortDown(int *perm, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownIntPtr(int *intarray, void **ptrarray, int len)
void SCIPsort(int *perm, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPskipSpace(char **s)
SCIP_RETCODE SCIPaddSymgraphEdge(SCIP *scip, SYM_GRAPH *graph, int first, int second, SCIP_Bool hasval, SCIP_Real val)
SCIP_RETCODE SCIPaddSymgraphOpnode(SCIP *scip, SYM_GRAPH *graph, int op, int *nodeidx)
SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
SCIP_RETCODE SCIPaddSymgraphValnode(SCIP *scip, SYM_GRAPH *graph, SCIP_Real val, int *nodeidx)
int SCIPgetSymgraphVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
SCIP_RETCODE SCIPaddSymgraphConsnode(SCIP *scip, SYM_GRAPH *graph, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, int *nodeidx)
SCIP_RETCODE SCIPaddSymgraphVarAggregation(SCIP *scip, SYM_GRAPH *graph, int rootidx, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real constant)
int SCIPgetSymExprdataNConstants(SYM_EXPRDATA *symdata)
int SCIPgetSymgraphNegatedVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
SCIP_RETCODE SCIPfreeSymDataExpr(SCIP *scip, SYM_EXPRDATA **symdata)
int SCIPgetSymgraphNNodes(SYM_GRAPH *graph)
SCIP_Real * SCIPgetSymExprdataConstants(SYM_EXPRDATA *symdata)
SCIP_RETCODE SCIPgetCoefSymData(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *parentexpr, SCIP_Real *coef, SCIP_Bool *success)
SCIPfreeSol(scip, &heurdata->sol))
SCIPfreeRandom(scip, &heurdata->randnumgen)
SCIPcreateRandom(scip, &heurdata->randnumgen, DEFAULT_RANDSEED, TRUE))
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
NLP local search primal heuristic using sub-SCIPs.
primal heuristic that tries a given solution
SCIP_Bool SCIPcliqueHasVar(SCIP_CLIQUE *clique, SCIP_VAR *var, SCIP_Bool value)
static volatile int nterms
SCIP_Bool SCIPlapackIsAvailable(void)
SCIP_RETCODE SCIPlapackSolveLinearEquations(BMS_BUFMEM *bufmem, int n, SCIP_Real *A, SCIP_Real *b, SCIP_Real *x, SCIP_Bool *success)
interface methods for lapack functions
static const char * paramname[]
#define BMSclearMemoryArray(ptr, num)
SCIP_RETCODE SCIPnlhdlrFree(SCIP *scip, SCIP_NLHDLR **nlhdlr)
SCIP_RETCODE SCIPnlhdlrCreate(SCIP *scip, SCIP_NLHDLR **nlhdlr, const char *name, const char *desc, int detectpriority, int enfopriority, SCIP_DECL_NLHDLRDETECT((*detect)), SCIP_DECL_NLHDLREVALAUX((*evalaux)), SCIP_NLHDLRDATA *nlhdlrdata)
void SCIPnlhdlrPrintStatistics(SCIP *scip, SCIP_NLHDLR **nlhdlrs, int nnlhdlrs, FILE *file)
private functions of nonlinear handlers of nonlinear constraints
#define SCIPnlhdlrIncrementNSeparated(nlhdlr)
#define SCIPnlhdlrResetNDetectionslast(nlhdlr)
#define SCIPnlhdlrIncrementNCutoffs(nlhdlr)
nonlinear handlers for convex and concave expressions, respectively
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
SCIP_RETCODE SCIPgetSymOpNodeType(SCIP *scip, const char *opnodename, int *nodetype)
propagator for symmetry handling
#define SCIPdebugPrintCons(x, y, z)
methods for sorting joint arrays of various types
public functions to work with algebraic expressions
SCIP_DECL_NONLINCONSUPGD((*consupgd))
SCIP_NLHDLR_METHOD nlhdlrparticipation
SCIP_Bool sepaaboveusesactivity
SCIP_Bool sepabelowusesactivity
SCIP_NLHDLREXPRDATA * nlhdlrexprdata
SCIP_CONSNONLINEAR_AUXEXPR ** exprs
union SCIP_ConsNonlinear_BilinTerm::@055261256347130033265073212045155110332303333345 aux
structs for symmetry computations
methods for dealing with symmetry detection graphs
struct SCIP_Clock SCIP_CLOCK
#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)
struct SCIP_Cons SCIP_CONS
#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)
struct SYM_Graph SYM_GRAPH
#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)
struct SCIP_Conshdlr SCIP_CONSHDLR
#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)
struct SCIP_Dialog SCIP_DIALOG
#define SCIP_DECL_DIALOGEXEC(x)
struct SCIP_Eventhdlr SCIP_EVENTHDLR
#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
struct SCIP_Expr SCIP_EXPR
struct SCIP_ExprIter SCIP_EXPRITER
#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
struct SYM_ExprData SYM_EXPRDATA
#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
struct SCIP_Heur SCIP_HEUR
@ SCIP_BRANCHDIR_DOWNWARDS
struct SCIP_Clique SCIP_CLIQUE
enum SCIP_BoundType SCIP_BOUNDTYPE
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
struct SCIP_RowPrep SCIP_ROWPREP
struct SCIP_HashMap SCIP_HASHMAP
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_SORTINDCOMP(x)
struct SCIP_RandNumGen SCIP_RANDNUMGEN
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
struct SCIP_PtrArray SCIP_PTRARRAY
struct SCIP_HashSet SCIP_HASHSET
struct SCIP_HashTable SCIP_HASHTABLE
struct SCIP_Queue SCIP_QUEUE
#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_Nlhdlr SCIP_NLHDLR
struct SCIP_NlhdlrExprData SCIP_NLHDLREXPRDATA
#define SCIP_NLHDLR_METHOD_ALL
#define SCIP_NLHDLR_METHOD_SEPABELOW
struct SCIP_NlRow SCIP_NLROW
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
struct SCIP_Node SCIP_NODE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR
enum SCIP_Vartype SCIP_VARTYPE