94#define CONSHDLR_NAME "linear"
95#define CONSHDLR_DESC "linear constraints of the form lhs <= a^T x <= rhs"
96#define CONSHDLR_SEPAPRIORITY +100000
97#define CONSHDLR_ENFOPRIORITY -1000000
98#define CONSHDLR_CHECKPRIORITY -1000000
99#define CONSHDLR_SEPAFREQ 0
100#define CONSHDLR_PROPFREQ 1
101#define CONSHDLR_EAGERFREQ 100
103#define CONSHDLR_MAXPREROUNDS -1
104#define CONSHDLR_DELAYSEPA FALSE
105#define CONSHDLR_DELAYPROP FALSE
106#define CONSHDLR_NEEDSCONS TRUE
108#define CONSHDLR_PRESOLTIMING (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_EXHAUSTIVE)
109#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
111#define EVENTHDLR_NAME "linear"
112#define EVENTHDLR_DESC "bound change event handler for linear constraints"
114#define CONFLICTHDLR_NAME "linear"
115#define CONFLICTHDLR_DESC "conflict handler creating linear constraints"
116#define CONFLICTHDLR_PRIORITY -1000000
118#define DEFAULT_TIGHTENBOUNDSFREQ 1
119#define DEFAULT_MAXROUNDS 5
120#define DEFAULT_MAXROUNDSROOT -1
121#define DEFAULT_MAXSEPACUTS 50
122#define DEFAULT_MAXSEPACUTSROOT 200
123#define DEFAULT_PRESOLPAIRWISE TRUE
124#define DEFAULT_PRESOLUSEHASHING TRUE
125#define DEFAULT_NMINCOMPARISONS 200000
126#define DEFAULT_MINGAINPERNMINCOMP 1e-06
128#define DEFAULT_SORTVARS TRUE
130#define DEFAULT_CHECKRELMAXABS FALSE
132#define DEFAULT_MAXAGGRNORMSCALE 0.0
134#define DEFAULT_MAXEASYACTIVITYDELTA 1e6
136#define DEFAULT_MAXCARDBOUNDDIST 0.0
138#define DEFAULT_SEPARATEALL FALSE
140#define DEFAULT_AGGREGATEVARIABLES TRUE
141#define DEFAULT_SIMPLIFYINEQUALITIES TRUE
142#define DEFAULT_DUALPRESOLVING TRUE
143#define DEFAULT_SINGLETONSTUFFING TRUE
144#define DEFAULT_SINGLEVARSTUFFING FALSE
146#define DEFAULT_DETECTCUTOFFBOUND TRUE
149#define DEFAULT_DETECTLOWERBOUND TRUE
152#define DEFAULT_DETECTPARTIALOBJECTIVE TRUE
154#define DEFAULT_RANGEDROWPROPAGATION TRUE
155#define DEFAULT_RANGEDROWARTCONS TRUE
156#define DEFAULT_RANGEDROWMAXDEPTH INT_MAX
157#define DEFAULT_RANGEDROWFREQ 1
159#define DEFAULT_MULTAGGRREMOVE FALSE
161#define DEFAULT_MAXMULTAGGRQUOT 1e+03
162#define DEFAULT_MAXDUALMULTAGGRQUOT 1e+20
163#define DEFAULT_EXTRACTCLIQUES TRUE
165#define MAXDNOM 10000LL
166#define MAXSCALEDCOEF 0
167#define MAXSCALEDCOEFINTEGER 0
170#define MAXACTVAL 1e+09
174#define MAXVALRECOMP 1e+06
175#define MINVALRECOMP 1e-05
178#define NONLINCONSUPGD_PRIORITY 1000000
196 SCIP_Real lastminactivity;
198 SCIP_Real lastmaxactivity;
204 SCIP_Real lastglbminactivity;
206 SCIP_Real lastglbmaxactivity;
208 SCIP_Real maxactdelta;
210 uint64_t possignature;
211 uint64_t negsignature;
217 int minactivityneginf;
218 int minactivityposinf;
219 int maxactivityneginf;
220 int maxactivityposinf;
221 int minactivityneghuge;
222 int minactivityposhuge;
223 int maxactivityneghuge;
224 int maxactivityposhuge;
225 int glbminactivityneginf;
226 int glbminactivityposinf;
227 int glbmaxactivityneginf;
228 int glbmaxactivityposinf;
229 int glbminactivityneghuge;
230 int glbminactivityposhuge;
231 int glbmaxactivityneghuge;
232 int glbmaxactivityposhuge;
238 unsigned int boundstightened:2;
239 unsigned int rangedrowpropagated:2;
241 unsigned int validmaxabsval:1;
242 unsigned int validminabsval:1;
243 unsigned int validactivities:1;
244 unsigned int validminact:1;
245 unsigned int validmaxact:1;
246 unsigned int validglbminact:1;
247 unsigned int validglbmaxact:1;
248 unsigned int presolved:1;
249 unsigned int removedfixings:1;
250 unsigned int validsignature:1;
251 unsigned int changed:1;
252 unsigned int normalized:1;
253 unsigned int upgradetried:1;
254 unsigned int upgraded:1;
255 unsigned int indexsorted:1;
256 unsigned int merged:1;
257 unsigned int cliquesadded:1;
258 unsigned int implsadded:1;
259 unsigned int coefsorted:1;
260 unsigned int varsdeleted:1;
261 unsigned int hascontvar:1;
262 unsigned int hasnonbinvar:1;
263 unsigned int hasnonbinvalid:1;
264 unsigned int checkabsolute:1;
276struct SCIP_ConshdlrData
280 SCIP_Real maxaggrnormscale;
282 SCIP_Real maxcardbounddist;
284 SCIP_Real mingainpernmincomp;
285 SCIP_Real maxeasyactivitydelta;
287 int linconsupgradessize;
288 int nlinconsupgrades;
289 int tightenboundsfreq;
296 SCIP_Bool presolpairwise;
297 SCIP_Bool presolusehashing;
298 SCIP_Bool separateall;
300 SCIP_Bool aggregatevariables;
301 SCIP_Bool simplifyinequalities;
302 SCIP_Bool dualpresolving;
303 SCIP_Bool singletonstuffing;
304 SCIP_Bool singlevarstuffing;
307 SCIP_Bool checkrelmaxabs;
309 SCIP_Bool detectcutoffbound;
312 SCIP_Bool detectlowerbound;
315 SCIP_Bool detectpartialobjective;
317 SCIP_Bool rangedrowpropagation;
320 SCIP_Bool rangedrowartcons;
321 int rangedrowmaxdepth;
323 SCIP_Bool multaggrremove;
325 SCIP_Real maxmultaggrquot;
326 SCIP_Real maxdualmultaggrquot;
327 SCIP_Bool extractcliques;
362 unsigned int proprule:8;
378 inferinfo.val.asint =
i;
389 return inferinfo.val.asint;
398 return (
int) inferinfo.val.asbits.proprule;
407 return (
int) inferinfo.val.asbits.pos;
423 inferinfo.val.asbits.proprule = (
unsigned int) proprule;
424 inferinfo.val.asbits.pos = (
unsigned int) pos;
454 assert(conshdlrdata->nlinconsupgrades <= conshdlrdata->linconsupgradessize);
456 if( num > conshdlrdata->linconsupgradessize )
462 conshdlrdata->linconsupgradessize =
newsize;
479 assert(consdata->nvars <= consdata->varssize);
481 if( num > consdata->varssize )
488 if( consdata->eventdata !=
NULL )
519 (*linconsupgrade)->priority = priority;
520 (*linconsupgrade)->active =
TRUE;
552 (*conshdlrdata)->linconsupgrades =
NULL;
553 (*conshdlrdata)->linconsupgradessize = 0;
554 (*conshdlrdata)->nlinconsupgrades = 0;
555 (*conshdlrdata)->naddconss = 0;
558 (*conshdlrdata)->eventhdlr = eventhdlr;
576 for(
i = 0;
i < (*conshdlrdata)->nlinconsupgrades; ++
i )
601 for(
i = conshdlrdata->nlinconsupgrades - 1;
i >= 0; --
i )
603 if( conshdlrdata->linconsupgrades[
i]->linconsupgd ==
linconsupgd )
631 for(
i = conshdlrdata->nlinconsupgrades;
632 i > 0 && conshdlrdata->linconsupgrades[
i-1]->priority <
linconsupgrade->priority; --
i )
634 conshdlrdata->linconsupgrades[
i] = conshdlrdata->linconsupgrades[
i-1];
638 conshdlrdata->nlinconsupgrades++;
739 consdata->eventdata[pos]->cons = cons;
740 consdata->eventdata[pos]->varpos = pos;
745 eventhdlr, consdata->eventdata[pos], &consdata->eventdata[pos]->filterpos) );
747 consdata->removedfixings = consdata->removedfixings &&
SCIPvarIsActive(consdata->vars[pos]);
774 assert(consdata->eventdata[pos]->cons == cons);
775 assert(consdata->eventdata[pos]->varpos == pos);
780 eventhdlr, consdata->eventdata[pos], consdata->eventdata[pos]->filterpos) );
811 for(
i = 0;
i < consdata->nvars; ++
i )
838 for(
i = consdata->nvars - 1;
i >= 0; --
i )
888 (*consdata)->varssize = 0;
889 (*consdata)->nvars =
nvars;
890 (*consdata)->hascontvar =
FALSE;
891 (*consdata)->hasnonbinvar =
FALSE;
892 (*consdata)->hasnonbinvalid =
TRUE;
893 (*consdata)->vars =
NULL;
894 (*consdata)->vals =
NULL;
910 for( v = 0; v <
nvars; ++v )
933 if( !(*consdata)->hascontvar )
939 (*consdata)->hasnonbinvar =
TRUE;
942 (*consdata)->hascontvar =
TRUE;
948 (*consdata)->nvars =
k;
955 (*consdata)->varssize =
k;
962 (*consdata)->eventdata =
NULL;
974 (*consdata)->row =
NULL;
975 (*consdata)->nlrow =
NULL;
976 (*consdata)->lhs = lhs;
977 (*consdata)->rhs = rhs;
985 (*consdata)->maxactdeltavar =
NULL;
986 (*consdata)->minactivityneginf = -1;
987 (*consdata)->minactivityposinf = -1;
988 (*consdata)->maxactivityneginf = -1;
989 (*consdata)->maxactivityposinf = -1;
990 (*consdata)->minactivityneghuge = -1;
991 (*consdata)->minactivityposhuge = -1;
992 (*consdata)->maxactivityneghuge = -1;
993 (*consdata)->maxactivityposhuge = -1;
998 (*consdata)->glbminactivityneginf = -1;
999 (*consdata)->glbminactivityposinf = -1;
1000 (*consdata)->glbmaxactivityneginf = -1;
1001 (*consdata)->glbmaxactivityposinf = -1;
1002 (*consdata)->glbminactivityneghuge = -1;
1003 (*consdata)->glbminactivityposhuge = -1;
1004 (*consdata)->glbmaxactivityneghuge = -1;
1005 (*consdata)->glbmaxactivityposhuge = -1;
1006 (*consdata)->possignature = 0;
1007 (*consdata)->negsignature = 0;
1008 (*consdata)->validmaxabsval =
FALSE;
1009 (*consdata)->validminabsval =
FALSE;
1010 (*consdata)->validactivities =
FALSE;
1011 (*consdata)->validminact =
FALSE;
1012 (*consdata)->validmaxact =
FALSE;
1013 (*consdata)->validglbminact =
FALSE;
1014 (*consdata)->validglbmaxact =
FALSE;
1015 (*consdata)->boundstightened = 0;
1016 (*consdata)->presolved =
FALSE;
1017 (*consdata)->removedfixings =
FALSE;
1018 (*consdata)->validsignature =
FALSE;
1019 (*consdata)->changed =
TRUE;
1020 (*consdata)->normalized =
FALSE;
1021 (*consdata)->upgradetried =
FALSE;
1022 (*consdata)->upgraded =
FALSE;
1023 (*consdata)->indexsorted = (
nvars <= 1);
1024 (*consdata)->merged = (
nvars <= 1);
1025 (*consdata)->cliquesadded =
FALSE;
1026 (*consdata)->implsadded =
FALSE;
1027 (*consdata)->coefsorted =
FALSE;
1028 (*consdata)->nbinvars = -1;
1029 (*consdata)->varsdeleted =
FALSE;
1030 (*consdata)->rangedrowpropagated = 0;
1031 (*consdata)->checkabsolute =
FALSE;
1040 for( v = 0; v < (*consdata)->nvars; v++ )
1043 if( (*consdata)->vars[v] ==
NULL )
1070 assert((*consdata)->varssize >= 0);
1073 if( (*consdata)->row !=
NULL )
1079 if( (*consdata)->nlrow !=
NULL )
1085 for( v = 0; v < (*consdata)->nvars; v++ )
1117 if( consdata->nvars == 0 )
1164 if( consdata->nvars == 0 )
1171 for( v = 0; v < consdata->nvars; ++v )
1173 if( consdata->vals !=
NULL )
1175 if( consdata->vals[v] == 1.0 )
1180 else if( consdata->vals[v] == -1.0 )
1185 else if( consdata->nvars > 0 )
1218 consdata->validactivities =
FALSE;
1219 consdata->validminact =
FALSE;
1220 consdata->validmaxact =
FALSE;
1221 consdata->validglbminact =
FALSE;
1222 consdata->validglbmaxact =
FALSE;
1223 consdata->validmaxabsval =
FALSE;
1224 consdata->validminabsval =
FALSE;
1225 consdata->hasnonbinvalid =
FALSE;
1233 consdata->maxactdeltavar =
NULL;
1234 consdata->minactivityneginf = -1;
1235 consdata->minactivityposinf = -1;
1236 consdata->maxactivityneginf = -1;
1237 consdata->maxactivityposinf = -1;
1238 consdata->minactivityneghuge = -1;
1239 consdata->minactivityposhuge = -1;
1240 consdata->maxactivityneghuge = -1;
1241 consdata->maxactivityposhuge = -1;
1246 consdata->glbminactivityneginf = -1;
1247 consdata->glbminactivityposinf = -1;
1248 consdata->glbmaxactivityneginf = -1;
1249 consdata->glbmaxactivityposinf = -1;
1250 consdata->glbminactivityneghuge = -1;
1251 consdata->glbminactivityposhuge = -1;
1252 consdata->glbmaxactivityneghuge = -1;
1253 consdata->glbmaxactivityposhuge = -1;
1266 SCIP_Real pseudoactivity;
1274 for(
i = consdata->nvars - 1;
i >= 0; --
i )
1276 val = consdata->vals[
i];
1295 pseudoactivity += val *
bound;
1306 return pseudoactivity;
1321 for(
i = consdata->nvars - 1;
i >= 0; --
i )
1330 consdata->validminact =
TRUE;
1333 consdata->lastminactivity =
QUAD_TO_DBL(consdata->minactivity);
1348 for(
i = consdata->nvars - 1;
i >= 0; --
i )
1357 consdata->validmaxact =
TRUE;
1360 consdata->lastmaxactivity =
QUAD_TO_DBL(consdata->maxactivity);
1375 for(
i = consdata->nvars - 1;
i >= 0; --
i )
1384 consdata->validglbminact =
TRUE;
1387 consdata->lastglbminactivity =
QUAD_TO_DBL(consdata->glbminactivity);
1402 for(
i = consdata->nvars - 1;
i >= 0; --
i )
1411 consdata->validglbmaxact =
TRUE;
1414 consdata->lastglbmaxactivity =
QUAD_TO_DBL(consdata->glbmaxactivity);
1427 assert(!consdata->validmaxabsval);
1430 consdata->validmaxabsval =
TRUE;
1431 consdata->maxabsval = 0.0;
1432 for(
i = 0;
i < consdata->nvars; ++
i )
1436 if(
absval > consdata->maxabsval )
1437 consdata->maxabsval =
absval;
1451 assert(!consdata->validminabsval);
1454 consdata->validminabsval =
TRUE;
1456 if( consdata->nvars > 0 )
1457 consdata->minabsval =
REALABS(consdata->vals[0]);
1459 consdata->minabsval = 0.0;
1461 for(
i = 1;
i < consdata->nvars; ++
i )
1466 consdata->minabsval =
absval;
1478 assert(!consdata->hasnonbinvalid);
1479 consdata->hasnonbinvar =
FALSE;
1480 consdata->hascontvar =
FALSE;
1482 for( v = consdata->nvars - 1; v >= 0; --v )
1488 consdata->hasnonbinvar =
TRUE;
1492 consdata->hascontvar =
TRUE;
1497 assert(consdata->hascontvar || v < 0);
1499 consdata->hasnonbinvalid =
TRUE;
1503#ifdef CHECKMAXACTDELTA
1513 SCIP_Real maxactdelta = 0.0;
1520 for( v = consdata->nvars - 1; v >= 0; --v )
1532 delta =
REALABS(consdata->vals[v]) * domain;
1534 if( delta > maxactdelta )
1536 maxactdelta = delta;
1543#define checkMaxActivityDelta(scip, consdata)
1556 consdata->maxactdelta = 0.0;
1558 if( !consdata->hasnonbinvalid )
1562 if( !consdata->hasnonbinvar )
1564 for( v = consdata->nvars - 1; v >= 0; --v )
1568 delta =
REALABS(consdata->vals[v]);
1570 if( delta > consdata->maxactdelta )
1572 consdata->maxactdelta = delta;
1573 consdata->maxactdeltavar = consdata->vars[v];
1580 for( v = consdata->nvars - 1; v >= 0; --v )
1592 consdata->maxactdeltavar = consdata->vars[v];
1597 delta =
REALABS(consdata->vals[v]) * domain;
1599 if( delta > consdata->maxactdelta )
1601 consdata->maxactdelta = delta;
1602 consdata->maxactdeltavar = consdata->vars[v];
1638 assert(consdata->validactivities);
1643 assert(consdata->minactivityneginf >= 0);
1644 assert(consdata->minactivityposinf >= 0);
1645 assert(consdata->maxactivityneginf >= 0);
1646 assert(consdata->maxactivityposinf >= 0);
1647 assert(consdata->minactivityneghuge >= 0);
1648 assert(consdata->minactivityposhuge >= 0);
1649 assert(consdata->maxactivityneghuge >= 0);
1650 assert(consdata->maxactivityposhuge >= 0);
1655 assert(consdata->glbminactivityneginf >= 0);
1656 assert(consdata->glbminactivityposinf >= 0);
1657 assert(consdata->glbmaxactivityneginf >= 0);
1658 assert(consdata->glbmaxactivityposinf >= 0);
1659 assert(consdata->glbminactivityneghuge >= 0);
1660 assert(consdata->glbminactivityposhuge >= 0);
1661 assert(consdata->glbmaxactivityneghuge >= 0);
1662 assert(consdata->glbmaxactivityposhuge >= 0);
1685 validact = consdata->validglbminact;
1695 validact = consdata->validglbmaxact;
1708 validact = consdata->validglbmaxact;
1718 validact = consdata->validglbminact;
1787 if( oldbound > 0.0 )
1795 (*activityposinf)--;
1799 (*activityneginf)++;
1804 (*activityposhuge)++;
1823 (*activityneginf)--;
1827 (*activityposinf)++;
1832 (*activityposhuge)++;
1852 (*activityposhuge)--;
1857 if( newbound > 0.0 )
1858 (*activityposinf)++;
1867 (*activityposhuge)++;
1885 (*activityneghuge)--;
1890 if( newbound > 0.0 )
1891 (*activityposinf)++;
1900 (*activityposhuge)++;
1918 if( newbound > 0.0 )
1920 (*activityposinf)++;
1930 (*activityneginf)++;
1939 (*activityposhuge)++;
1944 (*activityneghuge)++;
1974 SCIPdebugMsg(
scip,
"%s activity of linear constraint unreliable after update: %16.9g\n",
1981 consdata->validglbminact =
FALSE;
1983 consdata->validglbmaxact =
FALSE;
1988 consdata->validminact =
FALSE;
1990 consdata->validmaxact =
FALSE;
2013 if( consdata->validactivities )
2038 if( consdata->validactivities )
2061 if( consdata->validactivities )
2084 if( consdata->validactivities )
2108 if( consdata->validmaxabsval )
2115 consdata->maxabsval =
MAX(consdata->maxabsval,
absval);
2118 if( consdata->validminabsval )
2125 consdata->minabsval =
MIN(consdata->minabsval,
absval);
2129 if( consdata->validactivities )
2158 if( consdata->validmaxabsval )
2166 consdata->validmaxabsval =
FALSE;
2172 if( consdata->validminabsval )
2180 consdata->validminabsval =
FALSE;
2186 if( consdata->validactivities )
2222 if( consdata->validmaxabsval )
2230 consdata->maxabsval =
absval;
2239 consdata->validmaxabsval =
FALSE;
2246 if( consdata->validminabsval )
2254 consdata->minabsval =
absval;
2263 consdata->validminabsval =
FALSE;
2279 delta =
REALABS(newval) * domain;
2281 if( delta > consdata->maxactdelta )
2283 consdata->maxactdelta = delta;
2284 consdata->maxactdeltavar =
var;
2289 if( consdata->maxactdeltavar ==
var )
2307 if( !consdata->validmaxabsval )
2309 assert(consdata->validmaxabsval);
2312 return consdata->maxabsval;
2323 if( !consdata->validminabsval )
2325 assert(consdata->validminabsval);
2328 return consdata->minabsval;
2344 assert(!consdata->validactivities);
2350 consdata->validmaxabsval =
TRUE;
2351 consdata->validminabsval =
TRUE;
2352 consdata->validactivities =
TRUE;
2353 consdata->validminact =
TRUE;
2354 consdata->validmaxact =
TRUE;
2355 consdata->validglbminact =
TRUE;
2356 consdata->validglbmaxact =
TRUE;
2357 consdata->maxabsval = 0.0;
2358 consdata->minabsval = (consdata->nvars == 0 ? 0.0 :
REALABS(consdata->vals[0]));
2361 consdata->lastminactivity = 0.0;
2362 consdata->lastmaxactivity = 0.0;
2363 consdata->minactivityneginf = 0;
2364 consdata->minactivityposinf = 0;
2365 consdata->maxactivityneginf = 0;
2366 consdata->maxactivityposinf = 0;
2367 consdata->minactivityneghuge = 0;
2368 consdata->minactivityposhuge = 0;
2369 consdata->maxactivityneghuge = 0;
2370 consdata->maxactivityposhuge = 0;
2373 consdata->lastglbminactivity = 0.0;
2374 consdata->lastglbmaxactivity = 0.0;
2375 consdata->glbminactivityneginf = 0;
2376 consdata->glbminactivityposinf = 0;
2377 consdata->glbmaxactivityneginf = 0;
2378 consdata->glbmaxactivityposinf = 0;
2379 consdata->glbminactivityneghuge = 0;
2380 consdata->glbminactivityposhuge = 0;
2381 consdata->glbmaxactivityneghuge = 0;
2382 consdata->glbmaxactivityposhuge = 0;
2384 for(
i = 0;
i < consdata->nvars; ++
i )
2387 consdata->lastminactivity =
QUAD_TO_DBL(consdata->minactivity);
2388 consdata->lastmaxactivity =
QUAD_TO_DBL(consdata->maxactivity);
2389 consdata->lastglbminactivity =
QUAD_TO_DBL(consdata->glbminactivity);
2390 consdata->lastglbmaxactivity =
QUAD_TO_DBL(consdata->glbmaxactivity);
2408 SCIP_Real* minactivity,
2459 if( !consdata->validglbminact )
2461 assert(consdata->validglbminact);
2467 if( !consdata->validminact )
2469 assert(consdata->validminact);
2509 SCIP_Real* maxactivity,
2560 if( !consdata->validglbmaxact )
2562 assert(consdata->validglbmaxact);
2568 if( !consdata->validmaxact )
2570 assert(consdata->validmaxact);
2602 SCIP_Real* minactivity,
2603 SCIP_Real* maxactivity,
2622 if( !consdata->validactivities )
2625 assert(consdata->validminact);
2626 assert(consdata->validmaxact);
2630 assert(consdata->minactivityneginf >= 0);
2631 assert(consdata->minactivityposinf >= 0);
2632 assert(consdata->maxactivityneginf >= 0);
2633 assert(consdata->maxactivityposinf >= 0);
2635 getMinActivity(
scip, consdata, consdata->minactivityposinf, consdata->minactivityneginf,
2636 consdata->minactivityposhuge, consdata->minactivityneghuge, 0.0,
FALSE,
goodrelax,
2639 getMaxActivity(
scip, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,
2640 consdata->maxactivityposhuge, consdata->maxactivityneghuge, 0.0,
FALSE,
goodrelax,
2668 for( v = 0; v < consdata->nvars; ++v )
2670 var = consdata->vars[v];
2675 val = consdata->vals[v];
2761 if( !consdata->validactivities )
2764 assert(consdata->validminact);
2765 assert(consdata->validmaxact);
2769 assert(consdata->minactivityneginf >= 0);
2770 assert(consdata->minactivityposinf >= 0);
2771 assert(consdata->maxactivityneginf >= 0);
2772 assert(consdata->maxactivityposinf >= 0);
2773 assert(consdata->minactivityneghuge >= 0);
2774 assert(consdata->minactivityposhuge >= 0);
2775 assert(consdata->maxactivityneghuge >= 0);
2776 assert(consdata->maxactivityposhuge >= 0);
2796 assert(consdata->minactivityposinf >= 1);
2798 getMinActivity(
scip, consdata, consdata->minactivityposinf - 1, consdata->minactivityneginf,
2799 consdata->minactivityposhuge, consdata->minactivityneghuge, 0.0,
FALSE,
goodrelax,
2804 assert(consdata->minactivityneginf >= 1);
2806 getMinActivity(
scip, consdata, consdata->minactivityposinf, consdata->minactivityneginf - 1,
2807 consdata->minactivityposhuge, consdata->minactivityneghuge, 0.0,
FALSE,
goodrelax,
2812 assert(consdata->minactivityposhuge >= 1);
2814 getMinActivity(
scip, consdata, consdata->minactivityposinf, consdata->minactivityneginf,
2815 consdata->minactivityposhuge - 1, consdata->minactivityneghuge, 0.0,
FALSE,
goodrelax,
2820 assert(consdata->minactivityneghuge >= 1);
2822 getMinActivity(
scip, consdata, consdata->minactivityposinf, consdata->minactivityneginf,
2823 consdata->minactivityposhuge, consdata->minactivityneghuge - 1, 0.0,
FALSE,
goodrelax,
2828 getMinActivity(
scip, consdata, consdata->minactivityposinf, consdata->minactivityneginf,
2838 assert(consdata->maxactivityneginf >= 1);
2840 getMaxActivity(
scip, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf - 1,
2841 consdata->maxactivityposhuge, consdata->maxactivityneghuge, 0.0,
FALSE,
goodrelax,
2846 assert(consdata->maxactivityposinf >= 1);
2848 getMaxActivity(
scip, consdata, consdata->maxactivityposinf - 1, consdata->maxactivityneginf,
2849 consdata->maxactivityposhuge, consdata->maxactivityneghuge, 0.0,
FALSE,
goodrelax,
2854 assert(consdata->maxactivityposhuge >= 1);
2856 getMaxActivity(
scip, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,
2857 consdata->maxactivityposhuge - 1, consdata->maxactivityneghuge, 0.0,
FALSE,
goodrelax,
2862 assert(consdata->maxactivityneghuge >= 1);
2864 getMaxActivity(
scip, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,
2865 consdata->maxactivityposhuge, consdata->maxactivityneghuge - 1, 0.0,
FALSE,
goodrelax,
2870 getMaxActivity(
scip, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,
2900 if( !consdata->validactivities )
2903 assert(consdata->validglbminact);
2904 assert(consdata->validglbmaxact);
2908 assert(consdata->glbminactivityneginf >= 0);
2909 assert(consdata->glbminactivityposinf >= 0);
2910 assert(consdata->glbmaxactivityneginf >= 0);
2911 assert(consdata->glbmaxactivityposinf >= 0);
2912 assert(consdata->glbminactivityneghuge >= 0);
2913 assert(consdata->glbminactivityposhuge >= 0);
2914 assert(consdata->glbmaxactivityneghuge >= 0);
2915 assert(consdata->glbmaxactivityposhuge >= 0);
2922 getMinActivity(
scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,
2923 consdata->glbminactivityposhuge, consdata->glbminactivityneghuge, 0.0,
TRUE,
goodrelax,
2932 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,
2933 consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge, 0.0,
TRUE,
goodrelax,
2970 if( !consdata->validactivities )
2975 assert(consdata->glbminactivityneginf >= 0);
2976 assert(consdata->glbminactivityposinf >= 0);
2977 assert(consdata->glbmaxactivityneginf >= 0);
2978 assert(consdata->glbmaxactivityposinf >= 0);
3003 assert(consdata->glbminactivityposinf >= 1);
3005 getMinActivity(
scip, consdata, consdata->glbminactivityposinf - 1, consdata->glbminactivityneginf,
3006 consdata->glbminactivityposhuge, consdata->glbminactivityneghuge, 0.0,
TRUE,
goodrelax,
3011 assert(consdata->glbminactivityneginf >= 1);
3013 getMinActivity(
scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf - 1,
3014 consdata->glbminactivityposhuge, consdata->glbminactivityneghuge, 0.0,
TRUE,
goodrelax,
3019 assert(consdata->glbminactivityposhuge >= 1);
3021 getMinActivity(
scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,
3022 consdata->glbminactivityposhuge - 1, consdata->glbminactivityneghuge, 0.0,
TRUE,
goodrelax,
3027 assert(consdata->glbminactivityneghuge >= 1);
3029 getMinActivity(
scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,
3030 consdata->glbminactivityposhuge, consdata->glbminactivityneghuge - 1, 0.0,
TRUE,
goodrelax,
3035 getMinActivity(
scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,
3051 assert(consdata->glbmaxactivityneginf >= 1);
3053 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf - 1,
3054 consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge, 0.0,
TRUE,
goodrelax,
3059 assert(consdata->glbmaxactivityposinf >= 1);
3061 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf - 1, consdata->glbmaxactivityneginf,
3062 consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge, 0.0,
TRUE,
goodrelax,
3067 assert(consdata->glbmaxactivityposhuge >= 1);
3069 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,
3070 consdata->glbmaxactivityposhuge - 1, consdata->glbmaxactivityneghuge, 0.0,
TRUE,
goodrelax,
3075 assert(consdata->glbmaxactivityneghuge >= 1);
3077 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,
3078 consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge - 1, 0.0,
TRUE,
goodrelax,
3083 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,
3117 for( v = 0; v < consdata->nvars; ++v )
3121 if( consdata->vals[v] < 0 )
3131 activity += consdata->vals[v] * solval;
3135 SCIPdebugMsg(
scip,
"activity of linear constraint: %.15g, %d positive infinity values, %d negative infinity values \n", activity,
nposinf,
nneginf);
3139 activity = (consdata->rhs + consdata->lhs) / 2;
3145 SCIPdebugMsg(
scip,
"corrected activity of linear constraint: %.15g\n", activity);
3150 else if( activity < 0 )
3176 return MIN(consdata->rhs - activity, activity - consdata->lhs);
3192 assert(consdata->validsignature);
3197 val = consdata->vals[pos];
3198 if( (val > 0.0 && ub > 0.0) || (val < 0.0 && lb < 0.0) )
3212 if( !consdata->validsignature )
3216 consdata->validsignature =
TRUE;
3217 consdata->possignature = 0;
3218 consdata->negsignature = 0;
3219 for(
i = 0;
i < consdata->nvars; ++
i )
3353 for( v = 0; v <
nvars; ++v )
3357 varv = consdata->vars[v];
3358 valv = consdata->vals[v];
3359 if( consdata->eventdata !=
NULL )
3366 consdata->vars[
i] = consdata->vars[perm[
i]];
3367 consdata->vals[
i] = consdata->vals[perm[
i]];
3368 if( consdata->eventdata !=
NULL )
3370 consdata->eventdata[
i] = consdata->eventdata[perm[
i]];
3371 consdata->eventdata[
i]->varpos =
i;
3377 while( perm[
i] != v );
3378 consdata->vars[
i] =
varv;
3379 consdata->vals[
i] =
valv;
3380 if( consdata->eventdata !=
NULL )
3383 consdata->eventdata[
i]->varpos =
i;
3390 for( v = 0; v <
nvars; ++v )
3393 assert(consdata->eventdata ==
NULL || consdata->eventdata[v]->varpos == v);
3420 if( consdata->nvars <= 1 )
3422 consdata->indexsorted =
TRUE;
3423 consdata->coefsorted =
TRUE;
3424 consdata->nbinvars = (consdata->nvars == 1 ? (int)
SCIPvarIsBinary(consdata->vars[0]) : 0);
3448 consdata->indexsorted =
FALSE;
3449 consdata->coefsorted =
TRUE;
3452 consdata->nbinvars = 0;
3453 for( v = 0; v < consdata->nvars; ++v )
3456 ++consdata->nbinvars;
3463 consdata->indexsorted =
TRUE;
3464 consdata->coefsorted =
FALSE;
3498 assert(consdata->nvars == 0 || (consdata->vars !=
NULL && consdata->vals !=
NULL));
3508 consdata->rhs = lhs;
3526 vars = consdata->vars;
3527 vals = consdata->vals;
3529 for( v = 0; v < consdata->nvars; ++v )
3551 vars = consdata->vars;
3552 vals = consdata->vals;
3554 for( v = 0; v < consdata->nvars; ++v )
3574 consdata->boundstightened = 0;
3575 consdata->presolved =
FALSE;
3576 consdata->cliquesadded =
FALSE;
3577 consdata->implsadded =
FALSE;
3587 consdata->lhs = lhs;
3588 consdata->changed =
TRUE;
3589 consdata->normalized =
FALSE;
3590 consdata->upgradetried =
FALSE;
3591 consdata->rangedrowpropagated = 0;
3594 if( consdata->row !=
NULL )
3624 assert(consdata->nvars == 0 || (consdata->vars !=
NULL && consdata->vals !=
NULL));
3634 consdata->lhs = rhs;
3654 vars = consdata->vars;
3655 vals = consdata->vals;
3657 for( v = 0; v < consdata->nvars; ++v )
3679 vars = consdata->vars;
3680 vals = consdata->vals;
3682 for( v = 0; v < consdata->nvars; ++v )
3702 consdata->boundstightened = 0;
3703 consdata->presolved =
FALSE;
3704 consdata->cliquesadded =
FALSE;
3705 consdata->implsadded =
FALSE;
3715 consdata->rhs = rhs;
3716 consdata->changed =
TRUE;
3717 consdata->normalized =
FALSE;
3718 consdata->upgradetried =
FALSE;
3719 consdata->rangedrowpropagated = 0;
3722 if( consdata->row !=
NULL )
3740 SCIP_Bool transformed;
3768 consdata->vars[consdata->nvars] =
var;
3769 consdata->vals[consdata->nvars] = val;
3778 if( consdata->eventdata !=
NULL )
3790 consdata->eventdata[consdata->nvars-1] =
NULL;
3811 consdata->maxactdeltavar =
var;
3815 SCIP_Real domain = ub - lb;
3816 SCIP_Real delta =
REALABS(val) * domain;
3818 if( delta > consdata->maxactdelta )
3820 consdata->maxactdelta = delta;
3821 consdata->maxactdeltavar =
var;
3836 consdata->boundstightened = 0;
3837 consdata->presolved =
FALSE;
3840 if( consdata->validsignature )
3843 consdata->changed =
TRUE;
3844 consdata->normalized =
FALSE;
3845 consdata->upgradetried =
FALSE;
3846 consdata->cliquesadded =
FALSE;
3847 consdata->implsadded =
FALSE;
3848 consdata->rangedrowpropagated = 0;
3850 if( consdata->nvars == 1 )
3852 consdata->indexsorted =
TRUE;
3853 consdata->coefsorted =
TRUE;
3854 consdata->merged =
TRUE;
3858 consdata->merged =
FALSE;
3862 consdata->indexsorted = consdata->indexsorted && (
consdataCompVar((
void*)consdata, consdata->nvars-2, consdata->nvars-1) <= 0);
3863 consdata->coefsorted =
FALSE;
3867 consdata->indexsorted =
FALSE;
3868 consdata->coefsorted = consdata->coefsorted && (
consdataCompVarProp((
void*)consdata, consdata->nvars-2, consdata->nvars-1) <= 0);
3873 if( consdata->hasnonbinvalid && !consdata->hascontvar )
3879 consdata->hasnonbinvar =
TRUE;
3882 consdata->hascontvar =
TRUE;
3887 if( consdata->row !=
NULL )
3914 var = consdata->vars[pos];
3915 val = consdata->vals[pos];
3934 if( consdata->eventdata !=
NULL )
3942 if( pos != consdata->nvars - 1 )
3944 consdata->vars[pos] = consdata->vars[consdata->nvars-1];
3945 consdata->vals[pos] = consdata->vals[consdata->nvars-1];
3947 if( consdata->eventdata !=
NULL )
3949 consdata->eventdata[pos] = consdata->eventdata[consdata->nvars-1];
3951 consdata->eventdata[pos]->varpos = pos;
3954 consdata->indexsorted = consdata->indexsorted && (pos + 2 >= consdata->nvars);
3955 consdata->coefsorted = consdata->coefsorted && (pos + 2 >= consdata->nvars);
3962 if( consdata->nvars <= 1 )
3974 if( consdata->maxactdeltavar ==
var )
3977 consdata->maxactdeltavar =
NULL;
3988 consdata->boundstightened = 0;
3989 consdata->presolved =
FALSE;
3990 consdata->validsignature =
FALSE;
3991 consdata->changed =
TRUE;
3992 consdata->normalized =
FALSE;
3993 consdata->upgradetried =
FALSE;
3994 consdata->cliquesadded =
FALSE;
3995 consdata->implsadded =
FALSE;
3996 consdata->rangedrowpropagated = 0;
4001 consdata->hasnonbinvalid =
FALSE;
4005 if( consdata->row !=
NULL )
4040 var = consdata->vars[pos];
4041 val = consdata->vals[pos];
4050 if( locked && newval * val < 0.0 )
4062 consdata->vals[pos] = newval;
4064 if( consdata->coefsorted )
4082 consdata->boundstightened = 0;
4083 consdata->presolved =
FALSE;
4084 consdata->validsignature = consdata->validsignature && (newval * val > 0.0);
4085 consdata->changed =
TRUE;
4086 consdata->normalized =
FALSE;
4087 consdata->upgradetried =
FALSE;
4088 consdata->cliquesadded =
FALSE;
4089 consdata->implsadded =
FALSE;
4090 consdata->rangedrowpropagated = 0;
4119 SCIPwarningMessage(
scip,
"skipped scaling for linear constraint <%s> to avoid numerical troubles (scalar: %.15g)\n",
4126 for(
i = consdata->nvars - 1;
i >= 0; --
i )
4128 newval = scalar * consdata->vals[
i];
4138 SCIPwarningMessage(
scip,
"coefficient %.15g of variable <%s> in linear constraint <%s> scaled to zero (scalar: %.15g)\n",
4143 consdata->vals[
i] = newval;
4151 lhs = consdata->lhs;
4152 consdata->lhs = -consdata->rhs;
4153 consdata->rhs = -lhs;
4166 consdata->lhs = newval;
4178 consdata->rhs = newval;
4182 consdata->cliquesadded =
FALSE;
4183 consdata->implsadded =
FALSE;
4208 for(
i = 0;
i < nconss;
i++ )
4213 if( consdata->varsdeleted )
4216 for( v = consdata->nvars - 1; v >= 0; --v )
4223 consdata->varsdeleted =
FALSE;
4252 SCIP_Bool* infeasible
4264 SCIP_Real maxabsval;
4265 SCIP_Real minabsval;
4279 *infeasible =
FALSE;
4290 if( consdata->normalized )
4294 vals = consdata->vals;
4295 nvars = consdata->nvars;
4300 consdata->normalized =
TRUE;
4321 for( v =
nvars - 1; v >= 0; --v )
4333 SCIPdebugMsg(
scip,
"divide linear constraint with %g, because all coefficients are in absolute value the same\n", maxabsval);
4337 if( consdata->validmaxabsval )
4340 consdata->maxabsval = 1.0;
4342 consdata->minabsval = 1.0;
4353 vals = consdata->vals;
4354 nvars = consdata->nvars;
4363 consdata->normalized =
TRUE;
4379 if( !consdata->hasnonbinvalid )
4383 if( !consdata->hascontvar )
4496 if( consdata->validmaxabsval )
4498 consdata->maxabsval *=
REALABS((SCIP_Real)
scm);
4501 consdata->validmaxabsval =
FALSE;
4507 if( consdata->validminabsval )
4509 consdata->minabsval *=
REALABS((SCIP_Real)
scm);
4512 consdata->validminabsval =
FALSE;
4519 vals = consdata->vals;
4520 nvars = consdata->nvars;
4560 if( consdata->validmaxabsval )
4562 consdata->maxabsval /=
REALABS((SCIP_Real)
gcd);
4564 if( consdata->validminabsval )
4566 consdata->minabsval /=
REALABS((SCIP_Real)
gcd);
4572 consdata->normalized =
TRUE;
4598 if( consdata->merged )
4608 v = consdata->nvars-1;
4611 var = consdata->vars[v];
4612 if( consdata->vars[v-1] ==
var )
4614 valsum = consdata->vals[v];
4619 valsum += consdata->vals[v];
4621 while( v >= 1 && consdata->vars[v-1] ==
var );
4632 if( consdata->maxactdeltavar ==
var )
4635 consdata->maxactdeltavar =
NULL;
4646 consdata->merged =
TRUE;
4656 SCIP_Bool* infeasible
4675 if( infeasible !=
NULL )
4676 *infeasible =
FALSE;
4681 if( consdata->eventdata ==
NULL )
4697 if( !consdata->removedfixings )
4716 var = consdata->vars[v];
4717 val = consdata->vals[v];
4744 if( infeasible !=
NULL )
4765 if( infeasible !=
NULL )
4818 for(
i = 0;
i < naggrvars; ++
i )
4883 consdata->removedfixings =
TRUE;
4896 assert(consdata->removedfixings);
4900 for( v = 0; v < consdata->nvars; ++v )
4935 vars = consdata->vars;
4936 vals = consdata->vals;
4937 nvars = consdata->nvars;
5113 vars = consdata->vars;
5114 nvars = consdata->nvars;
5122 for( v =
nvars - 1; v >= 0; --v )
5173 for( v =
nvars - 1; v >= 0; --v )
5235 vars = consdata->vars;
5236 nvars = consdata->nvars;
5238 vals = consdata->vals;
5291 SCIPerrorMessage(
"invalid inference information %d in linear constraint <%s> at position %d for %s bound of variable <%s>\n",
5340 + consdata->minactivityposinf
5341 + consdata->minactivityneghuge
5342 + consdata->minactivityposhuge;
5344 + consdata->maxactivityposinf
5345 + consdata->maxactivityneghuge
5346 + consdata->maxactivityposhuge;
5371 SCIP_Bool infeasible;
5372 SCIP_Bool tightened;
5379 var = consdata->vars[pos];
5389 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newub=%.15g\n",
5400 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5408 else if( tightened )
5411 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
5418 consdata->upgradetried =
FALSE;
5441 SCIP_Bool infeasible;
5442 SCIP_Bool tightened;
5449 var = consdata->vars[pos];
5459 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
5470 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5478 else if( tightened )
5481 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
5488 consdata->upgradetried =
FALSE;
5528 var = consdata->vars[pos];
5535 val = consdata->vals[pos];
5536 lhs = consdata->lhs;
5537 rhs = consdata->rhs;
5547 if( !consdata->validactivities )
5549 assert(consdata->validactivities);
5550 if( !consdata->validminact )
5552 assert(consdata->validminact);
5563 assert(consdata->validminact);
5568 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, minactivity=%.15g > rhs=%.15g\n",
5583 alpha = val * (ub - lb);
5591 newub = lb + (slack / val);
5597 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5615 if( !consdata->validmaxact )
5619 assert(consdata->validmaxact);
5624 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, maxactivity=%.15g < lhs=%.15g\n",
5639 alpha = val * (ub - lb);
5647 newlb = ub - (slack / val);
5653 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5670 assert(consdata->validminact);
5675 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, minactivity=%.15g > rhs=%.15g\n",
5690 alpha = val * (lb - ub);
5698 newlb = ub + slack / val;
5704 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5721 if( !consdata->validmaxact )
5725 assert(consdata->validmaxact);
5730 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, maxactivity=%.15g < lhs=%.15g\n",
5745 alpha = val * (lb - ub);
5753 newub = lb - (slack / val);
5759 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5883 if( consdata->rangedrowpropagated == 2 )
5887 if( consdata->nvars < 3 )
5904 consdata->rangedrowpropagated = 2;
5911 if( consdata->rangedrowpropagated > 0 )
5914 consdata->rangedrowpropagated = 1;
5919 for( v = consdata->nvars - 1; v >= 0; --v )
6009 if( v == consdata->nvars )
6026 for( ; v < consdata->nvars; ++v )
6139 SCIPdebugMsg(
scip,
"minactinfvarsinvalid = %u, minactinfvars = %g, maxactinfvarsinvalid = %u, maxactinfvars = %g, gcd = %lld, ninfcheckvars = %d, ncontvars = %d\n",
6165 else if( ncontvars == 0 )
6223 assert(nsols < 2 || minvalue <= maxvalue);
6247 assert(maxvalue > minvalue);
6255 SCIPdebugMsg(
scip,
"here nsols %s %d, minsolvalue = %g, maxsolvalue = %g, ninfcheckvars = %d, nunfixedvars = %d\n",
6261 SCIPdebugMsg(
scip,
"gcdinfvars = %lld, gcd = %lld, correctedlhs = %g, correctedrhs = %g\n",
6273 else if( nsols == 1 )
6275 assert(minvalue == maxvalue);
6284 SCIPdebugMsg(
scip,
"fixing single variable <%s> with bounds [%.15g,%.15g] to %.15g\n",
6315 for( v = 0; v < consdata->nvars - 1; ++v )
6341 if( consdata->vals[v] < 0 )
6350 SCIPdebugMsg(
scip,
"fixing variable <%s> with bounds [%.15g,%.15g] to %.15g\n",
6363 consdata->vars[v],
bound) );
6379 assert(v == consdata->nvars - 1);
6382 if( consdata->vals[v] < 0 )
6391 SCIPdebugMsg(
scip,
"fixing variable <%s> with bounds [%.15g,%.15g] to %.15g\n",
6404 consdata->vars[v],
bound) );
6419 ++conshdlrdata->naddconss;
6424 maxvalue, maxvalue,
TRUE,
TRUE,
TRUE,
FALSE,
TRUE,
TRUE,
FALSE,
FALSE,
TRUE,
FALSE) );
6443 SCIP_Bool tightened;
6464 SCIPdebugMsg(
scip,
"tightening lower bound of variable <%s> from %g to %g\n",
6485 SCIPdebugMsg(
scip,
"tightening upper bound of variable <%s> from %g to %g\n",
6507 SCIP_Bool tightened;
6513 assert(minvalue < maxvalue);
6516 for( v = 0; v < consdata->nvars - 1; ++v )
6542 if( consdata->vals[v] < 0 )
6557 SCIPdebugMsg(
scip,
"tightening lower bound of variable <%s> from %g to %g\n",
6569 consdata->vars[v],
newlb) );
6579 SCIPdebugMsg(
scip,
"tightening upper bound of variable <%s> from %g to %g\n",
6591 consdata->vars[v],
newub) );
6608 assert(v == consdata->nvars - 1);
6611 if( consdata->vals[v] < 0 )
6626 SCIPdebugMsg(
scip,
"tightening lower bound of variable <%s> from %g to %g\n",
6647 SCIPdebugMsg(
scip,
"tightening upper bound of variable <%s> from %g to %g\n",
6676 assert(maxvalue > minvalue);
6692 ++conshdlrdata->naddconss;
6718 for( v = 0; v < consdata->nvars; ++v )
6730 if( consdata->vals[v] > 0.0 )
6731 maxact += consdata->vals[v];
6733 minact += consdata->vals[v];
6741 if( consdata->vals[v] > 0.0 )
6792 ++conshdlrdata->naddconss;
6834 SCIP_Bool infeasible;
6835 SCIP_Bool tightened;
6856 var = consdata->vars[pos];
6862 val = consdata->vals[pos];
6863 lhs = consdata->lhs;
6864 rhs = consdata->rhs;
6904 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newub=%.15g\n",
6907 &infeasible, &tightened) );
6910 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6925 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
6953 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
6956 &infeasible, &tightened) );
6959 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6973 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
7006 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
7009 &infeasible, &tightened) );
7012 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
7026 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
7054 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g], newub=%.15g\n",
7057 &infeasible, &tightened) );
7060 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
7074 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
7084#define MAXTIGHTENROUNDS 10
7091 SCIP_Real maxeasyactivitydelta,
7136 nvars = consdata->nvars;
7146 if( !force && (consdata->boundstightened >=
tightenmode) )
7153 assert(consdata->coefsorted);
7172 SCIP_Real minactivity;
7173 SCIP_Real maxactivity;
7213 assert(consdata->coefsorted);
7217 consdata->boundstightened = (
unsigned int)
tightenmode;
7244 v = consdata->nbinvars;
7257 if( force &&
SCIPisEQ(
scip, consdata->lhs, consdata->rhs) )
7271 SCIP_Bool checkrelmaxabs,
7295 if( consdata->row !=
NULL )
7307 SCIPdebugMsg(
scip,
" consdata activity=%.15g (lhs=%.15g, rhs=%.15g, row=%p, checklprows=%u, rowinlp=%u, sol=%p, hascurrentnodelp=%u)\n",
7308 activity, consdata->lhs, consdata->rhs, (
void*)consdata->row,
checklprows,
7313 lhsviol = consdata->lhs - activity;
7314 rhsviol = activity - consdata->rhs;
7318 if( (lhsviol > 0) && (lhsviol > rhsviol) )
7323 else if( rhsviol > 0 )
7348 if( !checkrelmaxabs )
7372 for( v = 0; v < consdata->nvars; ++v )
7374 if( consdata->vals !=
NULL )
7376 coef = consdata->vals[v];
7390 if( (consdata->lhs - activity) <= (1
e-15 *
maxabs) )
7392 SCIPdebugMsg(
scip,
" lhs violated due to random noise: violation=%16.9g, maxabs=%16.9g\n",
7393 consdata->lhs - activity,
maxabs);
7407 SCIPdebugMsg(
scip,
" lhs violated absolutely (violation=%16.9g), but feasible when using relative tolerance w.r.t. maximum absolute value (%16.9g)\n",
7408 consdata->lhs - activity,
maxabs);
7444 if( (activity - consdata->rhs) <= (1
e-15 *
maxabs) )
7446 SCIPdebugMsg(
scip,
" rhs violated due to random noise: violation=%16.9g, maxabs=%16.9g\n",
7447 activity - consdata->rhs,
maxabs);
7461 SCIPdebugMsg(
scip,
" rhs violated absolutely (violation=%16.9g), but feasible when using relative tolerance w.r.t. maximum absolute value (%16.9g)\n",
7462 activity - consdata->rhs,
maxabs);
7496 else if( consdata->checkabsolute &&
7564 if( consdata->row ==
NULL )
7581 if( consdata->nvars == 0 )
7629 if( consdata->nlrow ==
NULL )
7631 assert(consdata->lhs <= consdata->rhs);
7655 SCIP_Bool separateall,
7688 if( !separateall &&
sol ==
NULL )
7701 consdata->vals, +1.0, consdata->rhs,
sol,
cutoff, ncuts) );
7709 consdata->vals, -1.0, -consdata->lhs,
sol,
cutoff, ncuts) );
7719 consdata->vals, +1.0, consdata->rhs,
sol,
cutoff, ncuts) );
7724 consdata->vals, -1.0, -consdata->lhs,
sol,
cutoff, ncuts) );
7729 if( *ncuts > oldncuts )
7742 SCIP_Bool tightenbounds,
7743 SCIP_Bool rangedrowpropagation,
7744 SCIP_Real maxeasyactivitydelta,
7751 SCIP_Real minactivity;
7752 SCIP_Real maxactivity;
7768 if( consdata->eventdata ==
NULL )
7811 if( rangedrowpropagation && tightenbounds && !(*
cutoff) )
7831 if( nfixedvars > 0 )
7832 *nchgbds += 2*nfixedvars;
7843 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible (rhs): activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7844 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7854 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible (lhs): activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7855 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7865 SCIPdebugMsg(
scip,
"linear constraint <%s> is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7866 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7869 if( consdata->nvars > 0 )
7900 SCIP_Bool infeasible;
7911 for( v = 0; v < consdata->nvars; ++v )
7914 var = consdata->vars[v];
7926 SCIPdebugMsg(
scip,
"converting variable <%s> with fixed bounds [%.15g,%.15g] into fixed variable fixed at %.15g\n",
7950 assert(consdata->removedfixings);
7955#define MAX_CLIQUE_NONZEROS_PER_CONS 1000000
8025 SCIP_Real maxeasyactivitydelta,
8045 SCIP_Bool infeasible;
8064 if( consdata->nvars < 2 )
8073 if( !consdata->implsadded )
8085 for(
i = 1;
i < consdata->nvars;
i++ )
8090 nvars = consdata->nvars;
8091 vars = consdata->vars;
8092 vals = consdata->vals;
8095 if( !consdata->validactivities )
8097 assert(consdata->validactivities);
8101 finitenegminact = (consdata->glbminactivityneginf == 0 && consdata->glbminactivityneghuge == 0);
8102 finitenegmaxact = (consdata->glbmaxactivityneginf == 0 && consdata->maxactivityneghuge == 0);
8103 finiteposminact = (consdata->glbminactivityposinf == 0 && consdata->glbminactivityposhuge == 0);
8104 finiteposmaxact = (consdata->glbmaxactivityposinf == 0 && consdata->glbmaxactivityposhuge == 0);
8122 assert(consdata->validglbminact);
8128 assert(consdata->validglbmaxact);
8130 assert(consdata->validglbminact || consdata->validglbmaxact);
8135 for( v =
nvars - 1; v >= 0; --v )
8177 for( v =
nvars - 1; v >= 0; --v )
8189 *nchgbds += nbdchgs;
8196 *nchgbds += nbdchgs;
8218 for( v =
nvars - 1; v >= 0; --v )
8230 *nchgbds += nbdchgs;
8237 *nchgbds += nbdchgs;
8283 consdata->implsadded =
TRUE;
8287 if( consdata->cliquesadded )
8290 consdata->cliquesadded =
TRUE;
8297 nvars = consdata->nvars;
8298 vars = consdata->vars;
8299 vals = consdata->vals;
8304 if( !consdata->validactivities )
8306 assert(consdata->validactivities);
8310 finitenegminact = (consdata->glbminactivityneginf == 0 && consdata->glbminactivityneghuge == 0);
8311 finitenegmaxact = (consdata->glbmaxactivityneginf == 0 && consdata->maxactivityneghuge == 0);
8312 finiteposminact = (consdata->glbminactivityposinf == 0 && consdata->glbminactivityposhuge == 0);
8313 finiteposmaxact = (consdata->glbmaxactivityposinf == 0 && consdata->glbmaxactivityposhuge == 0);
8372 assert(consdata->validglbminact);
8378 assert(consdata->validglbmaxact);
8380 assert(consdata->validglbminact || consdata->validglbmaxact);
8392#ifdef SCIP_DISABLED_CODE
8415 *nchgbds += nbdchgs;
8448 *nchgbds += nbdchgs;
8490 if( !consdata->validactivities )
8492 assert(consdata->validactivities);
8494 nvars = consdata->nvars;
8495 vars = consdata->vars;
8496 vals = consdata->vals;
8565 *nchgbds += nbdchgs;
8601 *nchgbds += nbdchgs;
8643 if( !consdata->validactivities )
8645 assert(consdata->validactivities);
8647 nvars = consdata->nvars;
8648 vars = consdata->vars;
8649 vals = consdata->vals;
8725 *nchgbds += nbdchgs;
8761 *nchgbds += nbdchgs;
8805 if( !consdata->validactivities )
8807 assert(consdata->validactivities);
8809 nvars = consdata->nvars;
8810 vars = consdata->vars;
8811 vals = consdata->vals;
8883 *nchgbds += nbdchgs;
8916 *nchgbds += nbdchgs;
8970 SCIPdebugMsg(
scip,
"linear constraint <%s>: adding clique with %d vars (%d pos, %d neg)\n",
8982 *nchgbds += nbdchgs;
8995 SCIP_Bool* infeasible
9014 *infeasible =
FALSE;
9024 for(
i = 0;
i < consdata->nvars && integral; ++
i )
9045 SCIPdebugMsg(
scip,
"rounding sides=[%.15g,%.15g] of linear constraint <%s> with integral coefficients and variables only "
9046 "is infeasible\n", consdata->lhs, consdata->rhs,
SCIPconsGetName(cons));
9052 SCIPdebugMsg(
scip,
"linear constraint <%s>: make sides integral: sides=[%.15g,%.15g]\n",
9060 if( !consdata->upgraded )
9068 if( !consdata->upgraded )
9071 SCIPdebugMsg(
scip,
"linear constraint <%s>: new integral sides: sides=[%.15g,%.15g]\n",
9122 SCIP_Real minactivity;
9124 SCIP_Real maxactivity;
9154 if( (consdata->validmaxabsval && consdata->maxabsval >
MAXVALRECOMP)
9155 || (consdata->validminabsval && consdata->minabsval <
MINVALRECOMP) )
9172 var = consdata->vars[
i];
9177 val = consdata->vals[
i];
9193 lval = consdata->lhs - minactivity;
9194 rval = maxactivity - consdata->rhs;
9197 if( consdata->nvars == 2 )
9204 lval = consdata->lhs - val*lb;
9210 rval = val*ub - consdata->rhs;
9219 newlhs = consdata->lhs - val * lb;
9221 newrhs = consdata->rhs - val * ub;
9226 SCIPdebugMsg(
scip,
"linear constraint <%s>: change coefficient %+.15g<%s> to %+.15g<%s>, act=[%.15g,%.15g], side=[%.15g,%.15g]\n",
9228 minactivity, maxactivity, consdata->lhs, consdata->rhs);
9300 lval = minactivity - consdata->lhs;
9301 rval = consdata->rhs - maxactivity;
9304 if( consdata->nvars == 2 )
9311 lval = val*ub - consdata->lhs;
9317 rval = consdata->rhs - val*lb;
9326 newlhs = consdata->lhs - val * ub;
9328 newrhs = consdata->rhs - val * lb;
9333 SCIPdebugMsg(
scip,
"linear constraint <%s>: change coefficient %+.15g<%s> to %+.15g<%s>, act=[%.15g,%.15g], side=[%.15g,%.15g]\n",
9335 minactivity, maxactivity, consdata->lhs, consdata->rhs);
9449 var = consdata->vars[
i];
9456 val = consdata->vals[
i];
9466 SCIPdebugMsg(
scip,
"minactivity = %g\tval = %g\tlhs = %g\n", minactivity, val, consdata->lhs);
9467 SCIPdebugMsg(
scip,
"maxactivity = %g\tval = %g\trhs = %g\n", maxactivity, val, consdata->rhs);
9468 SCIPdebugMsg(
scip,
"linear constraint <%s>: remove variable <%s> with coefficient <%g> from constraint since it is redundant\n",
9494 SCIPdebugMsg(
scip,
"linear constraint <%s>: remove variable <%s> with coefficient <%g> from constraint since it is redundant\n",
9559 SCIP_Bool infeasible;
9570 assert(consdata->nvars == 1);
9574 var = consdata->vars[0];
9575 val = consdata->vals[0];
9595 if( !consdata->upgraded )
9612 SCIP_Bool infeasible;
9613 SCIP_Bool redundant;
9624 assert(consdata->nvars == 2);
9627 SCIPdebugMsg(
scip,
"linear constraint <%s>: aggregate %.15g<%s> + %.15g<%s> == %.15g\n",
9629 consdata->vals[1],
SCIPvarGetName(consdata->vars[1]), consdata->rhs);
9633 consdata->rhs, &infeasible, &redundant, &
aggregated) );
9652 if( !consdata->upgraded )
9732 SCIP_Real minabsval;
9733 SCIP_Real maxabsval;
9738 SCIP_Bool infeasible;
9764 assert(consdata->nvars > 2);
9774 lhs = consdata->lhs;
9775 rhs = consdata->rhs;
9777 if( consdata->nvars == 3 )
9784 else if( consdata->nvars == 4 )
9813 vars = consdata->vars;
9814 vals = consdata->vals;
9830 for( v = 0; v < consdata->nvars; ++v )
9860 if( maxabsval / minabsval > conshdlrdata->maxmultaggrquot )
9964 if( conshdlrdata->multaggrremove && !
removescons )
10004 for( v = 0; v < consdata->nvars; ++v )
10044 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: infimum and supremum are both infinite\n");
10093 for( v = 0; v < consdata->nvars; ++v )
10098 SCIPdebugMsgPrint(
scip,
" %+.15g, bounds of <%s>: [%.15g,%.15g], nlocks=%d, maxnlocks=%d, removescons=%u\n",
10126 if( !consdata->upgraded )
10130 else if( ncontvars == 1 )
10144 SCIPdebugMsg(
scip,
"linear constraint <%s>: converting continuous variable <%s> to implicit integer variable\n",
10162 SCIP_Bool redundant;
10176#ifdef WITH_DEBUG_SOLUTION
10186 SCIPdebugMsg(
scip,
"linear constraint <%s>: aggregating continuous variable <%s> to newly created implicit integer variable <%s>, aggregation factor = %g\n",
10194 SCIPdebugMsg(
scip,
"infeasible aggregation of variable <%s> to implicit variable <%s>, domain is empty\n",
10216 consdata->boundstightened = 0;
10217 consdata->rangedrowpropagated = 0;
10218 consdata->presolved =
FALSE;
10238 SCIPdebugMsg(
scip,
"linear constraint <%s>: converting integer variable <%s> to implicit integer variable\n",
10272 vars = consdata->vars;
10273 nvars = consdata->nvars;
10277 for( v = 0; v <
nvars; ++v )
10301 val = consdata->vals[v];
10308 (*scale) = val / -
objval;
10320 (*scale) = val /
objval;
10343 SCIP_Bool applicable;
10356 nvars = consdata->nvars;
10365 (
nvars == nobjvars && (!conshdlrdata->detectcutoffbound || !conshdlrdata->detectlowerbound)) )
10378 vars = consdata->vars;
10383 SCIPdebugMsg(
scip,
"linear equality constraint <%s> == %g (offset %g) is a subset of the objective function\n",
10391 for( v = 0; v <
nvars; ++v )
10411 SCIP_Real cutoffbound;
10460 SCIP_Bool applicable;
10475 nvars = consdata->nvars;
10490 if( nobjvars == 0 )
10505 if( conshdlrdata->detectcutoffbound &&
rhsfinite )
10511 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a cutoff bound <%g>\n",
10517 if( conshdlrdata->detectlowerbound &&
lhsfinite )
10519 SCIP_Real lowerbound;
10521 lowerbound = (consdata->lhs -
offset) / scale;
10523 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a lower bound <%g>\n",
10529 if( (conshdlrdata->detectcutoffbound && (conshdlrdata->detectlowerbound || !
lhsfinite)) ||
10530 (conshdlrdata->detectlowerbound && !
rhsfinite) )
10539 if( conshdlrdata->detectlowerbound &&
rhsfinite )
10541 SCIP_Real lowerbound;
10543 lowerbound = (consdata->rhs -
offset) / scale;
10545 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a lower bound <%g>\n",
10551 if( conshdlrdata->detectcutoffbound &&
lhsfinite )
10557 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a cutoff bound <%g>\n",
10563 if( (conshdlrdata->detectcutoffbound && (conshdlrdata->detectlowerbound || !
rhsfinite)) ||
10564 (conshdlrdata->detectlowerbound && !
lhsfinite) )
10600 assert(consdata->removedfixings);
10607 if( consdata->nvars == 1 )
10612 else if( consdata->nvars == 2 )
10646 for( v = 0; v < consdata->nvars; ++v )
10719 SCIP_Real minabsval;
10720 SCIP_Real maxabsval;
10763 if( consdata->nvars <= 2 )
10765 else if( consdata->nvars == 3 )
10767 else if( consdata->nvars == 4 )
10790 val = consdata->vals[
i];
10794 if(
absval < minabsval )
10796 if(
absval > maxabsval )
10800 if( maxabsval / minabsval > conshdlrdata->maxdualmultaggrquot )
10803 var = consdata->vars[
i];
10819 val = consdata->vals[
i];
11004 SCIP_Bool infeasible;
11035 for(
j = 0;
j < consdata->nvars; ++
j )
11050 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: too large aggregation coefficients\n");
11113 infeasible =
FALSE;
11147 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: infimum and supremum are both infinite\n");
11166 if( !consdata->upgraded )
11181#define CONTWEIGHT 8
11249 SCIP_Bool infeasible;
11252 SCIP_Bool redundant;
11260 lhs = consdata->lhs;
11261 vars = consdata->vars;
11262 vals = consdata->vals;
11263 nvars = consdata->nvars;
11303 SCIPdebugMsg(
scip,
"linear constraint <%s>: try fixing variable <%s> to <%g>\n",
11332 SCIPdebugMsg(
scip,
"linear constraint <%s>: try aggregation of variables <%s> and <%s>\n",
11420 return (value > 0 ? +1 : (value < 0 ? -1 : 0));
11457 nvars = consdata->nvars;
11463 lhs = consdata->lhs;
11464 rhs = consdata->rhs;
11473 vals = consdata->vals;
11474 vars = consdata->vars;
11482 for( v =
nvars - 1; v >= 0; --v )
11506 for( v =
nvars - 1; v >= 0; --v )
11510 (*nchgcoefs) +=
nvars;
11546 SCIP_Bool* infeasible
11593 *infeasible =
FALSE;
11605 nvars = consdata->nvars;
11629 consdata->normalized =
FALSE;
11638 if( !consdata->normalized )
11641 lhs = consdata->lhs;
11642 rhs = consdata->rhs;
11660 if( haslhs && hasrhs )
11666 assert(haslhs != hasrhs);
11682 consdata->indexsorted =
FALSE;
11683 consdata->coefsorted =
FALSE;
11685 vars = consdata->vars;
11686 vals = consdata->vals;
11723 side = haslhs ? lhs : rhs;
11794 for(
w = 0;
w < v; ++
w )
11819 SCIP_Bool redundant =
FALSE;
11851 for( ; v <
nvars - 1; ++v )
11930 SCIPdebugMsg(
scip,
"stopped at pos %d (of %d), subactivities [%g, %g], redundant = %u, hasrhs = %u, siderest = %g, gcd = %" SCIP_LONGINT_FORMAT ", offset position for 'side' coefficients = %d\n",
11994 SCIPdebugMsg(
scip,
"removing %d last variables from constraint <%s>, because they never change anything on the feasibility of this constraint\n",
12002 (*nchgcoefs) += (
nvars - v);
12011 assert(vals == consdata->vals);
12026 rhs = consdata->rhs;
12033 lhs = consdata->lhs;
12044 nvars = consdata->nvars;
12234 (*nchgcoefs) += (
offsetv + 1);
12242 assert(vals == consdata->vals);
12248 nvars = consdata->nvars;
12253 lhs = consdata->lhs;
12254 rhs = consdata->rhs;
12270 for( v =
nvars - 1; v >= 0; --v )
12287 SCIP_Real
frac = 0.0;
12288 SCIP_Bool found =
FALSE;
12303 for( v =
nvars - 1; v >= 0; --v )
12339 SCIPdebugMsg(
scip,
"rounding all non-integral coefficients and the right hand side down\n");
12344 for( v =
nvars - 1; v >= 0; --v )
12396 for( v =
nvars - 1; v >= 0; --v )
12444 SCIPdebugMsg(
scip,
"rounding all non-integral coefficients and the left hand side down\n");
12449 for( v =
nvars - 1; v >= 0; --v )
12488 assert(vals == consdata->vals);
12493 rhs = consdata->rhs;
12494 lhs = consdata->lhs;
12501 nvars = consdata->nvars;
12508 for( v =
nvars - 1; v >= 0; --v )
12551 for( v =
nvars - 1; v >= 0; --v )
12734 SCIPdebugMsg(
scip,
"gcd = %" SCIP_LONGINT_FORMAT ", rest = %" SCIP_LONGINT_FORMAT ", restcoef = %" SCIP_LONGINT_FORMAT "; changing coef of variable <%s> to %g and %s by %" SCIP_LONGINT_FORMAT "\n",
gcd,
rest,
restcoef,
SCIPvarGetName(
vars[
candpos]),
newcoef, hasrhs ?
"reduced rhs" :
"increased lhs", hasrhs ?
rest : (
rest > 0 ?
gcd -
rest : 0));
12751 assert(vals == consdata->vals);
12758 rhs = consdata->rhs;
12759 lhs = consdata->lhs;
12763 nvars = consdata->nvars;
12767 while(
nvars >= 2 );
12793 SCIP_Real maxaggrnormscale,
12796 SCIP_Bool* infeasible
12831 *infeasible =
FALSE;
12967 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> := %.15g*<%s> + %.15g*<%s> -> nvars: %d -> %d, weight: %d -> %d\n",
13189 assert(consdata->nvars > 0);
13191 assert(consdata->indexsorted);
13196 scale =
COPYSIGN(1.0/consdata->maxabsval, consdata->vals[0]);
13219 return (((
unsigned int)consdata->upgraded)<<31) + (
unsigned int)
SCIPconsGetPos(cons);
13314 hashtablesize = nconss;
13321 for(
c = 0;
c < nconss; ++
c )
13412 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with equal coefficients into single ranged row\n",
13426 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with negated coefficients into single ranged row\n",
13458 rhs = (lhs + rhs)/2;
13473#ifdef SCIP_MORE_DEBUG
13495 SCIP_Real maxaggrnormscale,
13803 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with %s coefficients into single ranged row\n",
13881 SCIPdebugMsg(
scip,
"left hand side of linear constraint <%s> is dominated by <%s>:\n",
13912 SCIPdebugMsg(
scip,
"left hand side of linear constraint <%s> is dominated by <%s>:\n",
13942 SCIPdebugMsg(
scip,
"right hand side of linear constraint <%s> is dominated by <%s>:\n",
13973 SCIPdebugMsg(
scip,
"right hand side of linear constraint <%s> is dominated by <%s>:\n",
14097 SCIP_Bool singletonstuffing,
14098 SCIP_Bool singlevarstuffing,
14114 SCIP_Real minactivity;
14115 SCIP_Real maxactivity;
14142 if( singlevarstuffing )
14160 rhs = -consdata->lhs;
14162 maxactivity = -minactivity;
14168 rhs = consdata->rhs;
14172 nvars = consdata->nvars;
14173 vars = consdata->vars;
14174 vals = consdata->vals;
14177 if( singletonstuffing )
14179 for( v = 0; v <
nvars; ++v )
14195 assert(singletonstuffing);
14206 for( v = 0; v <
nvars; ++v )
14317 SCIP_Bool tightened;
14330 val =
factor * vals[idx];
14350 delta = -(lb - ub) * val;
14352 delta = (ub - lb) * val;
14462 for( v = 0; v <
nvars; ++v )
14545 SCIP_Bool tightened =
FALSE;
14640 for( v = 0; v <
nvars; ++v )
14650 for( v = 0; v <
nvars; ++v )
14655 if(
factor * vals[v] < 0 )
14758 for( v = 0; v <
nvars; ++v )
14770 for( v = 0; v < ncontvars; v++ )
14797 for(
c = 0;
c < nconss; ++
c )
14824 for(
i = 0;
i < consdata->nvars; ++
i )
14828 var = consdata->vars[
i];
14850 for(
i = 0;
i < consdata->nvars; ++
i )
14864 var = consdata->vars[
i];
14865 val = consdata->vals[
i];
15029 for( v = 0; v <
nvars; ++v )
15033 SCIP_Bool infeasible;
15034 SCIP_Bool tightened;
15059 SCIPdebugMsg(
scip,
"variable <%s> only locked down in linear constraints: dual presolve <%s>[%.15g,%.15g] <= %.15g\n",
15088 SCIPdebugMsg(
scip,
"variable <%s> only locked up in linear constraints: dual presolve <%s>[%.15g,%.15g] >= %.15g\n",
15106 SCIP_Bool infeasible;
15132 SCIPdebugMsg(
scip,
"dual presolve: converting continuous variable <%s>[%g,%g] to implicit integer\n",
15163 SCIP_Bool checkrelmaxabs;
15164 SCIP_Bool violated;
15176 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
15178 SCIPdebugMsg(
scip,
"Enforcement method of linear constraints for %s solution\n",
sol ==
NULL ?
"LP" :
"relaxation");
15279 conshdlrdata->naddconss = 0;
15282 for(
c = 0;
c < nconss; ++
c )
15307 for(
c = nconss - 1;
c >= 0; --
c )
15314 if( consdata->eventdata !=
NULL )
15388 for(
c = 0;
c < nconss;
c++ )
15407 rhs = consdata->rhs;
15408 lhs = consdata->lhs;
15412 for(
i = 0;
i < consdata->nvars;
i++ )
15418 if( consdata->nvars == 0 )
15438 if( consdata->nvars == 1 )
15448 if( consdata->nvars == 2 &&
SCIPisEQ(
scip, lhs, rhs) )
15458 if( consdata->nvars == 2 )
15463 if(
SCIPisEQ(
scip, consdata->vals[0], -consdata->vals[1])
15491 scale =
REALABS(consdata->vals[0]);
15501 if( consdata->vals[
i] < 0.0 )
15593 b -= consdata->vals[
i];
15613 for(
i = 0;
i < consdata->nvars && !
matched;
i++ )
15701#ifdef SCIP_STATISTIC
15712#ifdef SCIP_STATISTIC
15720 for(
c = 0;
c < nconss; ++
c )
15730 if( consdata->upgraded )
15737 if(
SCIPisLT(
scip, consdata->maxactdelta, conshdlrdata->maxeasyactivitydelta) )
15746 for(
c = 0;
c < nconss; ++
c )
15756 if( consdata->upgraded )
15781 for(
c = 0;
c < nconss; ++
c )
15799 for(
c = 0;
c < nconss; ++
c )
15806 if( consdata->row !=
NULL )
15811 if( consdata->nlrow !=
NULL )
15827 if( ncutsadded > 0 )
15830 "(restart) converted %d cuts from the global cut pool into linear constraints\n", ncutsadded);
15881 if( consdata->eventdata !=
NULL )
15909 if( (*consdata)->eventdata !=
NULL )
15956 for(n =
targetdata->nvars - 1; n >= 0; --n )
15981 *infeasible =
FALSE;
15983 for(
c = 0;
c < nconss && !(*infeasible); ++
c )
16000 SCIP_Real cutoffbound;
16025 if( (
depth == 0 && conshdlrdata->maxroundsroot >= 0 &&
nrounds >= conshdlrdata->maxroundsroot)
16026 || (
depth > 0 && conshdlrdata->maxrounds >= 0 &&
nrounds >= conshdlrdata->maxrounds) )
16030 maxsepacuts = (
depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);
16054 else if( ncuts > 0 )
16091 if( (
depth == 0 && conshdlrdata->maxroundsroot >= 0 &&
nrounds >= conshdlrdata->maxroundsroot)
16092 || (
depth > 0 && conshdlrdata->maxrounds >= 0 &&
nrounds >= conshdlrdata->maxrounds) )
16096 maxsepacuts = (
depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);
16112 else if( ncuts > 0 )
16145 SCIP_Bool checkrelmaxabs;
16146 SCIP_Bool violated;
16157 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
16164 SCIPdebugMsg(
scip,
"-> pseudo solution is objective infeasible, return.\n");
16172 for(
c = 0;
c < nconss && !violated; ++
c )
16193 SCIP_Bool checkrelmaxabs;
16206 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
16213 SCIP_Bool violated =
FALSE;
16223 SCIP_Real activity;
16252 SCIP_Bool rangedrowpropagation =
FALSE;
16253 SCIP_Bool tightenbounds;
16271 tightenbounds =
TRUE;
16276 int tightenboundsfreq;
16281 tightenboundsfreq = propfreq * conshdlrdata->tightenboundsfreq;
16282 tightenbounds = (conshdlrdata->tightenboundsfreq >= 0)
16283 && ((tightenboundsfreq == 0 &&
depth == 0) || (tightenboundsfreq >= 1 && (
depth % tightenboundsfreq == 0)));
16286 rangedrowpropagation = conshdlrdata->rangedrowpropagation;
16288 rangedrowpropagation = rangedrowpropagation && (
depth <= conshdlrdata->rangedrowmaxdepth);
16289 rangedrowfreq = propfreq * conshdlrdata->rangedrowfreq;
16290 rangedrowpropagation = rangedrowpropagation && (conshdlrdata->rangedrowfreq >= 0)
16291 && ((rangedrowfreq == 0 &&
depth == 0) || (rangedrowfreq >= 1 && (
depth % rangedrowfreq == 0)));
16302 conshdlrdata->maxeasyactivitydelta, conshdlrdata->sortvars, &
cutoff, &nchgbds) );
16308 else if( nchgbds > 0 )
16317#define MAXCONSPRESOLROUNDS 10
16325 SCIP_Real minactivity;
16326 SCIP_Real maxactivity;
16370 SCIP_Bool infeasible;
16372 infeasible =
FALSE;
16382 consdata->lhs = consdata->rhs;
16386 if( consdata->eventdata ==
NULL )
16409 assert(consdata->removedfixings);
16424 if( consdata->presolved )
16442 consdata->presolved =
TRUE;
16460 SCIPdebugMsg(
scip,
" -> infeasibility detected during tightening sides\n");
16468 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16489 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16490 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16496 SCIPdebugMsg(
scip,
"linear constraint <%s> is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16497 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16501 if( !consdata->upgraded )
16507 SCIPdebugMsg(
scip,
"linear constraint <%s> left hand side is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16508 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16510 if( !consdata->upgraded )
16515 SCIPdebugMsg(
scip,
"linear constraint <%s> right hand side is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16516 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16518 if( !consdata->upgraded )
16523 if( consdata->nvars == 0 )
16527 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16533 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16538 if( !consdata->upgraded )
16548 if( conshdlrdata->simplifyinequalities )
16557 if( conshdlrdata->aggregatevariables )
16568 if( conshdlrdata->rangedrowpropagation )
16570 int lastnfixedvars;
16572 lastnfixedvars = *nfixedvars;
16577 if( lastnfixedvars < *nfixedvars )
16588 nfixedvars, nchgbds, &
cutoff) );
16595 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16601 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16606 if( !consdata->upgraded )
16644 conshdlrdata->singlevarstuffing, &
cutoff, nfixedvars, nchgbds) );
16647 if( consdata->nvars == 0 )
16651 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16657 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16662 if( !consdata->upgraded )
16681 ndelconss, nchgsides) );
16701 for(
c = 0;
c < nconss; ++
c )
16727 &
cutoff, ndelconss, nchgsides, nchgcoefs) );
16777 if( consdata->upgradetried )
16780 if( !consdata->presolved )
16783 consdata->upgradetried =
TRUE;
16799 assert(!consdata->upgraded);
16800 consdata->upgraded =
TRUE;
16806 || !conshdlrdata->presolpairwise
16807 || (conshdlrdata->maxaggrnormscale == 0.0) )
16861 for(
i = 0;
i < consdata->nvars; ++
i )
16926 const char* consname;
16945 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
valid) );
16980 SCIP_Bool found =
FALSE;
16991 if( curr[1] ==
'=' )
17000 if(
strncmp(curr,
"[free]", 6) == 0 )
17031 else if(
strncmp(curr,
"<=", 2) != 0 )
17084 (*success) =
FALSE;
17203 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
17223 (*success) =
FALSE;
17245 (*nvars) = consdata->nvars;
17271 cons = eventdata->cons;
17285 SCIP_Real oldbound;
17286 SCIP_Real newbound;
17290 varpos = eventdata->varpos;
17296 val = consdata->vals[varpos];
17315 consdata->presolved =
FALSE;
17316 consdata->rangedrowpropagated = 0;
17324 if( consdata->maxactdeltavar ==
var )
17327 consdata->maxactdeltavar =
NULL;
17331 if( consdata->boundstightened > 0)
17333 switch( eventtype )
17337 consdata->boundstightened = 0;
17341 consdata->boundstightened = 0;
17363 delta =
REALABS(val) * domain;
17365 if( delta > consdata->maxactdelta )
17367 consdata->maxactdelta = delta;
17368 consdata->maxactdeltavar =
var;
17375 consdata->presolved =
FALSE;
17376 consdata->removedfixings =
FALSE;
17377 consdata->rangedrowpropagated = 0;
17380 if( consdata->maxactdeltavar ==
var )
17383 consdata->maxactdeltavar =
NULL;
17391 consdata->presolved =
FALSE;
17395 SCIP_Real oldbound;
17396 SCIP_Real newbound;
17400 varpos = eventdata->varpos;
17406 val = consdata->vals[varpos];
17408 consdata->rangedrowpropagated = 0;
17423 consdata->indexsorted =
FALSE;
17425 consdata->coefsorted =
FALSE;
17441 consdata->varsdeleted =
TRUE;
17464 assert(bdchginfos !=
NULL || nbdchginfos == 0);
17480 for(
i = 0;
i < nbdchginfos; ++
i )
17501 if(
i == nbdchginfos )
17588 consdata->checkabsolute =
TRUE;
17668 "multiplier on propagation frequency, how often the bounds are tightened (-1: never, 0: only at root)",
17672 "maximal number of separation rounds per node (-1: unlimited)",
17676 "maximal number of separation rounds per node in the root node (-1: unlimited)",
17680 "maximal number of cuts separated per separation round",
17684 "maximal number of cuts separated per separation round in the root node",
17688 "should pairwise constraint comparison be performed in presolving?",
17692 "should hash table be used for detecting redundant constraints in advance",
17696 "number for minimal pairwise presolve comparisons",
17700 "minimal gain per minimal pairwise presolve comparisons to repeat pairwise comparison round",
17704 "maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint aggregation)",
17708 "maximum activity delta to run easy propagation on linear constraint (faster, but numerically less stable)",
17712 "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts",
17716 "should all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value?",
17720 "should presolving search for aggregations in equations",
17724 "should presolving try to simplify inequalities",
17728 "should dual presolving steps be performed?",
17732 "should stuffing of singleton continuous variables be performed?",
17736 "should single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable?",
17739 "constraints/" CONSHDLR_NAME "/sortvars",
"apply binaries sorting in decr. order of coeff abs value?",
17743 "should the violation for a constraint with side 0.0 be checked relative to 1.0 (FALSE) or to the maximum absolute value in the activity (TRUE)?",
17747 "should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP?",
17751 "should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP?",
17755 "should presolving try to detect subsets of constraints parallel to the objective function?",
17759 "should presolving and propagation try to improve bounds, detect infeasibility, and extract sub-constraints from ranged rows and equations?",
17763 "should presolving and propagation extract sub-constraints from ranged rows and equations?",
17767 "maximum depth to apply ranged row propagation",
17771 "frequency for applying ranged row propagation",
17775 "should multi-aggregations only be performed if the constraint can be removed afterwards?",
17779 "maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation",
17783 "maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation",
17787 "should Cliques be extracted?",
17813 if( conshdlr ==
NULL )
17857 SCIP_Bool separate,
17867 SCIP_Bool modifiable,
17873 SCIP_Bool removable,
17875 SCIP_Bool stickingatnode
17888 if( conshdlr ==
NULL )
17901 SCIP_Real constant = 0.0;
17925 if( constant < 0.0 )
17932 SCIPerrorMessage(
"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite left hand side of the constraint\n", name);
17942 SCIPerrorMessage(
"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite right hand side of the constraint\n", name);
17958 SCIPerrorMessage(
"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite left hand side of the constraint\n", name);
17968 SCIPerrorMessage(
"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite right hand side of the constraint\n", name);
18012 if( check || enforce )
18015 for(n = consdata->nvars - 1; n >= 0; --n )
18021 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
18022 local, modifiable, dynamic, removable, stickingatnode) );
18070 SCIP_Bool separate,
18075 SCIP_Bool modifiable,
18077 SCIP_Bool removable,
18078 SCIP_Bool stickingatnode,
18087 SCIP_Real constant;
18103 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
18118 for( v = 0; v <
nvars; ++v )
18142 for( v = 0; v <
nvars; ++v )
18174 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
18212 SCIP_Real constant = 0.0;
18241 lhs = consdata->lhs;
18242 rhs = consdata->rhs;
18248 if( constant < 0.0 )
18321 for( v = nconsvars - 1; v >= 0; --v )
18372 SCIPerrorMessage(
"method may only be called during problem creation stage for original constraints and variables\n");
18379 vars = consdata->vars;
18452 return consdata->lhs;
18476 return consdata->rhs;
18539 return consdata->nvars;
18563 return consdata->vars;
18587 return consdata->vals;
18616 if( consdata->row !=
NULL )
18644 if( consdata->row !=
NULL )
18672 if( consdata->row !=
NULL )
18700 if( consdata->row !=
NULL )
18729 return consdata->row;
18748 SCIP_Bool infeasible;
18749 SCIP_Bool integral;
18798 if( consdata->upgraded )
18802 if( consdata->row !=
NULL )
18806 SCIPerrorMessage(
"cannot upgrade linear constraint that is already stored as row in the LP\n");
18859 for(
i = 0;
i < consdata->nvars; ++
i )
18861 var = consdata->vars[
i];
18862 val = consdata->vals[
i];
18939 SCIPdebugMsg(
scip,
"upgrading linear constraint <%s> (%d upgrade methods):\n",
18941 SCIPdebugMsg(
scip,
" +bin=%d -bin=%d +int=%d -int=%d +impl=%d -impl=%d +cont=%d -cont=%d +1=%d -1=%d +I=%d -I=%d +F=%d -F=%d possum=%.15g negsum=%.15g integral=%u\n",
18947 for(
i = 0;
i < conshdlrdata->nlinconsupgrades && *
upgdcons ==
NULL; ++
i )
18949 if( conshdlrdata->linconsupgrades[
i]->active )
18951 SCIP_CALL( conshdlrdata->linconsupgrades[
i]->linconsupgd(
scip, cons, consdata->nvars,
18952 consdata->vars, consdata->vals, consdata->lhs, consdata->rhs,
18953 nposbin,
nnegbin,
nposint,
nnegint,
nposimpl,
nnegimpl,
nposimplbin,
nnegimplbin,
nposcont,
nnegcont,
18976 SCIP_Bool* infeasible
18985 if( conshdlr ==
NULL )
18989 *infeasible =
FALSE;
18994 for(
i = 0;
i < nconss; ++
i )
struct InferInfo INFERINFO
Constraint handler for knapsack constraints of the form , x binary and .
#define MAX_CLIQUE_NONZEROS_PER_CONS
static SCIP_RETCODE addCoef(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
#define DEFAULT_AGGREGATEVARIABLES
static SCIP_RETCODE consdataPrint(SCIP *scip, SCIP_CONSDATA *consdata, FILE *file)
#define DEFAULT_NMINCOMPARISONS
#define DEFAULT_MULTAGGRREMOVE
#define DEFAULT_DUALPRESOLVING
#define DEFAULT_EXTRACTCLIQUES
static void permSortConsdata(SCIP_CONSDATA *consdata, int *perm, int nvars)
#define CONSHDLR_NEEDSCONS
static void consdataRecomputeMaxActivityDelta(SCIP *scip, SCIP_CONSDATA *consdata)
#define CONSHDLR_SEPAFREQ
static SCIP_RETCODE checkCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checklprows, SCIP_Bool checkrelmaxabs, SCIP_Bool *violated)
static SCIP_RETCODE addRelaxation(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff)
#define CONFLICTHDLR_PRIORITY
static void consdataGetReliableResidualActivity(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *cancelvar, SCIP_Real *resactivity, SCIP_Bool isminresact, SCIP_Bool useglobalbounds)
static SCIP_Bool checkEqualObjective(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Real *scale, SCIP_Real *offset)
#define CONFLICTHDLR_NAME
static SCIP_RETCODE conshdlrdataIncludeUpgrade(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_LINCONSUPGRADE *linconsupgrade)
static SCIP_RETCODE extractCliques(SCIP *scip, SCIP_CONS *cons, SCIP_Real maxeasyactivitydelta, SCIP_Bool sortvars, int *nfixedvars, int *nchgbds, SCIP_Bool *cutoff)
static void getMaxActivity(SCIP *scip, SCIP_CONSDATA *consdata, int posinf, int neginf, int poshuge, int neghuge, SCIP_Real delta, SCIP_Bool global, SCIP_Bool goodrelax, SCIP_Real *maxactivity, SCIP_Bool *isrelax, SCIP_Bool *issettoinfinity)
#define CONSHDLR_CHECKPRIORITY
static SCIP_RETCODE createRow(SCIP *scip, SCIP_CONS *cons)
static int getVarWeight(SCIP_VAR *var)
static SCIP_RETCODE convertBinaryEquality(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *naggrvars, int *ndelconss)
static void consdataRecomputeMinactivity(SCIP *scip, SCIP_CONSDATA *consdata)
static SCIP_RETCODE addConflictFixedVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, SCIP_BDCHGIDX *bdchgidx, int inferpos)
#define DEFAULT_DETECTCUTOFFBOUND
static SCIP_RETCODE tightenVarLb(SCIP *scip, SCIP_CONS *cons, int pos, PROPRULE proprule, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool force)
#define CONSHDLR_PROP_TIMING
static SCIP_Real consdataComputePseudoActivity(SCIP *scip, SCIP_CONSDATA *consdata)
static SCIP_RETCODE conshdlrdataEnsureLinconsupgradesSize(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, int num)
static SCIP_RETCODE retrieveParallelConstraints(SCIP_HASHTABLE *hashtable, SCIP_CONS **querycons, SCIP_CONS **parallelconss, int *nparallelconss)
#define CONFLICTHDLR_DESC
static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)
static void calculateMinvalAndMaxval(SCIP *scip, SCIP_Real side, SCIP_Real val, SCIP_Real minresactivity, SCIP_Real maxresactivity, SCIP_Real *minval, SCIP_Real *maxval)
static SCIP_RETCODE lockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
static void consdataRecomputeGlbMinactivity(SCIP *scip, SCIP_CONSDATA *consdata)
static void consdataGetActivityResiduals(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real val, SCIP_Bool goodrelax, SCIP_Real *minresactivity, SCIP_Real *maxresactivity, SCIP_Bool *minisrelax, SCIP_Bool *maxisrelax, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
static void consdataUpdateActivitiesUb(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub, SCIP_Real val, SCIP_Bool checkreliability)
static SCIP_RETCODE tightenSides(SCIP *scip, SCIP_CONS *cons, int *nchgsides, SCIP_Bool *infeasible)
static void consdataUpdateActivitiesGlbLb(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Real oldlb, SCIP_Real newlb, SCIP_Real val, SCIP_Bool checkreliability)
static void consdataUpdateActivitiesLb(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb, SCIP_Real val, SCIP_Bool checkreliability)
#define CONSHDLR_MAXPREROUNDS
static SCIP_Bool conshdlrdataHasUpgrade(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DECL_LINCONSUPGD((*linconsupgd)), const char *conshdlrname)
static SCIP_RETCODE chgCoefPos(SCIP *scip, SCIP_CONS *cons, int pos, SCIP_Real newval)
static void consdataRecomputeMaxactivity(SCIP *scip, SCIP_CONSDATA *consdata)
static SCIP_RETCODE linconsupgradeCreate(SCIP *scip, SCIP_LINCONSUPGRADE **linconsupgrade, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority)
#define DEFAULT_PRESOLPAIRWISE
#define DEFAULT_MAXAGGRNORMSCALE
static SCIP_RETCODE performVarDeletions(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
#define checkMaxActivityDelta(scip, consdata)
#define CONSHDLR_SEPAPRIORITY
static SCIP_Bool isFiniteNonnegativeIntegral(SCIP *scip, SCIP_Real x)
#define DEFAULT_SINGLETONSTUFFING
#define DEFAULT_MAXROUNDSROOT
static void consdataUpdateSignatures(SCIP_CONSDATA *consdata, int pos)
#define DEFAULT_MAXCARDBOUNDDIST
#define DEFAULT_MAXEASYACTIVITYDELTA
static SCIP_RETCODE scaleCons(SCIP *scip, SCIP_CONS *cons, SCIP_Real scalar)
static int inferInfoGetPos(INFERINFO inferinfo)
static SCIP_RETCODE detectRedundantConstraints(SCIP *scip, BMS_BLKMEM *blkmem, SCIP_CONS **conss, int nconss, int *firstchange, SCIP_Bool *cutoff, int *ndelconss, int *nchgsides)
static void consdataGetActivityBounds(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Bool goodrelax, SCIP_Real *minactivity, SCIP_Real *maxactivity, SCIP_Bool *minisrelax, SCIP_Bool *maxisrelax, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
#define DEFAULT_CHECKRELMAXABS
#define DEFAULT_MAXDUALMULTAGGRQUOT
static void linconsupgradeFree(SCIP *scip, SCIP_LINCONSUPGRADE **linconsupgrade)
static SCIP_RETCODE aggregateConstraints(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1, int *commonidx0, int *commonidx1, int *diffidx0minus1, int *diffidx1minus0, int nvarscommon, int commonidxweight, int diffidx0minus1weight, int diffidx1minus0weight, SCIP_Real maxaggrnormscale, int *nchgcoefs, SCIP_Bool *aggregated, SCIP_Bool *infeasible)
static SCIP_RETCODE analyzeConflict(SCIP *scip, SCIP_CONS *cons, SCIP_Bool reasonisrhs)
static SCIP_RETCODE rangedRowPropagation(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *nchgbds, int *naddconss)
static INFERINFO intToInferInfo(int i)
static SCIP_RETCODE mergeMultiples(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_SOL *sol, SCIP_Bool separatecards, SCIP_Bool separateall, int *ncuts, SCIP_Bool *cutoff)
static SCIP_RETCODE convertLongEquality(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS *cons, SCIP_Bool *cutoff, int *naggrvars, int *ndelconss)
static void consdataCheckNonbinvar(SCIP_CONSDATA *consdata)
static SCIP_RETCODE chgLhs(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
#define DEFAULT_MAXMULTAGGRQUOT
static void consdataUpdateActivitiesGlbUb(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Real oldub, SCIP_Real newub, SCIP_Real val, SCIP_Bool checkreliability)
static void consdataGetGlbActivityBounds(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Bool goodrelax, SCIP_Real *glbminactivity, SCIP_Real *glbmaxactivity, SCIP_Bool *minisrelax, SCIP_Bool *maxisrelax, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
static SCIP_RETCODE consCatchEvent(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)
static void consdataCalcMinAbsval(SCIP_CONSDATA *consdata)
static SCIP_RETCODE addConflictBounds(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, SCIP_BDCHGIDX *bdchgidx, int inferpos, SCIP_Bool reasonisrhs)
#define MAXCONSPRESOLROUNDS
static SCIP_RETCODE consdataEnsureVarsSize(SCIP *scip, SCIP_CONSDATA *consdata, int num)
#define NONLINCONSUPGD_PRIORITY
#define DEFAULT_MAXSEPACUTSROOT
static SCIP_RETCODE tightenBounds(SCIP *scip, SCIP_CONS *cons, SCIP_Real maxeasyactivitydelta, SCIP_Bool sortvars, SCIP_Bool *cutoff, int *nchgbds)
static void consdataCalcMaxAbsval(SCIP_CONSDATA *consdata)
#define DEFAULT_RANGEDROWPROPAGATION
static SCIP_RETCODE consDropAllEvents(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)
#define DEFAULT_PRESOLUSEHASHING
static SCIP_Real consdataGetActivity(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol)
static SCIP_RETCODE consdataTightenCoefs(SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgsides)
static SCIP_RETCODE normalizeCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
static SCIP_RETCODE presolStuffing(SCIP *scip, SCIP_CONS *cons, SCIP_Bool singletonstuffing, SCIP_Bool singlevarstuffing, SCIP_Bool *cutoff, int *nfixedvars, int *nchgbds)
static SCIP_RETCODE unlockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
static void consdataCalcSignatures(SCIP_CONSDATA *consdata)
static SCIP_RETCODE addConflictReasonVars(SCIP *scip, SCIP_VAR **vars, int nvars, SCIP_VAR *var, SCIP_Real bound)
#define DEFAULT_RANGEDROWFREQ
static SCIP_RETCODE propagateCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool tightenbounds, SCIP_Bool rangedrowpropagation, SCIP_Real maxeasyactivitydelta, SCIP_Bool sortvars, SCIP_Bool *cutoff, int *nchgbds)
static SCIP_RETCODE updateCutoffbound(SCIP *scip, SCIP_CONS *cons, SCIP_Real primalbound)
static void consdataUpdateDelCoef(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real val, SCIP_Bool checkreliability)
#define DEFAULT_RANGEDROWARTCONS
static SCIP_RETCODE delCoefPos(SCIP *scip, SCIP_CONS *cons, int pos)
#define MAXSCALEDCOEFINTEGER
static void consdataUpdateAddCoef(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real val, SCIP_Bool checkreliability)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs)
static SCIP_RETCODE chgRhs(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
#define DEFAULT_SIMPLIFYINEQUALITIES
#define CONSHDLR_PROPFREQ
static SCIP_RETCODE tightenVarBoundsEasy(SCIP *scip, SCIP_CONS *cons, int pos, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool force)
static void consdataUpdateActivities(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound, SCIP_Real val, SCIP_BOUNDTYPE boundtype, SCIP_Bool global, SCIP_Bool checkreliability)
static SCIP_RETCODE convertEquality(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *ndelconss)
static unsigned int getParallelConsKey(SCIP_CONS *cons)
static SCIP_RETCODE fixVariables(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars)
#define CONSHDLR_PRESOLTIMING
#define DEFAULT_DETECTPARTIALOBJECTIVE
static SCIP_RETCODE enforceConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_RESULT *result)
static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)
static SCIP_RETCODE dualPresolve(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *ndelconss)
#define DEFAULT_MAXSEPACUTS
static SCIP_Real consdataGetMaxAbsval(SCIP_CONSDATA *consdata)
static SCIP_RETCODE addNlrow(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE consPrintConsSol(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, FILE *file)
#define CONSHDLR_EAGERFREQ
#define DEFAULT_TIGHTENBOUNDSFREQ
static void getNewSidesAfterAggregation(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *slackvar, SCIP_Real slackcoef, SCIP_Real *newlhs, SCIP_Real *newrhs)
static SCIP_RETCODE convertUnaryEquality(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *ndelconss)
static void consdataUpdateChgCoef(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real oldval, SCIP_Real newval, SCIP_Bool checkreliability)
static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)
static void consdataRecomputeGlbMaxactivity(SCIP *scip, SCIP_CONSDATA *consdata)
static SCIP_RETCODE applyFixings(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
static void consdataCalcActivities(SCIP *scip, SCIP_CONSDATA *consdata)
#define DEFAULT_MAXROUNDS
#define CONSHDLR_ENFOPRIORITY
static SCIP_RETCODE tightenVarUb(SCIP *scip, SCIP_CONS *cons, int pos, PROPRULE proprule, SCIP_Real newub, SCIP_Real oldub, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool force)
static int getInferInt(PROPRULE proprule, int pos)
static int inferInfoGetProprule(INFERINFO inferinfo)
#define DEFAULT_MINGAINPERNMINCOMP
static SCIP_Real consdataGetFeasibility(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol)
static SCIP_RETCODE rangedRowSimplify(SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgsides)
static SCIP_RETCODE aggregateVariables(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars)
#define CONSHDLR_DELAYSEPA
static void consdataInvalidateActivities(SCIP_CONSDATA *consdata)
#define DEFAULT_RANGEDROWMAXDEPTH
static SCIP_RETCODE analyzeConflictRangedRow(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int nvars, SCIP_VAR *var, SCIP_Real bound)
static SCIP_RETCODE consDropEvent(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)
static SCIP_RETCODE tightenVarBounds(SCIP *scip, SCIP_CONS *cons, int pos, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool force)
static SCIP_Real consdataGetMinAbsval(SCIP_CONSDATA *consdata)
static SCIP_Bool consdataIsResidualIntegral(SCIP *scip, SCIP_CONSDATA *consdata, int pos, SCIP_Real val)
static int inferInfoToInt(INFERINFO inferinfo)
static SCIP_RETCODE preprocessConstraintPairs(SCIP *scip, SCIP_CONS **conss, int firstchange, int chkind, SCIP_Real maxaggrnormscale, SCIP_Bool *cutoff, int *ndelconss, int *nchgsides, int *nchgcoefs)
static SCIP_RETCODE consdataSort(SCIP *scip, SCIP_CONSDATA *consdata)
#define DEFAULT_SINGLEVARSTUFFING
static SCIP_RETCODE checkParallelObjective(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata)
static SCIP_RETCODE simplifyInequalities(SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgsides, SCIP_Bool *infeasible)
static SCIP_RETCODE consCatchAllEvents(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, INFERINFO inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_RESULT *result)
static SCIP_Bool isRangedRow(SCIP *scip, SCIP_Real lhs, SCIP_Real rhs)
#define DEFAULT_DETECTLOWERBOUND
static SCIP_RETCODE checkPartialObjective(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata)
#define CONSHDLR_DELAYPROP
static SCIP_Bool canTightenBounds(SCIP_CONS *cons)
#define DEFAULT_SEPARATEALL
static void findOperators(const char *str, char **firstoperator, char **secondoperator, SCIP_Bool *success)
static void getMinActivity(SCIP *scip, SCIP_CONSDATA *consdata, int posinf, int neginf, int poshuge, int neghuge, SCIP_Real delta, SCIP_Bool global, SCIP_Bool goodrelax, SCIP_Real *minactivity, SCIP_Bool *isrelax, SCIP_Bool *issettoinfinity)
static SCIP_RETCODE fullDualPresolve(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool *cutoff, int *nchgbds)
static INFERINFO getInferInfo(PROPRULE proprule, int pos)
static void consdataGetGlbActivityResiduals(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real val, SCIP_Bool goodrelax, SCIP_Real *minresactivity, SCIP_Real *maxresactivity, SCIP_Bool *minisrelax, SCIP_Bool *maxisrelax, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
Constraint handler for linear constraints in their most general form, .
constraint handler for nonlinear constraints specified by algebraic expressions
defines macros for basic operations in double-double arithmetic giving roughly twice the precision of...
#define SCIPquadprecSumQD(r, a, b)
#define QUAD_ASSIGN(a, constant)
#define QUAD_ASSIGN_Q(a, b)
#define SCIPdebugGetSolVal(scip, var, val)
#define SCIPdebugAddSolVal(scip, var, val)
#define SCIP_MAXTREEDEPTH
#define SCIP_CALL_ABORT(x)
SCIP_Real SCIPgetDualsolLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPincludeLinconsUpgrade(SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)
#define SCIP_DECL_NONLINCONSUPGD(x)
SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPupgradeConsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **upgdcons)
SCIP_VAR ** SCIPgetVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPchgRhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
SCIP_RETCODE SCIPincludeConsUpgradeNonlinear(SCIP *scip, SCIP_DECL_NONLINCONSUPGD((*nlconsupgd)), int priority, SCIP_Bool active, const char *conshdlrname)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_Real * SCIPgetValsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_ROW * SCIPgetRowLinear(SCIP *scip, SCIP_CONS *cons)
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_EXPR * SCIPgetExprNonlinear(SCIP_CONS *cons)
SCIP_RETCODE SCIPseparateRelaxedKnapsack(SCIP *scip, SCIP_CONS *cons, SCIP_SEPA *sepa, int nknapvars, SCIP_VAR **knapvars, SCIP_Real *knapvals, SCIP_Real valscale, SCIP_Real rhs, SCIP_SOL *sol, SCIP_Bool *cutoff, int *ncuts)
SCIP_Real SCIPgetRhsNonlinear(SCIP_CONS *cons)
SCIP_Real SCIPgetDualfarkasLinear(SCIP *scip, SCIP_CONS *cons)
#define SCIP_DECL_LINCONSUPGD(x)
SCIP_RETCODE SCIPcopyConsLinear(SCIP *scip, SCIP_CONS **cons, SCIP *sourcescip, const char *name, int nvars, SCIP_VAR **sourcevars, SCIP_Real *sourcecoefs, SCIP_Real lhs, SCIP_Real rhs, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, 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 global, SCIP_Bool *valid)
SCIP_RETCODE SCIPcleanupConssLinear(SCIP *scip, SCIP_Bool onlychecked, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, 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_Bool stickingatnode)
SCIP_Real SCIPgetActivityLinear(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
SCIP_Real SCIPgetFeasibilityLinear(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
SCIP_RETCODE SCIPclassifyConstraintTypesLinear(SCIP *scip, SCIP_LINCONSSTATS *linconsstats)
SCIP_RETCODE SCIPchgLhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
SCIP_Real SCIPgetLhsNonlinear(SCIP_CONS *cons)
SCIP_RETCODE SCIPchgCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPdelCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
SCIP_RETCODE SCIPincludeConshdlrLinear(SCIP *scip)
SCIP_RETCODE SCIPconvertCutsToConss(SCIP *scip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
SCIP_Bool SCIPisConsCompressionEnabled(SCIP *scip)
SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisPresolveFinished(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNObjVars(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
int SCIPgetNContVars(SCIP *scip)
SCIP_CONS ** SCIPgetConss(SCIP *scip)
SCIP_RETCODE SCIPaddObjoffset(SCIP *scip, SCIP_Real addval)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNConss(SCIP *scip)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
int SCIPgetNBinVars(SCIP *scip)
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
SCIP_RETCODE SCIPhashtableSafeInsert(SCIP_HASHTABLE *hashtable, void *element)
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)
#define SCIPhashSeven(a, b, c, d, e, f, g)
void SCIPhashtablePrintStatistics(SCIP_HASHTABLE *hashtable, SCIP_MESSAGEHDLR *messagehdlr)
static INLINE uint32_t SCIPrealHashCode(double x)
SCIP_RETCODE SCIPhashtableRemove(SCIP_HASHTABLE *hashtable, void *element)
SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)
#define SCIPhashSignature64(a)
SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetLocalLowerbound(SCIP *scip)
SCIP_RETCODE SCIPaddConflict(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
SCIP_RETCODE SCIPaddConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_NODE *validnode)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
#define SCIPdebugMsgPrint
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_Longint SCIPcalcGreComDiv(SCIP_Longint val1, SCIP_Longint val2)
SCIP_Longint SCIPcalcSmaComMul(SCIP_Longint val1, SCIP_Longint val2)
SCIP_Bool SCIPrealToRational(SCIP_Real val, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Longint *nominator, SCIP_Longint *denominator)
SCIP_Real SCIPselectSimpleValue(SCIP_Real lb, SCIP_Real ub, SCIP_Longint maxdnom)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
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 SCIPgetIntParam(SCIP *scip, const char *name, int *value)
int SCIPgetNLPBranchCands(SCIP *scip)
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
SCIP_RETCODE SCIPincludeConflicthdlrBasic(SCIP *scip, SCIP_CONFLICTHDLR **conflicthdlrptr, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONS ** SCIPconshdlrGetCheckConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
int SCIPconshdlrGetPropFreq(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)),)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetConshdlrInit(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrDelvars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrExit(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
int SCIPconsGetPos(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
int SCIPconsGetNUpgradeLocks(SCIP_CONS *cons)
SCIP_RETCODE SCIPsetConsSeparated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool separate)
SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsOriginal(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
int SCIPconsGetNLocksPos(SCIP_CONS *cons)
SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
SCIP_RETCODE SCIPsetConsEnforced(SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)
SCIP_Bool SCIPconsIsLockedType(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_RETCODE SCIPunmarkConsPropagate(SCIP *scip, 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)
int SCIPconsGetNLocksNeg(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocked(SCIP_CONS *cons)
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_RETCODE SCIPsetConsPropagated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool propagate)
SCIP_RETCODE SCIPsetConsChecked(SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_EVENTTYPE SCIPeventGetType(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_Real SCIPeventGetOldbound(SCIP_EVENT *event)
SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)
SCIP_Real SCIPeventGetNewbound(SCIP_EVENT *event)
SCIP_VARTYPE SCIPeventGetOldtype(SCIP_EVENT *event)
int SCIPexprGetNChildren(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprSum(SCIP *scip, SCIP_EXPR *expr)
SCIP_Real * SCIPgetCoefsExprSum(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprVar(SCIP *scip, SCIP_EXPR *expr)
SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)
SCIP_Real SCIPgetConstantExprSum(SCIP_EXPR *expr)
SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
#define SCIPfreeBlockMemoryArray(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 SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_RETCODE SCIPdelNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
SCIP_Bool SCIPnlrowIsInNLP(SCIP_NLROW *nlrow)
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)
SCIP_Bool SCIPinProbing(SCIP *scip)
void SCIPlinConsStatsIncTypeCount(SCIP_LINCONSSTATS *linconsstats, SCIP_LINCONSTYPE linconstype, int increment)
void SCIPlinConsStatsReset(SCIP_LINCONSSTATS *linconsstats)
SCIP_Bool SCIProwIsModifiable(SCIP_ROW *row)
SCIP_RETCODE SCIPchgRowLhs(SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)
SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Real SCIProwGetDualfarkas(SCIP_ROW *row)
SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
void SCIPupdateSolLPConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)
int SCIPgetNSepaRounds(SCIP *scip)
SCIP_Real SCIPgetLowerbound(SCIP *scip)
int SCIPgetNRuns(SCIP *scip)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
SCIP_Bool SCIPisUbBetter(SCIP *scip, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisSumRelLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisSumRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
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_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
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 SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Real SCIPgetHugeValue(SCIP *scip)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisSumRelGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisScalingIntegral(SCIP *scip, SCIP_Real val, SCIP_Real scalar)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPcutoffbounddelta(SCIP *scip)
SCIP_Bool SCIPisUpdateUnreliable(SCIP *scip, SCIP_Real newvalue, SCIP_Real oldvalue)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPepsilon(SCIP *scip)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisSumGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
SCIP_Bool SCIPinRepropagation(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
SCIP_Real SCIPvarGetNegationConstant(SCIP_VAR *var)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Bool SCIPdoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_Real SCIPvarGetAggrScalar(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_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetIndex(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPmultiaggregateVar(SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
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)
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_Bool SCIPvarIsRemovable(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
SCIP_RETCODE SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
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)
SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)
SCIP_RETCODE SCIPinferVarFixCons(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
void SCIPsortDownRealPtr(SCIP_Real *realarray, void **ptrarray, int len)
void SCIPsortRealInt(SCIP_Real *realarray, int *intarray, 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)
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
static const SCIP_Real scalars[]
static const char * paramname[]
memory allocation routines
#define BMScopyMemoryArray(ptr, source, num)
#define BMSclearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for conflict analysis handlers
public methods for managing constraints
public methods for managing events
public functions to work with algebraic expressions
public methods for LP management
public methods for message output
#define SCIPstatisticMessage
#define SCIPdebugPrintCons(x, y, z)
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for problem variables
public methods for branching rule plugins and branching
public methods for conflict handler plugins and conflict analysis
public methods for constraint handler plugins and constraints
public methods for problem copies
public methods for cuts and aggregation rows
public methods for event handler plugins and event handlers
public methods for the LP relaxation, rows and columns
public methods for memory management
public methods for message handling
public methods for numerical tolerances
public methods for SCIP parameter handling
public methods for global and local (sub)problems
public methods for the probing mode
public methods for solutions
public methods for querying solving statistics
public methods for the branch-and-bound tree
public methods for SCIP variables
SCIP_DECL_LINCONSUPGD((*linconsupgd))
#define SCIP_DECL_CONFLICTEXEC(x)
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSDELETE(x)
#define SCIP_DECL_CONSEXIT(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSINITSOL(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSSEPALP(x)
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSRESPROP(x)
@ SCIP_LINCONSTYPE_BINPACKING
@ SCIP_LINCONSTYPE_VARBOUND
@ SCIP_LINCONSTYPE_INVKNAPSACK
@ SCIP_LINCONSTYPE_PRECEDENCE
@ SCIP_LINCONSTYPE_AGGREGATION
@ SCIP_LINCONSTYPE_MIXEDBINARY
@ SCIP_LINCONSTYPE_SINGLETON
@ SCIP_LINCONSTYPE_SETCOVERING
@ SCIP_LINCONSTYPE_EQKNAPSACK
@ SCIP_LINCONSTYPE_KNAPSACK
@ SCIP_LINCONSTYPE_SETPARTITION
@ SCIP_LINCONSTYPE_INTKNAPSACK
@ SCIP_LINCONSTYPE_SETPACKING
@ SCIP_LINCONSTYPE_GENERAL
@ SCIP_LINCONSTYPE_CARDINALITY
#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_CONSINITLP(x)
#define SCIP_DECL_CONSEXITPRE(x)
#define SCIP_DECL_CONSLOCK(x)
#define SCIP_DECL_CONSCOPY(x)
#define SCIP_DECL_CONSINIT(x)
struct SCIP_ConsData SCIP_CONSDATA
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSHDLRCOPY(x)
#define SCIP_DECL_CONSEXITSOL(x)
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
enum SCIP_LinConstype SCIP_LINCONSTYPE
#define SCIP_DECL_CONSDELVARS(x)
#define SCIP_EVENTTYPE_BOUNDCHANGED
#define SCIP_EVENTTYPE_VARUNLOCKED
#define SCIP_EVENTTYPE_TYPECHANGED
#define SCIP_EVENTTYPE_GUBCHANGED
#define SCIP_EVENTTYPE_GBDCHANGED
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_UBTIGHTENED
#define SCIP_EVENTTYPE_VARFIXED
#define SCIP_EVENTTYPE_VARDELETED
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_FORMAT
#define SCIP_EVENTTYPE_GLBCHANGED
#define SCIP_EVENTTYPE_BOUNDRELAXED
#define SCIP_EVENTTYPE_LBCHANGED
#define SCIP_EVENTTYPE_UBCHANGED
#define SCIP_EVENTTYPE_BOUNDTIGHTENED
#define SCIP_EVENTTYPE_LBTIGHTENED
enum SCIP_BoundType SCIP_BOUNDTYPE
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_SORTINDCOMP(x)
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_EXITPRESOLVE
@ SCIP_STAGE_TRANSFORMING
#define SCIP_PRESOLTIMING_EXHAUSTIVE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_ORIGINAL
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
enum SCIP_LockType SCIP_LOCKTYPE
enum SCIP_Vartype SCIP_VARTYPE
enum SCIP_Varstatus SCIP_VARSTATUS