45#ifdef INTERCUTS_VERBOSE
50#define INTERLOG(x) if( SCIPgetSubscipDepth(scip) == 0 && SCIPgetVerbLevel(scip) >= SCIP_VERBLEVEL_NORMAL ) { x }
65#define NLHDLR_NAME "quadratic"
66#define NLHDLR_DESC "handler for quadratic expressions"
67#define NLHDLR_DETECTPRIORITY 1
68#define NLHDLR_ENFOPRIORITY 100
71#define TABLE_NAME_QUADRATIC "nlhdlr_quadratic"
72#define TABLE_DESC_QUADRATIC "quadratic nlhdlr statistics table"
73#define TABLE_POSITION_QUADRATIC 14700
74#define TABLE_EARLIEST_STAGE_QUADRATIC SCIP_STAGE_TRANSFORMED
77#define INTERCUTS_MINVIOL 1e-4
78#define DEFAULT_USEINTERCUTS FALSE
79#define DEFAULT_USESTRENGTH FALSE
80#define DEFAULT_USEMONOIDAL TRUE
81#define DEFAULT_USEMINREP TRUE
82#define DEFAULT_USEBOUNDS FALSE
83#define BINSEARCH_MAXITERS 120
84#define DEFAULT_NCUTSROOT 20
85#define DEFAULT_NCUTS 2
92struct SCIP_NlhdlrExprData
101 SCIP_Real minquadfiniteact;
103 SCIP_Real maxquadfiniteact;
105 int nneginfinityquadact;
106 int nposinfinityquadact;
109 SCIP_Longint activitiestag;
112 SCIP_Bool separating;
119struct SCIP_NlhdlrData
123 SCIP_Longint lastnodenumber;
127 SCIP_Bool useintersectioncuts;
128 SCIP_Bool usestrengthening;
129 SCIP_Bool usemonoidal;
131 SCIP_Bool useboundsasrays;
135 SCIP_Real mincutviolation;
136 SCIP_Real minviolation;
140 SCIP_Bool sparsifycuts;
141 SCIP_Bool ignorebadrayrestriction;
142 SCIP_Bool ignorehighre;
146 int ncouldimprovedcoef;
147 int nbadrayrestriction;
155 SCIP_Real densitysum;
156 SCIP_Real cutcoefsum;
157 SCIP_Real monoidalimprovementsum;
158 SCIP_Real efficacysum;
159 SCIP_Real currentavecutcoef;
160 SCIP_Real currentavemonoidalimprovement;
198 SCIPinfoMessage(
scip, file,
"Quadratic Nlhdlr : %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %20s %10s %10s %10s \n",
"GenCuts",
"AddCuts",
"CouldImpr",
"NLargeRE",
199 "AbrtBadRay",
"AbrtPosPhi",
"AbrtNonBas",
"NStrength",
"NMonoidal",
"AveCutcoef",
"AveMonoidalImprov",
"AveDensity",
"AveEfficacy",
"AveBCutsFrac");
237#ifdef DEBUG_INTERCUTS_NUMERICS
281#ifdef DEBUG_INTERCUTS_NUMERICS
311 for(
i = 0;
i < nnonz;
i++ )
336 for(
i = 0;
i < nrows; ++
i )
365 qexpr = nlhdlrexprdata->qexpr;
369 for(
i = 0;
i < nquadexprs; ++
i )
386 for(
i = 0;
i < nlinexprs; ++
i )
466 for(
i = 0;
i < ncols; ++
i )
472 for( ;
i < ncols + nrows; ++
i )
524 for(
i = 0;
i < ncols; ++
i )
528 qexpr = nlhdlrexprdata->qexpr;
533 for(
i = 0;
i < nquadexprs; ++
i )
549 for(
i = 0;
i < nlinexprs; ++
i )
576#ifdef DEBUG_INTERSECTIONCUT
577 for(
i = 0;
i < ncols; ++
i )
609 (*rays)->raysbegin[0] = 0;
633 (*rays)->raysbegin[0] = 0;
635 (*rays)->rayssize = size;
705 qexpr = nlhdlrexprdata->qexpr;
709 for(
i = 0;
i < nquadexprs; ++
i )
718 for(
i = 0;
i < nlinexprs; ++
i )
721 map[lppos] = nquadexprs +
i;
727 map[lppos] = nquadexprs + nlinexprs;
780#ifdef DEBUG_INTERSECTIONCUT
801#ifdef DEBUG_INTERSECTIONCUT
810 rays->raysbegin[
rays->nrays + 1] = *nnonz;
812#ifdef DEBUG_INTERSECTIONCUT
814 for(
i =
rays->raysbegin[
rays->nrays];
i < *nnonz; ++
i )
888 SCIPdebugMsg(
scip,
"failed to store sparse rays: there is a var with base status zero\n");
901 for(
i = 0;
i < ncols; ++
i )
915 for(
i = 0;
i < ncols; ++
i )
936#ifdef DEBUG_INTERSECTIONCUT
937 SCIPinfoMessage(
scip,
NULL,
"looked at ray of var %s with basestat %d, it has %d nonzeros\n-----------------\n",
942#ifdef DEBUG_INTERSECTIONCUT
943 SCIPdebugMsg(
scip,
"nonzero ray associated with variable <%s> has base status zero -> abort storing rays\n",
961 for(
i = 0;
i < nrows; ++
i )
983#ifdef DEBUG_INTERSECTIONCUT
1073 SCIP_Real* eigenvectors;
1074 SCIP_Real* eigenvalues;
1075 SCIP_Real* lincoefs;
1085 qexpr = nlhdlrexprdata->qexpr;
1092 if( nlhdlrexprdata->cons !=
NULL )
1102 for(
i = 0;
i < nquadexprs; ++
i )
1113 for(
j = 0;
j < nquadexprs; ++
j )
1122#ifdef INTERCUT_MOREDEBUG
1123 printf(
"vdotb: offset %d, eigenvector %d = %g, lincoef quad %g\n",
offset,
j,
1124 eigenvectors[
offset +
j], lincoef);
1139 for(
j = 0;
j < nquadexprs; ++
j )
1154 for(
i = 0;
i < nlinexprs; ++
i )
1158 if( auxvar !=
NULL )
1163#ifdef DEBUG_INTERSECTIONCUT
1166 for(
i = 0;
i < nquadexprs; ++
i )
1215 SCIP_Real* lincoefs;
1223#ifdef INTERCUT_MOREDEBUG
1224 printf(
"Computing w(ray) \n");
1229 qexpr = nlhdlrexprdata->qexpr;
1235#ifdef INTERCUT_MOREDEBUG
1249#ifdef INTERCUT_MOREDEBUG
1275 SCIP_Real* eigenvectors;
1276 SCIP_Real* eigenvalues;
1279 qexpr = nlhdlrexprdata->qexpr;
1282 for(
i = 0;
i < nquadexprs; ++
i )
1296 for(
j = 0;
j < nquadexprs; ++
j )
1348 SCIP_Real* eigenvectors;
1349 SCIP_Real* eigenvalues;
1362 qexpr = nlhdlrexprdata->qexpr;
1365#ifdef DEBUG_INTERSECTIONCUT
1387 for(
i = 0;
i < nquadexprs; ++
i )
1434#ifdef DEBUG_INTERSECTIONCUT
1435 SCIPinfoMessage(
scip,
NULL,
"Restriction yields case 2: a,b,c,d,e %g %g %g %g %g\n",
coefs1234a[0],
coefs1234a[1],
coefs1234a[2],
1485 SCIP_Real* eigenvectors;
1486 SCIP_Real* eigenvalues;
1497 qexpr = nlhdlrexprdata->qexpr;
1500#ifdef DEBUG_INTERSECTIONCUT
1531 for(
i = 0;
i < nquadexprs; ++
i )
1533 SCIP_Real dot = 0.0;
1552#ifdef INTERCUT_MOREDEBUG
1562#ifdef INTERCUT_MOREDEBUG
1563 printf(
"Positive eigenvalue: computing D: v^T ray %g, v^T( zlp + b/theta ) %g and theta %g \n",
vdotray, dot, (
sidefactor * eigenvalues[
i]));
1573#ifdef INTERCUT_MOREDEBUG
1668#ifdef DEBUG_INTERSECTIONCUT
1671 SCIPinfoMessage(
scip,
NULL,
"Restriction yields case 1,2 or 3: a,b,c,d,e %g %g %g %g %g\n",
coefs1234a[0],
coefs1234a[1],
coefs1234a[2],
1678 SCIPinfoMessage(
scip,
NULL,
" Case 4b: a,b,c,d,e %g %g %g %g %g\n",
coefs4b[0],
coefs4b[1],
coefs4b[2],
1710#ifdef INTERCUTS_DBLDBL
1714 SCIP_Real
QUAD(root);
1751 return sqrt(
a * t * t +
b * t +
c) - (
d * t +
e );
1789 SCIP_Real ub = *
sol;
1797 curr = (lb + ub) / 2.0;
1799#ifdef INTERCUT_MOREDEBUG
1800 printf(
"%d: lb,ub %.10f, %.10f. curr = %g -> phi at curr %g -> phi at lb %g \n",
i, lb, ub, curr,
phival,
evalPhiAtRay(lb,
a,
b,
c,
d,
e));
1831 SCIP_Real
a = coefs[0];
1832 SCIP_Real
b = coefs[1];
1833 SCIP_Real
c = coefs[2];
1834 SCIP_Real
d = coefs[3];
1835 SCIP_Real
e = coefs[4];
1853 e, -(
c -
e *
e), bounds);
1858#ifdef INTERCUT_MOREDEBUG
1874#ifdef INTERCUT_MOREDEBUG
1876 printf(
"don't do bin search\n");
1883#ifdef INTERCUT_MOREDEBUG
1937#ifdef DEBUG_INTERSECTIONCUT
1947#ifdef DEBUG_INTERSECTIONCUT
1967#ifdef DEBUG_INTERSECTIONCUT
2017 for(
j = 0;
j < 3; ++
j )
2030 INTERLOG(
printf(
"Bad numerics 1 2 3 or 4a: max(A,B,C)/min(A,B,C) is too large (%g)\n",
max /
min); )
2040 for(
j = 0;
j < 3; ++
j )
2087 SCIP_Real* eigenvectors;
2088 SCIP_Real* eigenvalues;
2091 qexpr = nlhdlrexprdata->qexpr;
2097 for(
i = 0;
i < nquadexprs; ++
i )
2134 SCIP_Real* eigenvectors;
2135 SCIP_Real* eigenvalues;
2140 qexpr = nlhdlrexprdata->qexpr;
2145 for(
i = 0;
i < nquadexprs; ++
i )
2165 return num /
denom < 1;
2219 lb = -
b / (2.0 *
a);
2227 sol = (ub + lb) / 2.0;
2236 if( val > 0.0 && val < 1
e-6 )
2273 SCIP_Real* eigenvectors;
2274 SCIP_Real* eigenvalues;
2277 qexpr = nlhdlrexprdata->qexpr;
2282 for(
i = 0;
i < nquadexprs; ++
i )
2292 for(
j = 0;
j < nquadexprs; ++
j )
2305 num += eigenvectors[
j * nquadexprs +
i] * dot;
2378 if(
SQR(
b) - (4 *
a *
c) >= 0.0 )
2482 SCIP_Bool usemonoidal;
2521 for(
i = 0;
i <
rays->nrays; ++
i )
2566#ifdef DEBUG_INTERSECTIONCUT
2624 lppos =
rays->lpposray[
i];
2881 for(
i = 0;
i <
rays->nrays; ++
i )
2899 &
rays->raysidx[
rays->raysbegin[idx]],
rays->raysbegin[idx + 1] -
rays->raysbegin[idx], &coef) )
2922 alpha = (lb + ub) / 2.0;
2961 if( *
rho < -10
e+06 )
3011 SCIP_CALL(
computeIntercut(
scip,
nlhdlrdata, nlhdlrexprdata,
rays,
sidefactor,
iscase4,
vb,
vzlp,
wcoefs,
wzlp,
kappa,
3023 for(
i = 0;
i <
rays->nrays; ++
i )
3037 SCIP_CALL(
findRho(
scip,
nlhdlrdata, nlhdlrexprdata,
rays,
i,
sidefactor,
iscase4,
vb,
vzlp,
wcoefs,
wzlp,
kappa,
3054 lppos =
rays->lpposray[
i];
3157 qexpr = nlhdlrexprdata->qexpr;
3160 raylength = (auxvar ==
NULL) ? nquadexprs + nlinexprs : nquadexprs + nlinexprs + 1;
3170 for(
i = 0;
i < nquadexprs; ++
i )
3187 for(
i = 0;
i < nlinexprs; ++
i )
3189 rays->raysbegin[
i + nquadexprs] =
i + nquadexprs;
3190 rays->raysidx[
i + nquadexprs] =
i + nquadexprs;
3201 if( auxvar !=
NULL )
3203 rays->raysbegin[nquadexprs + nlinexprs] = nquadexprs + nlinexprs;
3204 rays->raysidx[nquadexprs + nlinexprs] = nquadexprs + nlinexprs;
3230 SCIP_Real* lincoefs;
3238 qexpr = nlhdlrexprdata->qexpr;
3245 for(
i = 0;
i < nquadexprs;
i++ )
3257 val += sqrcoef *
SQR(solval);
3277 for(
i = 0;
i < nlinexprs;
i++ )
3283 if( auxvar !=
NULL )
3296 if( val <= constant )
3312 SCIP_Bool overestimate,
3335 qexpr = nlhdlrexprdata->qexpr;
3338#ifdef DEBUG_INTERSECTIONCUT
3365 INTERLOG(
printf(
"Failed to get rays: there is a var with base status ZERO!\n"); )
3375 if( auxvar !=
NULL )
3389 INTERLOG(
printf(
"Failed to use bounds as rays: variable is unbounded!\n"); )
3400 INTERLOG(
printf(
"Failed to use bounds as rays: nearest vertex is not violated!\n"); )
3418 if( nlinexprs == 0 && auxvar ==
NULL )
3420 for(
i = 0;
i < nquadexprs; ++
i )
3424 if(
i == nquadexprs )
3445 SCIP_CALL(
computeIntercut(
scip,
nlhdlrdata, nlhdlrexprdata,
rays,
sidefactor,
iscase4,
vb,
vzlp,
wcoefs,
wzlp,
kappa,
3480 for(
i = 0;
i < nquadexprs; ++
i )
3488 if( (lincoef != 0.0) + (sqrcoef != 0.0) + nadjbilin >= 2 )
3515 return (lincoef != 0.0) + (sqrcoef != 0.0) + nadjbilin >= 2;
3528 SCIP_Bool* infeasible,
3578 SCIP_Bool* infeasible,
3657 if(
a >= 0.0 ||
c <= 0.0 )
3743 SCIP_Real* lincoefs,
3746 SCIP_Bool* infeasible,
3754 if( nlinexprs == 0 )
3760 for(
i = 0;
i < nlinexprs; ++
i )
3766 if( *nreductions > 0 && !*infeasible )
3770 for(
i = 0;
i < nlinexprs && ! (*infeasible); ++
i )
3794 if( (*nlhdlrexprdata)->quadactivities !=
NULL )
3858 SCIP_Real* eigenvalues;
3898 SCIPdebugMsg(
scip,
"expr %p is not quadratic -> abort detect\n", (
void*)expr);
3907 SCIPdebugMsg(
scip,
"expr %p is not propagable and in presolving -> abort detect\n", (
void*)expr);
3916 SCIPdebugMsg(
scip,
"expr %p is not propagable -> abort detect\n", (
void*)expr);
3947 for(
i = 0;
i < nlinexprs; ++
i )
3950 for(
i = 0;
i < nquadexprs; ++
i )
3974 if( sqrexpr !=
NULL )
4014 for(
j = 0;
j < nquadexprs; ++
j )
4018 if( expr1 ==
exprj )
4049 SCIPdebugMsg(
scip,
"expr %p is quadratic and propagable -> propagate\n", (
void*)expr);
4095 for(
i = 0;
i < nlinexprs; ++
i )
4099 for(
i = 0;
i < nquadexprs; ++
i )
4106 SCIPdebugMsg(
scip,
"expr %p is quadratic and propagable -> propagate and separate\n", (
void*)expr);
4112 SCIPdebugMsg(
scip,
"expr %p is quadratic and propagable -> propagate only\n", (
void*)expr);
4134 SCIP_Real* lincoefs;
4140 assert(nlhdlrexprdata->separating);
4141 assert(nlhdlrexprdata->qexpr == expr);
4144 if( nlhdlrexprdata->origvars )
4157 *auxvalue = constant;
4159 for(
i = 0;
i < nlinexprs; ++
i )
4162 for(
i = 0;
i < nquadexprs; ++
i )
4172 *auxvalue += (lincoef + sqrcoef * solval) * solval;
4199 SCIP_Longint nodenumber;
4200 SCIP_Real* eigenvalues;
4204 assert(nlhdlrexprdata->qexpr == expr);
4217 INTERLOG(
printf(
"Convex or concave, no need of interesection cuts!\n");)
4248 if(
nlhdlrdata->lastnodenumber != nodenumber )
4257 nlhdlrexprdata->ncutsadded >=
nlhdlrdata->ncutslimitroot) )
4265 if( eigenvalues ==
NULL )
4272 if( cons != nlhdlrexprdata->cons )
4291 if( nlhdlrexprdata->cons !=
NULL && cons != nlhdlrexprdata->cons )
4293 INTERLOG(
printf(
"WARNING!! expr is root of one constraint and subexpr of another!\n"); )
4303 INTERLOG(
printf(
"We are actually feasible for the sides of the constraint\n"); )
4307#ifdef DEBUG_INTERSECTIONCUT
4309 if( cons == nlhdlrexprdata->cons )
4337 nlhdlrexprdata->ncutsadded += 1;
4354 SCIP_Bool infeasible;
4361 overestimate ?
"over" :
"under",
4447 SCIP_Real* lincoefs;
4456 assert(nlhdlrexprdata->quadactivities !=
NULL);
4457 assert(nlhdlrexprdata->qexpr == expr);
4472 for(
i = 0;
i < nlinexprs; ++
i )
4487 SCIPdebugMsg(
scip,
"Activity of linear part is [%g, %g]\n", nlhdlrexprdata->linactivity.inf,
4488 nlhdlrexprdata->linactivity.sup);
4499 nlhdlrexprdata->nneginfinityquadact = 0;
4500 nlhdlrexprdata->nposinfinityquadact = 0;
4501 nlhdlrexprdata->minquadfiniteact = 0.0;
4502 nlhdlrexprdata->maxquadfiniteact = 0.0;
4505 for(
i = 0;
i < nquadexprs; ++
i )
4528 if( sqrcoef != 0.0 )
4558 if( expr1 == qexpr )
4605 for(
j = 0;
j < nadjbilin; ++
j )
4614 if( expr1 != qexpr )
4649 SCIPinfoMessage(
scip,
NULL,
"Computing activity for quadratic term %g <expr>^2 + [%g,%g] <expr>, where <expr> is: ", sqrcoef,
b.inf,
b.sup);
4662 nlhdlrexprdata->nneginfinityquadact++;
4670 nlhdlrexprdata->minquadfiniteact +=
quadlb;
4675 nlhdlrexprdata->nposinfinityquadact++;
4683 nlhdlrexprdata->maxquadfiniteact +=
quadub;
4689 SCIPdebugMsg(
scip,
"Activity of quadratic part is [%g, %g]\n", nlhdlrexprdata->quadactivity.inf, nlhdlrexprdata->quadactivity.sup);
4711 SCIP_Real* lincoefs;
4720 SCIPdebugMsg(
scip,
"Reverse propagation of quadratic expr given bounds = [%g,%g]\n", bounds.inf, bounds.sup);
4727 assert(nlhdlrexprdata->quadactivities !=
NULL);
4728 assert(nlhdlrexprdata->qexpr == expr);
4811 for(
i = 0;
i < nquadexprs; ++
i )
4836 nlhdlrexprdata->nposinfinityquadact == 0 )
4847 nlhdlrexprdata->nposinfinityquadact == 1 )
4848 rest_i.sup = nlhdlrexprdata->maxquadfiniteact;
4854 nlhdlrexprdata->nneginfinityquadact == 0 )
4865 nlhdlrexprdata->nneginfinityquadact == 1 )
4866 rest_i.inf = nlhdlrexprdata->minquadfiniteact;
4870#ifdef SCIP_DISABLED_CODE
4898 if( sqrcoef != 0.0 )
4922 if( expr1 == qexpr )
4943 for(
j = 0;
j < nadjbilin; ++
j )
4950 if( expr1 != qexpr )
4976 if(
nbilin > 0 && !*infeasible )
4998 infeasible, &
nreds) );
5001 *nreductions +=
nreds;
5067 "whether to use intersection cuts for quadratic constraints to separate",
5071 "whether the strengthening should be used",
5075 "whether monoidal strengthening should be used",
5079 "whether the minimal representation of the S-free set should be used (instead of the gauge)",
5083 "use bounds of variables in quadratic as rays for intersection cuts",
5087 "limit for number of cuts generated consecutively",
5091 "limit for number of cuts generated at root node",
5095 "maximal rank a slackvar can have",
5099 "minimal cut violation the generated cuts must fulfill to be added to the LP",
5103 "minimal violation the constraint must fulfill such that a cut is generated",
5107 "determines at which nodes cut is used (if it's -1, it's used only at the root node, if it's n >= 0, it's used at every multiple of n",
5111 "limit for number of rays we do the strengthening for",
5115 "should we try to sparisfy the intersection cut?",
5119 "should cut be generated even with bad numerics when restricting to ray?",
5123 "should cut be added even when range / efficacy is large?",
5127 "for monoidal strengthening, should we track more statistics (more expensive)?",
constraint handler for nonlinear constraints specified by algebraic expressions
#define SCIPquadprecSqrtQ(r, a)
#define SCIPquadprecProdDD(r, a, b)
#define SCIPquadprecProdQD(r, a, b)
#define SCIPquadprecSumQD(r, a, b)
#define QUAD_ASSIGN(a, constant)
#define SCIPquadprecSquareD(r, a)
#define SCIPquadprecSumQQ(r, a, b)
#define SCIP_INTERVAL_INFINITY
#define SCIP_LONGINT_FORMAT
power and signed power expression handlers
product expression handler
variable expression handler
SCIP_Longint SCIPgetCurBoundsTagNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_VAR * SCIPgetExprAuxVarNonlinear(SCIP_EXPR *expr)
SCIP_Real SCIPgetRhsNonlinear(SCIP_CONS *cons)
SCIP_RETCODE SCIPtightenExprIntervalNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_INTERVAL newbounds, SCIP_Bool *cutoff, int *ntightenings)
SCIP_RETCODE SCIPregisterExprUsageNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool useauxvar, SCIP_Bool useactivityforprop, SCIP_Bool useactivityforsepabelow, SCIP_Bool useactivityforsepaabove)
SCIP_INTERVAL SCIPgetExprBoundsNonlinear(SCIP *scip, SCIP_EXPR *expr)
SCIP_Real SCIPgetLhsNonlinear(SCIP_CONS *cons)
int SCIPgetSubscipDepth(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPincludeNlhdlrQuadratic(SCIP *scip)
SCIP_Real SCIPnextafter(SCIP_Real from, SCIP_Real to)
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)
void SCIPswapReals(SCIP_Real *value1, SCIP_Real *value2)
int SCIPcolGetLPPos(SCIP_COL *col)
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
int SCIPexprGetNChildren(SCIP_EXPR *expr)
SCIP_RETCODE SCIPprintExprQuadratic(SCIP *scip, SCIP_EXPR *expr)
void SCIPexprGetQuadraticBilinTerm(SCIP_EXPR *expr, int termidx, SCIP_EXPR **expr1, SCIP_EXPR **expr2, SCIP_Real *coef, int *pos2, SCIP_EXPR **prodexpr)
void SCIPexprSetCurvature(SCIP_EXPR *expr, SCIP_EXPRCURV curvature)
SCIP_Bool SCIPisExprSum(SCIP *scip, 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 SCIPcomputeExprQuadraticCurvature(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPRCURV *curv, SCIP_HASHMAP *assumevarfixed, SCIP_Bool storeeigeninfo)
SCIP_RETCODE SCIPprintExpr(SCIP *scip, SCIP_EXPR *expr, FILE *file)
SCIP_Real SCIPexprGetEvalValue(SCIP_EXPR *expr)
SCIP_Longint SCIPexprGetActivityTag(SCIP_EXPR *expr)
SCIP_RETCODE SCIPcheckExprQuadratic(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool *isquadratic)
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)
void SCIPintervalSetRoundingModeUpwards(void)
void SCIPintervalSetRoundingModeDownwards(void)
SCIP_Real SCIPintervalGetInf(SCIP_INTERVAL interval)
SCIP_Real SCIPintervalQuadUpperBound(SCIP_Real infinity, SCIP_Real a, SCIP_INTERVAL b_, SCIP_INTERVAL x)
SCIP_Bool SCIPintervalIsEntire(SCIP_Real infinity, SCIP_INTERVAL operand)
void SCIPintervalSub(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
void SCIPintervalSetEntire(SCIP_Real infinity, SCIP_INTERVAL *resultant)
void SCIPintervalSquareRoot(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand)
SCIP_ROUNDMODE SCIPintervalGetRoundingMode(void)
void SCIPintervalSolveUnivariateQuadExpression(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL sqrcoeff, SCIP_INTERVAL lincoeff, SCIP_INTERVAL rhs, SCIP_INTERVAL xbnds)
void SCIPintervalSetRoundingMode(SCIP_ROUNDMODE roundmode)
void SCIPintervalSet(SCIP_INTERVAL *resultant, SCIP_Real value)
SCIP_Bool SCIPintervalIsEmpty(SCIP_Real infinity, SCIP_INTERVAL operand)
void SCIPintervalSetBounds(SCIP_INTERVAL *resultant, SCIP_Real inf, SCIP_Real sup)
void SCIPintervalMulScalar(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_Real operand2)
void SCIPintervalDivScalar(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_Real operand2)
SCIP_Real SCIPintervalGetSup(SCIP_INTERVAL interval)
void SCIPintervalSolveUnivariateQuadExpressionPositiveAllScalar(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_Real sqrcoeff, SCIP_Real lincoeff, SCIP_Real rhs, SCIP_INTERVAL xbnds)
SCIP_Real SCIPintervalNegateReal(SCIP_Real x)
int SCIPintervalPropagateWeightedSum(SCIP_Real infinity, int noperands, SCIP_INTERVAL *operands, SCIP_Real *weights, SCIP_Real constant, SCIP_INTERVAL rhs, SCIP_INTERVAL *resultants, SCIP_Bool *infeasible)
void SCIPintervalAdd(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
void SCIPintervalSetEmpty(SCIP_INTERVAL *resultant)
SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)
SCIP_RETCODE SCIPgetLPColsData(SCIP *scip, SCIP_COL ***cols, int *ncols)
SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
SCIP_ROW ** SCIPgetLPRows(SCIP *scip)
int SCIPgetNLPRows(SCIP *scip)
SCIP_RETCODE SCIPgetLPBInvARow(SCIP *scip, int r, SCIP_Real *binvrow, SCIP_Real *coefs, int *inds, int *ninds)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
SCIP_COL ** SCIPgetLPCols(SCIP *scip)
int SCIPgetNLPCols(SCIP *scip)
SCIP_Bool SCIPisLPSolBasic(SCIP *scip)
SCIP_RETCODE SCIPgetLPBInvRow(SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)
#define SCIPfreeBuffer(scip, ptr)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocClearBlockMemory(scip, ptr)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPallocBuffer(scip, ptr)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_NLHDLRDATA * SCIPnlhdlrGetData(SCIP_NLHDLR *nlhdlr)
void SCIPnlhdlrSetFreeExprData(SCIP_NLHDLR *nlhdlr,)
const char * SCIPnlhdlrGetName(SCIP_NLHDLR *nlhdlr)
SCIP_NLHDLR * SCIPfindNlhdlrNonlinear(SCIP_CONSHDLR *conshdlr, const char *name)
void SCIPnlhdlrSetSepa(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRINITSEPA((*initsepa)), SCIP_DECL_NLHDLRENFO((*enfo)), SCIP_DECL_NLHDLRESTIMATE((*estimate)),)
void SCIPnlhdlrSetFreeHdlrData(SCIP_NLHDLR *nlhdlr,)
void SCIPnlhdlrSetCopyHdlr(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)
void SCIPnlhdlrSetProp(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRINTEVAL((*inteval)),)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
int SCIPnodeGetDepth(SCIP_NODE *node)
SCIP_Bool SCIProwIsIntegral(SCIP_ROW *row)
SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
int SCIProwGetNLPNonz(SCIP_ROW *row)
int SCIProwGetLPPos(SCIP_ROW *row)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
SCIP_Real SCIPgetRowActivity(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
SCIP_BASESTAT SCIProwGetBasisStatus(SCIP_ROW *row)
SCIP_RETCODE SCIPprintTransSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
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_Longint SCIPgetNLPs(SCIP *scip)
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_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisSumRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisHugeValue(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_VAR ** SCIProwprepGetVars(SCIP_ROWPREP *rowprep)
SCIP_Real SCIProwprepGetSide(SCIP_ROWPREP *rowprep)
void SCIPmergeRowprepTerms(SCIP *scip, SCIP_ROWPREP *rowprep)
void SCIProwprepSetCoef(SCIP_ROWPREP *rowprep, int idx, SCIP_Real newcoef)
SCIP_Real * SCIProwprepGetCoefs(SCIP_ROWPREP *rowprep)
char * SCIProwprepGetName(SCIP_ROWPREP *rowprep)
void SCIProwprepSetSidetype(SCIP_ROWPREP *rowprep, SCIP_SIDETYPE sidetype)
void SCIProwprepAddConstant(SCIP_ROWPREP *rowprep, SCIP_Real constant)
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)
SCIP_RETCODE SCIPcreateRowprep(SCIP *scip, SCIP_ROWPREP **rowprep, SCIP_SIDETYPE sidetype, SCIP_Bool local)
int SCIProwprepGetNVars(SCIP_ROWPREP *rowprep)
void SCIProwprepAddSide(SCIP_ROWPREP *rowprep, SCIP_Real side)
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)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIPfreeSol(scip, &heurdata->sol))
SCIPcreateSol(scip, &heurdata->sol, heur))
assert(minobj< SCIPgetCutoffbound(scip))
#define BMSclearMemory(ptr)
#define BMSclearMemoryArray(ptr, num)
static SCIP_Bool raysAreDependent(SCIP *scip, SCIP_Real *raycoefs1, int *rayidx1, int raynnonz1, SCIP_Real *raycoefs2, int *rayidx2, int raynnonz2, SCIP_Real *coef)
#define NLHDLR_DETECTPRIORITY
static SCIP_RETCODE computeRestrictionToLine(SCIP *scip, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_Real sidefactor, SCIP_Real *raycoefs, int *rayidx, int raynnonz, SCIP_Real *vb, SCIP_Real *vzlp, SCIP_Real kappa, SCIP_Real *apex, SCIP_Real *coefs2, SCIP_Bool *success)
#define DEFAULT_USEBOUNDS
#define DEFAULT_USESTRENGTH
static SCIP_Real computeMaxBoundaryForBilinearProp(SCIP_Real a, SCIP_Real c, SCIP_Real x1, SCIP_Real x2)
static SCIP_RETCODE setVarToNearestBound(SCIP *scip, SCIP_SOL *sol, SCIP_SOL *vertex, SCIP_VAR *var, SCIP_Real *factor, SCIP_Bool *success)
static void computeVApexAndVRay(SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_Real *apex, SCIP_Real *raycoefs, int *rayidx, int raynnonz, SCIP_Real *vapex, SCIP_Real *vray)
static void computeRangeForBilinearProp(SCIP_INTERVAL exprdom, SCIP_Real coef, SCIP_INTERVAL rhs, SCIP_INTERVAL *range)
static SCIP_RETCODE computeIntercut(SCIP *scip, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, RAYS *rays, SCIP_Real sidefactor, SCIP_Bool iscase4, SCIP_Real *vb, SCIP_Real *vzlp, SCIP_Real *wcoefs, SCIP_Real wzlp, SCIP_Real kappa, SCIP_ROWPREP *rowprep, SCIP_Real *interpoints, SCIP_SOL *sol, SCIP_Bool *success)
#define NLHDLR_ENFOPRIORITY
static SCIP_RETCODE computeRestrictionToRay(SCIP *scip, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_Real sidefactor, SCIP_Bool iscase4, SCIP_Real *raycoefs, int *rayidx, int raynnonz, SCIP_Real *vb, SCIP_Real *vzlp, SCIP_Real *wcoefs, SCIP_Real wzlp, SCIP_Real kappa, SCIP_Real *coefs1234a, SCIP_Real *coefs4b, SCIP_Real *coefscondition, SCIP_Bool *success)
static SCIP_RETCODE findRho(SCIP *scip, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, RAYS *rays, int idx, SCIP_Real sidefactor, SCIP_Bool iscase4, SCIP_Real *vb, SCIP_Real *vzlp, SCIP_Real *wcoefs, SCIP_Real wzlp, SCIP_Real kappa, SCIP_Real *interpoints, SCIP_Real *rho, SCIP_Bool *success)
static SCIP_RETCODE createAndStoreSparseRays(SCIP *scip, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_VAR *auxvar, RAYS **raysptr, SCIP_Bool *success)
static SCIP_RETCODE insertRayEntry(SCIP *scip, RAYS *rays, SCIP_Real coef, int coefidx, int coefpos)
static void sparsifyIntercut(SCIP *scip, SCIP_ROWPREP *rowprep)
static SCIP_RETCODE computeMonoidalStrengthCoef(SCIP *scip, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, int lppos, SCIP_Real *raycoefs, int *rayidx, int raynnonz, SCIP_Real *vb, SCIP_Real *vzlp, SCIP_Real *wcoefs, SCIP_Real kappa, SCIP_Real *apex, SCIP_Real sidefactor, SCIP_Real *cutcoef, SCIP_Bool *success)
static SCIP_Real findMonoidalQuadRoot(SCIP *scip, SCIP_Real a, SCIP_Real b, SCIP_Real c)
static SCIP_RETCODE propagateBoundsQuadExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_Real sqrcoef, SCIP_INTERVAL b, SCIP_INTERVAL rhs, SCIP_Bool *infeasible, int *nreductions)
static SCIP_RETCODE createBoundRays(SCIP *scip, RAYS **rays, int size)
#define TABLE_DESC_QUADRATIC
static void freeRays(SCIP *scip, RAYS **rays)
static void combineRays(SCIP_Real *raycoefs1, int *rayidx1, int raynnonz1, SCIP_Real *raycoefs2, int *rayidx2, int raynnonz2, SCIP_Real *newraycoefs, int *newrayidx, int *newraynnonz, SCIP_Real coef1, SCIP_Real coef2)
static SCIP_Real computeEigenvecDotRay(SCIP_Real *eigenvec, int nquadvars, SCIP_Real *raycoefs, int *rayidx, int raynnonz)
static SCIP_Bool isPropagableTerm(SCIP_EXPR *qexpr, int idx)
static SCIP_Real computeWRayLinear(SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_Real sidefactor, SCIP_Real *raycoefs, int *rayidx, int raynnonz)
#define DEFAULT_NCUTSROOT
#define DEFAULT_USEMONOIDAL
static SCIP_RETCODE storeDenseTableauRow(SCIP *scip, SCIP_COL *col, int *basicvarpos2tableaurow, int nbasiccol, int raylength, SCIP_Real *binvrow, SCIP_Real *binvarow, SCIP_Real *tableaurows)
static SCIP_RETCODE addRowToCut(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_Real cutcoef, SCIP_ROW *row, SCIP_Bool *success)
static SCIP_Real computeIntersectionPoint(SCIP *scip, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_Bool iscase4, SCIP_Real *coefs1234a, SCIP_Real *coefs4b, SCIP_Real *coefscondition)
static SCIP_Real isCase4a(SCIP_Real tsol, SCIP_Real *coefs4a, SCIP_Real *coefscondition)
#define DEFAULT_USEMINREP
static SCIP_Real computeMaxForBilinearProp(SCIP_Real a, SCIP_Real c, SCIP_INTERVAL dom)
#define DEFAULT_USEINTERCUTS
static void constructLPPos2ConsPosMap(SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_VAR *auxvar, int *map)
static SCIP_Real computeRoot(SCIP *scip, SCIP_Real *coefs)
static SCIP_Bool isQuadConsViolated(SCIP *scip, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_VAR *auxvar, SCIP_SOL *sol, SCIP_Real sidefactor)
static SCIP_Bool areCoefsNumericsGood(SCIP *scip, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_Real *coefs1234a, SCIP_Real *coefs4b, SCIP_Bool iscase4)
static SCIP_RETCODE intercutsComputeCommonQuantities(SCIP *scip, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_VAR *auxvar, SCIP_Real sidefactor, SCIP_SOL *sol, SCIP_Real *vb, SCIP_Real *vzlp, SCIP_Real *wcoefs, SCIP_Real *wzlp, SCIP_Real *kappa)
static SCIP_Real evalPhiAtRay(SCIP_Real t, SCIP_Real a, SCIP_Real b, SCIP_Real c, SCIP_Real d, SCIP_Real e)
#define TABLE_POSITION_QUADRATIC
static SCIP_RETCODE insertRayEntries(SCIP *scip, RAYS *rays, SCIP_Real *densetableaucols, int *rayentry2conspos, int raylength, int nray, int conspos, SCIP_Real factor, int *nnonz, SCIP_Bool *success)
static SCIP_RETCODE computeStrengthenedIntercut(SCIP *scip, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, RAYS *rays, SCIP_Real sidefactor, SCIP_Bool iscase4, SCIP_Real *vb, SCIP_Real *vzlp, SCIP_Real *wcoefs, SCIP_Real wzlp, SCIP_Real kappa, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *strengthsuccess)
#define TABLE_NAME_QUADRATIC
#define INTERCUTS_MINVIOL
static void computeApex(SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_Real *vb, SCIP_Real *vzlp, SCIP_Real kappa, SCIP_Real sidefactor, SCIP_Real *apex, SCIP_Bool *success)
static SCIP_RETCODE propagateBoundsLinExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_Real b, SCIP_INTERVAL rhs, SCIP_Bool *infeasible, int *nreductions)
static SCIP_RETCODE createRays(SCIP *scip, RAYS **rays)
#define BINSEARCH_MAXITERS
static int countBasicVars(SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_VAR *auxvar, SCIP_Bool *nozerostat)
static SCIP_RETCODE findVertexAndGetRays(SCIP *scip, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_SOL *sol, SCIP_SOL *vertex, SCIP_VAR *auxvar, RAYS **raysptr, SCIP_Bool *success)
static SCIP_RETCODE reversePropagateLinearExpr(SCIP *scip, SCIP_EXPR **linexprs, int nlinexprs, SCIP_Real *lincoefs, SCIP_Real constant, SCIP_INTERVAL rhs, SCIP_Bool *infeasible, int *nreductions)
static SCIP_Bool isPropagable(SCIP_EXPR *qexpr)
static SCIP_Bool isRayInStrip(SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_Real *vb, SCIP_Real *vzlp, SCIP_Real *vapex, SCIP_Real *vray, SCIP_Real kappa, SCIP_Real sidefactor, SCIP_Real cutcoef)
static void doBinarySearch(SCIP *scip, SCIP_Real a, SCIP_Real b, SCIP_Real c, SCIP_Real d, SCIP_Real e, SCIP_Real *sol)
static SCIP_RETCODE storeDenseTableauRowsByColumns(SCIP *scip, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, int raylength, SCIP_VAR *auxvar, SCIP_Real *tableaurows, int *rayentry2conspos)
static SCIP_RETCODE computeMonoidalQuadCoefs(SCIP *scip, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_Real *vb, SCIP_Real *vzlp, SCIP_Real *vapex, SCIP_Real *vray, SCIP_Real kappa, SCIP_Real sidefactor, SCIP_Real *a, SCIP_Real *b, SCIP_Real *c)
#define TABLE_EARLIEST_STAGE_QUADRATIC
static SCIP_RETCODE constructBasicVars2TableauRowMap(SCIP *scip, int *map)
static SCIP_RETCODE rayInRecessionCone(SCIP *scip, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, RAYS *rays, int j, int i, SCIP_Real sidefactor, SCIP_Bool iscase4, SCIP_Real *vb, SCIP_Real *vzlp, SCIP_Real *wcoefs, SCIP_Real wzlp, SCIP_Real kappa, SCIP_Real alpha, SCIP_Bool *inreccone, SCIP_Bool *success)
static SCIP_RETCODE generateIntercut(SCIP *scip, SCIP_EXPR *expr, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_ROWPREP *rowprep, SCIP_Bool overestimate, SCIP_Bool *success)
static SCIP_RETCODE addColToCut(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Real cutcoef, SCIP_COL *col)
nonlinear handler to handle quadratic expressions
preparation of a linear inequality to become a SCIP_ROW
public functions of nonlinear handlers of nonlinear constraints
#define SCIP_NLHDLR_METHOD_SEPAABOVE
#define SCIP_DECL_NLHDLREVALAUX(x)
struct SCIP_NlhdlrData SCIP_NLHDLRDATA
#define SCIP_NLHDLR_METHOD_SEPABOTH
#define SCIP_DECL_NLHDLRCOPYHDLR(x)
#define SCIP_NLHDLR_METHOD_ACTIVITY
#define SCIP_DECL_NLHDLRFREEEXPRDATA(x)
#define SCIP_DECL_NLHDLRDETECT(x)
#define SCIP_NLHDLR_METHOD_NONE
#define SCIP_DECL_NLHDLRFREEHDLRDATA(x)
struct SCIP_NlhdlrExprData SCIP_NLHDLREXPRDATA
#define SCIP_DECL_NLHDLRREVERSEPROP(x)
#define SCIP_NLHDLR_METHOD_ALL
#define SCIP_DECL_NLHDLRENFO(x)
#define SCIP_DECL_NLHDLRINTEVAL(x)
#define SCIP_NLHDLR_METHOD_SEPABELOW
enum SCIP_Retcode SCIP_RETCODE
#define SCIP_DECL_TABLEOUTPUT(x)
@ SCIP_VARTYPE_CONTINUOUS