96#define CONSHDLR_NAME "linear"
97#define CONSHDLR_DESC "linear constraints of the form lhs <= a^T x <= rhs"
98#define CONSHDLR_SEPAPRIORITY +100000
99#define CONSHDLR_ENFOPRIORITY -1000000
100#define CONSHDLR_CHECKPRIORITY -1000000
101#define CONSHDLR_SEPAFREQ 0
102#define CONSHDLR_PROPFREQ 1
103#define CONSHDLR_EAGERFREQ 100
105#define CONSHDLR_MAXPREROUNDS -1
106#define CONSHDLR_DELAYSEPA FALSE
107#define CONSHDLR_DELAYPROP FALSE
108#define CONSHDLR_NEEDSCONS TRUE
110#define CONSHDLR_PRESOLTIMING (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_EXHAUSTIVE)
111#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
113#define EVENTHDLR_NAME "linear"
114#define EVENTHDLR_DESC "bound change event handler for linear constraints"
116#define CONFLICTHDLR_NAME "linear"
117#define CONFLICTHDLR_DESC "conflict handler creating linear constraints"
118#define CONFLICTHDLR_PRIORITY -1000000
120#define DEFAULT_TIGHTENBOUNDSFREQ 1
121#define DEFAULT_MAXROUNDS 5
122#define DEFAULT_MAXROUNDSROOT -1
123#define DEFAULT_MAXSEPACUTS 50
124#define DEFAULT_MAXSEPACUTSROOT 200
125#define DEFAULT_PRESOLPAIRWISE TRUE
126#define DEFAULT_PRESOLUSEHASHING TRUE
127#define DEFAULT_NMINCOMPARISONS 200000
128#define DEFAULT_MINGAINPERNMINCOMP 1e-06
130#define DEFAULT_SORTVARS TRUE
132#define DEFAULT_CHECKRELMAXABS FALSE
134#define DEFAULT_MAXAGGRNORMSCALE 0.0
136#define DEFAULT_MAXEASYACTIVITYDELTA 1e6
138#define DEFAULT_MAXCARDBOUNDDIST 0.0
140#define DEFAULT_SEPARATEALL FALSE
142#define DEFAULT_AGGREGATEVARIABLES TRUE
143#define DEFAULT_SIMPLIFYINEQUALITIES TRUE
144#define DEFAULT_DUALPRESOLVING TRUE
145#define DEFAULT_SINGLETONSTUFFING TRUE
146#define DEFAULT_SINGLEVARSTUFFING FALSE
148#define DEFAULT_DETECTCUTOFFBOUND TRUE
151#define DEFAULT_DETECTLOWERBOUND TRUE
154#define DEFAULT_DETECTPARTIALOBJECTIVE TRUE
156#define DEFAULT_RANGEDROWPROPAGATION TRUE
157#define DEFAULT_RANGEDROWARTCONS TRUE
158#define DEFAULT_RANGEDROWMAXDEPTH INT_MAX
159#define DEFAULT_RANGEDROWFREQ 1
161#define DEFAULT_MULTAGGRREMOVE FALSE
163#define DEFAULT_MAXMULTAGGRQUOT 1e+03
164#define DEFAULT_MAXDUALMULTAGGRQUOT 1e+20
165#define DEFAULT_EXTRACTCLIQUES TRUE
167#define MAXDNOM 10000LL
168#define MAXSCALEDCOEF 0
169#define MAXSCALEDCOEFINTEGER 0
172#define MAXACTVAL 1e+09
176#define MAXVALRECOMP 1e+06
177#define MINVALRECOMP 1e-05
180#define NONLINCONSUPGD_PRIORITY 1000000
198 SCIP_Real lastminactivity;
200 SCIP_Real lastmaxactivity;
206 SCIP_Real lastglbminactivity;
208 SCIP_Real lastglbmaxactivity;
210 SCIP_Real maxactdelta;
212 uint64_t possignature;
213 uint64_t negsignature;
219 int minactivityneginf;
220 int minactivityposinf;
221 int maxactivityneginf;
222 int maxactivityposinf;
223 int minactivityneghuge;
224 int minactivityposhuge;
225 int maxactivityneghuge;
226 int maxactivityposhuge;
227 int glbminactivityneginf;
228 int glbminactivityposinf;
229 int glbmaxactivityneginf;
230 int glbmaxactivityposinf;
231 int glbminactivityneghuge;
232 int glbminactivityposhuge;
233 int glbmaxactivityneghuge;
234 int glbmaxactivityposhuge;
240 unsigned int boundstightened:2;
241 unsigned int rangedrowpropagated:2;
243 unsigned int validmaxabsval:1;
244 unsigned int validminabsval:1;
245 unsigned int validactivities:1;
246 unsigned int validminact:1;
247 unsigned int validmaxact:1;
248 unsigned int validglbminact:1;
249 unsigned int validglbmaxact:1;
250 unsigned int presolved:1;
251 unsigned int removedfixings:1;
252 unsigned int validsignature:1;
253 unsigned int changed:1;
254 unsigned int normalized:1;
255 unsigned int upgradetried:1;
256 unsigned int upgraded:1;
257 unsigned int indexsorted:1;
258 unsigned int merged:1;
259 unsigned int cliquesadded:1;
260 unsigned int implsadded:1;
261 unsigned int coefsorted:1;
262 unsigned int varsdeleted:1;
263 unsigned int hascontvar:1;
264 unsigned int hasnonbinvar:1;
265 unsigned int hasnonbinvalid:1;
266 unsigned int checkabsolute:1;
278struct SCIP_ConshdlrData
282 SCIP_Real maxaggrnormscale;
284 SCIP_Real maxcardbounddist;
286 SCIP_Real mingainpernmincomp;
287 SCIP_Real maxeasyactivitydelta;
289 int linconsupgradessize;
290 int nlinconsupgrades;
291 int tightenboundsfreq;
298 SCIP_Bool presolpairwise;
299 SCIP_Bool presolusehashing;
300 SCIP_Bool separateall;
302 SCIP_Bool aggregatevariables;
303 SCIP_Bool simplifyinequalities;
304 SCIP_Bool dualpresolving;
305 SCIP_Bool singletonstuffing;
306 SCIP_Bool singlevarstuffing;
309 SCIP_Bool checkrelmaxabs;
311 SCIP_Bool detectcutoffbound;
314 SCIP_Bool detectlowerbound;
317 SCIP_Bool detectpartialobjective;
319 SCIP_Bool rangedrowpropagation;
322 SCIP_Bool rangedrowartcons;
323 int rangedrowmaxdepth;
325 SCIP_Bool multaggrremove;
327 SCIP_Real maxmultaggrquot;
328 SCIP_Real maxdualmultaggrquot;
329 SCIP_Bool extractcliques;
364 unsigned int proprule:8;
380 inferinfo.val.asint =
i;
391 return inferinfo.val.asint;
400 return (
int) inferinfo.val.asbits.proprule;
409 return (
int) inferinfo.val.asbits.pos;
425 inferinfo.val.asbits.proprule = (
unsigned int) proprule;
426 inferinfo.val.asbits.pos = (
unsigned int) pos;
456 assert(conshdlrdata->nlinconsupgrades <= conshdlrdata->linconsupgradessize);
458 if( num > conshdlrdata->linconsupgradessize )
464 conshdlrdata->linconsupgradessize = newsize;
466 assert(num <= conshdlrdata->linconsupgradessize);
481 assert(consdata->nvars <= consdata->varssize);
483 if( num > consdata->varssize )
490 if( consdata->eventdata !=
NULL )
494 consdata->varssize = newsize;
496 assert(num <= consdata->varssize);
520 (*linconsupgrade)->linconsupgd = linconsupgd;
521 (*linconsupgrade)->priority = priority;
522 (*linconsupgrade)->active =
TRUE;
554 (*conshdlrdata)->linconsupgrades =
NULL;
555 (*conshdlrdata)->linconsupgradessize = 0;
556 (*conshdlrdata)->nlinconsupgrades = 0;
557 (*conshdlrdata)->naddconss = 0;
560 (*conshdlrdata)->eventhdlr = eventhdlr;
578 for(
i = 0;
i < (*conshdlrdata)->nlinconsupgrades; ++
i )
593 const char* conshdlrname
603 for(
i = conshdlrdata->nlinconsupgrades - 1;
i >= 0; --
i )
605 if( conshdlrdata->linconsupgrades[
i]->linconsupgd == linconsupgd )
608 SCIPwarningMessage(
scip,
"Try to add already known upgrade message for constraint handler %s.\n", conshdlrname);
633 for(
i = conshdlrdata->nlinconsupgrades;
634 i > 0 && conshdlrdata->linconsupgrades[
i-1]->priority < linconsupgrade->
priority; --
i )
636 conshdlrdata->linconsupgrades[
i] = conshdlrdata->linconsupgrades[
i-1];
639 conshdlrdata->linconsupgrades[
i] = linconsupgrade;
640 conshdlrdata->nlinconsupgrades++;
741 consdata->eventdata[pos]->cons = cons;
742 consdata->eventdata[pos]->varpos = pos;
747 eventhdlr, consdata->eventdata[pos], &consdata->eventdata[pos]->filterpos) );
749 consdata->removedfixings = consdata->removedfixings &&
SCIPvarIsActive(consdata->vars[pos]);
776 assert(consdata->eventdata[pos]->cons == cons);
777 assert(consdata->eventdata[pos]->varpos == pos);
782 eventhdlr, consdata->eventdata[pos], consdata->eventdata[pos]->filterpos) );
813 for(
i = 0;
i < consdata->nvars; ++
i )
840 for(
i = consdata->nvars - 1;
i >= 0; --
i )
890 (*consdata)->varssize = 0;
891 (*consdata)->nvars =
nvars;
892 (*consdata)->hascontvar =
FALSE;
893 (*consdata)->hasnonbinvar =
FALSE;
894 (*consdata)->hasnonbinvalid =
TRUE;
895 (*consdata)->vars =
NULL;
896 (*consdata)->vals =
NULL;
902 SCIP_Real* valsbuffer;
910 for( v = 0; v < (*consdata)->nvars; ++v )
929 valsbuffer[
nvars] = val;
933 if( !(*consdata)->hascontvar )
939 (*consdata)->hasnonbinvar =
TRUE;
942 (*consdata)->hascontvar =
TRUE;
948 (*consdata)->nvars =
nvars;
955 (*consdata)->varssize =
nvars;
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;
1264 int pseudoactivityposinf;
1265 int pseudoactivityneginf;
1266 SCIP_Real pseudoactivity;
1271 pseudoactivityposinf = 0;
1272 pseudoactivityneginf = 0;
1274 for(
i = consdata->nvars - 1;
i >= 0; --
i )
1276 val = consdata->vals[
i];
1281 pseudoactivityposinf++;
1283 pseudoactivityneginf++;
1290 pseudoactivityneginf++;
1292 pseudoactivityposinf++;
1295 pseudoactivity += val *
bound;
1299 if( pseudoactivityneginf > 0 && pseudoactivityposinf > 0 )
1301 else if( pseudoactivityneginf > 0 )
1303 else if( pseudoactivityposinf > 0 )
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 )
1434 absval = consdata->vals[
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 )
1463 absval = consdata->vals[
i];
1465 if( absval < consdata->minabsval )
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];
1619 SCIP_Bool checkreliability
1624 SCIP_Real* lastactivity;
1625 int* activityposinf;
1626 int* activityneginf;
1627 int* activityposhuge;
1628 int* activityneghuge;
1629 SCIP_Real oldcontribution;
1630 SCIP_Real newcontribution;
1632 SCIP_Bool finitenewbound;
1633 SCIP_Bool hugevalnewcont;
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);
1680 lastactivity = &(consdata->lastglbminactivity);
1681 activityposinf = &(consdata->glbminactivityposinf);
1682 activityneginf = &(consdata->glbminactivityneginf);
1683 activityposhuge = &(consdata->glbminactivityposhuge);
1684 activityneghuge = &(consdata->glbminactivityneghuge);
1685 validact = consdata->validglbminact;
1690 lastactivity = &(consdata->lastglbmaxactivity);
1691 activityposinf = &(consdata->glbmaxactivityneginf);
1692 activityneginf = &(consdata->glbmaxactivityposinf);
1693 activityposhuge = &(consdata->glbmaxactivityposhuge);
1694 activityneghuge = &(consdata->glbmaxactivityneghuge);
1695 validact = consdata->validglbmaxact;
1703 lastactivity = &(consdata->lastglbmaxactivity);
1704 activityposinf = &(consdata->glbmaxactivityposinf);
1705 activityneginf = &(consdata->glbmaxactivityneginf);
1706 activityposhuge = &(consdata->glbmaxactivityposhuge);
1707 activityneghuge = &(consdata->glbmaxactivityneghuge);
1708 validact = consdata->validglbmaxact;
1713 lastactivity = &(consdata->lastglbminactivity);
1714 activityposinf = &(consdata->glbminactivityneginf);
1715 activityneginf = &(consdata->glbminactivityposinf);
1716 activityposhuge = &(consdata->glbminactivityposhuge);
1717 activityneghuge = &(consdata->glbminactivityneghuge);
1718 validact = consdata->validglbminact;
1736 lastactivity = &(consdata->lastminactivity);
1737 activityposinf = &(consdata->minactivityposinf);
1738 activityneginf = &(consdata->minactivityneginf);
1739 activityposhuge = &(consdata->minactivityposhuge);
1740 activityneghuge = &(consdata->minactivityneghuge);
1741 validact = consdata->validminact;
1746 lastactivity = &(consdata->lastmaxactivity);
1747 activityposinf = &(consdata->maxactivityneginf);
1748 activityneginf = &(consdata->maxactivityposinf);
1749 activityposhuge = &(consdata->maxactivityposhuge);
1750 activityneghuge = &(consdata->maxactivityneghuge);
1751 validact = consdata->validmaxact;
1759 lastactivity = &(consdata->lastmaxactivity);
1760 activityposinf = &(consdata->maxactivityposinf);
1761 activityneginf = &(consdata->maxactivityneginf);
1762 activityposhuge = &(consdata->maxactivityposhuge);
1763 activityneghuge = &(consdata->maxactivityneghuge);
1764 validact = consdata->validmaxact;
1769 lastactivity = &(consdata->lastminactivity);
1770 activityposinf = &(consdata->minactivityneginf);
1771 activityneginf = &(consdata->minactivityposinf);
1772 activityposhuge = &(consdata->minactivityposhuge);
1773 activityneghuge = &(consdata->minactivityneghuge);
1774 validact = consdata->validminact;
1779 oldcontribution = val * oldbound;
1780 newcontribution = val * newbound;
1787 if( oldbound > 0.0 )
1789 assert((*activityposinf) >= 1);
1792 if( finitenewbound || newbound < 0.0 )
1795 (*activityposinf)--;
1798 if( !finitenewbound && newbound < 0.0 )
1799 (*activityneginf)++;
1800 else if( hugevalnewcont )
1803 if( newcontribution > 0.0 )
1804 (*activityposhuge)++;
1806 (*activityneghuge)++;
1817 assert((*activityneginf) >= 1);
1820 if( finitenewbound || newbound > 0.0 )
1823 (*activityneginf)--;
1826 if( !finitenewbound && newbound > 0.0 )
1827 (*activityposinf)++;
1828 else if( hugevalnewcont )
1831 if( newcontribution > 0.0 )
1832 (*activityposhuge)++;
1834 (*activityneghuge)++;
1845 if( oldcontribution > 0.0 )
1847 assert((*activityposhuge) >= 1);
1852 (*activityposhuge)--;
1854 if( !finitenewbound )
1857 if( newbound > 0.0 )
1858 (*activityposinf)++;
1861 (*activityneginf)++;
1863 else if( hugevalnewcont )
1866 if( newcontribution > 0.0 )
1867 (*activityposhuge)++;
1870 (*activityneghuge)++;
1879 assert(oldcontribution < 0.0);
1880 assert((*activityneghuge) >= 1);
1885 (*activityneghuge)--;
1887 if( !finitenewbound )
1890 if( newbound > 0.0 )
1891 (*activityposinf)++;
1894 (*activityneginf)++;
1896 else if( hugevalnewcont )
1899 if( newcontribution > 0.0 )
1900 (*activityposhuge)++;
1903 (*activityneghuge)++;
1913 if( !finitenewbound )
1918 if( newbound > 0.0 )
1920 (*activityposinf)++;
1930 (*activityneginf)++;
1935 else if( hugevalnewcont )
1937 if( newcontribution > 0.0 )
1939 (*activityposhuge)++;
1944 (*activityneghuge)++;
1959 SCIP_Real curractivity;
1971 (*lastactivity) = curractivity;
1977 SCIPdebugMsg(
scip,
"%s activity of linear constraint unreliable after update: %16.9g\n",
1978 (global ?
"global " :
""), curractivity);
1984 consdata->validglbminact =
FALSE;
1986 consdata->validglbmaxact =
FALSE;
1991 consdata->validminact =
FALSE;
1993 consdata->validmaxact =
FALSE;
2009 SCIP_Bool checkreliability
2016 if( consdata->validactivities )
2034 SCIP_Bool checkreliability
2041 if( consdata->validactivities )
2058 SCIP_Bool checkreliability
2064 if( consdata->validactivities )
2081 SCIP_Bool checkreliability
2087 if( consdata->validactivities )
2103 SCIP_Bool checkreliability
2112 if( consdata->validmaxabsval )
2119 consdata->maxabsval =
MAX(consdata->maxabsval, absval);
2123 if( consdata->validminabsval )
2130 consdata->minabsval =
MIN(consdata->minabsval, absval);
2134 if( consdata->validactivities )
2156 consdata->maxactdeltavar =
var;
2158 else if( consdata->maxactdeltavar !=
NULL )
2160 SCIP_Real domain = ub - lb;
2161 SCIP_Real delta =
REALABS(val) * domain;
2163 if( delta > consdata->maxactdelta )
2165 consdata->maxactdelta = delta;
2166 consdata->maxactdeltavar =
var;
2179 SCIP_Bool checkreliability
2188 if( consdata->validmaxabsval )
2196 consdata->validmaxabsval =
FALSE;
2202 if( consdata->validminabsval )
2210 consdata->validminabsval =
FALSE;
2216 if( consdata->validactivities )
2230 if( consdata->maxactdeltavar ==
var )
2233 consdata->maxactdeltavar =
NULL;
2245 SCIP_Bool checkreliability
2261 if( !consdata->validmaxabsval )
2263 assert(consdata->validmaxabsval);
2266 return consdata->maxabsval;
2277 if( !consdata->validminabsval )
2279 assert(consdata->validminabsval);
2282 return consdata->minabsval;
2298 assert(!consdata->validactivities);
2304 consdata->validmaxabsval =
TRUE;
2305 consdata->validminabsval =
TRUE;
2306 consdata->validactivities =
TRUE;
2307 consdata->validminact =
TRUE;
2308 consdata->validmaxact =
TRUE;
2309 consdata->validglbminact =
TRUE;
2310 consdata->validglbmaxact =
TRUE;
2311 consdata->maxabsval = 0.0;
2312 consdata->minabsval = (consdata->nvars == 0 ? 0.0 :
REALABS(consdata->vals[0]));
2315 consdata->lastminactivity = 0.0;
2316 consdata->lastmaxactivity = 0.0;
2317 consdata->minactivityneginf = 0;
2318 consdata->minactivityposinf = 0;
2319 consdata->maxactivityneginf = 0;
2320 consdata->maxactivityposinf = 0;
2321 consdata->minactivityneghuge = 0;
2322 consdata->minactivityposhuge = 0;
2323 consdata->maxactivityneghuge = 0;
2324 consdata->maxactivityposhuge = 0;
2327 consdata->lastglbminactivity = 0.0;
2328 consdata->lastglbmaxactivity = 0.0;
2329 consdata->glbminactivityneginf = 0;
2330 consdata->glbminactivityposinf = 0;
2331 consdata->glbmaxactivityneginf = 0;
2332 consdata->glbmaxactivityposinf = 0;
2333 consdata->glbminactivityneghuge = 0;
2334 consdata->glbminactivityposhuge = 0;
2335 consdata->glbmaxactivityneghuge = 0;
2336 consdata->glbmaxactivityposhuge = 0;
2338 for(
i = 0;
i < consdata->nvars; ++
i )
2341 consdata->lastminactivity =
QUAD_TO_DBL(consdata->minactivity);
2342 consdata->lastmaxactivity =
QUAD_TO_DBL(consdata->maxactivity);
2343 consdata->lastglbminactivity =
QUAD_TO_DBL(consdata->glbminactivity);
2344 consdata->lastglbmaxactivity =
QUAD_TO_DBL(consdata->glbmaxactivity);
2361 SCIP_Bool goodrelax,
2362 SCIP_Real* minactivity,
2365 SCIP_Bool* issettoinfinity
2382 *issettoinfinity =
TRUE;
2383 *istight = posinf == 0;
2386 else if( posinf > 0 )
2389 *issettoinfinity =
TRUE;
2393 else if( neghuge > 0 || ( poshuge > 0 && !goodrelax ) )
2396 *issettoinfinity =
TRUE;
2401 SCIP_Real
QUAD(tmpactivity);
2406 if( !consdata->validglbminact )
2408 assert(consdata->validglbminact);
2414 if( !consdata->validminact )
2416 assert(consdata->validminact);
2438 *issettoinfinity =
FALSE;
2456 SCIP_Bool goodrelax,
2457 SCIP_Real* maxactivity,
2460 SCIP_Bool* issettoinfinity
2477 *issettoinfinity =
TRUE;
2478 *istight = neginf == 0;
2481 else if( neginf > 0 )
2484 *issettoinfinity =
TRUE;
2488 else if( poshuge > 0 || ( neghuge > 0 && !goodrelax ) )
2491 *issettoinfinity =
TRUE;
2496 SCIP_Real
QUAD(tmpactivity);
2501 if( !consdata->validglbmaxact )
2503 assert(consdata->validglbmaxact);
2509 if( !consdata->validmaxact )
2511 assert(consdata->validmaxact);
2533 *issettoinfinity =
FALSE;
2542 SCIP_Bool goodrelax,
2544 SCIP_Real* minactivity,
2545 SCIP_Real* maxactivity,
2546 SCIP_Bool* ismintight,
2548 SCIP_Bool* ismaxtight,
2550 SCIP_Bool* isminsettoinfinity,
2551 SCIP_Bool* ismaxsettoinfinity
2562 if( !consdata->validactivities )
2565 assert(consdata->validminact);
2566 assert(consdata->validmaxact);
2570 assert(consdata->minactivityneginf >= 0);
2571 assert(consdata->minactivityposinf >= 0);
2572 assert(consdata->maxactivityneginf >= 0);
2573 assert(consdata->maxactivityposinf >= 0);
2575 getMinActivity(
scip, consdata, consdata->minactivityposinf, consdata->minactivityneginf,
2576 consdata->minactivityposhuge, consdata->minactivityneghuge, 0.0,
FALSE, goodrelax,
2577 minactivity, ismintight, isminsettoinfinity);
2579 getMaxActivity(
scip, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,
2580 consdata->maxactivityposhuge, consdata->maxactivityneghuge, 0.0,
FALSE, goodrelax,
2581 maxactivity, ismaxtight, ismaxsettoinfinity);
2590 SCIP_Real* resactivity,
2591 SCIP_Bool isminresact,
2592 SCIP_Bool useglobalbounds
2608 for( v = 0; v < consdata->nvars; ++v )
2610 var = consdata->vars[v];
2612 if(
var == cancelvar )
2615 val = consdata->vals[v];
2617 if( useglobalbounds )
2637 *resactivity += val*lb;
2643 *resactivity += val*ub;
2652 *resactivity += val*ub;
2658 *resactivity += val*lb;
2672 SCIP_Bool goodrelax,
2674 SCIP_Real* minresactivity,
2675 SCIP_Real* maxresactivity,
2676 SCIP_Bool* ismintight,
2678 SCIP_Bool* ismaxtight,
2680 SCIP_Bool* isminsettoinfinity,
2681 SCIP_Bool* ismaxsettoinfinity
2684 SCIP_Real minactbound;
2685 SCIP_Real maxactbound;
2699 if( !consdata->validactivities )
2702 assert(consdata->validminact);
2703 assert(consdata->validmaxact);
2707 assert(consdata->minactivityneginf >= 0);
2708 assert(consdata->minactivityposinf >= 0);
2709 assert(consdata->maxactivityneginf >= 0);
2710 assert(consdata->maxactivityposinf >= 0);
2711 assert(consdata->minactivityneghuge >= 0);
2712 assert(consdata->minactivityposhuge >= 0);
2713 assert(consdata->maxactivityneghuge >= 0);
2714 assert(consdata->maxactivityposhuge >= 0);
2734 assert(consdata->minactivityposinf >= 1);
2736 getMinActivity(
scip, consdata, consdata->minactivityposinf - 1, consdata->minactivityneginf,
2737 consdata->minactivityposhuge, consdata->minactivityneghuge, 0.0,
FALSE, goodrelax,
2738 minresactivity, ismintight, isminsettoinfinity);
2742 assert(consdata->minactivityneginf >= 1);
2744 getMinActivity(
scip, consdata, consdata->minactivityposinf, consdata->minactivityneginf - 1,
2745 consdata->minactivityposhuge, consdata->minactivityneghuge, 0.0,
FALSE, goodrelax,
2746 minresactivity, ismintight, isminsettoinfinity);
2750 assert(consdata->minactivityposhuge >= 1);
2752 getMinActivity(
scip, consdata, consdata->minactivityposinf, consdata->minactivityneginf,
2753 consdata->minactivityposhuge - 1, consdata->minactivityneghuge, 0.0,
FALSE, goodrelax,
2754 minresactivity, ismintight, isminsettoinfinity);
2758 assert(consdata->minactivityneghuge >= 1);
2760 getMinActivity(
scip, consdata, consdata->minactivityposinf, consdata->minactivityneginf,
2761 consdata->minactivityposhuge, consdata->minactivityneghuge - 1, 0.0,
FALSE, goodrelax,
2762 minresactivity, ismintight, isminsettoinfinity);
2766 getMinActivity(
scip, consdata, consdata->minactivityposinf, consdata->minactivityneginf,
2767 consdata->minactivityposhuge, consdata->minactivityneghuge, absval * minactbound,
FALSE, goodrelax,
2768 minresactivity, ismintight, isminsettoinfinity);
2776 assert(consdata->maxactivityneginf >= 1);
2778 getMaxActivity(
scip, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf - 1,
2779 consdata->maxactivityposhuge, consdata->maxactivityneghuge, 0.0,
FALSE, goodrelax,
2780 maxresactivity, ismaxtight, ismaxsettoinfinity);
2784 assert(consdata->maxactivityposinf >= 1);
2786 getMaxActivity(
scip, consdata, consdata->maxactivityposinf - 1, consdata->maxactivityneginf,
2787 consdata->maxactivityposhuge, consdata->maxactivityneghuge, 0.0,
FALSE, goodrelax,
2788 maxresactivity, ismaxtight, ismaxsettoinfinity);
2792 assert(consdata->maxactivityposhuge >= 1);
2794 getMaxActivity(
scip, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,
2795 consdata->maxactivityposhuge - 1, consdata->maxactivityneghuge, 0.0,
FALSE, goodrelax,
2796 maxresactivity, ismaxtight, ismaxsettoinfinity);
2800 assert(consdata->maxactivityneghuge >= 1);
2802 getMaxActivity(
scip, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,
2803 consdata->maxactivityposhuge, consdata->maxactivityneghuge - 1, 0.0,
FALSE, goodrelax,
2804 maxresactivity, ismaxtight, ismaxsettoinfinity);
2808 getMaxActivity(
scip, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,
2809 consdata->maxactivityposhuge, consdata->maxactivityneghuge, absval * maxactbound,
FALSE, goodrelax,
2810 maxresactivity, ismaxtight, ismaxsettoinfinity);
2819 SCIP_Bool goodrelax,
2821 SCIP_Real* glbminactivity,
2822 SCIP_Real* glbmaxactivity,
2823 SCIP_Bool* ismintight,
2825 SCIP_Bool* ismaxtight,
2827 SCIP_Bool* isminsettoinfinity,
2828 SCIP_Bool* ismaxsettoinfinity
2834 || (glbmaxactivity !=
NULL && ismaxtight !=
NULL && ismaxsettoinfinity !=
NULL));
2836 if( !consdata->validactivities )
2839 assert(consdata->validglbminact);
2840 assert(consdata->validglbmaxact);
2844 assert(consdata->glbminactivityneginf >= 0);
2845 assert(consdata->glbminactivityposinf >= 0);
2846 assert(consdata->glbmaxactivityneginf >= 0);
2847 assert(consdata->glbmaxactivityposinf >= 0);
2848 assert(consdata->glbminactivityneghuge >= 0);
2849 assert(consdata->glbminactivityposhuge >= 0);
2850 assert(consdata->glbmaxactivityneghuge >= 0);
2851 assert(consdata->glbmaxactivityposhuge >= 0);
2853 if( glbminactivity !=
NULL )
2858 getMinActivity(
scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,
2859 consdata->glbminactivityposhuge, consdata->glbminactivityneghuge, 0.0,
TRUE, goodrelax,
2860 glbminactivity, ismintight, isminsettoinfinity);
2863 if( glbmaxactivity !=
NULL )
2868 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,
2869 consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge, 0.0,
TRUE, goodrelax,
2870 glbmaxactivity, ismaxtight, ismaxsettoinfinity);
2881 SCIP_Bool goodrelax,
2883 SCIP_Real* minresactivity,
2884 SCIP_Real* maxresactivity,
2885 SCIP_Bool* ismintight,
2887 SCIP_Bool* ismaxtight,
2889 SCIP_Bool* isminsettoinfinity,
2890 SCIP_Bool* ismaxsettoinfinity
2893 SCIP_Real minactbound;
2894 SCIP_Real maxactbound;
2901 || (maxresactivity !=
NULL && ismaxtight !=
NULL && ismaxsettoinfinity !=
NULL));
2904 if( !consdata->validactivities )
2909 assert(consdata->glbminactivityneginf >= 0);
2910 assert(consdata->glbminactivityposinf >= 0);
2911 assert(consdata->glbmaxactivityneginf >= 0);
2912 assert(consdata->glbmaxactivityposinf >= 0);
2927 if( minresactivity !=
NULL )
2937 assert(consdata->glbminactivityposinf >= 1);
2939 getMinActivity(
scip, consdata, consdata->glbminactivityposinf - 1, consdata->glbminactivityneginf,
2940 consdata->glbminactivityposhuge, consdata->glbminactivityneghuge, 0.0,
TRUE, goodrelax,
2941 minresactivity, ismintight, isminsettoinfinity);
2945 assert(consdata->glbminactivityneginf >= 1);
2947 getMinActivity(
scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf - 1,
2948 consdata->glbminactivityposhuge, consdata->glbminactivityneghuge, 0.0,
TRUE, goodrelax,
2949 minresactivity, ismintight, isminsettoinfinity);
2953 assert(consdata->glbminactivityposhuge >= 1);
2955 getMinActivity(
scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,
2956 consdata->glbminactivityposhuge - 1, consdata->glbminactivityneghuge, 0.0,
TRUE, goodrelax,
2957 minresactivity, ismintight, isminsettoinfinity);
2961 assert(consdata->glbminactivityneghuge >= 1);
2963 getMinActivity(
scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,
2964 consdata->glbminactivityposhuge, consdata->glbminactivityneghuge - 1, 0.0,
TRUE, goodrelax,
2965 minresactivity, ismintight, isminsettoinfinity);
2969 getMinActivity(
scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,
2970 consdata->glbminactivityposhuge, consdata->glbminactivityneghuge, absval * minactbound,
TRUE,
2971 goodrelax, minresactivity, ismintight, isminsettoinfinity);
2975 if( maxresactivity !=
NULL )
2985 assert(consdata->glbmaxactivityneginf >= 1);
2987 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf - 1,
2988 consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge, 0.0,
TRUE, goodrelax,
2989 maxresactivity, ismaxtight, ismaxsettoinfinity);
2993 assert(consdata->glbmaxactivityposinf >= 1);
2995 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf - 1, consdata->glbmaxactivityneginf,
2996 consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge, 0.0,
TRUE, goodrelax,
2997 maxresactivity, ismaxtight, ismaxsettoinfinity);
3001 assert(consdata->glbmaxactivityposhuge >= 1);
3003 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,
3004 consdata->glbmaxactivityposhuge - 1, consdata->glbmaxactivityneghuge, 0.0,
TRUE, goodrelax,
3005 maxresactivity, ismaxtight, ismaxsettoinfinity);
3009 assert(consdata->glbmaxactivityneghuge >= 1);
3011 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,
3012 consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge - 1, 0.0,
TRUE, goodrelax,
3013 maxresactivity, ismaxtight, ismaxsettoinfinity);
3017 getMaxActivity(
scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,
3018 consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge, absval * maxactbound,
TRUE,
3019 goodrelax, maxresactivity, ismaxtight, ismaxsettoinfinity);
3051 for( v = 0; v < consdata->nvars; ++v )
3055 if( consdata->vals[v] < 0 )
3065 activity += consdata->vals[v] * solval;
3067 assert(nneginf >= 0 && nposinf >= 0);
3069 SCIPdebugMsg(
scip,
"activity of linear constraint: %.15g, %d positive infinity values, %d negative infinity values \n", activity, nposinf, nneginf);
3072 if( nposinf > 0 && nneginf > 0 )
3073 activity = (consdata->rhs + consdata->lhs) / 2;
3074 else if( nposinf > 0 )
3076 else if( nneginf > 0 )
3079 SCIPdebugMsg(
scip,
"corrected activity of linear constraint: %.15g\n", activity);
3084 else if( activity < 0 )
3110 return MIN(consdata->rhs - activity, activity - consdata->lhs);
3120 uint64_t varsignature;
3126 assert(consdata->validsignature);
3131 val = consdata->vals[pos];
3132 if( (val > 0.0 && ub > 0.0) || (val < 0.0 && lb < 0.0) )
3133 consdata->possignature |= varsignature;
3134 if( (val > 0.0 && lb < 0.0) || (val < 0.0 && ub > 0.0) )
3135 consdata->negsignature |= varsignature;
3146 if( !consdata->validsignature )
3150 consdata->validsignature =
TRUE;
3151 consdata->possignature = 0;
3152 consdata->negsignature = 0;
3153 for(
i = 0;
i < consdata->nvars; ++
i )
3170 var1 = consdata->vars[ind1];
3171 var2 = consdata->vars[ind2];
3188 if( vartype1 < vartype2 )
3190 else if( vartype1 > vartype2 )
3209 var1 = consdata->vars[ind1];
3210 var2 = consdata->vars[ind2];
3220 SCIP_Real abscoef1 =
REALABS(consdata->vals[ind1]);
3221 SCIP_Real abscoef2 =
REALABS(consdata->vals[ind2]);
3223 if(
EPSGT(abscoef1, abscoef2, 1e-9) )
3225 else if(
EPSGT(abscoef2, abscoef1, 1e-9) )
3235 if( vartype1 < vartype2 )
3239 else if( vartype1 > vartype2 )
3256 if(
EPSGT(abscont1, abscont2, 1e-9) )
3258 else if(
EPSGT(abscont2, abscont1, 1e-9) )
3287 for( v = 0; v <
nvars; ++v )
3291 varv = consdata->vars[v];
3292 valv = consdata->vals[v];
3293 if( consdata->eventdata !=
NULL )
3294 eventdatav = consdata->eventdata[v];
3300 consdata->vars[
i] = consdata->vars[perm[
i]];
3301 consdata->vals[
i] = consdata->vals[perm[
i]];
3302 if( consdata->eventdata !=
NULL )
3304 consdata->eventdata[
i] = consdata->eventdata[perm[
i]];
3305 consdata->eventdata[
i]->varpos =
i;
3311 while( perm[
i] != v );
3312 consdata->vars[
i] = varv;
3313 consdata->vals[
i] = valv;
3314 if( consdata->eventdata !=
NULL )
3316 consdata->eventdata[
i] = eventdatav;
3317 consdata->eventdata[
i]->varpos =
i;
3324 for( v = 0; v <
nvars; ++v )
3327 assert(consdata->eventdata ==
NULL || consdata->eventdata[v]->varpos == v);
3354 if( consdata->nvars <= 1 )
3356 consdata->indexsorted =
TRUE;
3357 consdata->coefsorted =
TRUE;
3358 consdata->nbinvars = (consdata->nvars == 1 ? (int)
SCIPvarIsBinary(consdata->vars[0]) : 0);
3371 SCIPsort(perm, consdataCompVar, (
void*)consdata, consdata->nvars);
3373 SCIPsort(perm, consdataCompVarProp, (
void*)consdata, consdata->nvars);
3382 consdata->indexsorted =
FALSE;
3383 consdata->coefsorted =
TRUE;
3386 consdata->nbinvars = 0;
3387 for( v = 0; v < consdata->nvars; ++v )
3390 ++consdata->nbinvars;
3397 consdata->indexsorted =
TRUE;
3398 consdata->coefsorted =
FALSE;
3433 assert(consdata->nvars == 0 || (consdata->vars !=
NULL && consdata->vals !=
NULL));
3444 consdata->rhs = lhs;
3462 vars = consdata->vars;
3463 vals = consdata->vals;
3465 for( v = 0; v < consdata->nvars; ++v )
3487 vars = consdata->vars;
3488 vals = consdata->vals;
3490 for( v = 0; v < consdata->nvars; ++v )
3510 consdata->boundstightened = 0;
3511 consdata->presolved =
FALSE;
3512 consdata->cliquesadded =
FALSE;
3513 consdata->implsadded =
FALSE;
3523 consdata->lhs = lhs;
3524 consdata->changed =
TRUE;
3525 consdata->normalized =
FALSE;
3526 consdata->upgradetried =
FALSE;
3527 consdata->rangedrowpropagated = 0;
3530 if( consdata->row !=
NULL )
3561 assert(consdata->nvars == 0 || (consdata->vars !=
NULL && consdata->vals !=
NULL));
3572 consdata->lhs = rhs;
3592 vars = consdata->vars;
3593 vals = consdata->vals;
3595 for( v = 0; v < consdata->nvars; ++v )
3617 vars = consdata->vars;
3618 vals = consdata->vals;
3620 for( v = 0; v < consdata->nvars; ++v )
3640 consdata->boundstightened = 0;
3641 consdata->presolved =
FALSE;
3642 consdata->cliquesadded =
FALSE;
3643 consdata->implsadded =
FALSE;
3653 consdata->rhs = rhs;
3654 consdata->changed =
TRUE;
3655 consdata->normalized =
FALSE;
3656 consdata->upgradetried =
FALSE;
3657 consdata->rangedrowpropagated = 0;
3660 if( consdata->row !=
NULL )
3678 SCIP_Bool transformed;
3701 consdata->vars[consdata->nvars] =
var;
3702 consdata->vals[consdata->nvars] = val;
3711 if( consdata->eventdata !=
NULL )
3723 consdata->eventdata[consdata->nvars-1] =
NULL;
3746 consdata->boundstightened = 0;
3747 consdata->presolved =
FALSE;
3750 if( consdata->validsignature )
3753 consdata->changed =
TRUE;
3754 consdata->normalized =
FALSE;
3755 consdata->upgradetried =
FALSE;
3756 consdata->cliquesadded =
FALSE;
3757 consdata->implsadded =
FALSE;
3758 consdata->rangedrowpropagated = 0;
3759 consdata->merged =
FALSE;
3761 if( consdata->nvars == 1 )
3763 consdata->indexsorted =
TRUE;
3764 consdata->coefsorted =
TRUE;
3770 consdata->indexsorted = consdata->indexsorted && (consdataCompVar((
void*)consdata, consdata->nvars-2, consdata->nvars-1) <= 0);
3771 consdata->coefsorted =
FALSE;
3775 consdata->indexsorted =
FALSE;
3776 consdata->coefsorted = consdata->coefsorted && (consdataCompVarProp((
void*)consdata, consdata->nvars-2, consdata->nvars-1) <= 0);
3781 if( consdata->hasnonbinvalid && !consdata->hascontvar )
3787 consdata->hasnonbinvar =
TRUE;
3790 consdata->hascontvar =
TRUE;
3795 if( consdata->row !=
NULL )
3822 var = consdata->vars[pos];
3823 val = consdata->vals[pos];
3845 if( consdata->eventdata !=
NULL )
3853 if( pos != consdata->nvars - 1 )
3855 consdata->vars[pos] = consdata->vars[consdata->nvars-1];
3856 consdata->vals[pos] = consdata->vals[consdata->nvars-1];
3858 if( consdata->eventdata !=
NULL )
3860 consdata->eventdata[pos] = consdata->eventdata[consdata->nvars-1];
3862 consdata->eventdata[pos]->varpos = pos;
3865 consdata->indexsorted = consdata->indexsorted && (pos + 2 >= consdata->nvars);
3866 consdata->coefsorted = consdata->coefsorted && (pos + 2 >= consdata->nvars);
3873 if( consdata->nvars <= 1 )
3888 consdata->boundstightened = 0;
3889 consdata->presolved =
FALSE;
3890 consdata->validsignature =
FALSE;
3891 consdata->changed =
TRUE;
3892 consdata->normalized =
FALSE;
3893 consdata->upgradetried =
FALSE;
3894 consdata->cliquesadded =
FALSE;
3895 consdata->implsadded =
FALSE;
3896 consdata->rangedrowpropagated = 0;
3901 consdata->hasnonbinvalid =
FALSE;
3905 if( consdata->row !=
NULL )
3936 var = consdata->vars[pos];
3939 val = consdata->vals[pos];
3966 consdata->vals[pos] = newval;
3968 if( consdata->coefsorted )
3971 consdata->coefsorted = (consdataCompVarProp((
void*)consdata, pos - 1, pos) <= 0);
3972 if( consdata->coefsorted && pos < consdata->
nvars - 1 )
3973 consdata->coefsorted = (consdataCompVarProp((
void*)consdata, pos, pos + 1) <= 0);
3993 consdata->boundstightened = 0;
3994 consdata->presolved =
FALSE;
3995 consdata->validsignature = consdata->validsignature && (newval * val > 0.0);
3996 consdata->changed =
TRUE;
3997 consdata->normalized =
FALSE;
3998 consdata->upgradetried =
FALSE;
3999 consdata->cliquesadded =
FALSE;
4000 consdata->implsadded =
FALSE;
4001 consdata->rangedrowpropagated = 0;
4016 SCIP_Real absscalar;
4030 SCIPwarningMessage(
scip,
"skipped scaling for linear constraint <%s> to avoid numerical troubles (scalar: %.15g)\n",
4037 for(
i = consdata->nvars - 1;
i >= 0; --
i )
4039 newval = scalar * consdata->vals[
i];
4049 SCIPwarningMessage(
scip,
"coefficient %.15g of variable <%s> in linear constraint <%s> scaled to zero (scalar: %.15g)\n",
4054 consdata->vals[
i] = newval;
4062 lhs = consdata->lhs;
4063 consdata->lhs = -consdata->rhs;
4064 consdata->rhs = -lhs;
4069 newval = absscalar * consdata->lhs;
4077 consdata->lhs = newval;
4081 newval = absscalar * consdata->rhs;
4089 consdata->rhs = newval;
4093 consdata->cliquesadded =
FALSE;
4094 consdata->implsadded =
FALSE;
4119 for(
i = 0;
i < nconss;
i++ )
4124 if( consdata->varsdeleted )
4127 for( v = consdata->nvars - 1; v >= 0; --v )
4134 consdata->varsdeleted =
FALSE;
4163 SCIP_Bool* infeasible
4169 SCIP_Longint nominator;
4170 SCIP_Longint denominator;
4172 SCIP_Longint maxmult;
4175 SCIP_Real maxabsval;
4176 SCIP_Real minabsval;
4178 SCIP_Bool onlyintegral;
4189 *infeasible =
FALSE;
4200 if( consdata->normalized )
4204 vals = consdata->vals;
4205 nvars = consdata->nvars;
4210 consdata->normalized =
TRUE;
4236 scalar = 2.0 / (minabsval + maxabsval);
4243 SCIPdebugMsg(
scip,
"divide linear constraint with %g, because all coefficients are in absolute value the same\n", maxabsval);
4248 vals = consdata->vals;
4249 nvars = consdata->nvars;
4258 consdata->normalized =
TRUE;
4274 if( !consdata->hasnonbinvalid )
4281 if( !consdata->hascontvar )
4327 if( nposcoeffs > nnegcoeffs )
4329 else if( nposcoeffs < nnegcoeffs )
4339 assert(mult == +1 || mult == -1);
4358 for(
i = 0;
i <
nvars && success && scm <= maxmult; ++
i )
4363 success =
SCIPrealToRational(vals[
i], -epsilon, epsilon , maxmult, &nominator, &denominator);
4373 onlyintegral =
TRUE;
4380 onlyintegral =
FALSE;
4386 success = success && (scm <= maxmult || (scm == 1 && onlyintegral));
4387 if( success && scm != 1 )
4394 if( consdata->validmaxabsval )
4396 consdata->maxabsval *=
REALABS((SCIP_Real)scm);
4399 consdata->validmaxabsval =
FALSE;
4405 if( consdata->validminabsval )
4407 consdata->minabsval *=
REALABS((SCIP_Real)scm);
4410 consdata->validminabsval =
FALSE;
4417 vals = consdata->vals;
4418 nvars = consdata->nvars;
4425 if( success &&
nvars >= 1 )
4440 if( !consdata->hascontvar && onlyintegral )
4458 if( consdata->validmaxabsval )
4460 consdata->maxabsval /=
REALABS((SCIP_Real)gcd);
4462 if( consdata->validminabsval )
4464 consdata->minabsval /=
REALABS((SCIP_Real)gcd);
4470 consdata->normalized =
TRUE;
4496 if( consdata->merged )
4502 v = consdata->nvars - 1;
4510 var = consdata->vars[v];
4511 valsum = consdata->vals[v];
4514 while( v >= 1 && consdata->vars[v-1] ==
var )
4518 valsum += consdata->vals[v];
4528 else if( valsum != consdata->vals[v] )
4536 consdata->merged =
TRUE;
4546 SCIP_Bool* infeasible
4555 SCIP_Real* aggrscalars;
4557 SCIP_Real aggrconst;
4565 if( infeasible !=
NULL )
4566 *infeasible =
FALSE;
4571 if( consdata->eventdata ==
NULL )
4587 if( !consdata->removedfixings )
4589 SCIP_Real lhssubtrahend;
4590 SCIP_Real rhssubtrahend;
4597 lhssubtrahend = 0.0;
4598 rhssubtrahend = 0.0;
4604 while( v < consdata->
nvars )
4606 var = consdata->vars[v];
4607 val = consdata->vals[v];
4629 if( ( val > 0.0 ) != ( fixedval > 0.0 ) )
4633 if( infeasible !=
NULL )
4645 lhssubtrahend += val * fixedval;
4652 if( ( val > 0.0 ) == ( fixedval > 0.0 ) )
4656 if( infeasible !=
NULL )
4668 rhssubtrahend += val * fixedval;
4684 if( activeconstant != 0.0 )
4687 lhssubtrahend += val * activeconstant;
4689 rhssubtrahend += val * activeconstant;
4702 for(
i = 0;
i < naggrvars; ++
i )
4707 if( aggrconst != 0.0 )
4710 lhssubtrahend += val * aggrconst;
4712 rhssubtrahend += val * aggrconst;
4723 lhssubtrahend += val * aggrconst;
4725 rhssubtrahend += val * aggrconst;
4746 if( infeasible !=
NULL )
4778 if( infeasible !=
NULL )
4801 consdata->removedfixings =
TRUE;
4814 assert(consdata->removedfixings);
4818 for( v = 0; v < consdata->nvars; ++v )
4837 SCIP_Bool reasonisrhs
4853 vars = consdata->vars;
4854 vals = consdata->vals;
4855 nvars = consdata->nvars;
4861 assert((infervar ==
NULL) == (inferpos == -1));
4862 assert(inferpos == -1 ||
vars[inferpos] == infervar);
4873 SCIP_Real minresactivity;
4874 SCIP_Real maxresactivity;
4875 SCIP_Bool ismintight;
4876 SCIP_Bool ismaxtight;
4877 SCIP_Bool isminsettoinfinity;
4878 SCIP_Bool ismaxsettoinfinity;
4884 if( infervar !=
NULL )
4889 &ismintight,
NULL, &isminsettoinfinity,
NULL);
4892 NULL, &ismaxtight,
NULL, &ismaxsettoinfinity);
4898 &ismintight,
NULL, &isminsettoinfinity,
NULL);
4901 NULL, &ismaxtight,
NULL, &ismaxsettoinfinity);
4905 if( (reasonisrhs && !isminsettoinfinity && ismintight) || (!reasonisrhs && !ismaxsettoinfinity && ismaxtight) )
4908 SCIP_Bool resactisinf;
4910 resactisinf =
FALSE;
4915 if( infervar !=
NULL )
4927 rescap = consdata->rhs - minresactivity;
4937 rescap = consdata->lhs - maxresactivity;
4940 if( reasonisrhs == (vals[inferpos] > 0.0) )
4946 rescap = (reasonisrhs ? consdata->rhs - minresactivity : consdata->lhs - maxresactivity);
4965 if( reasonisrhs == (vals[
i] > 0.0) )
4993 if( reasonisrhs == (vals[
i] > 0.0) )
5031 vars = consdata->vars;
5032 nvars = consdata->nvars;
5035 assert((infervar ==
NULL) == (inferpos == -1));
5037 assert(inferpos == -1 ||
vars[inferpos] == infervar);
5040 for( v =
nvars - 1; v >= 0; --v )
5045 if(
vars[v] == infervar )
5091 for( v =
nvars - 1; v >= 0; --v )
5153 vars = consdata->vars;
5154 nvars = consdata->nvars;
5156 vals = consdata->vals;
5163 if( inferpos >=
nvars ||
vars[inferpos] != infervar )
5167 for( inferpos = 0; inferpos <
nvars &&
vars[inferpos] != infervar; ++inferpos )
5209 SCIPerrorMessage(
"invalid inference information %d in linear constraint <%s> at position %d for %s bound of variable <%s>\n",
5225 SCIP_Bool reasonisrhs
5257 infcountmin = consdata->minactivityneginf
5258 + consdata->minactivityposinf
5259 + consdata->minactivityneghuge
5260 + consdata->minactivityposhuge;
5261 infcountmax = consdata->maxactivityneginf
5262 + consdata->maxactivityposinf
5263 + consdata->maxactivityneghuge
5264 + consdata->maxactivityposhuge;
5266 if( infcountmin > 1 && infcountmax > 1 )
5289 SCIP_Bool infeasible;
5290 SCIP_Bool tightened;
5297 var = consdata->vars[pos];
5307 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newub=%.15g\n",
5309 QUAD_TO_DBL(consdata->minactivity),
QUAD_TO_DBL(consdata->maxactivity), consdata->lhs, consdata->rhs, newub);
5318 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5326 else if( tightened )
5329 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
5336 consdata->upgradetried =
FALSE;
5359 SCIP_Bool infeasible;
5360 SCIP_Bool tightened;
5367 var = consdata->vars[pos];
5377 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
5379 QUAD_TO_DBL(consdata->minactivity),
QUAD_TO_DBL(consdata->maxactivity), consdata->lhs, consdata->rhs, newlb);
5388 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5396 else if( tightened )
5399 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
5406 consdata->upgradetried =
FALSE;
5446 var = consdata->vars[pos];
5453 val = consdata->vals[pos];
5454 lhs = consdata->lhs;
5455 rhs = consdata->rhs;
5465 if( !consdata->validactivities )
5467 assert(consdata->validactivities);
5468 if( !consdata->validminact )
5470 assert(consdata->validminact);
5481 assert(consdata->validminact);
5486 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, minactivity=%.15g > rhs=%.15g\n",
5501 alpha = val * (ub - lb);
5509 newub = lb + (slack / val);
5515 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5533 if( !consdata->validmaxact )
5537 assert(consdata->validmaxact);
5542 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, maxactivity=%.15g < lhs=%.15g\n",
5557 alpha = val * (ub - lb);
5565 newlb = ub - (slack / val);
5571 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5588 assert(consdata->validminact);
5593 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, minactivity=%.15g > rhs=%.15g\n",
5608 alpha = val * (lb - ub);
5616 newlb = ub + slack / val;
5622 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5639 if( !consdata->validmaxact )
5643 assert(consdata->validmaxact);
5648 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, maxactivity=%.15g < lhs=%.15g\n",
5663 alpha = val * (lb - ub);
5671 newub = lb - (slack / val);
5677 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5762 SCIP_Real* infcheckvals;
5763 SCIP_Real minactinfvars;
5764 SCIP_Real maxactinfvars;
5771 SCIP_Real absminbincoef;
5773 SCIP_Longint gcdtmp;
5774 SCIP_Bool minactinfvarsinvalid;
5775 SCIP_Bool maxactinfvarsinvalid;
5776 SCIP_Bool possiblegcd;
5778 SCIP_Bool addartconss;
5801 if( consdata->rangedrowpropagated == 2 )
5805 if( consdata->nvars < 3 )
5822 consdata->rangedrowpropagated = 2;
5829 if( consdata->rangedrowpropagated > 0 )
5832 consdata->rangedrowpropagated = 1;
5837 for( v = consdata->nvars - 1; v >= 0; --v )
5855 lhs = consdata->lhs - fixedact;
5856 rhs = consdata->rhs - fixedact;
5857 nunfixedvars = consdata->nvars - nfixedconsvars;
5902 absval =
REALABS(consdata->vals[v]);
5904 if( absminbincoef > absval )
5905 absminbincoef = absval;
5909 possiblegcd =
FALSE;
5910 infcheckvars[ninfcheckvars] = consdata->vars[v];
5911 infcheckvals[ninfcheckvars] = consdata->vals[v];
5927 if( v == consdata->nvars )
5931 if( ncontvars + 2 > nunfixedvars )
5944 for( ; v < consdata->nvars; ++v )
5953 absval =
REALABS(consdata->vals[v]);
5955 if( absminbincoef > absval )
5956 absminbincoef = absval;
5966 possiblegcd =
FALSE;
5967 infcheckvars[ninfcheckvars] = consdata->vars[v];
5968 infcheckvals[ninfcheckvars] = consdata->vals[v];
5984 infcheckvars[ninfcheckvars] = consdata->vars[v];
5985 infcheckvals[ninfcheckvars] = consdata->vals[v];
6000 if( ninfcheckvars == 0 )
6005 minactinfvarsinvalid =
FALSE;
6006 maxactinfvarsinvalid =
FALSE;
6007 maxactinfvars = 0.0;
6008 minactinfvars = 0.0;
6011 for( v = ninfcheckvars - 1; v >= 0; --v )
6018 if( infcheckvals[v] < 0.0 )
6019 maxactinfvarsinvalid =
TRUE;
6021 minactinfvarsinvalid =
TRUE;
6025 if( infcheckvals[v] < 0.0 )
6026 maxactinfvars += infcheckvals[v] * lb;
6028 minactinfvars += infcheckvals[v] * lb;
6033 if( infcheckvals[v] > 0.0 )
6034 maxactinfvarsinvalid =
TRUE;
6036 minactinfvarsinvalid =
TRUE;
6040 if( infcheckvals[v] > 0.0 )
6041 maxactinfvars += infcheckvals[v] * ub;
6043 minactinfvars += infcheckvals[v] * ub;
6048 minactinfvarsinvalid =
TRUE;
6050 maxactinfvarsinvalid =
TRUE;
6052 if( minactinfvarsinvalid || maxactinfvarsinvalid )
6055 assert(!minactinfvarsinvalid && !maxactinfvarsinvalid);
6057 SCIPdebugMsg(
scip,
"minactinfvarsinvalid = %u, minactinfvars = %g, maxactinfvarsinvalid = %u, maxactinfvars = %g, gcd = %lld, ninfcheckvars = %d, ncontvars = %d\n",
6058 minactinfvarsinvalid, minactinfvars, maxactinfvarsinvalid, maxactinfvars, gcd, ninfcheckvars, ncontvars);
6083 else if( ncontvars == 0 )
6085 SCIP_Longint gcdinfvars = -1;
6090 v = ninfcheckvars - 1;
6094 for( ; v >= 0 && gcdinfvars >= 2; --v )
6102 SCIPdebugMsg(
scip,
"gcdinfvars =%lld, possiblegcd = %u\n", gcdinfvars, possiblegcd);
6105 if( gcdinfvars >= 1 )
6118 value2 = value + gcd * (
SCIPceil(
scip, (lhs - value) / gcd));
6139 value += gcdinfvars;
6141 assert(nsols < 2 || minvalue <= maxvalue);
6147 SCIP_Real secondsolval = maxvalue;
6154 value2 = value + gcd * (
SCIPfloor(
scip, (rhs - value) / gcd));
6165 assert(maxvalue > minvalue);
6168 value -= gcdinfvars;
6170 assert(maxvalue > secondsolval);
6173 SCIPdebugMsg(
scip,
"here nsols %s %d, minsolvalue = %g, maxsolvalue = %g, ninfcheckvars = %d, nunfixedvars = %d\n",
6174 nsols > 2 ?
">=" :
"=", nsols, minvalue, maxvalue, ninfcheckvars, nunfixedvars);
6179 SCIPdebugMsg(
scip,
"gcdinfvars = %lld, gcd = %lld, correctedlhs = %g, correctedrhs = %g\n",
6180 gcdinfvars, gcd, lhs, rhs);
6191 else if( nsols == 1 )
6193 assert(minvalue == maxvalue);
6196 if( ninfcheckvars == 1 )
6202 SCIPdebugMsg(
scip,
"fixing single variable <%s> with bounds [%.15g,%.15g] to %.15g\n",
6223 if( ninfcheckvars == nunfixedvars - 1 )
6226 SCIP_Bool foundvar =
FALSE;
6230 assert(ninfcheckvars > 0);
6233 for( v = 0; v < consdata->nvars - 1; ++v )
6237 if(
w >= ninfcheckvars || consdata->vars[v] != infcheckvars[
w] )
6243 assert((nfixedconsvars == 0) ? (consdata->nvars - v - 1 == ninfcheckvars -
w) :
TRUE);
6245 for( ; v2 < consdata->nvars && w2 < ninfcheckvars; ++v2 )
6250 assert(consdata->vars[v2] == infcheckvars[w2]);
6253 assert(w2 == ninfcheckvars);
6259 if( consdata->vals[v] < 0 )
6268 SCIPdebugMsg(
scip,
"fixing variable <%s> with bounds [%.15g,%.15g] to %.15g\n",
6281 consdata->vars[v],
bound) );
6297 assert(v == consdata->nvars - 1);
6300 if( consdata->vals[v] < 0 )
6309 SCIPdebugMsg(
scip,
"fixing variable <%s> with bounds [%.15g,%.15g] to %.15g\n",
6322 consdata->vars[v],
bound) );
6337 ++conshdlrdata->naddconss;
6342 maxvalue, maxvalue,
TRUE,
TRUE,
TRUE,
FALSE,
TRUE,
TRUE,
FALSE,
FALSE,
TRUE,
FALSE) );
6359 if( ninfcheckvars == 1 )
6361 SCIP_Bool tightened;
6367 if( infcheckvals[0] < 0 )
6369 newlb = maxvalue/infcheckvals[0];
6370 newub = minvalue/infcheckvals[0];
6374 newlb = minvalue/infcheckvals[0];
6375 newub = maxvalue/infcheckvals[0];
6382 SCIPdebugMsg(
scip,
"tightening lower bound of variable <%s> from %g to %g\n",
6403 SCIPdebugMsg(
scip,
"tightening upper bound of variable <%s> from %g to %g\n",
6422 else if( ninfcheckvars == nunfixedvars - 1 )
6424 SCIP_Bool foundvar =
FALSE;
6425 SCIP_Bool tightened;
6430 assert(ninfcheckvars > 0);
6431 assert(minvalue < maxvalue);
6434 for( v = 0; v < consdata->nvars - 1; ++v )
6438 if(
w >= ninfcheckvars || consdata->vars[v] != infcheckvars[
w] )
6444 assert((nfixedconsvars == 0) ? (consdata->nvars - v - 1 == ninfcheckvars -
w) :
TRUE);
6446 for( ; v2 < consdata->nvars && w2 < ninfcheckvars; ++v2 )
6451 assert(consdata->vars[v2] == infcheckvars[w2]);
6454 assert(w2 == ninfcheckvars);
6460 if( consdata->vals[v] < 0 )
6462 newlb =
SCIPfloor(
scip, (rhs - minvalue) / consdata->vals[v]);
6463 newub =
SCIPfloor(
scip, (lhs - maxvalue) / consdata->vals[v]);
6467 newlb =
SCIPceil(
scip, (lhs - maxvalue) / consdata->vals[v]);
6468 newub =
SCIPceil(
scip, (rhs - minvalue) / consdata->vals[v]);
6475 SCIPdebugMsg(
scip,
"tightening lower bound of variable <%s> from %g to %g\n",
6487 consdata->vars[v], newlb) );
6497 SCIPdebugMsg(
scip,
"tightening upper bound of variable <%s> from %g to %g\n",
6509 consdata->vars[v], newub) );
6526 assert(v == consdata->nvars - 1);
6529 if( consdata->vals[v] < 0 )
6531 newlb =
SCIPfloor(
scip, (rhs - minvalue) / consdata->vals[v]);
6532 newub =
SCIPfloor(
scip, (lhs - maxvalue) / consdata->vals[v]);
6536 newlb =
SCIPceil(
scip, (lhs - maxvalue) / consdata->vals[v]);
6537 newub =
SCIPceil(
scip, (rhs - minvalue) / consdata->vals[v]);
6544 SCIPdebugMsg(
scip,
"tightening lower bound of variable <%s> from %g to %g\n",
6565 SCIPdebugMsg(
scip,
"tightening upper bound of variable <%s> from %g to %g\n",
6594 assert(maxvalue > minvalue);
6610 ++conshdlrdata->naddconss;
6629 else if( addartconss && ncontvars < ninfcheckvars )
6631 SCIP_Real maxact = 0.0;
6632 SCIP_Real minact = 0.0;
6636 for( v = 0; v < consdata->nvars; ++v )
6648 if( consdata->vals[v] > 0.0 )
6649 maxact += consdata->vals[v];
6651 minact += consdata->vals[v];
6659 if( consdata->vals[v] > 0.0 )
6704 newlhs = lhs - maxact;
6705 newrhs = rhs - minact;
6710 ++conshdlrdata->naddconss;
6748 SCIP_Real minresactivity;
6749 SCIP_Real maxresactivity;
6752 SCIP_Bool infeasible;
6753 SCIP_Bool tightened;
6754 SCIP_Bool ismintight;
6755 SCIP_Bool ismaxtight;
6756 SCIP_Bool isminsettoinfinity;
6757 SCIP_Bool ismaxsettoinfinity;
6774 var = consdata->vars[pos];
6780 val = consdata->vals[pos];
6781 lhs = consdata->lhs;
6782 rhs = consdata->rhs;
6784 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
6801 newub = (rhs - minresactivity)/val;
6806 SCIP_Bool activityunreliable;
6810 if( activityunreliable )
6813 newub = (rhs - minresactivity)/val;
6819 if( !activityunreliable )
6822 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newub=%.15g\n",
6825 &infeasible, &tightened) );
6828 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6843 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
6854 newlb = (lhs - maxresactivity)/val;
6862 newlb = (lhs - maxresactivity)/val;
6871 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
6874 &infeasible, &tightened) );
6877 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6891 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
6904 newlb = (rhs - minresactivity)/val;
6908 SCIP_Bool activityunreliable;
6911 if( activityunreliable )
6914 newlb = (rhs - minresactivity)/val;
6921 if( !activityunreliable )
6924 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
6927 &infeasible, &tightened) );
6930 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6944 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
6955 newub = (lhs - maxresactivity)/val;
6963 newub = (lhs - maxresactivity)/val;
6972 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g], newub=%.15g\n",
6975 &infeasible, &tightened) );
6978 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6992 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
7002#define MAXTIGHTENROUNDS 10
7009 SCIP_Real maxeasyactivitydelta,
7016 unsigned int tightenmode;
7022 int oldnchgbdstotal;
7054 nvars = consdata->nvars;
7064 if( !force && (consdata->boundstightened >= tightenmode) )
7071 assert(consdata->coefsorted);
7090 SCIP_Real minactivity;
7091 SCIP_Real maxactivity;
7092 SCIP_Bool ismintight;
7093 SCIP_Bool ismaxtight;
7094 SCIP_Bool isminsettoinfinity;
7095 SCIP_Bool ismaxsettoinfinity;
7099 &isminsettoinfinity, &ismaxsettoinfinity);
7112 easycase =
SCIPisLT(
scip, consdata->maxactdelta, maxeasyactivitydelta);
7119 oldnchgbdstotal = *nchgbds;
7122 for( nrounds = 0; (force || consdata->boundstightened < tightenmode) && nrounds <
MAXTIGHTENROUNDS; ++nrounds )
7131 assert(consdata->coefsorted);
7135 consdata->boundstightened = (
unsigned int)tightenmode;
7141 while( v <
nvars && v != lastchange && !(*
cutoff) )
7143 oldnchgbds = *nchgbds;
7155 if( *nchgbds > oldnchgbds )
7160 else if( consdata->coefsorted && v < consdata->
nbinvars - 1
7162 v = consdata->nbinvars;
7169 *nchgbds - oldnchgbdstotal, nrounds);
7170 oldnchgbdstotal += oldnchgbds;
7175 if( force &&
SCIPisEQ(
scip, consdata->lhs, consdata->rhs) )
7188 SCIP_Bool checklprows,
7189 SCIP_Bool checkrelmaxabs,
7213 if( consdata->row !=
NULL )
7225 SCIPdebugMsg(
scip,
" consdata activity=%.15g (lhs=%.15g, rhs=%.15g, row=%p, checklprows=%u, rowinlp=%u, sol=%p, hascurrentnodelp=%u)\n",
7226 activity, consdata->lhs, consdata->rhs, (
void*)consdata->row, checklprows,
7231 lhsviol = consdata->lhs - activity;
7232 rhsviol = activity - consdata->rhs;
7236 if( (lhsviol > 0) && (lhsviol > rhsviol) )
7241 else if( rhsviol > 0 )
7266 if( !checkrelmaxabs )
7290 for( v = 0; v < consdata->nvars; ++v )
7292 if( consdata->vals !=
NULL )
7294 coef = consdata->vals[v];
7300 absval =
REALABS( coef * solval );
7301 maxabs =
MAX( maxabs, absval );
7308 if( (consdata->lhs - activity) <= (1e-15 * maxabs) )
7310 SCIPdebugMsg(
scip,
" lhs violated due to random noise: violation=%16.9g, maxabs=%16.9g\n",
7311 consdata->lhs - activity, maxabs);
7325 SCIPdebugMsg(
scip,
" lhs violated absolutely (violation=%16.9g), but feasible when using relative tolerance w.r.t. maximum absolute value (%16.9g)\n",
7326 consdata->lhs - activity, maxabs);
7362 if( (activity - consdata->rhs) <= (1e-15 * maxabs) )
7364 SCIPdebugMsg(
scip,
" rhs violated due to random noise: violation=%16.9g, maxabs=%16.9g\n",
7365 activity - consdata->rhs, maxabs);
7379 SCIPdebugMsg(
scip,
" rhs violated absolutely (violation=%16.9g), but feasible when using relative tolerance w.r.t. maximum absolute value (%16.9g)\n",
7380 activity - consdata->rhs, maxabs);
7414 else if( consdata->checkabsolute &&
7482 if( consdata->row ==
NULL )
7499 if( consdata->nvars == 0 )
7521 assert( pr == 0 || cr == 0 );
7547 if( consdata->nlrow ==
NULL )
7549 assert(consdata->lhs <= consdata->rhs);
7572 SCIP_Bool separatecards,
7573 SCIP_Bool separateall,
7606 if( !separateall &&
sol ==
NULL )
7619 consdata->vals, +1.0, consdata->rhs,
sol,
cutoff, ncuts) );
7627 consdata->vals, -1.0, -consdata->lhs,
sol,
cutoff, ncuts) );
7637 consdata->vals, +1.0, consdata->rhs,
sol,
cutoff, ncuts) );
7642 consdata->vals, -1.0, -consdata->lhs,
sol,
cutoff, ncuts) );
7647 if( *ncuts > oldncuts )
7660 SCIP_Bool tightenbounds,
7661 SCIP_Bool rangedrowpropagation,
7662 SCIP_Real maxeasyactivitydelta,
7669 SCIP_Real minactivity;
7670 SCIP_Real maxactivity;
7671 SCIP_Bool isminacttight;
7672 SCIP_Bool ismaxacttight;
7673 SCIP_Bool isminsettoinfinity;
7674 SCIP_Bool ismaxsettoinfinity;
7686 if( consdata->eventdata ==
NULL )
7718 oldnchgbds = *nchgbds;
7722 if( *nchgbds > oldnchgbds )
7729 if( rangedrowpropagation && tightenbounds && !(*
cutoff) )
7749 if( nfixedvars > 0 )
7750 *nchgbds += 2*nfixedvars;
7757 &isminsettoinfinity, &ismaxsettoinfinity);
7761 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible (rhs): activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7762 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7772 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible (lhs): activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7773 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7783 SCIPdebugMsg(
scip,
"linear constraint <%s> is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7784 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7787 if( consdata->nvars > 0 )
7818 SCIP_Bool infeasible;
7829 for( v = 0; v < consdata->nvars; ++v )
7832 var = consdata->vars[v];
7844 SCIPdebugMsg(
scip,
"converting variable <%s> with fixed bounds [%.15g,%.15g] into fixed variable fixed at %.15g\n",
7868 assert(consdata->removedfixings);
7873#define MAX_CLIQUE_NONZEROS_PER_CONS 1000000
7943 SCIP_Real maxeasyactivitydelta,
7953 SCIP_Bool lhsclique;
7954 SCIP_Bool rhsclique;
7955 SCIP_Bool finitelhs;
7956 SCIP_Bool finiterhs;
7957 SCIP_Bool finiteminact;
7958 SCIP_Bool finitemaxact;
7959 SCIP_Bool finitenegminact;
7960 SCIP_Bool finitenegmaxact;
7961 SCIP_Bool finiteposminact;
7962 SCIP_Bool finiteposmaxact;
7963 SCIP_Bool infeasible;
7965 int cliquenonzerosadded;
7982 if( consdata->nvars < 2 )
7991 if( !consdata->implsadded )
8009 nvars = consdata->nvars;
8010 vars = consdata->vars;
8011 vals = consdata->vals;
8014 if( !consdata->validactivities )
8016 assert(consdata->validactivities);
8020 finitenegminact = (consdata->glbminactivityneginf == 0 && consdata->glbminactivityneghuge == 0);
8021 finitenegmaxact = (consdata->glbmaxactivityneginf == 0 && consdata->maxactivityneghuge == 0);
8022 finiteposminact = (consdata->glbminactivityposinf == 0 && consdata->glbminactivityposhuge == 0);
8023 finiteposmaxact = (consdata->glbmaxactivityposinf == 0 && consdata->glbmaxactivityposhuge == 0);
8024 finiteminact = (finitenegminact && finiteposminact);
8025 finitemaxact = (finitenegmaxact && finiteposmaxact);
8027 if( (finiterhs || finitelhs) && (finitenegminact || finiteposminact || finitenegmaxact || finiteposmaxact) )
8029 SCIP_Real maxabscontrib = -1.0;
8030 SCIP_Bool posval =
FALSE;
8031 SCIP_Bool allbinary =
TRUE;
8032 int oldnchgbds = *nchgbds;
8038 if( (finitenegminact || finiteposminact) && !consdata->validglbminact )
8041 assert(consdata->validglbminact);
8044 if( (finitenegmaxact || finiteposmaxact) && !consdata->validglbmaxact )
8047 assert(consdata->validglbmaxact);
8049 assert(consdata->validglbminact || consdata->validglbmaxact);
8054 for( v =
nvars - 1; v >= 0; --v )
8062 if( value > maxabscontrib )
8064 maxabscontrib = value;
8075 if( value > maxabscontrib )
8077 maxabscontrib = value;
8088 if( !
SCIPisEQ(
scip, maxabscontrib, 1.0) && !allbinary )
8094 if( finiterhs && finiteminact &&
SCIPisEQ(
scip,
QUAD_TO_DBL(consdata->glbminactivity), consdata->rhs - maxabscontrib) )
8096 for( v =
nvars - 1; v >= 0; --v )
8108 *nchgbds += nbdchgs;
8115 *nchgbds += nbdchgs;
8135 if( finitelhs && finitemaxact &&
SCIPisEQ(
scip,
QUAD_TO_DBL(consdata->glbmaxactivity), consdata->lhs - maxabscontrib) )
8137 for( v =
nvars - 1; v >= 0; --v )
8149 *nchgbds += nbdchgs;
8156 *nchgbds += nbdchgs;
8175 SCIPdebugMsg(
scip,
"extracted %d implications from constraint %s which led to %d bound changes, %scutoff detetcted\n", nimpls,
SCIPconsGetName(cons), *nchgbds - oldnchgbds, *
cutoff ?
"" :
"no ");
8181 if( *nchgbds - oldnchgbds > 0 )
8202 consdata->implsadded =
TRUE;
8206 if( consdata->cliquesadded )
8209 consdata->cliquesadded =
TRUE;
8210 cliquenonzerosadded = 0;
8216 nvars = consdata->nvars;
8217 vars = consdata->vars;
8218 vals = consdata->vals;
8223 if( !consdata->validactivities )
8225 assert(consdata->validactivities);
8229 finitenegminact = (consdata->glbminactivityneginf == 0 && consdata->glbminactivityneghuge == 0);
8230 finitenegmaxact = (consdata->glbmaxactivityneginf == 0 && consdata->maxactivityneghuge == 0);
8231 finiteposminact = (consdata->glbminactivityposinf == 0 && consdata->glbminactivityposhuge == 0);
8232 finiteposmaxact = (consdata->glbmaxactivityposinf == 0 && consdata->glbmaxactivityposhuge == 0);
8233 finiteminact = (finitenegminact && finiteposminact);
8234 finitemaxact = (finitenegmaxact && finiteposmaxact);
8239 if( (finiterhs || finitelhs) && (finitenegminact || finiteposminact || finitenegmaxact || finiteposmaxact) )
8242 SCIP_Real* binvarvals;
8243 int nposbinvars = 0;
8244 int nnegbinvars = 0;
8245 int allonebinary = 0;
8260 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8261 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8279 if( allonebinary <
nvars && (nposbinvars >= 2 || nnegbinvars >= 2) )
8281 SCIP_Real threshold;
8282 int oldnchgbds = *nchgbds;
8288 if( (finitenegminact || finiteposminact) && !consdata->validglbminact )
8291 assert(consdata->validglbminact);
8294 if( (finitenegmaxact || finiteposmaxact) && !consdata->validglbmaxact )
8297 assert(consdata->validglbmaxact);
8299 assert(consdata->validglbminact || consdata->validglbmaxact);
8305 if( finiterhs && finitenegminact && nposbinvars >= 2 )
8308 threshold = consdata->rhs -
QUAD_TO_DBL(consdata->glbminactivity);
8311#ifdef SCIP_DISABLED_CODE
8320 while( j < nposbinvars )
8334 *nchgbds += nbdchgs;
8336 cliquenonzerosadded += j;
8341 if( !stopped && !(*
cutoff) && j < nposbinvars )
8344 int lastfit = j - 2;
8351 while( lastfit >= 0 && j < nposbinvars )
8356 clqvars[lastfit + 1] = binvars[j];
8367 *nchgbds += nbdchgs;
8369 cliquenonzerosadded += (lastfit + 2);
8388 if( !stopped && !*
cutoff && *nchgbds - oldnchgbds > 0 )
8409 if( !consdata->validactivities )
8411 assert(consdata->validactivities);
8413 nvars = consdata->nvars;
8414 vars = consdata->vars;
8415 vals = consdata->vals;
8430 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8431 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8449 oldnchgbds = *nchgbds;
8453 if( !stopped && !(*
cutoff) && finitelhs && finiteposmaxact && nnegbinvars >= 2 )
8456 threshold = consdata->lhs -
QUAD_TO_DBL(consdata->glbmaxactivity);
8458 i = nposbinvars + nnegbinvars - 1;
8469 while( j >= nposbinvars )
8484 *nchgbds += nbdchgs;
8486 cliquenonzerosadded += (
i - j);
8491 if( !stopped && !(*
cutoff) && jstart >= nposbinvars )
8494 int lastfit = jstart + 1;
8502 while( lastfit <= i && j >= nposbinvars )
8507 assert(lastfit - jstart - 2 >= 0 && lastfit - jstart - 2 <
i);
8508 clqvars[lastfit - jstart - 2] = binvars[j];
8520 *nchgbds += nbdchgs;
8522 cliquenonzerosadded += (
i - lastfit + 2);
8541 if( !stopped && !*
cutoff && *nchgbds - oldnchgbds > 0 )
8562 if( !consdata->validactivities )
8564 assert(consdata->validactivities);
8566 nvars = consdata->nvars;
8567 vars = consdata->vars;
8568 vals = consdata->vals;
8583 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8584 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8602 oldnchgbds = *nchgbds;
8606 if( !(*
cutoff) && finiterhs && finiteminact && nnegbinvars >= 2 )
8615 threshold = consdata->rhs -
QUAD_TO_DBL(consdata->glbminactivity);
8617 i = nposbinvars + nnegbinvars - 1;
8629 while( j >= nposbinvars )
8644 *nchgbds += nbdchgs;
8646 cliquenonzerosadded += (
i - j);
8651 if( !stopped && !(*
cutoff) && jstart >= nposbinvars )
8654 int lastfit = j + 1;
8662 while( lastfit <= i && j >= nposbinvars )
8667 assert(lastfit - jstart - 2 >= 0 && lastfit - jstart - 2 <
i);
8668 clqvars[lastfit - jstart - 2] = binvars[j];
8680 *nchgbds += nbdchgs;
8682 cliquenonzerosadded += (
i - lastfit + 2);
8703 if( !stopped && !*
cutoff && *nchgbds - oldnchgbds > 0 )
8724 if( !consdata->validactivities )
8726 assert(consdata->validactivities);
8728 nvars = consdata->nvars;
8729 vars = consdata->vars;
8730 vals = consdata->vals;
8745 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8746 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8766 if( !stopped && !(*
cutoff) && finitelhs && finitemaxact && nposbinvars >= 2 )
8775 threshold = consdata->lhs -
QUAD_TO_DBL(consdata->glbmaxactivity);
8788 while( j < nposbinvars )
8802 *nchgbds += nbdchgs;
8804 cliquenonzerosadded += j;
8809 if( !stopped && !(*
cutoff) && j < nposbinvars )
8812 int lastfit = j - 2;
8819 while( lastfit >= 0 && j < nposbinvars )
8824 clqvars[lastfit + 1] = binvars[j];
8835 *nchgbds += nbdchgs;
8837 cliquenonzerosadded += lastfit + 2;
8881 lhsclique =
SCIPisEQ(
scip, consdata->lhs, (SCIP_Real)nposcoefs - 1.0);
8882 rhsclique =
SCIPisEQ(
scip, consdata->rhs, 1.0 - (SCIP_Real)nnegcoefs);
8884 if( lhsclique || rhsclique )
8889 SCIPdebugMsg(
scip,
"linear constraint <%s>: adding clique with %d vars (%d pos, %d neg)\n",
8894 values[
i] = (rhsclique == (vals[
i] > 0.0));
8901 *nchgbds += nbdchgs;
8914 SCIP_Bool* infeasible
8933 *infeasible =
FALSE;
8943 for(
i = 0;
i < consdata->nvars && integral; ++
i )
8964 SCIPdebugMsg(
scip,
"rounding sides=[%.15g,%.15g] of linear constraint <%s> with integral coefficients and variables only "
8965 "is infeasible\n", consdata->lhs, consdata->rhs,
SCIPconsGetName(cons));
8971 SCIPdebugMsg(
scip,
"linear constraint <%s>: make sides integral: sides=[%.15g,%.15g]\n",
8979 if( !consdata->upgraded )
8987 if( !consdata->upgraded )
8990 SCIPdebugMsg(
scip,
"linear constraint <%s>: new integral sides: sides=[%.15g,%.15g]\n",
9041 SCIP_Bool* isvarrelevant;
9042 SCIP_Real minactivity;
9044 SCIP_Real maxactivity;
9046 SCIP_Bool isminacttight;
9047 SCIP_Bool ismaxacttight;
9048 SCIP_Bool isminsettoinfinity;
9049 SCIP_Bool ismaxsettoinfinity;
9050 SCIP_Real minleftactivity;
9051 SCIP_Real maxleftactivity;
9077 if( (consdata->validmaxabsval && consdata->maxabsval >
MAXVALRECOMP)
9078 || (consdata->validminabsval && consdata->minabsval <
MINVALRECOMP) )
9086 &isminsettoinfinity, &ismaxsettoinfinity);
9092 minleftactivity = 0.0;
9093 maxleftactivity = 0.0;
9100 var = consdata->vars[
i];
9101 val = consdata->vals[
i];
9113 if( isvarrelevant[
i] )
9121 lval = consdata->lhs - minactivity;
9122 rval = maxactivity - consdata->rhs;
9125 if( consdata->nvars == 2 )
9128 otherval = consdata->vals[1-
i];
9132 lval = consdata->lhs - val*lb;
9138 rval = val*ub - consdata->rhs;
9143 newval =
MAX3(lval, rval, 0.0);
9147 newlhs = consdata->lhs - val * lb;
9148 newlhs += newval * lb;
9149 newrhs = consdata->rhs - val * ub;
9150 newrhs += newval * ub;
9154 SCIPdebugMsg(
scip,
"linear constraint <%s>: change coefficient %+.15g<%s> to %+.15g<%s>, act=[%.15g,%.15g], side=[%.15g,%.15g]\n",
9156 maxactivity, consdata->lhs, consdata->rhs);
9172 &ismaxacttight, &isminsettoinfinity, &ismaxsettoinfinity);
9177 consdata->lhs, newlhs);
9187 consdata->rhs, newrhs);
9204 minleftactivity += val * lb;
9214 maxleftactivity += val * ub;
9224 if( isvarrelevant[
i] )
9232 lval = minactivity - consdata->lhs;
9233 rval = consdata->rhs - maxactivity;
9236 if( consdata->nvars == 2 )
9239 otherval = consdata->vals[1-
i];
9243 lval = val*ub - consdata->lhs;
9249 rval = consdata->rhs - val*lb;
9254 newval =
MIN3(lval, rval, 0.0);
9258 newlhs = consdata->lhs - val * ub;
9259 newlhs += newval * ub;
9260 newrhs = consdata->rhs - val * lb;
9261 newrhs += newval * lb;
9265 SCIPdebugMsg(
scip,
"linear constraint <%s>: change coefficient %+.15g<%s> to %+.15g<%s>, act=[%.15g,%.15g], side=[%.15g,%.15g]\n",
9267 maxactivity, consdata->lhs, consdata->rhs);
9283 &ismaxacttight, &isminsettoinfinity, &ismaxsettoinfinity);
9288 consdata->lhs, newlhs);
9298 consdata->rhs, newrhs);
9315 minleftactivity += val * ub;
9325 maxleftactivity += val * lb;
9334 minleftactivity, consdata->rhs);
9336 maxleftactivity, consdata->lhs);
9363 aggrlhs = consdata->lhs - minactivity + minleftactivity;
9364 aggrrhs = consdata->rhs - maxactivity + maxleftactivity;
9374 SCIP_Real minleftactivitypart;
9375 SCIP_Real maxleftactivitypart;
9384 if( !isvarrelevant[
i] )
9387 var = consdata->vars[
i];
9388 val = consdata->vals[
i];
9393 SCIPdebugMsg(
scip,
"val = %g\tlhs = %g\trhs = %g\n", val, consdata->lhs, consdata->rhs);
9394 SCIPdebugMsg(
scip,
"linear constraint <%s>: remove variable <%s> from constraint since it is redundant\n",
9400 minleftactivitypart = val * lb;
9401 maxleftactivitypart = val * ub;
9405 minleftactivitypart = val * ub;
9406 maxleftactivitypart = val * lb;
9410 isvarrelevant[
i] = isvarrelevant[consdata->nvars - 1];
9415 newlhs = consdata->lhs - minleftactivitypart;
9416 newrhs = consdata->rhs - maxleftactivitypart;
9421 consdata->lhs, newlhs);
9431 consdata->rhs, newrhs);
9464 SCIP_Bool infeasible;
9475 assert(consdata->nvars == 1);
9479 var = consdata->vars[0];
9480 val = consdata->vals[0];
9500 if( !consdata->upgraded )
9517 SCIP_Bool infeasible;
9518 SCIP_Bool redundant;
9519 SCIP_Bool aggregated;
9529 assert(consdata->nvars == 2);
9532 SCIPdebugMsg(
scip,
"linear constraint <%s>: aggregate %.15g<%s> + %.15g<%s> == %.15g\n",
9534 consdata->vals[1],
SCIPvarGetName(consdata->vars[1]), consdata->rhs);
9538 consdata->rhs, &infeasible, &redundant, &aggregated) );
9557 if( !consdata->upgraded )
9570 SCIP_Real slackcoef,
9575 SCIP_Real slackvarlb;
9576 SCIP_Real slackvarub;
9587 if( slackcoef > 0.0 )
9592 *newrhs = consdata->rhs - slackcoef * slackvarlb;
9596 *newlhs = consdata->lhs - slackcoef * slackvarub;
9603 *newlhs = consdata->rhs - slackcoef * slackvarlb;
9607 *newrhs = consdata->lhs - slackcoef * slackvarub;
9637 SCIP_Real bestslackdomrng;
9638 SCIP_Real minabsval;
9639 SCIP_Real maxabsval;
9640 SCIP_Bool bestremovescons;
9641 SCIP_Bool coefszeroone;
9642 SCIP_Bool coefsintegral;
9643 SCIP_Bool varsintegral;
9644 SCIP_Bool infeasible;
9653 int maxnlocksremove;
9670 assert(consdata->nvars > 2);
9680 lhs = consdata->lhs;
9681 rhs = consdata->rhs;
9683 if( consdata->nvars == 3 )
9688 maxnlocksremove = 3;
9690 else if( consdata->nvars == 4 )
9695 maxnlocksremove = 2;
9700 maxnlocksremove = 1;
9719 vars = consdata->vars;
9720 vals = consdata->vals;
9723 bestnlocks = INT_MAX;
9724 bestremovescons =
FALSE;
9725 bestslackdomrng = 0.0;
9726 coefszeroone =
TRUE;
9727 coefsintegral =
TRUE;
9728 varsintegral =
TRUE;
9736 for( v = 0; v < consdata->nvars; ++v )
9760 if( absval < minabsval )
9762 if( absval > maxabsval )
9767 if( maxabsval / minabsval > conshdlrdata->maxmultaggrquot )
9771 coefszeroone = coefszeroone &&
SCIPisEQ(
scip, absval, 1.0);
9799 if( nlocks > maxnlocksremove )
9803 if( (iscont || (coefsintegral && varsintegral &&
SCIPisEQ(
scip, absval, 1.0))) &&
9808 SCIP_Real slackdomrng;
9817 slackdomrng = (varub - varlb)*absval;
9821 better = (slacktype > bestslacktype) || (bestslackpos == -1);
9822 if( !better && slacktype == bestslacktype )
9824 better = (nlocks < bestnlocks);
9825 if( nlocks == bestnlocks && !bestremovescons )
9828 equal = !better &&
SCIPisGE(
scip, slackdomrng, bestslackdomrng);
9832 if( better || equal )
9834 SCIP_Real minresactivity;
9835 SCIP_Real maxresactivity;
9838 SCIP_Bool removescons;
9839 SCIP_Bool ismintight;
9840 SCIP_Bool ismaxtight;
9841 SCIP_Bool isminsettoinfinity;
9842 SCIP_Bool ismaxsettoinfinity;
9846 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
9851 if( !ismintight || !ismaxtight )
9871 if( conshdlrdata->multaggrremove && !removescons )
9875 if( bestremovescons && !removescons )
9881 if( !removescons && nlocks > maxnlocksstay )
9884 better = better || (!bestremovescons && removescons);
9888 bestslacktype = slacktype;
9889 bestnlocks = nlocks;
9890 bestslackdomrng = slackdomrng;
9891 bestremovescons = removescons;
9911 for( v = 0; v < consdata->nvars; ++v )
9913 if( v != bestslackpos )
9945 assert(!samevar || (supinf > 0 && infinf > 0));
9950 if( (samevar && (supinf > 1 || infinf > 1)) || (!samevar && supinf > 0 && infinf > 0) )
9952 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: infimum and supremum are both infinite\n");
9961 if( bestslackpos >= 0
9963 || (coefsintegral && varsintegral && nimplvars == 0)) )
9967 SCIP_Real slackcoef;
9968 SCIP_Real aggrconst;
9971 SCIP_Bool aggregated;
9985 slackvar =
vars[bestslackpos];
9986 slackcoef = vals[bestslackpos];
9988 aggrconst = consdata->rhs/slackcoef;
10001 for( v = 0; v < consdata->nvars; ++v )
10003 scalars[v] = -consdata->vals[v]/slackcoef;
10006 SCIPdebugMsgPrint(
scip,
" %+.15g, bounds of <%s>: [%.15g,%.15g], nlocks=%d, maxnlocks=%d, removescons=%u\n",
10008 bestnlocks, bestremovescons ? maxnlocksremove : maxnlocksstay, bestremovescons);
10012 &infeasible, &aggregated) );
10029 if( bestremovescons )
10034 if( !consdata->upgraded )
10038 else if( ncontvars == 1 )
10042 assert(0 <= contvarpos && contvarpos < consdata->
nvars);
10052 SCIPdebugMsg(
scip,
"linear constraint <%s>: converting continuous variable <%s> to implicit integer variable\n",
10071 SCIP_Bool redundant;
10072 SCIP_Bool aggregated;
10074 absval =
REALABS(vals[contvarpos]);
10085#ifdef WITH_DEBUG_SOLUTION
10086 if( SCIPdebugIsMainscip(
scip) )
10095 SCIPdebugMsg(
scip,
"linear constraint <%s>: aggregating continuous variable <%s> to newly created implicit integer variable <%s>, aggregation factor = %g\n",
10103 SCIPdebugMsg(
scip,
"infeasible aggregation of variable <%s> to implicit variable <%s>, domain is empty\n",
10125 consdata->boundstightened = 0;
10126 consdata->rangedrowpropagated = 0;
10127 consdata->presolved =
FALSE;
10130 else if( ncontvars == 0 && nimplvars == 0 &&
nintvars == 1 && !coefszeroone )
10138 assert(0 <= intvarpos && intvarpos < consdata->
nvars);
10147 SCIPdebugMsg(
scip,
"linear constraint <%s>: converting integer variable <%s> to implicit integer variable\n",
10182 vars = consdata->vars;
10183 nvars = consdata->nvars;
10187 for( v = 0; v <
nvars; ++v )
10211 val = consdata->vals[v];
10218 (*scale) = val / -
objval;
10230 (*scale) = val /
objval;
10253 SCIP_Bool applicable;
10266 nvars = consdata->nvars;
10275 (
nvars == nobjvars && (!conshdlrdata->detectcutoffbound || !conshdlrdata->detectlowerbound)) )
10278 offset = consdata->rhs;
10288 vars = consdata->vars;
10293 SCIPdebugMsg(
scip,
"linear equality constraint <%s> == %g (offset %g) is a subset of the objective function\n",
10301 for( v = 0; v <
nvars; ++v )
10318 SCIP_Real primalbound
10321 SCIP_Real cutoffbound;
10370 SCIP_Bool applicable;
10385 nvars = consdata->nvars;
10400 if( nobjvars == 0 )
10415 if( conshdlrdata->detectcutoffbound && rhsfinite )
10417 SCIP_Real primalbound;
10419 primalbound = (consdata->rhs - offset) / scale;
10421 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a cutoff bound <%g>\n",
10427 if( conshdlrdata->detectlowerbound && lhsfinite )
10429 SCIP_Real lowerbound;
10431 lowerbound = (consdata->lhs - offset) / scale;
10433 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a lower bound <%g>\n",
10439 if( (conshdlrdata->detectcutoffbound && (conshdlrdata->detectlowerbound || !lhsfinite)) ||
10440 (conshdlrdata->detectlowerbound && !rhsfinite) )
10449 if( conshdlrdata->detectlowerbound && rhsfinite )
10451 SCIP_Real lowerbound;
10453 lowerbound = (consdata->rhs - offset) / scale;
10455 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a lower bound <%g>\n",
10461 if( conshdlrdata->detectcutoffbound && lhsfinite )
10463 SCIP_Real primalbound;
10465 primalbound = (consdata->lhs - offset) / scale;
10467 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a cutoff bound <%g>\n",
10473 if( (conshdlrdata->detectcutoffbound && (conshdlrdata->detectlowerbound || !rhsfinite)) ||
10474 (conshdlrdata->detectlowerbound && !lhsfinite) )
10511 assert(consdata->removedfixings);
10518 if( consdata->nvars == 1 )
10523 else if( consdata->nvars == 2 )
10557 for( v = 0; v < consdata->nvars; ++v )
10574 SCIP_Real minresactivity,
10575 SCIP_Real maxresactivity,
10587 *minval = -maxresactivity;
10589 *minval = (side - maxresactivity)/val;
10592 *maxval = -minresactivity;
10594 *maxval = (side - minresactivity)/val;
10599 *minval = minresactivity;
10601 *minval = (side - minresactivity)/val;
10604 *maxval = maxresactivity;
10606 *maxval = (side - maxresactivity)/val;
10627 SCIP_Bool lhsexists;
10628 SCIP_Bool rhsexists;
10629 SCIP_Bool bestisint;
10630 SCIP_Bool bestislhs;
10631 SCIP_Real minabsval;
10632 SCIP_Real maxabsval;
10675 if( consdata->nvars <= 2 )
10676 maxotherlocks = INT_MAX;
10677 else if( consdata->nvars == 3 )
10679 else if( consdata->nvars == 4 )
10685 if( lhsexists && rhsexists && maxotherlocks < INT_MAX )
10690 for(
i = 0;
i < consdata->nvars && bestisint; ++
i )
10702 val = consdata->vals[
i];
10706 if( absval < minabsval )
10707 minabsval = absval;
10708 if( absval > maxabsval )
10709 maxabsval = absval;
10712 if( maxabsval / minabsval > conshdlrdata->maxdualmultaggrquot )
10715 var = consdata->vars[
i];
10719 if( bestpos >= 0 && isint )
10731 val = consdata->vals[
i];
10768 if( agglhs || aggrhs )
10770 SCIP_Real minresactivity;
10771 SCIP_Real maxresactivity;
10774 SCIP_Bool ismintight;
10775 SCIP_Bool ismaxtight;
10776 SCIP_Bool isminsettoinfinity;
10777 SCIP_Bool ismaxsettoinfinity;
10781 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
10788 assert((ismintight || isminsettoinfinity) && (ismaxtight || ismaxsettoinfinity));
10799 SCIP_Real oldmaxresactivity;
10800 SCIP_Real oldminresactivity;
10801 SCIP_Bool recalculated;
10803 recalculated =
FALSE;
10804 oldmaxresactivity = maxresactivity;
10805 oldminresactivity = minresactivity;
10811 recalculated = !
SCIPisEQ(
scip, oldminresactivity, minresactivity);
10812 isminsettoinfinity =
TRUE;
10819 recalculated = recalculated || !
SCIPisEQ(
scip, oldmaxresactivity, maxresactivity);
10820 ismaxsettoinfinity =
TRUE;
10859 SCIP_Real oldmaxresactivity;
10860 SCIP_Real oldminresactivity;
10861 SCIP_Bool recalculated;
10863 recalculated =
FALSE;
10864 oldmaxresactivity = maxresactivity;
10865 oldminresactivity = minresactivity;
10871 recalculated = !
SCIPisEQ(
scip, oldminresactivity, minresactivity);
10878 recalculated = recalculated || !
SCIPisEQ(
scip, oldmaxresactivity, maxresactivity);
10909 SCIP_Real* aggrcoefs;
10910 SCIP_Real aggrconst;
10916 SCIP_Bool infeasible;
10917 SCIP_Bool aggregated;
10926 assert(!bestislhs || lhsexists);
10927 assert(bestislhs || rhsexists);
10929 bestvar = consdata->vars[bestpos];
10930 bestval = consdata->vals[bestpos];
10947 for( j = 0; j < consdata->nvars; ++j )
10951 SCIP_Real absaggrcoef;
10953 aggrvars[naggrs] = consdata->vars[j];
10954 aggrcoefs[naggrs] = -consdata->vals[j]/consdata->vals[bestpos];
10957 absaggrcoef =
REALABS(aggrcoefs[naggrs]);
10960 if( absaggrcoef < epsilon )
10962 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: too large aggregation coefficients\n");
10975 aggrcoefs[naggrs] =
SCIPfloor(
scip, aggrcoefs[naggrs]+0.5);
11010 assert(!samevar || (supinf > 0 && infinf > 0));
11012 aggrconst = (bestislhs ? consdata->lhs/bestval : consdata->rhs/bestval);
11015 assert(naggrs == consdata->nvars-1);
11024 aggregated =
FALSE;
11025 infeasible =
FALSE;
11028 if( (samevar && supinf == 1 && infinf == 1) || (!samevar && (supinf == 0 || infinf == 0)) )
11040 SCIP_Bool infeasiblevartypechg;
11042 for( j = 0; j < naggrs; ++j)
11051 assert(!infeasiblevartypechg);
11060 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: infimum and supremum are both infinite\n");
11079 if( !consdata->upgraded )
11094#define CONTWEIGHT 8
11162 SCIP_Bool infeasible;
11164 SCIP_Bool aggregated;
11165 SCIP_Bool redundant;
11173 lhs = consdata->lhs;
11174 vars = consdata->vars;
11175 vals = consdata->vals;
11176 nvars = consdata->nvars;
11185 for( v = 0; v <
nvars && noddvars < 3; ++v )
11200 if( noddvars == 0 )
11212 if( noddvars == 1 )
11216 SCIPdebugMsg(
scip,
"linear constraint <%s>: try fixing variable <%s> to <%g>\n",
11236 else if( noddvars == 2 )
11245 SCIPdebugMsg(
scip,
"linear constraint <%s>: try aggregation of variables <%s> and <%s>\n",
11249 lhsodd ? 1.0 : 0.0, &infeasible, &redundant, &aggregated) );
11290 while( success && consdata->nvars >= 1 );
11319 if( vartype2 != vartype1 )
11329 value =
REALABS(consdata->vals[ind2]) -
REALABS(consdata->vals[ind1]);
11332 return (value > 0 ? +1 : (value < 0 ? -1 : 0));
11352 SCIP_Real secondminval;
11369 nvars = consdata->nvars;
11375 lhs = consdata->lhs;
11376 rhs = consdata->rhs;
11385 vals = consdata->vals;
11386 vars = consdata->vars;
11394 for( v =
nvars - 1; v >= 0; --v )
11400 secondminval = minval;
11403 else if( secondminval > vals[v] || secondminval ==
SCIP_INVALID )
11404 secondminval = vals[v];
11418 for( v =
nvars - 1; v >= 0; --v )
11422 (*nchgcoefs) +=
nvars;
11458 SCIP_Bool* infeasible
11465 SCIP_Real minactsub;
11466 SCIP_Real maxactsub;
11467 SCIP_Real siderest;
11478 SCIP_Longint restcoef;
11479 SCIP_Longint oldgcd;
11482 SCIP_Bool isminsettoinfinity;
11483 SCIP_Bool ismaxsettoinfinity;
11484 SCIP_Bool ismintight;
11485 SCIP_Bool ismaxtight;
11486 SCIP_Bool allcoefintegral;
11505 *infeasible =
FALSE;
11517 nvars = consdata->nvars;
11541 consdata->normalized =
FALSE;
11549 if( !consdata->normalized )
11552 lhs = consdata->lhs;
11553 rhs = consdata->rhs;
11567 SCIPdebug( oldnchgcoefs = *nchgcoefs; )
11568 SCIPdebug( oldnchgsides = *nchgsides; )
11571 if( haslhs && hasrhs )
11577 assert(haslhs != hasrhs);
11593 consdata->indexsorted =
FALSE;
11594 consdata->coefsorted =
FALSE;
11596 vars = consdata->vars;
11597 vals = consdata->vals;
11620 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
11623 if( isminsettoinfinity || ismaxsettoinfinity )
11628 assert(maxact > minact);
11634 side = haslhs ? lhs : rhs;
11635 minactsub = minact;
11636 maxactsub = maxact;
11705 for(
w = 0;
w < v; ++
w )
11713 maxactsub -= ub * vals[
w];
11714 minactsub -= lb * vals[
w];
11715 assert(maxactsub > minactsub);
11730 SCIP_Bool redundant =
FALSE;
11731 SCIP_Bool numericsok;
11732 SCIP_Bool rredundant;
11733 SCIP_Bool lredundant;
11746 maxactsub -= ub * vals[0];
11747 minactsub -= lb * vals[0];
11751 maxactsub -= lb * vals[0];
11752 minactsub -= ub * vals[0];
11754 assert(maxactsub > minactsub);
11759 allcoefintegral =
TRUE;
11762 for( ; v <
nvars - 1; ++v )
11769 allcoefintegral =
FALSE;
11788 maxactsub -= ub * vals[v];
11789 minactsub -= lb * vals[v];
11793 maxactsub -= lb * vals[v];
11794 minactsub -= ub * vals[v];
11811 rredundant = hasrhs && maxactsub <= siderest &&
SCIPisFeasGT(
scip, minactsub, siderest - gcd);
11812 lredundant = haslhs &&
SCIPisFeasLT(
scip, maxactsub, siderest) && minactsub >= siderest - gcd;
11815 if( offsetv == -1 && (rredundant || lredundant) )
11841 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",
11842 v,
nvars, minactsub, maxactsub, redundant, hasrhs, siderest, gcd, offsetv);
11849 rredundant = hasrhs && maxactsub <= siderest &&
SCIPisFeasGT(
scip, minactsub, siderest - gcd);
11850 lredundant = haslhs &&
SCIPisFeasLT(
scip, maxactsub, siderest) && minactsub >= siderest - gcd;
11853 if( v <
nvars && numericsok && (redundant || (offsetv == -1 && (rredundant || lredundant))) )
11859 SCIP_Real tmpminactsub = 0.0;
11860 SCIP_Real tmpmaxactsub = 0.0;
11874 tmpmaxactsub += ub * vals[
w];
11875 tmpminactsub += lb * vals[
w];
11879 tmpmaxactsub += lb * vals[
w];
11880 tmpminactsub += ub * vals[
w];
11882 assert(tmpmaxactsub >= tmpminactsub);
11902 (haslhs && tmpmaxactsub < siderest &&
SCIPisFeasGE(
scip, tmpminactsub, siderest - gcd)));
11905 SCIPdebugMsg(
scip,
"removing %d last variables from constraint <%s>, because they never change anything on the feasibility of this constraint\n",
11913 (*nchgcoefs) += (
nvars - v);
11921 assert(vals == consdata->vals);
11936 rhs = consdata->rhs;
11943 lhs = consdata->lhs;
11954 nvars = consdata->nvars;
11957 allcoefintegral =
TRUE;
11961 for(
w = offsetv + 1;
w <
nvars; ++
w )
11970 if( offsetv >= 0 && gcd == 1 )
11980 for( v =
nvars - 1; v > offsetv; --v )
11988 allcoefintegral =
FALSE;
12014 if( candpos == -1 )
12024 assert(v > offsetv || candpos > offsetv);
12030 candpos =
nvars - 1;
12033 if( gcd > 1 && allcoefintegral && !redundant )
12036 allcoefintegral =
FALSE;
12040 if( offsetv >= 0 && gcd > 1 && allcoefintegral )
12047 SCIP_Bool notchangable =
FALSE;
12051 for(
w = offsetv + 1;
w <
nvars; ++
w )
12069 restcoef = ((
SCIP_Longint)(vals[candpos] + feastol)) % gcd;
12076 if( restcoef > rest )
12077 newcoef = vals[candpos] - restcoef + gcd;
12079 newcoef = vals[candpos] - restcoef;
12084 if( rest == 0 || restcoef < rest )
12085 newcoef = vals[candpos] - restcoef;
12087 newcoef = vals[candpos] - restcoef + gcd;
12097 notchangable =
TRUE;
12138 for(
w = offsetv;
w >= 0; --
w )
12144 (*nchgcoefs) += (offsetv + 1);
12147 if( !notchangable )
12151 assert(vals == consdata->vals);
12157 nvars = consdata->nvars;
12162 lhs = consdata->lhs;
12163 rhs = consdata->rhs;
12177 allcoefintegral =
TRUE;
12179 for( v =
nvars - 1; v >= 0; --v )
12184 allcoefintegral =
FALSE;
12196 SCIP_Real
frac = 0.0;
12197 SCIP_Bool found =
FALSE;
12201 if( allcoefintegral )
12212 for( v =
nvars - 1; v >= 0; --v )
12248 SCIPdebugMsg(
scip,
"rounding all non-integral coefficients and the right hand side down\n");
12253 for( v =
nvars - 1; v >= 0; --v )
12290 if( allcoefintegral )
12305 for( v =
nvars - 1; v >= 0; --v )
12353 SCIPdebugMsg(
scip,
"rounding all non-integral coefficients and the left hand side down\n");
12358 for( v =
nvars - 1; v >= 0; --v )
12396 assert(vals == consdata->vals);
12401 rhs = consdata->rhs;
12402 lhs = consdata->lhs;
12409 nvars = consdata->nvars;
12413 allcoefintegral =
TRUE;
12416 for( v =
nvars - 1; v >= 0; --v )
12423 if( !allcoefintegral )
12443 SCIPdebug( oldnchgcoefs = *nchgcoefs; )
12444 SCIPdebug( oldnchgsides = *nchgsides; )
12459 for( v =
nvars - 1; v >= 0; --v )
12466 if( foundbin == -1 )
12494 foundbin =
nvars - 1;
12497 if( gcd == 1 || foundbin == -1)
12500 assert((onlybin && gcd == -1) || (!onlybin && gcd > 1));
12508 for( v = foundbin; v >= 0; --v )
12537 if( candpos == -1 )
12545 if( onlybin && v == foundbin - 1 )
12546 candpos2 = foundbin;
12551 if( onlybin && candpos == v + 1 && candpos2 == v + 2 )
12556 candpos = candpos2;
12599 if( vals[candpos] < 0 )
12601 restcoef = ((
SCIP_Longint)(vals[candpos] - feastol)) % gcd;
12606 restcoef = ((
SCIP_Longint)(vals[candpos] + feastol)) % gcd;
12620 if( restcoef > rest )
12621 newcoef = vals[candpos] - restcoef + gcd;
12623 newcoef = vals[candpos] - restcoef;
12635 if( rest == 0 || restcoef < rest )
12636 newcoef = vals[candpos] - restcoef;
12638 newcoef = vals[candpos] - restcoef + gcd;
12642 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));
12659 assert(vals == consdata->vals);
12666 rhs = consdata->rhs;
12667 lhs = consdata->lhs;
12671 nvars = consdata->nvars;
12673 SCIPdebugMsg(
scip,
"we did %d coefficient changes and %d side changes on constraint %s when applying one round of the gcd algorithm\n", *nchgcoefs - oldnchgcoefs, *nchgsides - oldnchgsides,
SCIPconsGetName(cons));
12675 while(
nvars >= 2 );
12695 int* diffidx0minus1,
12696 int* diffidx1minus0,
12698 int commonidxweight,
12699 int diffidx0minus1weight,
12700 int diffidx1minus0weight,
12701 SCIP_Real maxaggrnormscale,
12703 SCIP_Bool* aggregated,
12704 SCIP_Bool* infeasible
12711 SCIP_Real aggrcoef;
12712 SCIP_Real scalarsum;
12713 SCIP_Real bestscalarsum;
12714 SCIP_Bool betterscalarsum;
12715 SCIP_Bool commonvarlindependent;
12731 assert(nvarscommon >= 1);
12732 assert(commonidxweight >= nvarscommon);
12739 *infeasible =
FALSE;
12746 assert(consdata0->nvars >= 1);
12748 assert(diffidx0minus1weight >= consdata0->nvars - nvarscommon);
12753 assert(consdata1->nvars >= 1);
12755 assert(diffidx1minus0weight >= consdata1->nvars - nvarscommon);
12757 *aggregated =
FALSE;
12763 bestvarweight = commonidxweight + diffidx0minus1weight;
12764 bestnvars = consdata0->nvars;
12766 bestscalarsum = 0.0;
12767 commonvarlindependent =
TRUE;
12768 for( v = 0; v < nvarscommon; ++v )
12770 assert(consdata0->vars[commonidx0[v]] == consdata1->vars[commonidx1[v]]);
12771 a = consdata1->vals[commonidx1[v]];
12772 b = -consdata0->vals[commonidx0[v]];
12778 varweight = diffidx0minus1weight + diffidx1minus0weight;
12779 nvars = consdata0->nvars + consdata1->nvars - 2*nvarscommon;
12781 betterscalarsum = (scalarsum < bestscalarsum);
12782 for(
i = 0;
i < nvarscommon
12783 && (varweight < bestvarweight || (varweight == bestvarweight && betterscalarsum)); ++
i )
12785 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12792 if( varweight < bestvarweight || (varweight == bestvarweight && betterscalarsum) )
12795 bestvarweight = varweight;
12797 bestscalarsum = scalarsum;
12804 if( commonvarlindependent && v > 0 )
12806 consdata1->vals[commonidx1[v]] * consdata0->vals[commonidx0[0]],
12807 consdata1->vals[commonidx1[0]] * consdata0->vals[commonidx0[v]]);
12816 SCIP_Real* newvals;
12824 if( consdata1->vals[commonidx1[bestv]] > 0.0 )
12826 a = consdata1->vals[commonidx1[bestv]];
12827 b = -consdata0->vals[commonidx0[bestv]];
12831 a = -consdata1->vals[commonidx1[bestv]];
12832 b = consdata0->vals[commonidx0[bestv]];
12841 assert(commonvarlindependent);
12842 if( consdata1->vals[commonidx1[0]] > 0.0 )
12844 a = consdata1->vals[commonidx1[0]];
12845 b = -consdata0->vals[commonidx0[0]];
12849 a = -consdata1->vals[commonidx1[0]];
12850 b = consdata0->vals[commonidx0[0]];
12871 SCIPdebug( bestvarweight = diffidx0minus1weight + diffidx1minus0weight; )
12872 bestnvars = consdata0->nvars + consdata1->nvars - 2*nvarscommon;
12875 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> := %.15g*<%s> + %.15g*<%s> -> nvars: %d -> %d, weight: %d -> %d\n",
12877 consdata0->nvars, bestnvars, commonidxweight + diffidx0minus1weight, bestvarweight);
12887 if( !commonvarlindependent )
12889 for(
i = 0;
i < nvarscommon; ++
i )
12891 assert(0 <= commonidx0[
i] && commonidx0[
i] < consdata0->nvars);
12892 assert(0 <= commonidx1[
i] && commonidx1[
i] < consdata1->nvars);
12894 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12897 assert(newnvars < bestnvars);
12898 newvars[newnvars] = consdata0->vars[commonidx0[
i]];
12899 newvals[newnvars] = aggrcoef;
12908 for(
i = 0;
i < nvarscommon; ++
i )
12910 assert(0 <= commonidx0[
i] && commonidx0[
i] < consdata0->nvars);
12911 assert(0 <= commonidx1[
i] && commonidx1[
i] < consdata1->nvars);
12913 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12920 for(
i = 0;
i < consdata0->nvars - nvarscommon; ++
i )
12922 assert(0 <= diffidx0minus1[
i] && diffidx0minus1[
i] < consdata0->nvars);
12924 aggrcoef =
a * consdata0->vals[diffidx0minus1[
i]];
12926 assert(newnvars < bestnvars);
12927 newvars[newnvars] = consdata0->vars[diffidx0minus1[
i]];
12928 newvals[newnvars] = aggrcoef;
12933 for(
i = 0;
i < consdata1->nvars - nvarscommon; ++
i )
12935 assert(0 <= diffidx1minus0[
i] && diffidx1minus0[
i] < consdata1->nvars);
12937 aggrcoef =
b * consdata1->vals[diffidx1minus0[
i]];
12939 assert(newnvars < bestnvars);
12940 newvars[newnvars] = consdata1->vars[diffidx1minus0[
i]];
12941 newvals[newnvars] = aggrcoef;
12944 assert(newnvars == bestnvars);
12952 newlhs =
a * consdata0->lhs +
b * consdata1->lhs;
12956 newrhs =
a * consdata0->rhs +
b * consdata1->rhs;
12969 newconsdata->upgraded = consdata0->upgraded;
12985 if( !consdata0->upgraded )
12986 (*nchgcoefs) += consdata0->nvars + consdata1->nvars - nvarscommon;
12987 *aggregated =
TRUE;
13023 SCIP_Real minscale;
13024 SCIP_Real maxscale;
13031 assert(consdata1->indexsorted);
13032 assert(consdata2->indexsorted);
13042 if( consdata1->nvars != consdata2->nvars )
13046 for(
i = 0;
i < consdata1->nvars; ++
i )
13048 if( consdata1->vars[
i] != consdata2->vars[
i] )
13066 for(
i = 0;
i < consdata1->nvars; ++
i )
13068 SCIP_Real scale = consdata2->vals[
i] / consdata1->vals[
i];
13070 if( minscale > scale )
13078 if( maxscale < scale )
13108 assert(consdata->nvars > 0);
13110 assert(consdata->indexsorted);
13117 return SCIPhashFour(consdata->nvars, minidx, mididx, maxidx);
13135 return (((
unsigned int)consdata->upgraded)<<31) + (
unsigned int)
SCIPconsGetPos(cons);
13149 int* nparallelconss
13153 unsigned int querykey;
13155 *nparallelconss = 0;
13162 if( conskey < querykey )
13164 parallelconss[(*nparallelconss)++] = *querycons;
13165 *querycons = parallelcons;
13166 querykey = conskey;
13170 parallelconss[(*nparallelconss)++] = parallelcons;
13181 if( *querycons == parallelcons )
13217 int nparallelconss;
13230 hashtablesize = nconss;
13232 hashGetKeyLinearcons, hashKeyEqLinearcons, hashKeyValLinearcons, (
void*)
scip) );
13237 for(
c = 0;
c < nconss; ++
c )
13259 assert(consdata0->indexsorted);
13268 if( nparallelconss != 0 )
13278 lhs = consdata0->lhs;
13279 rhs = consdata0->rhs;
13281 for(
i = 0;
i < nparallelconss; ++
i )
13287 consdel = parallelconss[
i];
13301 assert(consdata0->nvars >= 1 && consdata0->nvars == consdatadel->nvars);
13303 assert(consdatadel->indexsorted);
13304 assert(consdata0->vars[0] == consdatadel->vars[0]);
13306 scale = consdata0->vals[0] / consdatadel->vals[0];
13314 assert(consdata0->validmaxabsval);
13315 assert(consdatadel->validmaxabsval);
13317 SCIP_Real scale0 = 1.0 / consdata0->maxabsval;
13318 SCIP_Real scaledel =
COPYSIGN(1.0 / consdatadel->maxabsval, scale);
13320 for( k = 0; k < consdata0->nvars; ++k )
13322 assert(
SCIPisEQ(
scip, scale0 * consdata0->vals[k], scaledel * consdatadel->vals[k]));
13330 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with equal coefficients into single ranged row\n",
13336 lhs =
MAX(scale * consdatadel->lhs, lhs);
13339 rhs =
MIN(scale * consdatadel->rhs, rhs);
13344 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with negated coefficients into single ranged row\n",
13350 lhs =
MAX(scale * consdatadel->rhs, lhs);
13353 rhs =
MIN(scale * consdatadel->lhs, rhs);
13360 assert( ! consdata0->upgraded || consdatadel->upgraded );
13362 if( !consdatadel->upgraded )
13376 rhs = (lhs + rhs)/2;
13385 if( consdata0->changed &&
SCIPconsGetPos(cons0) < *firstchange )
13391#ifdef SCIP_MORE_DEBUG
13413 SCIP_Real maxaggrnormscale,
13424 int* diffidx0minus1;
13425 int* diffidx1minus0;
13426 uint64_t possignature0;
13427 uint64_t negsignature0;
13428 SCIP_Bool cons0changed;
13429 SCIP_Bool cons0isequality;
13430 int diffidx1minus0size;
13432 SCIP_Real cons0lhs;
13433 SCIP_Real cons0rhs;
13434 SCIP_Bool cons0upgraded;
13438 assert(firstchange <= chkind);
13445 cons0 = conss[chkind];
13452 assert(consdata0->nvars >= 1);
13453 cons0isequality =
SCIPisEQ(
scip, consdata0->lhs, consdata0->rhs);
13460 possignature0 = consdata0->possignature;
13461 negsignature0 = consdata0->negsignature;
13468 diffidx1minus0size = consdata0->nvars;
13470 cons0lhs = consdata0->lhs;
13471 cons0rhs = consdata0->rhs;
13472 cons0upgraded = consdata0->upgraded;
13475 cons0changed = consdata0->changed;
13476 consdata0->changed =
FALSE;
13477 for(
c = (cons0changed ? 0 : firstchange);
c < chkind && !(*cutoff) && conss[chkind] !=
NULL; ++
c )
13481 uint64_t possignature1;
13482 uint64_t negsignature1;
13483 SCIP_Bool cons0dominateslhs;
13484 SCIP_Bool cons1dominateslhs;
13485 SCIP_Bool cons0dominatesrhs;
13486 SCIP_Bool cons1dominatesrhs;
13487 SCIP_Bool cons1isequality;
13488 SCIP_Bool coefsequal;
13489 SCIP_Bool coefsnegated;
13490 SCIP_Bool tryaggregation;
13494 int commonidxweight;
13495 int diffidx0minus1weight;
13496 int diffidx1minus0weight;
13500 assert(cons0lhs == consdata0->lhs);
13501 assert(cons0rhs == consdata0->rhs);
13502 assert(cons0upgraded == consdata0->upgraded);
13507 if( cons1 ==
NULL )
13521 if( !cons0changed && !consdata1->changed )
13526 if( cons0upgraded && consdata1->upgraded )
13529 assert(consdata1->nvars >= 1);
13536 possignature1 = consdata1->possignature;
13537 negsignature1 = consdata1->negsignature;
13540 coefsequal = (possignature0 == possignature1) && (negsignature0 == negsignature1);
13541 coefsnegated = (possignature0 == negsignature1) && (negsignature0 == possignature1);
13542 cons0dominateslhs =
SCIPisGE(
scip, cons0lhs, consdata1->lhs)
13543 && ((possignature0 | possignature1) == possignature1)
13544 && ((negsignature0 | negsignature1) == negsignature0);
13545 cons1dominateslhs =
SCIPisGE(
scip, consdata1->lhs, cons0lhs)
13546 && ((possignature0 | possignature1) == possignature0)
13547 && ((negsignature0 | negsignature1) == negsignature1);
13548 cons0dominatesrhs =
SCIPisLE(
scip, cons0rhs, consdata1->rhs)
13549 && ((possignature0 | possignature1) == possignature0)
13550 && ((negsignature0 | negsignature1) == negsignature1);
13551 cons1dominatesrhs =
SCIPisLE(
scip, consdata1->rhs, cons0rhs)
13552 && ((possignature0 | possignature1) == possignature1)
13553 && ((negsignature0 | negsignature1) == negsignature0);
13554 cons1isequality =
SCIPisEQ(
scip, consdata1->lhs, consdata1->rhs);
13555 tryaggregation = (cons0isequality || cons1isequality) && (maxaggrnormscale > 0.0);
13556 if( !cons0dominateslhs && !cons1dominateslhs && !cons0dominatesrhs && !cons1dominatesrhs
13557 && !coefsequal && !coefsnegated && !tryaggregation )
13561 if( tryaggregation && consdata1->nvars > diffidx1minus0size )
13564 diffidx1minus0size = consdata1->nvars;
13590 commonidxweight = 0;
13592 diffidx0minus1weight = 0;
13594 diffidx1minus0weight = 0;
13597 while( (v0 < consdata0->
nvars || v1 < consdata1->
nvars)
13598 && (cons0dominateslhs || cons1dominateslhs || cons0dominatesrhs || cons1dominatesrhs
13599 || coefsequal || coefsnegated || tryaggregation) )
13607 if( v0 < consdata0->
nvars && v1 < consdata1->
nvars )
13608 varcmp =
SCIPvarCompare(consdata0->vars[v0], consdata1->vars[v1]);
13609 else if( v0 < consdata0->
nvars )
13618 var = consdata0->vars[v0];
13619 val0 = consdata0->vals[v0];
13621 if( tryaggregation )
13623 diffidx0minus1[nvars0minus1] = v0;
13628 coefsequal =
FALSE;
13629 coefsnegated =
FALSE;
13634 var = consdata1->vars[v1];
13636 val1 = consdata1->vals[v1];
13637 if( tryaggregation )
13639 diffidx1minus0[nvars1minus0] = v1;
13644 coefsequal =
FALSE;
13645 coefsnegated =
FALSE;
13650 assert(consdata0->vars[v0] == consdata1->vars[v1]);
13651 var = consdata0->vars[v0];
13652 val0 = consdata0->vals[v0];
13653 val1 = consdata1->vals[v1];
13654 if( tryaggregation )
13656 commonidx0[nvarscommon] = v0;
13657 commonidx1[nvarscommon] = v1;
13663 coefsequal = coefsequal && (
SCIPisEQ(
scip, val0, val1));
13664 coefsnegated = coefsnegated && (
SCIPisEQ(
scip, val0, -val1));
13681 cons0dominatesrhs =
FALSE;
13682 cons1dominateslhs =
FALSE;
13686 cons0dominateslhs =
FALSE;
13687 cons1dominatesrhs =
FALSE;
13694 cons0dominateslhs =
FALSE;
13695 cons1dominatesrhs =
FALSE;
13699 cons0dominatesrhs =
FALSE;
13700 cons1dominateslhs =
FALSE;
13706 if( coefsequal || coefsnegated )
13721 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with %s coefficients into single ranged row\n",
13729 lhs =
MAX(consdata0->lhs, consdata1->lhs);
13730 rhs =
MIN(consdata0->rhs, consdata1->rhs);
13735 lhs =
MAX(consdata0->lhs, -consdata1->rhs);
13736 rhs =
MIN(consdata0->rhs, -consdata1->lhs);
13747 if( consdata0->upgraded )
13749 assert(!consdata1->upgraded);
13752 consdatastay = consdata1;
13756 consdatadel = consdata0;
13757 consinddel = chkind;
13763 consdatastay = consdata0;
13767 consdatadel = consdata1;
13774 if( !consdata0->upgraded )
13776 assert(consstay == cons0);
13777 cons0lhs = consdata0->lhs;
13778 cons0rhs = consdata0->rhs;
13784 assert( !consdatastay->upgraded );
13787 conss[consinddel] =
NULL;
13788 if( !consdatadel->upgraded )
13796 if( cons1dominateslhs && (!cons0isequality || cons1dominatesrhs ||
SCIPisInfinity(
scip, consdata0->rhs) ) )
13799 SCIPdebugMsg(
scip,
"left hand side of linear constraint <%s> is dominated by <%s>:\n",
13816 cons0lhs = consdata0->lhs;
13817 cons0isequality =
FALSE;
13818 if( !consdata0->upgraded )
13827 else if( cons0dominateslhs && (!cons1isequality || cons0dominatesrhs ||
SCIPisInfinity(
scip, consdata1->rhs)) )
13830 SCIPdebugMsg(
scip,
"left hand side of linear constraint <%s> is dominated by <%s>:\n",
13847 cons1isequality =
FALSE;
13848 if( !consdata1->upgraded )
13857 if( cons1dominatesrhs && (!cons0isequality || cons1dominateslhs ||
SCIPisInfinity(
scip, -consdata0->lhs)) )
13860 SCIPdebugMsg(
scip,
"right hand side of linear constraint <%s> is dominated by <%s>:\n",
13877 cons0rhs = consdata0->rhs;
13878 cons0isequality =
FALSE;
13879 if( !consdata0->upgraded )
13888 else if( cons0dominatesrhs && (!cons1isequality || cons0dominateslhs ||
SCIPisInfinity(
scip, -consdata1->lhs)) )
13891 SCIPdebugMsg(
scip,
"right hand side of linear constraint <%s> is dominated by <%s>:\n",
13908 cons1isequality =
FALSE;
13909 if( !consdata1->upgraded )
13925 conss[chkind] =
NULL;
13926 if( !consdata0->upgraded )
13941 if( !consdata1->upgraded )
13954 if( tryaggregation )
13956 SCIP_Bool aggregated;
13958 assert(consdata0->nvars == nvarscommon + nvars0minus1);
13959 assert(consdata1->nvars == nvarscommon + nvars1minus0);
13961 aggregated =
FALSE;
13962 if( cons1isequality && !consdata0->upgraded && commonidxweight > diffidx1minus0weight )
13966 nvarscommon, commonidxweight, diffidx0minus1weight, diffidx1minus0weight, maxaggrnormscale,
13967 nchgcoefs, &aggregated,
cutoff) );
13977 conss[chkind] =
NULL;
13980 if( !aggregated && cons0isequality && !consdata1->upgraded && commonidxweight > diffidx0minus1weight )
13984 nvarscommon, commonidxweight, diffidx1minus0weight, diffidx0minus1weight, maxaggrnormscale,
13985 nchgcoefs, &aggregated,
cutoff) );
14015 SCIP_Bool singletonstuffing,
14016 SCIP_Bool singlevarstuffing,
14026 SCIP_Bool* swapped;
14032 SCIP_Real minactivity;
14033 SCIP_Real maxactivity;
14034 SCIP_Real maxcondactivity;
14035 SCIP_Real mincondactivity;
14040 SCIP_Bool isminacttight;
14041 SCIP_Bool ismaxacttight;
14042 SCIP_Bool isminsettoinfinity;
14043 SCIP_Bool ismaxsettoinfinity;
14044 SCIP_Bool tryfixing;
14060 if( singlevarstuffing )
14063 &isminsettoinfinity, &ismaxsettoinfinity);
14069 isminsettoinfinity =
FALSE;
14070 ismaxsettoinfinity =
FALSE;
14078 rhs = -consdata->lhs;
14080 maxactivity = -minactivity;
14081 ismaxsettoinfinity = isminsettoinfinity;
14086 rhs = consdata->rhs;
14090 nvars = consdata->nvars;
14091 vars = consdata->vars;
14092 vals = consdata->vals;
14095 if( singletonstuffing )
14097 for( v = 0; v <
nvars; ++v )
14113 assert(singletonstuffing);
14121 mincondactivity = 0.0;
14122 maxcondactivity = 0.0;
14124 for( v = 0; v <
nvars; ++v )
14130 val = factor * vals[v];
14147 maxcondactivity += val * lb;
14148 mincondactivity += val * lb;
14149 swapped[v] =
FALSE;
14150 ratios[nsingletons] =
obj / val;
14151 varpos[nsingletons] = v;
14166 maxcondactivity += val * ub;
14167 mincondactivity += val * ub;
14169 ratios[nsingletons] =
obj / val;
14170 varpos[nsingletons] = v;
14187 maxcondactivity += val * lb;
14188 mincondactivity += val * lb;
14205 maxcondactivity += val * ub;
14206 mincondactivity += val * ub;
14222 maxcondactivity += val * ub;
14223 mincondactivity += val * lb;
14227 maxcondactivity += val * lb;
14228 mincondactivity += val * ub;
14232 if( tryfixing && nsingletons > 0 && (
SCIPisGT(
scip, rhs, maxcondactivity) ||
SCIPisLE(
scip, rhs, mincondactivity)) )
14235 SCIP_Bool tightened;
14237 int oldnfixedvars = *nfixedvars;
14238 int oldnchgbds = *nchgbds;
14244 for( v = 0; v < nsingletons; ++v )
14248 val = factor * vals[idx];
14253 assert((val < 0) == swapped[idx]);
14268 delta = -(lb - ub) * val;
14270 delta = (ub - lb) * val;
14320 maxcondactivity += delta;
14321 mincondactivity += delta;
14325 if( *nfixedvars - oldnfixedvars > 0 || *nchgbds - oldnchgbds > 0 )
14327 SCIPdebugMsg(
scip,
"### stuffing fixed %d variables and changed %d bounds\n", *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds);
14366 if( singlevarstuffing && !ismaxsettoinfinity )
14371 int bestindex = -1;
14372 int bestuplocks = 0;
14373 int bestdownlocks = 1;
14376 SCIPdebug(
int oldnfixedvars = *nfixedvars; )
14377 SCIPdebug(
int oldnchgbds = *nchgbds; )
14380 for( v = 0; v <
nvars; ++v )
14384 val = factor * vals[v];
14412 if( ratio > bestratio || ((ratio == bestratio) && downlocks == 0 && (bestdownlocks > 0
14417 if( bestindex != -1 )
14420 if( bestuplocks > 1 )
14427 secondbestratio = bestratio;
14430 bestdownlocks = downlocks;
14431 bestuplocks = uplocks;
14438 if( bestdownlocks > 0 && bestuplocks > 1 )
14453 if( ratio > secondbestratio )
14455 secondbestratio = ratio;
14461 if( bestindex != -1 && bestdownlocks == 0 )
14463 SCIP_Bool tightened =
FALSE;
14464 SCIP_Real bounddelta;
14468 val = factor * vals[bestindex];
14480 SCIP_Real bestvarfloor =
SCIPfloor(
scip, (maxactivity - rhs)/-val);
14481 SCIP_Real activitydelta = (maxactivity - rhs) - (bestvarfloor * -val);
14486 bounddelta =
SCIPceil(
scip, (maxactivity - rhs)/-val);
14490 bounddelta = (maxactivity - rhs)/-val;
14492 tryfixing = tryfixing &&
SCIPisLE(
scip, bounddelta, ub - lb);
14517 SCIP_Real bestvarfloor =
SCIPfloor(
scip, (maxactivity - rhs)/val);
14518 SCIP_Real activitydelta = (maxactivity - rhs) - (bestvarfloor * val);
14527 bounddelta = (maxactivity - rhs)/val;
14529 tryfixing = tryfixing &&
SCIPisLE(
scip, bounddelta, ub - lb);
14558 for( v = 0; v <
nvars; ++v )
14566 SCIPdebugMsg(
scip,
"<= %g\n", factor > 0 ? consdata->rhs : -consdata->lhs);
14568 for( v = 0; v <
nvars; ++v )
14570 if( v == bestindex )
14573 if( factor * vals[v] < 0 )
14593 SCIPdebug(
SCIPdebugMsg(
scip,
"### new stuffing fixed %d vars, tightened %d bounds\n", *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds); )
14616 SCIP_Bool* isimplint;
14677 for( v = 0; v <
nvars; ++v )
14689 for( v = 0; v < ncontvars; v++ )
14716 for(
c = 0;
c < nconss; ++
c )
14724 SCIP_Bool lhsexists;
14725 SCIP_Bool rhsexists;
14726 SCIP_Bool hasimpliedpotential;
14727 SCIP_Bool integralcoefs;
14743 for(
i = 0;
i < consdata->nvars; ++
i )
14747 var = consdata->vars[
i];
14752 assert(0 <= contv && contv < ncontvars);
14753 isimplint[contv] =
FALSE;
14766 hasimpliedpotential =
FALSE;
14769 for(
i = 0;
i < consdata->nvars; ++
i )
14773 SCIP_Real minresactivity;
14774 SCIP_Real maxresactivity;
14775 SCIP_Real newredlb;
14776 SCIP_Real newredub;
14777 SCIP_Bool ismintight;
14778 SCIP_Bool ismaxtight;
14779 SCIP_Bool isminsettoinfinity;
14780 SCIP_Bool ismaxsettoinfinity;
14783 var = consdata->vars[
i];
14785 val = consdata->vals[
i];
14800 isminsettoinfinity =
TRUE;
14801 ismaxsettoinfinity =
TRUE;
14807 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
14813 assert((ismintight || isminsettoinfinity) && (ismaxtight || ismaxsettoinfinity));
14828 newredlb = redlb[arrayindex];
14829 newredub = redub[arrayindex];
14835 nlocksdown[arrayindex] += nlockspos;
14836 newredlb = (isminsettoinfinity ?
SCIPinfinity(
scip) : (consdata->lhs - minresactivity)/val);
14841 nlocksup[arrayindex] += nlockspos;
14842 newredub = (ismaxsettoinfinity ? -
SCIPinfinity(
scip) : (consdata->rhs - maxresactivity)/val);
14850 nlocksup[arrayindex] += nlockspos;
14851 newredub = (isminsettoinfinity ? -
SCIPinfinity(
scip) : (consdata->lhs - minresactivity)/val);
14856 nlocksdown[arrayindex] += nlockspos;
14857 newredlb = (ismaxsettoinfinity ?
SCIPinfinity(
scip) : (consdata->rhs - maxresactivity)/val);
14871 redlb[arrayindex] =
MAX(redlb[arrayindex], newredlb);
14872 redub[arrayindex] =
MIN(redub[arrayindex], newredub);
14879 assert(nconscontvars < ncontvars);
14881 conscontvars[nconscontvars] =
var;
14885 assert(0 <= contv && contv < ncontvars);
14886 hasimpliedpotential = hasimpliedpotential || isimplint[contv];
14891 if( hasimpliedpotential )
14893 if( nconscontvars > 1 || !integralcoefs )
14898 for(
i = 0;
i < nconscontvars;
i++ )
14902 assert(0 <= contv && contv < ncontvars);
14903 isimplint[contv] =
FALSE;
14917 assert(nconscontvars == 1);
14918 assert(0 <= contvarpos && contvarpos < consdata->
nvars);
14919 var = consdata->vars[contvarpos];
14920 val = consdata->vals[contvarpos];
14922 assert(0 <= contv && contv < ncontvars);
14923 assert(isimplint[contv]);
14927 isimplint[contv] =
FALSE;
14933 if(
obj * val >= 0.0 && lhsexists )
14938 if(
obj * val <= 0.0 && rhsexists )
14950 for( v = 0; v <
nvars; ++v )
14954 SCIP_Bool infeasible;
14955 SCIP_Bool tightened;
14980 SCIPdebugMsg(
scip,
"variable <%s> only locked down in linear constraints: dual presolve <%s>[%.15g,%.15g] <= %.15g\n",
14987 redub[v] =
MIN(redub[v], ub);
15009 SCIPdebugMsg(
scip,
"variable <%s> only locked up in linear constraints: dual presolve <%s>[%.15g,%.15g] >= %.15g\n",
15016 redlb[v] =
MAX(redlb[v], lb);
15027 SCIP_Bool infeasible;
15053 SCIPdebugMsg(
scip,
"dual presolve: converting continuous variable <%s>[%g,%g] to implicit integer\n",
15084 SCIP_Bool checkrelmaxabs;
15085 SCIP_Bool violated;
15097 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
15099 SCIPdebugMsg(
scip,
"Enforcement method of linear constraints for %s solution\n",
sol ==
NULL ?
"LP" :
"relaxation");
15107 for(
c = 0;
c < nusefulconss; ++
c )
15156 SCIP_Real constant = 0.0;
15173 nlocvars = consdata->nvars;
15178 for(
i = 0;
i < nlocvars; ++
i )
15180 vars[
i] = consdata->vars[
i];
15181 vals[
i] = consdata->vals[
i];
15185 lhs = consdata->lhs - constant;
15186 rhs = consdata->rhs - constant;
15196 for(
i = 0;
i < nlocvars; ++
i )
15204 cons, lhs, rhs, success) );
15269 conshdlrdata->naddconss = 0;
15272 for(
c = 0;
c < nconss; ++
c )
15297 for(
c = nconss - 1;
c >= 0; --
c )
15304 if( consdata->eventdata !=
NULL )
15378 for(
c = 0;
c < nconss;
c++ )
15397 rhs = consdata->rhs;
15398 lhs = consdata->lhs;
15402 for(
i = 0;
i < consdata->nvars;
i++ )
15408 if( consdata->nvars == 0 )
15428 if( consdata->nvars == 1 )
15438 if( consdata->nvars == 2 &&
SCIPisEQ(
scip, lhs, rhs) )
15448 if( consdata->nvars == 2 )
15453 if(
SCIPisEQ(
scip, consdata->vals[0], -consdata->vals[1])
15475 SCIP_Bool unmatched;
15481 scale =
REALABS(consdata->vals[0]);
15484 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15491 if( consdata->vals[
i] < 0.0 )
15499 b = rhs/scale + nnegbinvars;
15520 b = rhs/scale + nnegbinvars;
15545 b = lhs/scale + nnegbinvars;
15571 SCIP_Bool unmatched;
15575 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15583 b -= consdata->vals[
i];
15603 for(
i = 0;
i < consdata->nvars && !matched;
i++ )
15608 SCIPdebugMsg(
scip,
"classified as %s: ", matched ?
"BINPACKING" :
"KNAPSACK");
15624 SCIP_Bool unmatched;
15631 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15655 SCIP_Bool unmatched;
15658 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15691#ifdef SCIP_STATISTIC
15702#ifdef SCIP_STATISTIC
15710 for(
c = 0;
c < nconss; ++
c )
15720 if( consdata->upgraded )
15727 if(
SCIPisLT(
scip, consdata->maxactdelta, conshdlrdata->maxeasyactivitydelta) )
15732 SCIPstatisticMessage(
"below threshold: %d / %d ratio= %g\n", ngoodconss, nallconss, (100.0 * ngoodconss / nallconss));
15736 for(
c = 0;
c < nconss; ++
c )
15746 if( consdata->upgraded )
15771 for(
c = 0;
c < nconss; ++
c )
15789 for(
c = 0;
c < nconss; ++
c )
15796 if( consdata->row !=
NULL )
15801 if( consdata->nlrow !=
NULL )
15817 if( ncutsadded > 0 )
15820 "(restart) converted %d cuts from the global cut pool into linear constraints\n", ncutsadded);
15871 if( consdata->eventdata !=
NULL )
15899 if( (*consdata)->eventdata !=
NULL )
15939 SCIP_CALL(
consdataCreate(
scip, &targetdata, sourcedata->nvars, sourcedata->vars, sourcedata->vals, sourcedata->lhs, sourcedata->rhs) );
15946 for(n = targetdata->nvars - 1; n >= 0; --n )
15971 *infeasible =
FALSE;
15973 for(
c = 0;
c < nconss && !(*infeasible); ++
c )
15988 SCIP_Real loclowerbound;
15989 SCIP_Real glblowerbound;
15990 SCIP_Real cutoffbound;
15991 SCIP_Real maxbound;
15992 SCIP_Bool separatecards;
16015 if( (
depth == 0 && conshdlrdata->maxroundsroot >= 0 && nrounds >= conshdlrdata->maxroundsroot)
16016 || (
depth > 0 && conshdlrdata->maxrounds >= 0 && nrounds >= conshdlrdata->maxrounds) )
16020 maxsepacuts = (
depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);
16026 maxbound = glblowerbound + conshdlrdata->maxcardbounddist * (cutoffbound - glblowerbound);
16027 separatecards =
SCIPisLE(
scip, loclowerbound, maxbound);
16035 for(
c = 0;
c < nusefulconss && ncuts < maxsepacuts && !
cutoff; ++
c )
16044 else if( ncuts > 0 )
16081 if( (
depth == 0 && conshdlrdata->maxroundsroot >= 0 && nrounds >= conshdlrdata->maxroundsroot)
16082 || (
depth > 0 && conshdlrdata->maxrounds >= 0 && nrounds >= conshdlrdata->maxrounds) )
16086 maxsepacuts = (
depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);
16093 for(
c = 0;
c < nusefulconss && ncuts < maxsepacuts && !
cutoff; ++
c )
16102 else if( ncuts > 0 )
16135 SCIP_Bool checkrelmaxabs;
16136 SCIP_Bool violated;
16147 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
16152 if( objinfeasible )
16154 SCIPdebugMsg(
scip,
"-> pseudo solution is objective infeasible, return.\n");
16162 for(
c = 0;
c < nconss && !violated; ++
c )
16183 SCIP_Bool checkrelmaxabs;
16196 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
16203 SCIP_Bool violated =
FALSE;
16213 SCIP_Real activity;
16242 SCIP_Bool rangedrowpropagation =
FALSE;
16243 SCIP_Bool tightenbounds;
16261 tightenbounds =
TRUE;
16266 int tightenboundsfreq;
16271 tightenboundsfreq = propfreq * conshdlrdata->tightenboundsfreq;
16272 tightenbounds = (conshdlrdata->tightenboundsfreq >= 0)
16273 && ((tightenboundsfreq == 0 &&
depth == 0) || (tightenboundsfreq >= 1 && (
depth % tightenboundsfreq == 0)));
16276 rangedrowpropagation = conshdlrdata->rangedrowpropagation;
16278 rangedrowpropagation = rangedrowpropagation && (
depth <= conshdlrdata->rangedrowmaxdepth);
16279 rangedrowfreq = propfreq * conshdlrdata->rangedrowfreq;
16280 rangedrowpropagation = rangedrowpropagation && (conshdlrdata->rangedrowfreq >= 0)
16281 && ((rangedrowfreq == 0 &&
depth == 0) || (rangedrowfreq >= 1 && (
depth % rangedrowfreq == 0)));
16288 for(
i = 0;
i < nmarkedconss && !
cutoff;
i++ )
16292 conshdlrdata->maxeasyactivitydelta, conshdlrdata->sortvars, &
cutoff, &nchgbds) );
16298 else if( nchgbds > 0 )
16307#define MAXCONSPRESOLROUNDS 10
16315 SCIP_Real minactivity;
16316 SCIP_Real maxactivity;
16317 SCIP_Bool isminacttight;
16318 SCIP_Bool ismaxacttight;
16319 SCIP_Bool isminsettoinfinity;
16320 SCIP_Bool ismaxsettoinfinity;
16330 int firstupgradetry;
16342 oldnfixedvars = *nfixedvars;
16343 oldnaggrvars = *naggrvars;
16344 oldnchgbds = *nchgbds;
16345 oldndelconss = *ndelconss;
16346 oldnupgdconss = *nupgdconss;
16347 oldnchgcoefs = *nchgcoefs;
16348 oldnchgsides = *nchgsides;
16355 firstchange = INT_MAX;
16356 firstupgradetry = INT_MAX;
16360 SCIP_Bool infeasible;
16362 infeasible =
FALSE;
16372 consdata->lhs = consdata->rhs;
16376 if( consdata->eventdata ==
NULL )
16399 assert(consdata->removedfixings);
16406 if( firstchange == INT_MAX && consdata->changed )
16410 if( firstupgradetry == INT_MAX && !consdata->upgradetried )
16411 firstupgradetry =
c;
16414 if( consdata->presolved )
16432 consdata->presolved =
TRUE;
16449 SCIPdebugMsg(
scip,
" -> infeasibility detected during tightening sides\n");
16457 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16475 &isminsettoinfinity, &ismaxsettoinfinity);
16478 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16479 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16485 SCIPdebugMsg(
scip,
"linear constraint <%s> is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16486 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16490 if( !consdata->upgraded )
16496 SCIPdebugMsg(
scip,
"linear constraint <%s> left hand side is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16497 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16499 if( !consdata->upgraded )
16504 SCIPdebugMsg(
scip,
"linear constraint <%s> right hand side is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16505 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16507 if( !consdata->upgraded )
16512 if( consdata->nvars == 0 )
16516 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16522 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16527 if( !consdata->upgraded )
16537 if( conshdlrdata->simplifyinequalities )
16546 if( conshdlrdata->aggregatevariables )
16557 if( conshdlrdata->rangedrowpropagation )
16559 int lastnfixedvars;
16561 lastnfixedvars = *nfixedvars;
16566 if( lastnfixedvars < *nfixedvars )
16577 nfixedvars, nchgbds, &
cutoff) );
16584 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16590 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16595 if( !consdata->upgraded )
16620 if( firstchange == INT_MAX && consdata->changed )
16624 if( firstupgradetry == INT_MAX && !consdata->upgradetried )
16625 firstupgradetry =
c;
16633 conshdlrdata->singlevarstuffing, &
cutoff, nfixedvars, nchgbds) );
16636 if( consdata->nvars == 0 )
16640 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16646 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16651 if( !consdata->upgraded )
16664 assert(firstchange >= 0);
16666 if( firstchange < nconss && conshdlrdata->presolusehashing )
16670 ndelconss, nchgsides) );
16673 if( firstchange < nconss && conshdlrdata->presolpairwise )
16677 int firstchangenew;
16678 SCIP_Longint npaircomparisons;
16680 npaircomparisons = 0;
16681 oldndelconss = *ndelconss;
16682 oldnchgsides = *nchgsides;
16683 oldnchgcoefs = *nchgcoefs;
16689 firstchangenew = -1;
16690 for(
c = 0;
c < nconss; ++
c )
16693 if(
c == firstchange )
16694 firstchangenew = nusefulconss;
16700 usefulconss[nusefulconss] = conss[
c];
16703 firstchange = firstchangenew;
16704 assert(firstchangenew >= 0 && firstchangenew <= nusefulconss);
16709 if( usefulconss[
c] ==
NULL )
16716 &
cutoff, ndelconss, nchgsides, nchgcoefs) );
16718 if( npaircomparisons > conshdlrdata->nmincomparisons )
16720 assert(npaircomparisons > 0);
16721 if( ((*ndelconss - oldndelconss) + (*nchgsides - oldnchgsides)/2.0 + (*nchgcoefs - oldnchgcoefs)/10.0) / ((SCIP_Real) npaircomparisons) < conshdlrdata->mingainpernmincomp )
16723 oldndelconss = *ndelconss;
16724 oldnchgsides = *nchgsides;
16725 oldnchgcoefs = *nchgcoefs;
16726 npaircomparisons = 0;
16737 if( !
cutoff && firstupgradetry < nconss
16738 && *nfixedvars == oldnfixedvars && *naggrvars == oldnaggrvars && *nchgbds == oldnchgbds && *ndelconss == oldndelconss
16739 && *nupgdconss == oldnupgdconss && *nchgcoefs == oldnchgcoefs && *nchgsides == oldnchgsides
16766 if( consdata->upgradetried )
16769 if( !consdata->presolved )
16772 consdata->upgradetried =
TRUE;
16778 if( upgdcons !=
NULL )
16788 assert(!consdata->upgraded);
16789 consdata->upgraded =
TRUE;
16795 || !conshdlrdata->presolpairwise
16796 || (conshdlrdata->maxaggrnormscale == 0.0) )
16808 else if( *nfixedvars > oldnfixedvars || *naggrvars > oldnaggrvars || *nchgbds > oldnchgbds || *ndelconss > oldndelconss
16809 || *nupgdconss > oldnupgdconss || *nchgcoefs > oldnchgcoefs || *nchgsides > oldnchgsides )
16850 for(
i = 0;
i < consdata->nvars; ++
i )
16914 SCIP_Real* sourcecoefs;
16915 const char* consname;
16934 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
valid) );
16949 char** firstoperator,
16950 char** secondoperator,
16960 *firstoperator =
NULL;
16961 *secondoperator =
NULL;
16967 while( *curr && *success )
16969 SCIP_Bool found =
FALSE;
16980 if( curr[1] ==
'=' )
16989 if( strncmp(curr,
"[free]", 6) == 0 )
17004 if( *firstoperator ==
NULL )
17006 *firstoperator = curr;
17010 if( *secondoperator !=
NULL )
17015 else if( strncmp(*firstoperator,
"<=", 2) != 0 )
17017 SCIPerrorMessage(
"Two operators in line that is not a ranged row: %s", str);
17020 else if( strncmp(curr,
"<=", 2) != 0 )
17022 SCIPerrorMessage(
"Bad second operator, expected ranged row specification: %s", str);
17026 *secondoperator = curr;
17036 if( *firstoperator ==
NULL )
17058 SCIP_Bool operatorsuccess;
17073 (*success) =
FALSE;
17088 if( ! operatorsuccess )
17091 varstrptr = (
char *)str;
17092 lhsstrptr = rhsstrptr =
NULL;
17099 assert(firstop[1] ==
'=');
17101 if( secondop !=
NULL )
17103 assert(secondop[0] ==
'<' && secondop[1] ==
'=');
17104 lhsstrptr = (
char *)str;
17105 varstrptr = firstop + 2;
17106 rhsstrptr = secondop + 2;
17112 varstrptr = (
char *)str;
17113 rhsstrptr = firstop + 2;
17117 assert(firstop[1] ==
'=');
17120 lhsstrptr = firstop + 2;
17123 assert(firstop[1] ==
'=');
17126 rhsstrptr = firstop + 2;
17127 lhsstrptr = firstop + 2;
17130 assert(strncmp(firstop,
"[free]", 6) == 0);
17136 SCIPerrorMessage(
"Parsing has wrong operator character '%c', should be one of <=>[", *firstop);
17141 if( lhsstrptr !=
NULL )
17145 SCIPerrorMessage(
"error parsing left hand side number from <%s>\n", lhsstrptr);
17150 if( rhsstrptr == lhsstrptr )
17155 if( rhsstrptr !=
NULL && rhsstrptr != lhsstrptr )
17159 SCIPerrorMessage(
"error parsing right hand side number from <%s>\n", lhsstrptr);
17174 if( *success && requsize > coefssize )
17177 coefssize = requsize;
17182 assert(!*success || requsize <= coefssize);
17192 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
17211 if( varssize < consdata->
nvars )
17212 (*success) =
FALSE;
17234 (*nvars) = consdata->nvars;
17278 cons = eventdata->cons;
17292 SCIP_Real oldbound;
17293 SCIP_Real newbound;
17297 varpos = eventdata->varpos;
17303 val = consdata->vals[varpos];
17322 consdata->presolved =
FALSE;
17323 consdata->rangedrowpropagated = 0;
17331 if( consdata->maxactdeltavar ==
var )
17334 consdata->maxactdeltavar =
NULL;
17338 if( consdata->boundstightened > 0)
17340 switch( eventtype )
17344 consdata->boundstightened = 0;
17348 consdata->boundstightened = 0;
17370 delta =
REALABS(val) * domain;
17372 if( delta > consdata->maxactdelta )
17374 consdata->maxactdelta = delta;
17375 consdata->maxactdeltavar =
var;
17382 consdata->presolved =
FALSE;
17383 consdata->removedfixings =
FALSE;
17384 consdata->rangedrowpropagated = 0;
17387 if( consdata->maxactdeltavar ==
var )
17390 consdata->maxactdeltavar =
NULL;
17398 consdata->presolved =
FALSE;
17402 SCIP_Real oldbound;
17403 SCIP_Real newbound;
17407 varpos = eventdata->varpos;
17413 val = consdata->vals[varpos];
17415 consdata->rangedrowpropagated = 0;
17430 consdata->indexsorted =
FALSE;
17432 consdata->coefsorted =
FALSE;
17448 consdata->varsdeleted =
TRUE;
17471 assert(bdchginfos !=
NULL || nbdchginfos == 0);
17487 for(
i = 0;
i < nbdchginfos; ++
i )
17508 if(
i == nbdchginfos )
17521 if( upgdcons !=
NULL )
17557 assert(upgdconsssize > 0);
17595 consdata->checkabsolute =
TRUE;
17623 eventExecLinear,
NULL) );
17627 conflictExecLinear,
NULL) );
17635 consEnfolpLinear, consEnfopsLinear, consCheckLinear, consLockLinear,
17677 "multiplier on propagation frequency, how often the bounds are tightened (-1: never, 0: only at root)",
17681 "maximal number of separation rounds per node (-1: unlimited)",
17685 "maximal number of separation rounds per node in the root node (-1: unlimited)",
17689 "maximal number of cuts separated per separation round",
17693 "maximal number of cuts separated per separation round in the root node",
17697 "should pairwise constraint comparison be performed in presolving?",
17701 "should hash table be used for detecting redundant constraints in advance",
17705 "number for minimal pairwise presolve comparisons",
17709 "minimal gain per minimal pairwise presolve comparisons to repeat pairwise comparison round",
17713 "maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint aggregation)",
17717 "maximum activity delta to run easy propagation on linear constraint (faster, but numerically less stable)",
17721 "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts",
17725 "should all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value?",
17729 "should presolving search for aggregations in equations",
17733 "should presolving try to simplify inequalities",
17737 "should dual presolving steps be performed?",
17741 "should stuffing of singleton continuous variables be performed?",
17745 "should single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable?",
17748 "constraints/" CONSHDLR_NAME "/sortvars",
"apply binaries sorting in decr. order of coeff abs value?",
17752 "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)?",
17756 "should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP?",
17760 "should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP?",
17764 "should presolving try to detect subsets of constraints parallel to the objective function?",
17768 "should presolving and propagation try to improve bounds, detect infeasibility, and extract sub-constraints from ranged rows and equations?",
17772 "should presolving and propagation extract sub-constraints from ranged rows and equations?",
17776 "maximum depth to apply ranged row propagation",
17780 "frequency for applying ranged row propagation",
17784 "should multi-aggregations only be performed if the constraint can be removed afterwards?",
17788 "maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation",
17792 "maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation",
17796 "should Cliques be extracted?",
17807 const char* conshdlrname
17822 if( conshdlr ==
NULL )
17866 SCIP_Bool separate,
17876 SCIP_Bool modifiable,
17882 SCIP_Bool removable,
17884 SCIP_Bool stickingatnode
17898 if( conshdlr ==
NULL )
17904 for( j = 0; j <
nvars; ++j )
17920 SCIP_Real* consvals;
17921 SCIP_Real constant = 0.0;
17933 if( requiredsize > nconsvars )
17939 assert(requiredsize <= nconsvars);
17945 if( constant < 0.0 )
17952 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);
17962 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);
17978 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);
17988 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);
18032 if( check || enforce )
18035 for(n = consdata->nvars - 1; n >= 0; --n )
18041 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
18042 local, modifiable, dynamic, removable, stickingatnode) );
18082 SCIP_Real* sourcecoefs,
18090 SCIP_Bool separate,
18095 SCIP_Bool modifiable,
18097 SCIP_Bool removable,
18098 SCIP_Bool stickingatnode,
18107 SCIP_Real constant;
18123 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
18131 if( sourcecoefs !=
NULL )
18138 for( v = 0; v <
nvars; ++v )
18151 if( requiredsize >
nvars )
18162 for( v = 0; v <
nvars; ++v )
18172 for( v = 0; v <
nvars && success; ++v )
18194 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
18231 SCIP_Real* consvals;
18232 SCIP_Real constant = 0.0;
18249 if( requiredsize > nconsvars )
18255 assert(requiredsize <= nconsvars);
18261 lhs = consdata->lhs;
18262 rhs = consdata->rhs;
18268 if( constant < 0.0 )
18341 for( v = nconsvars - 1; v >= 0; --v )
18395 SCIPerrorMessage(
"method may only be called during problem creation stage for original constraints and variables\n");
18402 vars = consdata->vars;
18475 return consdata->lhs;
18499 return consdata->rhs;
18562 return consdata->nvars;
18586 return consdata->vars;
18610 return consdata->vals;
18639 if( consdata->row !=
NULL )
18667 if( consdata->row !=
NULL )
18695 if( consdata->row !=
NULL )
18723 if( consdata->row !=
NULL )
18752 return consdata->row;
18769 SCIP_Real poscoeffsum;
18770 SCIP_Real negcoeffsum;
18771 SCIP_Bool infeasible;
18772 SCIP_Bool integral;
18821 if( consdata->upgraded )
18825 if( consdata->row !=
NULL )
18829 SCIPerrorMessage(
"cannot upgrade linear constraint that is already stored as row in the LP\n");
18881 for(
i = 0;
i < consdata->nvars; ++
i )
18883 var = consdata->vars[
i];
18884 val = consdata->vals[
i];
18952 poscoeffsum += val;
18954 negcoeffsum += val;
18961 SCIPdebugMsg(
scip,
"upgrading linear constraint <%s> (%d upgrade methods):\n",
18963 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",
18964 nposbin, nnegbin, nposint, nnegint, nposimpl, nnegimpl, nposcont, nnegcont,
18965 ncoeffspone, ncoeffsnone, ncoeffspint, ncoeffsnint, ncoeffspfrac, ncoeffsnfrac,
18966 poscoeffsum, negcoeffsum, integral);
18969 for(
i = 0;
i < conshdlrdata->nlinconsupgrades && *upgdcons ==
NULL; ++
i )
18971 if( conshdlrdata->linconsupgrades[
i]->active )
18973 SCIP_CALL( conshdlrdata->linconsupgrades[
i]->linconsupgd(
scip, cons, consdata->nvars,
18974 consdata->vars, consdata->vals, consdata->lhs, consdata->rhs,
18975 nposbin, nnegbin, nposint, nnegint, nposimpl, nnegimpl, nposimplbin, nnegimplbin, nposcont, nnegcont,
18976 ncoeffspone, ncoeffsnone, ncoeffspint, ncoeffsnint, ncoeffspfrac, ncoeffsnfrac,
18977 poscoeffsum, negcoeffsum, integral,
18983 if( *upgdcons !=
NULL )
18997 SCIP_Bool onlychecked,
18998 SCIP_Bool* infeasible
19007 if( conshdlr ==
NULL )
19011 *infeasible =
FALSE;
19016 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_RETCODE convertEquality(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *ndelconss, int *nchgvartypes)
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)
#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)
static SCIP_RETCODE fullDualPresolve(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool *cutoff, int *nchgbds, int *nchgvartypes)
static SCIP_RETCODE convertLongEquality(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS *cons, SCIP_Bool *cutoff, int *naggrvars, int *ndelconss, int *nchgvartypes)
#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 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)
#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 addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
static void consdataGetActivityBounds(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Bool goodrelax, SCIP_Real *minactivity, SCIP_Real *maxactivity, SCIP_Bool *ismintight, SCIP_Bool *ismaxtight, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
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 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 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 *istight, SCIP_Bool *issettoinfinity)
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 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)
#define DEFAULT_MAXSEPACUTS
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 *ismintight, SCIP_Bool *ismaxtight, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
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
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 *istight, SCIP_Bool *issettoinfinity)
#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
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 *ismintight, SCIP_Bool *ismaxtight, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
#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)
static SCIP_RETCODE dualPresolve(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *ndelconss, int *nchgvartypes)
#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 void consdataGetGlbActivityBounds(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Bool goodrelax, SCIP_Real *glbminactivity, SCIP_Real *glbmaxactivity, SCIP_Bool *ismintight, SCIP_Bool *ismaxtight, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
static SCIP_Bool canTightenBounds(SCIP_CONS *cons)
#define DEFAULT_SEPARATEALL
static void findOperators(const char *str, char **firstoperator, char **secondoperator, SCIP_Bool *success)
static INFERINFO getInferInfo(PROPRULE proprule, int pos)
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)
#define SCIP_LONGINT_FORMAT
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)
#define SCIPhashFour(a, b, c, d)
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)
void SCIPhashtablePrintStatistics(SCIP_HASHTABLE *hashtable, SCIP_MESSAGEHDLR *messagehdlr)
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)
void SCIPswapPointers(void **pointer1, void **pointer2)
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)
SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(SCIP *scip, 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 SCIPsetConshdlrGetPermsymGraph(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_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
SCIP_RETCODE SCIPextendPermsymDetectionGraphLinear(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool *success)
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))
structs for symmetry computations
methods for dealing with symmetry detection graphs
#define SCIP_DECL_CONFLICTEXEC(x)
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
#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
enum SYM_Symtype SYM_SYMTYPE
#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