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);
6804 newub = (rhs - minresactivity)/val;
6809 SCIP_Bool activityunreliable;
6813 if( activityunreliable )
6816 newub = (rhs - minresactivity)/val;
6822 if( !activityunreliable )
6825 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newub=%.15g\n",
6828 &infeasible, &tightened) );
6831 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6846 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
6858 newlb = (lhs - maxresactivity)/val;
6866 newlb = (lhs - maxresactivity)/val;
6875 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
6878 &infeasible, &tightened) );
6881 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6895 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
6911 newlb = (rhs - minresactivity)/val;
6915 SCIP_Bool activityunreliable;
6918 if( activityunreliable )
6921 newlb = (rhs - minresactivity)/val;
6928 if( !activityunreliable )
6931 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
6934 &infeasible, &tightened) );
6937 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6951 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
6963 newub = (lhs - maxresactivity)/val;
6971 newub = (lhs - maxresactivity)/val;
6980 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g], newub=%.15g\n",
6983 &infeasible, &tightened) );
6986 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
7000 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
7010#define MAXTIGHTENROUNDS 10
7017 SCIP_Real maxeasyactivitydelta,
7024 unsigned int tightenmode;
7030 int oldnchgbdstotal;
7062 nvars = consdata->nvars;
7072 if( !force && (consdata->boundstightened >= tightenmode) )
7079 assert(consdata->coefsorted);
7098 SCIP_Real minactivity;
7099 SCIP_Real maxactivity;
7100 SCIP_Bool ismintight;
7101 SCIP_Bool ismaxtight;
7102 SCIP_Bool isminsettoinfinity;
7103 SCIP_Bool ismaxsettoinfinity;
7107 &isminsettoinfinity, &ismaxsettoinfinity);
7120 easycase =
SCIPisLT(
scip, consdata->maxactdelta, maxeasyactivitydelta);
7127 oldnchgbdstotal = *nchgbds;
7130 for( nrounds = 0; (force || consdata->boundstightened < tightenmode) && nrounds <
MAXTIGHTENROUNDS; ++nrounds )
7139 assert(consdata->coefsorted);
7143 consdata->boundstightened = (
unsigned int)tightenmode;
7149 while( v <
nvars && v != lastchange && !(*
cutoff) )
7151 oldnchgbds = *nchgbds;
7163 if( *nchgbds > oldnchgbds )
7168 else if( consdata->coefsorted && v < consdata->
nbinvars - 1
7170 v = consdata->nbinvars;
7177 *nchgbds - oldnchgbdstotal, nrounds);
7178 oldnchgbdstotal += oldnchgbds;
7183 if( force &&
SCIPisEQ(
scip, consdata->lhs, consdata->rhs) )
7196 SCIP_Bool checklprows,
7197 SCIP_Bool checkrelmaxabs,
7221 if( consdata->row !=
NULL )
7233 SCIPdebugMsg(
scip,
" consdata activity=%.15g (lhs=%.15g, rhs=%.15g, row=%p, checklprows=%u, rowinlp=%u, sol=%p, hascurrentnodelp=%u)\n",
7234 activity, consdata->lhs, consdata->rhs, (
void*)consdata->row, checklprows,
7239 lhsviol = consdata->lhs - activity;
7240 rhsviol = activity - consdata->rhs;
7244 if( (lhsviol > 0) && (lhsviol > rhsviol) )
7249 else if( rhsviol > 0 )
7274 if( !checkrelmaxabs )
7298 for( v = 0; v < consdata->nvars; ++v )
7300 if( consdata->vals !=
NULL )
7302 coef = consdata->vals[v];
7308 absval =
REALABS( coef * solval );
7309 maxabs =
MAX( maxabs, absval );
7316 if( (consdata->lhs - activity) <= (1e-15 * maxabs) )
7318 SCIPdebugMsg(
scip,
" lhs violated due to random noise: violation=%16.9g, maxabs=%16.9g\n",
7319 consdata->lhs - activity, maxabs);
7333 SCIPdebugMsg(
scip,
" lhs violated absolutely (violation=%16.9g), but feasible when using relative tolerance w.r.t. maximum absolute value (%16.9g)\n",
7334 consdata->lhs - activity, maxabs);
7370 if( (activity - consdata->rhs) <= (1e-15 * maxabs) )
7372 SCIPdebugMsg(
scip,
" rhs violated due to random noise: violation=%16.9g, maxabs=%16.9g\n",
7373 activity - consdata->rhs, maxabs);
7387 SCIPdebugMsg(
scip,
" rhs violated absolutely (violation=%16.9g), but feasible when using relative tolerance w.r.t. maximum absolute value (%16.9g)\n",
7388 activity - consdata->rhs, maxabs);
7422 else if( consdata->checkabsolute &&
7490 if( consdata->row ==
NULL )
7507 if( consdata->nvars == 0 )
7529 assert( pr == 0 || cr == 0 );
7555 if( consdata->nlrow ==
NULL )
7557 assert(consdata->lhs <= consdata->rhs);
7580 SCIP_Bool separatecards,
7581 SCIP_Bool separateall,
7614 if( !separateall &&
sol ==
NULL )
7627 consdata->vals, +1.0, consdata->rhs,
sol,
cutoff, ncuts) );
7635 consdata->vals, -1.0, -consdata->lhs,
sol,
cutoff, ncuts) );
7645 consdata->vals, +1.0, consdata->rhs,
sol,
cutoff, ncuts) );
7650 consdata->vals, -1.0, -consdata->lhs,
sol,
cutoff, ncuts) );
7655 if( *ncuts > oldncuts )
7668 SCIP_Bool tightenbounds,
7669 SCIP_Bool rangedrowpropagation,
7670 SCIP_Real maxeasyactivitydelta,
7677 SCIP_Real minactivity;
7678 SCIP_Real maxactivity;
7679 SCIP_Bool isminacttight;
7680 SCIP_Bool ismaxacttight;
7681 SCIP_Bool isminsettoinfinity;
7682 SCIP_Bool ismaxsettoinfinity;
7694 if( consdata->eventdata ==
NULL )
7726 oldnchgbds = *nchgbds;
7730 if( *nchgbds > oldnchgbds )
7737 if( rangedrowpropagation && tightenbounds && !(*
cutoff) )
7757 if( nfixedvars > 0 )
7758 *nchgbds += 2*nfixedvars;
7765 &isminsettoinfinity, &ismaxsettoinfinity);
7769 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible (rhs): activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7770 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7780 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible (lhs): activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7781 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7791 SCIPdebugMsg(
scip,
"linear constraint <%s> is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7792 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7795 if( consdata->nvars > 0 )
7826 SCIP_Bool infeasible;
7837 for( v = 0; v < consdata->nvars; ++v )
7840 var = consdata->vars[v];
7852 SCIPdebugMsg(
scip,
"converting variable <%s> with fixed bounds [%.15g,%.15g] into fixed variable fixed at %.15g\n",
7876 assert(consdata->removedfixings);
7881#define MAX_CLIQUE_NONZEROS_PER_CONS 1000000
7951 SCIP_Real maxeasyactivitydelta,
7961 SCIP_Bool lhsclique;
7962 SCIP_Bool rhsclique;
7963 SCIP_Bool finitelhs;
7964 SCIP_Bool finiterhs;
7965 SCIP_Bool finiteminact;
7966 SCIP_Bool finitemaxact;
7967 SCIP_Bool finitenegminact;
7968 SCIP_Bool finitenegmaxact;
7969 SCIP_Bool finiteposminact;
7970 SCIP_Bool finiteposmaxact;
7971 SCIP_Bool infeasible;
7973 int cliquenonzerosadded;
7990 if( consdata->nvars < 2 )
7999 if( !consdata->implsadded )
8017 nvars = consdata->nvars;
8018 vars = consdata->vars;
8019 vals = consdata->vals;
8022 if( !consdata->validactivities )
8024 assert(consdata->validactivities);
8028 finitenegminact = (consdata->glbminactivityneginf == 0 && consdata->glbminactivityneghuge == 0);
8029 finitenegmaxact = (consdata->glbmaxactivityneginf == 0 && consdata->maxactivityneghuge == 0);
8030 finiteposminact = (consdata->glbminactivityposinf == 0 && consdata->glbminactivityposhuge == 0);
8031 finiteposmaxact = (consdata->glbmaxactivityposinf == 0 && consdata->glbmaxactivityposhuge == 0);
8032 finiteminact = (finitenegminact && finiteposminact);
8033 finitemaxact = (finitenegmaxact && finiteposmaxact);
8035 if( (finiterhs || finitelhs) && (finitenegminact || finiteposminact || finitenegmaxact || finiteposmaxact) )
8037 SCIP_Real maxabscontrib = -1.0;
8038 SCIP_Bool posval =
FALSE;
8039 SCIP_Bool allbinary =
TRUE;
8040 int oldnchgbds = *nchgbds;
8046 if( (finitenegminact || finiteposminact) && !consdata->validglbminact )
8049 assert(consdata->validglbminact);
8052 if( (finitenegmaxact || finiteposmaxact) && !consdata->validglbmaxact )
8055 assert(consdata->validglbmaxact);
8057 assert(consdata->validglbminact || consdata->validglbmaxact);
8062 for( v =
nvars - 1; v >= 0; --v )
8070 if( value > maxabscontrib )
8072 maxabscontrib = value;
8083 if( value > maxabscontrib )
8085 maxabscontrib = value;
8096 if( !
SCIPisEQ(
scip, maxabscontrib, 1.0) && !allbinary )
8102 if( finiterhs && finiteminact &&
SCIPisEQ(
scip,
QUAD_TO_DBL(consdata->glbminactivity), consdata->rhs - maxabscontrib) )
8104 for( v =
nvars - 1; v >= 0; --v )
8116 *nchgbds += nbdchgs;
8123 *nchgbds += nbdchgs;
8143 if( finitelhs && finitemaxact &&
SCIPisEQ(
scip,
QUAD_TO_DBL(consdata->glbmaxactivity), consdata->lhs - maxabscontrib) )
8145 for( v =
nvars - 1; v >= 0; --v )
8157 *nchgbds += nbdchgs;
8164 *nchgbds += nbdchgs;
8183 SCIPdebugMsg(
scip,
"extracted %d implications from constraint %s which led to %d bound changes, %scutoff detetcted\n", nimpls,
SCIPconsGetName(cons), *nchgbds - oldnchgbds, *
cutoff ?
"" :
"no ");
8189 if( *nchgbds - oldnchgbds > 0 )
8210 consdata->implsadded =
TRUE;
8214 if( consdata->cliquesadded )
8217 consdata->cliquesadded =
TRUE;
8218 cliquenonzerosadded = 0;
8224 nvars = consdata->nvars;
8225 vars = consdata->vars;
8226 vals = consdata->vals;
8231 if( !consdata->validactivities )
8233 assert(consdata->validactivities);
8237 finitenegminact = (consdata->glbminactivityneginf == 0 && consdata->glbminactivityneghuge == 0);
8238 finitenegmaxact = (consdata->glbmaxactivityneginf == 0 && consdata->maxactivityneghuge == 0);
8239 finiteposminact = (consdata->glbminactivityposinf == 0 && consdata->glbminactivityposhuge == 0);
8240 finiteposmaxact = (consdata->glbmaxactivityposinf == 0 && consdata->glbmaxactivityposhuge == 0);
8241 finiteminact = (finitenegminact && finiteposminact);
8242 finitemaxact = (finitenegmaxact && finiteposmaxact);
8247 if( (finiterhs || finitelhs) && (finitenegminact || finiteposminact || finitenegmaxact || finiteposmaxact) )
8250 SCIP_Real* binvarvals;
8251 int nposbinvars = 0;
8252 int nnegbinvars = 0;
8253 int allonebinary = 0;
8268 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8269 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8287 if( allonebinary <
nvars && (nposbinvars >= 2 || nnegbinvars >= 2) )
8289 SCIP_Real threshold;
8290 int oldnchgbds = *nchgbds;
8296 if( (finitenegminact || finiteposminact) && !consdata->validglbminact )
8299 assert(consdata->validglbminact);
8302 if( (finitenegmaxact || finiteposmaxact) && !consdata->validglbmaxact )
8305 assert(consdata->validglbmaxact);
8307 assert(consdata->validglbminact || consdata->validglbmaxact);
8313 if( finiterhs && finitenegminact && nposbinvars >= 2 )
8316 threshold = consdata->rhs -
QUAD_TO_DBL(consdata->glbminactivity);
8319#ifdef SCIP_DISABLED_CODE
8328 while( j < nposbinvars )
8342 *nchgbds += nbdchgs;
8344 cliquenonzerosadded += j;
8349 if( !stopped && !(*
cutoff) && j < nposbinvars )
8352 int lastfit = j - 2;
8359 while( lastfit >= 0 && j < nposbinvars )
8364 clqvars[lastfit + 1] = binvars[j];
8375 *nchgbds += nbdchgs;
8377 cliquenonzerosadded += (lastfit + 2);
8396 if( !stopped && !*
cutoff && *nchgbds - oldnchgbds > 0 )
8417 if( !consdata->validactivities )
8419 assert(consdata->validactivities);
8421 nvars = consdata->nvars;
8422 vars = consdata->vars;
8423 vals = consdata->vals;
8438 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8439 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8457 oldnchgbds = *nchgbds;
8461 if( !stopped && !(*
cutoff) && finitelhs && finiteposmaxact && nnegbinvars >= 2 )
8464 threshold = consdata->lhs -
QUAD_TO_DBL(consdata->glbmaxactivity);
8466 i = nposbinvars + nnegbinvars - 1;
8468#ifdef SCIP_DISABLED_CODE
8478 while( j >= nposbinvars )
8493 *nchgbds += nbdchgs;
8495 cliquenonzerosadded += (
i - j);
8500 if( !stopped && !(*
cutoff) && jstart >= nposbinvars )
8503 int lastfit = jstart + 1;
8511 while( lastfit <= i && j >= nposbinvars )
8516 assert(lastfit - jstart - 2 >= 0 && lastfit - jstart - 2 <
i);
8517 clqvars[lastfit - jstart - 2] = binvars[j];
8529 *nchgbds += nbdchgs;
8531 cliquenonzerosadded += (
i - lastfit + 2);
8550 if( !stopped && !*
cutoff && *nchgbds - oldnchgbds > 0 )
8571 if( !consdata->validactivities )
8573 assert(consdata->validactivities);
8575 nvars = consdata->nvars;
8576 vars = consdata->vars;
8577 vals = consdata->vals;
8592 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8593 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8611 oldnchgbds = *nchgbds;
8615 if( !(*
cutoff) && finiterhs && finiteminact && nnegbinvars >= 2 )
8624 threshold = consdata->rhs -
QUAD_TO_DBL(consdata->glbminactivity);
8626 i = nposbinvars + nnegbinvars - 1;
8629#ifdef SCIP_DISABLED_CODE
8639 while( j >= nposbinvars )
8654 *nchgbds += nbdchgs;
8656 cliquenonzerosadded += (
i - j);
8661 if( !stopped && !(*
cutoff) && jstart >= nposbinvars )
8664 int lastfit = j + 1;
8672 while( lastfit <= i && j >= nposbinvars )
8677 assert(lastfit - jstart - 2 >= 0 && lastfit - jstart - 2 <
i);
8678 clqvars[lastfit - jstart - 2] = binvars[j];
8690 *nchgbds += nbdchgs;
8692 cliquenonzerosadded += (
i - lastfit + 2);
8713 if( !stopped && !*
cutoff && *nchgbds - oldnchgbds > 0 )
8734 if( !consdata->validactivities )
8736 assert(consdata->validactivities);
8738 nvars = consdata->nvars;
8739 vars = consdata->vars;
8740 vals = consdata->vals;
8755 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8756 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8776 if( !stopped && !(*
cutoff) && finitelhs && finitemaxact && nposbinvars >= 2 )
8785 threshold = consdata->lhs -
QUAD_TO_DBL(consdata->glbmaxactivity);
8789#ifdef SCIP_DISABLED_CODE
8799 while( j < nposbinvars )
8813 *nchgbds += nbdchgs;
8815 cliquenonzerosadded += j;
8820 if( !stopped && !(*
cutoff) && j < nposbinvars )
8823 int lastfit = j - 2;
8830 while( lastfit >= 0 && j < nposbinvars )
8835 clqvars[lastfit + 1] = binvars[j];
8846 *nchgbds += nbdchgs;
8848 cliquenonzerosadded += lastfit + 2;
8892 lhsclique =
SCIPisEQ(
scip, consdata->lhs, (SCIP_Real)nposcoefs - 1.0);
8893 rhsclique =
SCIPisEQ(
scip, consdata->rhs, 1.0 - (SCIP_Real)nnegcoefs);
8895 if( lhsclique || rhsclique )
8900 SCIPdebugMsg(
scip,
"linear constraint <%s>: adding clique with %d vars (%d pos, %d neg)\n",
8905 values[
i] = (rhsclique == (vals[
i] > 0.0));
8912 *nchgbds += nbdchgs;
8925 SCIP_Bool* infeasible
8944 *infeasible =
FALSE;
8954 for(
i = 0;
i < consdata->nvars && integral; ++
i )
8975 SCIPdebugMsg(
scip,
"rounding sides=[%.15g,%.15g] of linear constraint <%s> with integral coefficients and variables only "
8976 "is infeasible\n", consdata->lhs, consdata->rhs,
SCIPconsGetName(cons));
8982 SCIPdebugMsg(
scip,
"linear constraint <%s>: make sides integral: sides=[%.15g,%.15g]\n",
8990 if( !consdata->upgraded )
8998 if( !consdata->upgraded )
9001 SCIPdebugMsg(
scip,
"linear constraint <%s>: new integral sides: sides=[%.15g,%.15g]\n",
9052 SCIP_Bool* isvarrelevant;
9053 SCIP_Real minactivity;
9055 SCIP_Real maxactivity;
9057 SCIP_Bool isminacttight;
9058 SCIP_Bool ismaxacttight;
9059 SCIP_Bool isminsettoinfinity;
9060 SCIP_Bool ismaxsettoinfinity;
9061 SCIP_Real minleftactivity;
9062 SCIP_Real maxleftactivity;
9088 if( (consdata->validmaxabsval && consdata->maxabsval >
MAXVALRECOMP)
9089 || (consdata->validminabsval && consdata->minabsval <
MINVALRECOMP) )
9097 &isminsettoinfinity, &ismaxsettoinfinity);
9103 minleftactivity = 0.0;
9104 maxleftactivity = 0.0;
9111 var = consdata->vars[
i];
9112 val = consdata->vals[
i];
9124 if( isvarrelevant[
i] )
9132 lval = consdata->lhs - minactivity;
9133 rval = maxactivity - consdata->rhs;
9136 if( consdata->nvars == 2 )
9139 otherval = consdata->vals[1-
i];
9143 lval = consdata->lhs - val*lb;
9149 rval = val*ub - consdata->rhs;
9154 newval =
MAX3(lval, rval, 0.0);
9158 newlhs = consdata->lhs - val * lb;
9159 newlhs += newval * lb;
9160 newrhs = consdata->rhs - val * ub;
9161 newrhs += newval * ub;
9165 SCIPdebugMsg(
scip,
"linear constraint <%s>: change coefficient %+.15g<%s> to %+.15g<%s>, act=[%.15g,%.15g], side=[%.15g,%.15g]\n",
9167 maxactivity, consdata->lhs, consdata->rhs);
9183 &ismaxacttight, &isminsettoinfinity, &ismaxsettoinfinity);
9188 consdata->lhs, newlhs);
9198 consdata->rhs, newrhs);
9215 minleftactivity += val * lb;
9225 maxleftactivity += val * ub;
9235 if( isvarrelevant[
i] )
9243 lval = minactivity - consdata->lhs;
9244 rval = consdata->rhs - maxactivity;
9247 if( consdata->nvars == 2 )
9250 otherval = consdata->vals[1-
i];
9254 lval = val*ub - consdata->lhs;
9260 rval = consdata->rhs - val*lb;
9265 newval =
MIN3(lval, rval, 0.0);
9269 newlhs = consdata->lhs - val * ub;
9270 newlhs += newval * ub;
9271 newrhs = consdata->rhs - val * lb;
9272 newrhs += newval * lb;
9276 SCIPdebugMsg(
scip,
"linear constraint <%s>: change coefficient %+.15g<%s> to %+.15g<%s>, act=[%.15g,%.15g], side=[%.15g,%.15g]\n",
9278 maxactivity, consdata->lhs, consdata->rhs);
9294 &ismaxacttight, &isminsettoinfinity, &ismaxsettoinfinity);
9299 consdata->lhs, newlhs);
9309 consdata->rhs, newrhs);
9326 minleftactivity += val * ub;
9336 maxleftactivity += val * lb;
9345 minleftactivity, consdata->rhs);
9347 maxleftactivity, consdata->lhs);
9374 aggrlhs = consdata->lhs - minactivity + minleftactivity;
9375 aggrrhs = consdata->rhs - maxactivity + maxleftactivity;
9385 SCIP_Real minleftactivitypart;
9386 SCIP_Real maxleftactivitypart;
9395 if( !isvarrelevant[
i] )
9398 var = consdata->vars[
i];
9399 val = consdata->vals[
i];
9404 SCIPdebugMsg(
scip,
"val = %g\tlhs = %g\trhs = %g\n", val, consdata->lhs, consdata->rhs);
9405 SCIPdebugMsg(
scip,
"linear constraint <%s>: remove variable <%s> from constraint since it is redundant\n",
9411 minleftactivitypart = val * lb;
9412 maxleftactivitypart = val * ub;
9416 minleftactivitypart = val * ub;
9417 maxleftactivitypart = val * lb;
9421 isvarrelevant[
i] = isvarrelevant[consdata->nvars - 1];
9426 newlhs = consdata->lhs - minleftactivitypart;
9427 newrhs = consdata->rhs - maxleftactivitypart;
9432 consdata->lhs, newlhs);
9442 consdata->rhs, newrhs);
9475 SCIP_Bool infeasible;
9486 assert(consdata->nvars == 1);
9490 var = consdata->vars[0];
9491 val = consdata->vals[0];
9511 if( !consdata->upgraded )
9528 SCIP_Bool infeasible;
9529 SCIP_Bool redundant;
9530 SCIP_Bool aggregated;
9540 assert(consdata->nvars == 2);
9543 SCIPdebugMsg(
scip,
"linear constraint <%s>: aggregate %.15g<%s> + %.15g<%s> == %.15g\n",
9545 consdata->vals[1],
SCIPvarGetName(consdata->vars[1]), consdata->rhs);
9549 consdata->rhs, &infeasible, &redundant, &aggregated) );
9568 if( !consdata->upgraded )
9581 SCIP_Real slackcoef,
9586 SCIP_Real slackvarlb;
9587 SCIP_Real slackvarub;
9598 if( slackcoef > 0.0 )
9603 *newrhs = consdata->rhs - slackcoef * slackvarlb;
9607 *newlhs = consdata->lhs - slackcoef * slackvarub;
9614 *newlhs = consdata->rhs - slackcoef * slackvarlb;
9618 *newrhs = consdata->lhs - slackcoef * slackvarub;
9648 SCIP_Real bestslackdomrng;
9649 SCIP_Real minabsval;
9650 SCIP_Real maxabsval;
9651 SCIP_Bool bestremovescons;
9652 SCIP_Bool coefszeroone;
9653 SCIP_Bool coefsintegral;
9654 SCIP_Bool varsintegral;
9655 SCIP_Bool infeasible;
9664 int maxnlocksremove;
9681 assert(consdata->nvars > 2);
9691 lhs = consdata->lhs;
9692 rhs = consdata->rhs;
9694 if( consdata->nvars == 3 )
9699 maxnlocksremove = 3;
9701 else if( consdata->nvars == 4 )
9706 maxnlocksremove = 2;
9711 maxnlocksremove = 1;
9730 vars = consdata->vars;
9731 vals = consdata->vals;
9734 bestnlocks = INT_MAX;
9735 bestremovescons =
FALSE;
9736 bestslackdomrng = 0.0;
9737 coefszeroone =
TRUE;
9738 coefsintegral =
TRUE;
9739 varsintegral =
TRUE;
9747 for( v = 0; v < consdata->nvars; ++v )
9771 if( absval < minabsval )
9773 if( absval > maxabsval )
9778 if( maxabsval / minabsval > conshdlrdata->maxmultaggrquot )
9782 coefszeroone = coefszeroone &&
SCIPisEQ(
scip, absval, 1.0);
9810 if( nlocks > maxnlocksremove )
9814 if( (iscont || (coefsintegral && varsintegral &&
SCIPisEQ(
scip, absval, 1.0))) &&
9819 SCIP_Real slackdomrng;
9828 slackdomrng = (varub - varlb)*absval;
9832 better = (slacktype > bestslacktype) || (bestslackpos == -1);
9833 if( !better && slacktype == bestslacktype )
9835 better = (nlocks < bestnlocks);
9836 if( nlocks == bestnlocks && !bestremovescons )
9839 equal = !better &&
SCIPisGE(
scip, slackdomrng, bestslackdomrng);
9843 if( better || equal )
9845 SCIP_Real minresactivity;
9846 SCIP_Real maxresactivity;
9849 SCIP_Bool removescons;
9850 SCIP_Bool ismintight;
9851 SCIP_Bool ismaxtight;
9852 SCIP_Bool isminsettoinfinity;
9853 SCIP_Bool ismaxsettoinfinity;
9857 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
9862 if( !ismintight || !ismaxtight )
9882 if( conshdlrdata->multaggrremove && !removescons )
9886 if( bestremovescons && !removescons )
9892 if( !removescons && nlocks > maxnlocksstay )
9895 better = better || (!bestremovescons && removescons);
9899 bestslacktype = slacktype;
9900 bestnlocks = nlocks;
9901 bestslackdomrng = slackdomrng;
9902 bestremovescons = removescons;
9922 for( v = 0; v < consdata->nvars; ++v )
9924 if( v != bestslackpos )
9956 assert(!samevar || (supinf > 0 && infinf > 0));
9961 if( (samevar && (supinf > 1 || infinf > 1)) || (!samevar && supinf > 0 && infinf > 0) )
9963 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: infimum and supremum are both infinite\n");
9972 if( bestslackpos >= 0
9974 || (coefsintegral && varsintegral && nimplvars == 0)) )
9978 SCIP_Real slackcoef;
9979 SCIP_Real aggrconst;
9982 SCIP_Bool aggregated;
9996 slackvar =
vars[bestslackpos];
9997 slackcoef = vals[bestslackpos];
9999 aggrconst = consdata->rhs/slackcoef;
10012 for( v = 0; v < consdata->nvars; ++v )
10014 scalars[v] = -consdata->vals[v]/slackcoef;
10017 SCIPdebugMsgPrint(
scip,
" %+.15g, bounds of <%s>: [%.15g,%.15g], nlocks=%d, maxnlocks=%d, removescons=%u\n",
10019 bestnlocks, bestremovescons ? maxnlocksremove : maxnlocksstay, bestremovescons);
10023 &infeasible, &aggregated) );
10040 if( bestremovescons )
10045 if( !consdata->upgraded )
10049 else if( ncontvars == 1 )
10053 assert(0 <= contvarpos && contvarpos < consdata->
nvars);
10063 SCIPdebugMsg(
scip,
"linear constraint <%s>: converting continuous variable <%s> to implicit integer variable\n",
10082 SCIP_Bool redundant;
10083 SCIP_Bool aggregated;
10085 absval =
REALABS(vals[contvarpos]);
10096#ifdef WITH_DEBUG_SOLUTION
10097 if( SCIPdebugIsMainscip(
scip) )
10106 SCIPdebugMsg(
scip,
"linear constraint <%s>: aggregating continuous variable <%s> to newly created implicit integer variable <%s>, aggregation factor = %g\n",
10114 SCIPdebugMsg(
scip,
"infeasible aggregation of variable <%s> to implicit variable <%s>, domain is empty\n",
10136 consdata->boundstightened = 0;
10137 consdata->rangedrowpropagated = 0;
10138 consdata->presolved =
FALSE;
10141 else if( ncontvars == 0 && nimplvars == 0 &&
nintvars == 1 && !coefszeroone )
10149 assert(0 <= intvarpos && intvarpos < consdata->
nvars);
10158 SCIPdebugMsg(
scip,
"linear constraint <%s>: converting integer variable <%s> to implicit integer variable\n",
10193 vars = consdata->vars;
10194 nvars = consdata->nvars;
10198 for( v = 0; v <
nvars; ++v )
10222 val = consdata->vals[v];
10229 (*scale) = val / -
objval;
10241 (*scale) = val /
objval;
10264 SCIP_Bool applicable;
10277 nvars = consdata->nvars;
10286 (
nvars == nobjvars && (!conshdlrdata->detectcutoffbound || !conshdlrdata->detectlowerbound)) )
10289 offset = consdata->rhs;
10299 vars = consdata->vars;
10304 SCIPdebugMsg(
scip,
"linear equality constraint <%s> == %g (offset %g) is a subset of the objective function\n",
10312 for( v = 0; v <
nvars; ++v )
10329 SCIP_Real primalbound
10332 SCIP_Real cutoffbound;
10381 SCIP_Bool applicable;
10396 nvars = consdata->nvars;
10411 if( nobjvars == 0 )
10426 if( conshdlrdata->detectcutoffbound && rhsfinite )
10428 SCIP_Real primalbound;
10430 primalbound = (consdata->rhs - offset) / scale;
10432 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a cutoff bound <%g>\n",
10438 if( conshdlrdata->detectlowerbound && lhsfinite )
10440 SCIP_Real lowerbound;
10442 lowerbound = (consdata->lhs - offset) / scale;
10444 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a lower bound <%g>\n",
10450 if( (conshdlrdata->detectcutoffbound && (conshdlrdata->detectlowerbound || !lhsfinite)) ||
10451 (conshdlrdata->detectlowerbound && !rhsfinite) )
10460 if( conshdlrdata->detectlowerbound && rhsfinite )
10462 SCIP_Real lowerbound;
10464 lowerbound = (consdata->rhs - offset) / scale;
10466 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a lower bound <%g>\n",
10472 if( conshdlrdata->detectcutoffbound && lhsfinite )
10474 SCIP_Real primalbound;
10476 primalbound = (consdata->lhs - offset) / scale;
10478 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a cutoff bound <%g>\n",
10484 if( (conshdlrdata->detectcutoffbound && (conshdlrdata->detectlowerbound || !rhsfinite)) ||
10485 (conshdlrdata->detectlowerbound && !lhsfinite) )
10522 assert(consdata->removedfixings);
10529 if( consdata->nvars == 1 )
10534 else if( consdata->nvars == 2 )
10568 for( v = 0; v < consdata->nvars; ++v )
10585 SCIP_Real minresactivity,
10586 SCIP_Real maxresactivity,
10598 *minval = -maxresactivity;
10600 *minval = (side - maxresactivity)/val;
10603 *maxval = -minresactivity;
10605 *maxval = (side - minresactivity)/val;
10610 *minval = minresactivity;
10612 *minval = (side - minresactivity)/val;
10615 *maxval = maxresactivity;
10617 *maxval = (side - maxresactivity)/val;
10638 SCIP_Bool lhsexists;
10639 SCIP_Bool rhsexists;
10640 SCIP_Bool bestisint;
10641 SCIP_Bool bestislhs;
10642 SCIP_Real minabsval;
10643 SCIP_Real maxabsval;
10686 if( consdata->nvars <= 2 )
10687 maxotherlocks = INT_MAX;
10688 else if( consdata->nvars == 3 )
10690 else if( consdata->nvars == 4 )
10696 if( lhsexists && rhsexists && maxotherlocks < INT_MAX )
10701 for(
i = 0;
i < consdata->nvars && bestisint; ++
i )
10713 val = consdata->vals[
i];
10717 if( absval < minabsval )
10718 minabsval = absval;
10719 if( absval > maxabsval )
10720 maxabsval = absval;
10723 if( maxabsval / minabsval > conshdlrdata->maxdualmultaggrquot )
10726 var = consdata->vars[
i];
10730 if( bestpos >= 0 && isint )
10742 val = consdata->vals[
i];
10779 if( agglhs || aggrhs )
10781 SCIP_Real minresactivity;
10782 SCIP_Real maxresactivity;
10785 SCIP_Bool ismintight;
10786 SCIP_Bool ismaxtight;
10787 SCIP_Bool isminsettoinfinity;
10788 SCIP_Bool ismaxsettoinfinity;
10792 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
10799 assert((ismintight || isminsettoinfinity) && (ismaxtight || ismaxsettoinfinity));
10810 SCIP_Real oldmaxresactivity;
10811 SCIP_Real oldminresactivity;
10812 SCIP_Bool recalculated;
10814 recalculated =
FALSE;
10815 oldmaxresactivity = maxresactivity;
10816 oldminresactivity = minresactivity;
10822 recalculated = !
SCIPisEQ(
scip, oldminresactivity, minresactivity);
10823 isminsettoinfinity =
TRUE;
10830 recalculated = recalculated || !
SCIPisEQ(
scip, oldmaxresactivity, maxresactivity);
10831 ismaxsettoinfinity =
TRUE;
10870 SCIP_Real oldmaxresactivity;
10871 SCIP_Real oldminresactivity;
10872 SCIP_Bool recalculated;
10874 recalculated =
FALSE;
10875 oldmaxresactivity = maxresactivity;
10876 oldminresactivity = minresactivity;
10882 recalculated = !
SCIPisEQ(
scip, oldminresactivity, minresactivity);
10889 recalculated = recalculated || !
SCIPisEQ(
scip, oldmaxresactivity, maxresactivity);
10920 SCIP_Real* aggrcoefs;
10921 SCIP_Real aggrconst;
10927 SCIP_Bool infeasible;
10928 SCIP_Bool aggregated;
10937 assert(!bestislhs || lhsexists);
10938 assert(bestislhs || rhsexists);
10940 bestvar = consdata->vars[bestpos];
10941 bestval = consdata->vals[bestpos];
10958 for( j = 0; j < consdata->nvars; ++j )
10962 SCIP_Real absaggrcoef;
10964 aggrvars[naggrs] = consdata->vars[j];
10965 aggrcoefs[naggrs] = -consdata->vals[j]/consdata->vals[bestpos];
10968 absaggrcoef =
REALABS(aggrcoefs[naggrs]);
10971 if( absaggrcoef < epsilon )
10973 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: too large aggregation coefficients\n");
10986 aggrcoefs[naggrs] =
SCIPfloor(
scip, aggrcoefs[naggrs]+0.5);
11021 assert(!samevar || (supinf > 0 && infinf > 0));
11023 aggrconst = (bestislhs ? consdata->lhs/bestval : consdata->rhs/bestval);
11026 assert(naggrs == consdata->nvars-1);
11035 aggregated =
FALSE;
11036 infeasible =
FALSE;
11039 if( (samevar && supinf == 1 && infinf == 1) || (!samevar && (supinf == 0 || infinf == 0)) )
11051 SCIP_Bool infeasiblevartypechg;
11053 for( j = 0; j < naggrs; ++j)
11062 assert(!infeasiblevartypechg);
11071 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: infimum and supremum are both infinite\n");
11090 if( !consdata->upgraded )
11105#define CONTWEIGHT 8
11173 SCIP_Bool infeasible;
11175 SCIP_Bool aggregated;
11176 SCIP_Bool redundant;
11184 lhs = consdata->lhs;
11185 vars = consdata->vars;
11186 vals = consdata->vals;
11187 nvars = consdata->nvars;
11196 for( v = 0; v <
nvars && noddvars < 3; ++v )
11211 if( noddvars == 0 )
11223 if( noddvars == 1 )
11227 SCIPdebugMsg(
scip,
"linear constraint <%s>: try fixing variable <%s> to <%g>\n",
11247 else if( noddvars == 2 )
11256 SCIPdebugMsg(
scip,
"linear constraint <%s>: try aggregation of variables <%s> and <%s>\n",
11260 lhsodd ? 1.0 : 0.0, &infeasible, &redundant, &aggregated) );
11301 while( success && consdata->nvars >= 1 );
11330 if( vartype2 != vartype1 )
11340 value =
REALABS(consdata->vals[ind2]) -
REALABS(consdata->vals[ind1]);
11343 return (value > 0 ? +1 : (value < 0 ? -1 : 0));
11363 SCIP_Real secondminval;
11380 nvars = consdata->nvars;
11386 lhs = consdata->lhs;
11387 rhs = consdata->rhs;
11396 vals = consdata->vals;
11397 vars = consdata->vars;
11405 for( v =
nvars - 1; v >= 0; --v )
11411 secondminval = minval;
11414 else if( secondminval > vals[v] || secondminval ==
SCIP_INVALID )
11415 secondminval = vals[v];
11429 for( v =
nvars - 1; v >= 0; --v )
11433 (*nchgcoefs) +=
nvars;
11469 SCIP_Bool* infeasible
11476 SCIP_Real minactsub;
11477 SCIP_Real maxactsub;
11478 SCIP_Real siderest;
11489 SCIP_Longint restcoef;
11490 SCIP_Longint oldgcd;
11493 SCIP_Bool isminsettoinfinity;
11494 SCIP_Bool ismaxsettoinfinity;
11495 SCIP_Bool ismintight;
11496 SCIP_Bool ismaxtight;
11497 SCIP_Bool allcoefintegral;
11516 *infeasible =
FALSE;
11528 nvars = consdata->nvars;
11552 consdata->normalized =
FALSE;
11560 if( !consdata->normalized )
11563 lhs = consdata->lhs;
11564 rhs = consdata->rhs;
11578 SCIPdebug( oldnchgcoefs = *nchgcoefs; )
11579 SCIPdebug( oldnchgsides = *nchgsides; )
11582 if( haslhs && hasrhs )
11588 assert(haslhs != hasrhs);
11604 consdata->indexsorted =
FALSE;
11605 consdata->coefsorted =
FALSE;
11607 vars = consdata->vars;
11608 vals = consdata->vals;
11631 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
11634 if( isminsettoinfinity || ismaxsettoinfinity )
11639 assert(maxact > minact);
11645 side = haslhs ? lhs : rhs;
11646 minactsub = minact;
11647 maxactsub = maxact;
11716 for(
w = 0;
w < v; ++
w )
11724 maxactsub -= ub * vals[
w];
11725 minactsub -= lb * vals[
w];
11726 assert(maxactsub > minactsub);
11741 SCIP_Bool redundant =
FALSE;
11742 SCIP_Bool numericsok;
11743 SCIP_Bool rredundant;
11744 SCIP_Bool lredundant;
11757 maxactsub -= ub * vals[0];
11758 minactsub -= lb * vals[0];
11762 maxactsub -= lb * vals[0];
11763 minactsub -= ub * vals[0];
11765 assert(maxactsub > minactsub);
11770 allcoefintegral =
TRUE;
11773 for( ; v <
nvars - 1; ++v )
11780 allcoefintegral =
FALSE;
11799 maxactsub -= ub * vals[v];
11800 minactsub -= lb * vals[v];
11804 maxactsub -= lb * vals[v];
11805 minactsub -= ub * vals[v];
11822 rredundant = hasrhs && maxactsub <= siderest &&
SCIPisFeasGT(
scip, minactsub, siderest - gcd);
11823 lredundant = haslhs &&
SCIPisFeasLT(
scip, maxactsub, siderest) && minactsub >= siderest - gcd;
11826 if( offsetv == -1 && (rredundant || lredundant) )
11852 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",
11853 v,
nvars, minactsub, maxactsub, redundant, hasrhs, siderest, gcd, offsetv);
11860 rredundant = hasrhs && maxactsub <= siderest &&
SCIPisFeasGT(
scip, minactsub, siderest - gcd);
11861 lredundant = haslhs &&
SCIPisFeasLT(
scip, maxactsub, siderest) && minactsub >= siderest - gcd;
11864 if( v <
nvars && numericsok && (redundant || (offsetv == -1 && (rredundant || lredundant))) )
11870 SCIP_Real tmpminactsub = 0.0;
11871 SCIP_Real tmpmaxactsub = 0.0;
11885 tmpmaxactsub += ub * vals[
w];
11886 tmpminactsub += lb * vals[
w];
11890 tmpmaxactsub += lb * vals[
w];
11891 tmpminactsub += ub * vals[
w];
11893 assert(tmpmaxactsub >= tmpminactsub);
11913 (haslhs && tmpmaxactsub < siderest &&
SCIPisFeasGE(
scip, tmpminactsub, siderest - gcd)));
11916 SCIPdebugMsg(
scip,
"removing %d last variables from constraint <%s>, because they never change anything on the feasibility of this constraint\n",
11924 (*nchgcoefs) += (
nvars - v);
11932 assert(vals == consdata->vals);
11947 rhs = consdata->rhs;
11954 lhs = consdata->lhs;
11965 nvars = consdata->nvars;
11968 allcoefintegral =
TRUE;
11972 for(
w = offsetv + 1;
w <
nvars; ++
w )
11981 if( offsetv >= 0 && gcd == 1 )
11991 for( v =
nvars - 1; v > offsetv; --v )
11999 allcoefintegral =
FALSE;
12025 if( candpos == -1 )
12035 assert(v > offsetv || candpos > offsetv);
12041 candpos =
nvars - 1;
12044 if( gcd > 1 && allcoefintegral && !redundant )
12047 allcoefintegral =
FALSE;
12051 if( offsetv >= 0 && gcd > 1 && allcoefintegral )
12058 SCIP_Bool notchangable =
FALSE;
12062 for(
w = offsetv + 1;
w <
nvars; ++
w )
12080 restcoef = ((
SCIP_Longint)(vals[candpos] + feastol)) % gcd;
12087 if( restcoef > rest )
12088 newcoef = vals[candpos] - restcoef + gcd;
12090 newcoef = vals[candpos] - restcoef;
12095 if( rest == 0 || restcoef < rest )
12096 newcoef = vals[candpos] - restcoef;
12098 newcoef = vals[candpos] - restcoef + gcd;
12108 notchangable =
TRUE;
12149 for(
w = offsetv;
w >= 0; --
w )
12155 (*nchgcoefs) += (offsetv + 1);
12158 if( !notchangable )
12162 assert(vals == consdata->vals);
12168 nvars = consdata->nvars;
12173 lhs = consdata->lhs;
12174 rhs = consdata->rhs;
12188 allcoefintegral =
TRUE;
12190 for( v =
nvars - 1; v >= 0; --v )
12195 allcoefintegral =
FALSE;
12207 SCIP_Real
frac = 0.0;
12208 SCIP_Bool found =
FALSE;
12212 if( allcoefintegral )
12223 for( v =
nvars - 1; v >= 0; --v )
12259 SCIPdebugMsg(
scip,
"rounding all non-integral coefficients and the right hand side down\n");
12264 for( v =
nvars - 1; v >= 0; --v )
12301 if( allcoefintegral )
12316 for( v =
nvars - 1; v >= 0; --v )
12364 SCIPdebugMsg(
scip,
"rounding all non-integral coefficients and the left hand side down\n");
12369 for( v =
nvars - 1; v >= 0; --v )
12407 assert(vals == consdata->vals);
12412 rhs = consdata->rhs;
12413 lhs = consdata->lhs;
12420 nvars = consdata->nvars;
12424 allcoefintegral =
TRUE;
12427 for( v =
nvars - 1; v >= 0; --v )
12434 if( !allcoefintegral )
12454 SCIPdebug( oldnchgcoefs = *nchgcoefs; )
12455 SCIPdebug( oldnchgsides = *nchgsides; )
12470 for( v =
nvars - 1; v >= 0; --v )
12477 if( foundbin == -1 )
12505 foundbin =
nvars - 1;
12508 if( gcd == 1 || foundbin == -1)
12511 assert((onlybin && gcd == -1) || (!onlybin && gcd > 1));
12519 for( v = foundbin; v >= 0; --v )
12548 if( candpos == -1 )
12556 if( onlybin && v == foundbin - 1 )
12557 candpos2 = foundbin;
12562 if( onlybin && candpos == v + 1 && candpos2 == v + 2 )
12567 candpos = candpos2;
12610 if( vals[candpos] < 0 )
12612 restcoef = ((
SCIP_Longint)(vals[candpos] - feastol)) % gcd;
12617 restcoef = ((
SCIP_Longint)(vals[candpos] + feastol)) % gcd;
12631 if( restcoef > rest )
12632 newcoef = vals[candpos] - restcoef + gcd;
12634 newcoef = vals[candpos] - restcoef;
12646 if( rest == 0 || restcoef < rest )
12647 newcoef = vals[candpos] - restcoef;
12649 newcoef = vals[candpos] - restcoef + gcd;
12653 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));
12670 assert(vals == consdata->vals);
12677 rhs = consdata->rhs;
12678 lhs = consdata->lhs;
12682 nvars = consdata->nvars;
12684 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));
12686 while(
nvars >= 2 );
12706 int* diffidx0minus1,
12707 int* diffidx1minus0,
12709 int commonidxweight,
12710 int diffidx0minus1weight,
12711 int diffidx1minus0weight,
12712 SCIP_Real maxaggrnormscale,
12714 SCIP_Bool* aggregated,
12715 SCIP_Bool* infeasible
12722 SCIP_Real aggrcoef;
12723 SCIP_Real scalarsum;
12724 SCIP_Real bestscalarsum;
12725 SCIP_Bool betterscalarsum;
12726 SCIP_Bool commonvarlindependent;
12742 assert(nvarscommon >= 1);
12743 assert(commonidxweight >= nvarscommon);
12750 *infeasible =
FALSE;
12757 assert(consdata0->nvars >= 1);
12759 assert(diffidx0minus1weight >= consdata0->nvars - nvarscommon);
12764 assert(consdata1->nvars >= 1);
12766 assert(diffidx1minus0weight >= consdata1->nvars - nvarscommon);
12768 *aggregated =
FALSE;
12774 bestvarweight = commonidxweight + diffidx0minus1weight;
12775 bestnvars = consdata0->nvars;
12777 bestscalarsum = 0.0;
12778 commonvarlindependent =
TRUE;
12779 for( v = 0; v < nvarscommon; ++v )
12781 assert(consdata0->vars[commonidx0[v]] == consdata1->vars[commonidx1[v]]);
12782 a = consdata1->vals[commonidx1[v]];
12783 b = -consdata0->vals[commonidx0[v]];
12789 varweight = diffidx0minus1weight + diffidx1minus0weight;
12790 nvars = consdata0->nvars + consdata1->nvars - 2*nvarscommon;
12792 betterscalarsum = (scalarsum < bestscalarsum);
12793 for(
i = 0;
i < nvarscommon
12794 && (varweight < bestvarweight || (varweight == bestvarweight && betterscalarsum)); ++
i )
12796 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12803 if( varweight < bestvarweight || (varweight == bestvarweight && betterscalarsum) )
12806 bestvarweight = varweight;
12808 bestscalarsum = scalarsum;
12815 if( commonvarlindependent && v > 0 )
12817 consdata1->vals[commonidx1[v]] * consdata0->vals[commonidx0[0]],
12818 consdata1->vals[commonidx1[0]] * consdata0->vals[commonidx0[v]]);
12827 SCIP_Real* newvals;
12835 if( consdata1->vals[commonidx1[bestv]] > 0.0 )
12837 a = consdata1->vals[commonidx1[bestv]];
12838 b = -consdata0->vals[commonidx0[bestv]];
12842 a = -consdata1->vals[commonidx1[bestv]];
12843 b = consdata0->vals[commonidx0[bestv]];
12852 assert(commonvarlindependent);
12853 if( consdata1->vals[commonidx1[0]] > 0.0 )
12855 a = consdata1->vals[commonidx1[0]];
12856 b = -consdata0->vals[commonidx0[0]];
12860 a = -consdata1->vals[commonidx1[0]];
12861 b = consdata0->vals[commonidx0[0]];
12882 SCIPdebug( bestvarweight = diffidx0minus1weight + diffidx1minus0weight; )
12883 bestnvars = consdata0->nvars + consdata1->nvars - 2*nvarscommon;
12886 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> := %.15g*<%s> + %.15g*<%s> -> nvars: %d -> %d, weight: %d -> %d\n",
12888 consdata0->nvars, bestnvars, commonidxweight + diffidx0minus1weight, bestvarweight);
12898 if( !commonvarlindependent )
12900 for(
i = 0;
i < nvarscommon; ++
i )
12902 assert(0 <= commonidx0[
i] && commonidx0[
i] < consdata0->nvars);
12903 assert(0 <= commonidx1[
i] && commonidx1[
i] < consdata1->nvars);
12905 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12908 assert(newnvars < bestnvars);
12909 newvars[newnvars] = consdata0->vars[commonidx0[
i]];
12910 newvals[newnvars] = aggrcoef;
12919 for(
i = 0;
i < nvarscommon; ++
i )
12921 assert(0 <= commonidx0[
i] && commonidx0[
i] < consdata0->nvars);
12922 assert(0 <= commonidx1[
i] && commonidx1[
i] < consdata1->nvars);
12924 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12931 for(
i = 0;
i < consdata0->nvars - nvarscommon; ++
i )
12933 assert(0 <= diffidx0minus1[
i] && diffidx0minus1[
i] < consdata0->nvars);
12935 aggrcoef =
a * consdata0->vals[diffidx0minus1[
i]];
12937 assert(newnvars < bestnvars);
12938 newvars[newnvars] = consdata0->vars[diffidx0minus1[
i]];
12939 newvals[newnvars] = aggrcoef;
12944 for(
i = 0;
i < consdata1->nvars - nvarscommon; ++
i )
12946 assert(0 <= diffidx1minus0[
i] && diffidx1minus0[
i] < consdata1->nvars);
12948 aggrcoef =
b * consdata1->vals[diffidx1minus0[
i]];
12950 assert(newnvars < bestnvars);
12951 newvars[newnvars] = consdata1->vars[diffidx1minus0[
i]];
12952 newvals[newnvars] = aggrcoef;
12955 assert(newnvars == bestnvars);
12963 newlhs =
a * consdata0->lhs +
b * consdata1->lhs;
12967 newrhs =
a * consdata0->rhs +
b * consdata1->rhs;
12980 newconsdata->upgraded = consdata0->upgraded;
12996 if( !consdata0->upgraded )
12997 (*nchgcoefs) += consdata0->nvars + consdata1->nvars - nvarscommon;
12998 *aggregated =
TRUE;
13034 SCIP_Real minscale;
13035 SCIP_Real maxscale;
13042 assert(consdata1->indexsorted);
13043 assert(consdata2->indexsorted);
13053 if( consdata1->nvars != consdata2->nvars )
13057 for(
i = 0;
i < consdata1->nvars; ++
i )
13059 if( consdata1->vars[
i] != consdata2->vars[
i] )
13077 for(
i = 0;
i < consdata1->nvars; ++
i )
13079 SCIP_Real scale = consdata2->vals[
i] / consdata1->vals[
i];
13081 if( minscale > scale )
13089 if( maxscale < scale )
13119 assert(consdata->nvars > 0);
13121 assert(consdata->indexsorted);
13128 return SCIPhashFour(consdata->nvars, minidx, mididx, maxidx);
13146 return (((
unsigned int)consdata->upgraded)<<31) + (
unsigned int)
SCIPconsGetPos(cons);
13160 int* nparallelconss
13164 unsigned int querykey;
13166 *nparallelconss = 0;
13173 if( conskey < querykey )
13175 parallelconss[(*nparallelconss)++] = *querycons;
13176 *querycons = parallelcons;
13177 querykey = conskey;
13181 parallelconss[(*nparallelconss)++] = parallelcons;
13192 if( *querycons == parallelcons )
13228 int nparallelconss;
13241 hashtablesize = nconss;
13243 hashGetKeyLinearcons, hashKeyEqLinearcons, hashKeyValLinearcons, (
void*)
scip) );
13248 for(
c = 0;
c < nconss; ++
c )
13270 assert(consdata0->indexsorted);
13279 if( nparallelconss != 0 )
13289 lhs = consdata0->lhs;
13290 rhs = consdata0->rhs;
13292 for(
i = 0;
i < nparallelconss; ++
i )
13298 consdel = parallelconss[
i];
13312 assert(consdata0->nvars >= 1 && consdata0->nvars == consdatadel->nvars);
13314 assert(consdatadel->indexsorted);
13315 assert(consdata0->vars[0] == consdatadel->vars[0]);
13317 scale = consdata0->vals[0] / consdatadel->vals[0];
13325 assert(consdata0->validmaxabsval);
13326 assert(consdatadel->validmaxabsval);
13328 SCIP_Real scale0 = 1.0 / consdata0->maxabsval;
13329 SCIP_Real scaledel =
COPYSIGN(1.0 / consdatadel->maxabsval, scale);
13331 for( k = 0; k < consdata0->nvars; ++k )
13333 assert(
SCIPisEQ(
scip, scale0 * consdata0->vals[k], scaledel * consdatadel->vals[k]));
13341 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with equal coefficients into single ranged row\n",
13347 lhs =
MAX(scale * consdatadel->lhs, lhs);
13350 rhs =
MIN(scale * consdatadel->rhs, rhs);
13355 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with negated coefficients into single ranged row\n",
13361 lhs =
MAX(scale * consdatadel->rhs, lhs);
13364 rhs =
MIN(scale * consdatadel->lhs, rhs);
13371 assert( ! consdata0->upgraded || consdatadel->upgraded );
13373 if( !consdatadel->upgraded )
13387 rhs = (lhs + rhs)/2;
13396 if( consdata0->changed &&
SCIPconsGetPos(cons0) < *firstchange )
13402#ifdef SCIP_MORE_DEBUG
13424 SCIP_Real maxaggrnormscale,
13435 int* diffidx0minus1;
13436 int* diffidx1minus0;
13437 uint64_t possignature0;
13438 uint64_t negsignature0;
13439 SCIP_Bool cons0changed;
13440 SCIP_Bool cons0isequality;
13441 int diffidx1minus0size;
13443 SCIP_Real cons0lhs;
13444 SCIP_Real cons0rhs;
13445 SCIP_Bool cons0upgraded;
13449 assert(firstchange <= chkind);
13456 cons0 = conss[chkind];
13463 assert(consdata0->nvars >= 1);
13464 cons0isequality =
SCIPisEQ(
scip, consdata0->lhs, consdata0->rhs);
13471 possignature0 = consdata0->possignature;
13472 negsignature0 = consdata0->negsignature;
13479 diffidx1minus0size = consdata0->nvars;
13481 cons0lhs = consdata0->lhs;
13482 cons0rhs = consdata0->rhs;
13483 cons0upgraded = consdata0->upgraded;
13486 cons0changed = consdata0->changed;
13487 consdata0->changed =
FALSE;
13488 for(
c = (cons0changed ? 0 : firstchange);
c < chkind && !(*cutoff) && conss[chkind] !=
NULL; ++
c )
13492 uint64_t possignature1;
13493 uint64_t negsignature1;
13494 SCIP_Bool cons0dominateslhs;
13495 SCIP_Bool cons1dominateslhs;
13496 SCIP_Bool cons0dominatesrhs;
13497 SCIP_Bool cons1dominatesrhs;
13498 SCIP_Bool cons1isequality;
13499 SCIP_Bool coefsequal;
13500 SCIP_Bool coefsnegated;
13501 SCIP_Bool tryaggregation;
13505 int commonidxweight;
13506 int diffidx0minus1weight;
13507 int diffidx1minus0weight;
13511 assert(cons0lhs == consdata0->lhs);
13512 assert(cons0rhs == consdata0->rhs);
13513 assert(cons0upgraded == consdata0->upgraded);
13518 if( cons1 ==
NULL )
13532 if( !cons0changed && !consdata1->changed )
13537 if( cons0upgraded && consdata1->upgraded )
13540 assert(consdata1->nvars >= 1);
13547 possignature1 = consdata1->possignature;
13548 negsignature1 = consdata1->negsignature;
13551 coefsequal = (possignature0 == possignature1) && (negsignature0 == negsignature1);
13552 coefsnegated = (possignature0 == negsignature1) && (negsignature0 == possignature1);
13553 cons0dominateslhs =
SCIPisGE(
scip, cons0lhs, consdata1->lhs)
13554 && ((possignature0 | possignature1) == possignature1)
13555 && ((negsignature0 | negsignature1) == negsignature0);
13556 cons1dominateslhs =
SCIPisGE(
scip, consdata1->lhs, cons0lhs)
13557 && ((possignature0 | possignature1) == possignature0)
13558 && ((negsignature0 | negsignature1) == negsignature1);
13559 cons0dominatesrhs =
SCIPisLE(
scip, cons0rhs, consdata1->rhs)
13560 && ((possignature0 | possignature1) == possignature0)
13561 && ((negsignature0 | negsignature1) == negsignature1);
13562 cons1dominatesrhs =
SCIPisLE(
scip, consdata1->rhs, cons0rhs)
13563 && ((possignature0 | possignature1) == possignature1)
13564 && ((negsignature0 | negsignature1) == negsignature0);
13565 cons1isequality =
SCIPisEQ(
scip, consdata1->lhs, consdata1->rhs);
13566 tryaggregation = (cons0isequality || cons1isequality) && (maxaggrnormscale > 0.0);
13567 if( !cons0dominateslhs && !cons1dominateslhs && !cons0dominatesrhs && !cons1dominatesrhs
13568 && !coefsequal && !coefsnegated && !tryaggregation )
13572 if( tryaggregation && consdata1->nvars > diffidx1minus0size )
13575 diffidx1minus0size = consdata1->nvars;
13601 commonidxweight = 0;
13603 diffidx0minus1weight = 0;
13605 diffidx1minus0weight = 0;
13608 while( (v0 < consdata0->
nvars || v1 < consdata1->
nvars)
13609 && (cons0dominateslhs || cons1dominateslhs || cons0dominatesrhs || cons1dominatesrhs
13610 || coefsequal || coefsnegated || tryaggregation) )
13618 if( v0 < consdata0->
nvars && v1 < consdata1->
nvars )
13619 varcmp =
SCIPvarCompare(consdata0->vars[v0], consdata1->vars[v1]);
13620 else if( v0 < consdata0->
nvars )
13629 var = consdata0->vars[v0];
13630 val0 = consdata0->vals[v0];
13632 if( tryaggregation )
13634 diffidx0minus1[nvars0minus1] = v0;
13639 coefsequal =
FALSE;
13640 coefsnegated =
FALSE;
13645 var = consdata1->vars[v1];
13647 val1 = consdata1->vals[v1];
13648 if( tryaggregation )
13650 diffidx1minus0[nvars1minus0] = v1;
13655 coefsequal =
FALSE;
13656 coefsnegated =
FALSE;
13661 assert(consdata0->vars[v0] == consdata1->vars[v1]);
13662 var = consdata0->vars[v0];
13663 val0 = consdata0->vals[v0];
13664 val1 = consdata1->vals[v1];
13665 if( tryaggregation )
13667 commonidx0[nvarscommon] = v0;
13668 commonidx1[nvarscommon] = v1;
13674 coefsequal = coefsequal && (
SCIPisEQ(
scip, val0, val1));
13675 coefsnegated = coefsnegated && (
SCIPisEQ(
scip, val0, -val1));
13692 cons0dominatesrhs =
FALSE;
13693 cons1dominateslhs =
FALSE;
13697 cons0dominateslhs =
FALSE;
13698 cons1dominatesrhs =
FALSE;
13705 cons0dominateslhs =
FALSE;
13706 cons1dominatesrhs =
FALSE;
13710 cons0dominatesrhs =
FALSE;
13711 cons1dominateslhs =
FALSE;
13717 if( coefsequal || coefsnegated )
13732 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with %s coefficients into single ranged row\n",
13740 lhs =
MAX(consdata0->lhs, consdata1->lhs);
13741 rhs =
MIN(consdata0->rhs, consdata1->rhs);
13746 lhs =
MAX(consdata0->lhs, -consdata1->rhs);
13747 rhs =
MIN(consdata0->rhs, -consdata1->lhs);
13758 if( consdata0->upgraded )
13760 assert(!consdata1->upgraded);
13763 consdatastay = consdata1;
13767 consdatadel = consdata0;
13768 consinddel = chkind;
13774 consdatastay = consdata0;
13778 consdatadel = consdata1;
13785 if( !consdata0->upgraded )
13787 assert(consstay == cons0);
13788 cons0lhs = consdata0->lhs;
13789 cons0rhs = consdata0->rhs;
13795 assert( !consdatastay->upgraded );
13798 conss[consinddel] =
NULL;
13799 if( !consdatadel->upgraded )
13807 if( cons1dominateslhs && (!cons0isequality || cons1dominatesrhs ||
SCIPisInfinity(
scip, consdata0->rhs) ) )
13810 SCIPdebugMsg(
scip,
"left hand side of linear constraint <%s> is dominated by <%s>:\n",
13827 cons0lhs = consdata0->lhs;
13828 cons0isequality =
FALSE;
13829 if( !consdata0->upgraded )
13838 else if( cons0dominateslhs && (!cons1isequality || cons0dominatesrhs ||
SCIPisInfinity(
scip, consdata1->rhs)) )
13841 SCIPdebugMsg(
scip,
"left hand side of linear constraint <%s> is dominated by <%s>:\n",
13858 cons1isequality =
FALSE;
13859 if( !consdata1->upgraded )
13868 if( cons1dominatesrhs && (!cons0isequality || cons1dominateslhs ||
SCIPisInfinity(
scip, -consdata0->lhs)) )
13871 SCIPdebugMsg(
scip,
"right hand side of linear constraint <%s> is dominated by <%s>:\n",
13888 cons0rhs = consdata0->rhs;
13889 cons0isequality =
FALSE;
13890 if( !consdata0->upgraded )
13899 else if( cons0dominatesrhs && (!cons1isequality || cons0dominateslhs ||
SCIPisInfinity(
scip, -consdata1->lhs)) )
13902 SCIPdebugMsg(
scip,
"right hand side of linear constraint <%s> is dominated by <%s>:\n",
13919 cons1isequality =
FALSE;
13920 if( !consdata1->upgraded )
13936 conss[chkind] =
NULL;
13937 if( !consdata0->upgraded )
13952 if( !consdata1->upgraded )
13965 if( tryaggregation )
13967 SCIP_Bool aggregated;
13969 assert(consdata0->nvars == nvarscommon + nvars0minus1);
13970 assert(consdata1->nvars == nvarscommon + nvars1minus0);
13972 aggregated =
FALSE;
13973 if( cons1isequality && !consdata0->upgraded && commonidxweight > diffidx1minus0weight )
13977 nvarscommon, commonidxweight, diffidx0minus1weight, diffidx1minus0weight, maxaggrnormscale,
13978 nchgcoefs, &aggregated,
cutoff) );
13988 conss[chkind] =
NULL;
13991 if( !aggregated && cons0isequality && !consdata1->upgraded && commonidxweight > diffidx0minus1weight )
13995 nvarscommon, commonidxweight, diffidx1minus0weight, diffidx0minus1weight, maxaggrnormscale,
13996 nchgcoefs, &aggregated,
cutoff) );
14026 SCIP_Bool singletonstuffing,
14027 SCIP_Bool singlevarstuffing,
14037 SCIP_Bool* swapped;
14043 SCIP_Real minactivity;
14044 SCIP_Real maxactivity;
14045 SCIP_Real maxcondactivity;
14046 SCIP_Real mincondactivity;
14051 SCIP_Bool isminacttight;
14052 SCIP_Bool ismaxacttight;
14053 SCIP_Bool isminsettoinfinity;
14054 SCIP_Bool ismaxsettoinfinity;
14055 SCIP_Bool tryfixing;
14071 if( singlevarstuffing )
14074 &isminsettoinfinity, &ismaxsettoinfinity);
14080 isminsettoinfinity =
FALSE;
14081 ismaxsettoinfinity =
FALSE;
14089 rhs = -consdata->lhs;
14091 maxactivity = -minactivity;
14092 ismaxsettoinfinity = isminsettoinfinity;
14097 rhs = consdata->rhs;
14101 nvars = consdata->nvars;
14102 vars = consdata->vars;
14103 vals = consdata->vals;
14106 if( singletonstuffing )
14108 for( v = 0; v <
nvars; ++v )
14124 assert(singletonstuffing);
14132 mincondactivity = 0.0;
14133 maxcondactivity = 0.0;
14135 for( v = 0; v <
nvars; ++v )
14141 val = factor * vals[v];
14158 maxcondactivity += val * lb;
14159 mincondactivity += val * lb;
14160 swapped[v] =
FALSE;
14161 ratios[nsingletons] =
obj / val;
14162 varpos[nsingletons] = v;
14177 maxcondactivity += val * ub;
14178 mincondactivity += val * ub;
14180 ratios[nsingletons] =
obj / val;
14181 varpos[nsingletons] = v;
14198 maxcondactivity += val * lb;
14199 mincondactivity += val * lb;
14216 maxcondactivity += val * ub;
14217 mincondactivity += val * ub;
14233 maxcondactivity += val * ub;
14234 mincondactivity += val * lb;
14238 maxcondactivity += val * lb;
14239 mincondactivity += val * ub;
14243 if( tryfixing && nsingletons > 0 && (
SCIPisGT(
scip, rhs, maxcondactivity) ||
SCIPisLE(
scip, rhs, mincondactivity)) )
14246 SCIP_Bool tightened;
14248 int oldnfixedvars = *nfixedvars;
14249 int oldnchgbds = *nchgbds;
14255 for( v = 0; v < nsingletons; ++v )
14259 val = factor * vals[idx];
14264 assert((val < 0) == swapped[idx]);
14279 delta = -(lb - ub) * val;
14281 delta = (ub - lb) * val;
14331 maxcondactivity += delta;
14332 mincondactivity += delta;
14336 if( *nfixedvars - oldnfixedvars > 0 || *nchgbds - oldnchgbds > 0 )
14338 SCIPdebugMsg(
scip,
"### stuffing fixed %d variables and changed %d bounds\n", *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds);
14377 if( singlevarstuffing && !ismaxsettoinfinity )
14382 int bestindex = -1;
14383 int bestuplocks = 0;
14384 int bestdownlocks = 1;
14387 SCIPdebug(
int oldnfixedvars = *nfixedvars; )
14388 SCIPdebug(
int oldnchgbds = *nchgbds; )
14391 for( v = 0; v <
nvars; ++v )
14395 val = factor * vals[v];
14423 if( ratio > bestratio || ((ratio == bestratio) && downlocks == 0 && (bestdownlocks > 0
14428 if( bestindex != -1 )
14431 if( bestuplocks > 1 )
14438 secondbestratio = bestratio;
14441 bestdownlocks = downlocks;
14442 bestuplocks = uplocks;
14449 if( bestdownlocks > 0 && bestuplocks > 1 )
14464 if( ratio > secondbestratio )
14466 secondbestratio = ratio;
14472 if( bestindex != -1 && bestdownlocks == 0 )
14474 SCIP_Bool tightened =
FALSE;
14475 SCIP_Real bounddelta;
14479 val = factor * vals[bestindex];
14491 SCIP_Real bestvarfloor =
SCIPfloor(
scip, (maxactivity - rhs)/-val);
14492 SCIP_Real activitydelta = (maxactivity - rhs) - (bestvarfloor * -val);
14497 bounddelta =
SCIPceil(
scip, (maxactivity - rhs)/-val);
14501 bounddelta = (maxactivity - rhs)/-val;
14503 tryfixing = tryfixing &&
SCIPisLE(
scip, bounddelta, ub - lb);
14528 SCIP_Real bestvarfloor =
SCIPfloor(
scip, (maxactivity - rhs)/val);
14529 SCIP_Real activitydelta = (maxactivity - rhs) - (bestvarfloor * val);
14538 bounddelta = (maxactivity - rhs)/val;
14540 tryfixing = tryfixing &&
SCIPisLE(
scip, bounddelta, ub - lb);
14569 for( v = 0; v <
nvars; ++v )
14577 SCIPdebugMsg(
scip,
"<= %g\n", factor > 0 ? consdata->rhs : -consdata->lhs);
14579 for( v = 0; v <
nvars; ++v )
14581 if( v == bestindex )
14584 if( factor * vals[v] < 0 )
14604 SCIPdebug(
SCIPdebugMsg(
scip,
"### new stuffing fixed %d vars, tightened %d bounds\n", *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds); )
14627 SCIP_Bool* isimplint;
14688 for( v = 0; v <
nvars; ++v )
14700 for( v = 0; v < ncontvars; v++ )
14727 for(
c = 0;
c < nconss; ++
c )
14735 SCIP_Bool lhsexists;
14736 SCIP_Bool rhsexists;
14737 SCIP_Bool hasimpliedpotential;
14738 SCIP_Bool integralcoefs;
14754 for(
i = 0;
i < consdata->nvars; ++
i )
14758 var = consdata->vars[
i];
14763 assert(0 <= contv && contv < ncontvars);
14764 isimplint[contv] =
FALSE;
14777 hasimpliedpotential =
FALSE;
14780 for(
i = 0;
i < consdata->nvars; ++
i )
14784 SCIP_Real minresactivity;
14785 SCIP_Real maxresactivity;
14786 SCIP_Real newredlb;
14787 SCIP_Real newredub;
14788 SCIP_Bool ismintight;
14789 SCIP_Bool ismaxtight;
14790 SCIP_Bool isminsettoinfinity;
14791 SCIP_Bool ismaxsettoinfinity;
14794 var = consdata->vars[
i];
14796 val = consdata->vals[
i];
14811 isminsettoinfinity =
TRUE;
14812 ismaxsettoinfinity =
TRUE;
14818 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
14824 assert((ismintight || isminsettoinfinity) && (ismaxtight || ismaxsettoinfinity));
14839 newredlb = redlb[arrayindex];
14840 newredub = redub[arrayindex];
14846 nlocksdown[arrayindex] += nlockspos;
14847 newredlb = (isminsettoinfinity ?
SCIPinfinity(
scip) : (consdata->lhs - minresactivity)/val);
14852 nlocksup[arrayindex] += nlockspos;
14853 newredub = (ismaxsettoinfinity ? -
SCIPinfinity(
scip) : (consdata->rhs - maxresactivity)/val);
14861 nlocksup[arrayindex] += nlockspos;
14862 newredub = (isminsettoinfinity ? -
SCIPinfinity(
scip) : (consdata->lhs - minresactivity)/val);
14867 nlocksdown[arrayindex] += nlockspos;
14868 newredlb = (ismaxsettoinfinity ?
SCIPinfinity(
scip) : (consdata->rhs - maxresactivity)/val);
14882 redlb[arrayindex] =
MAX(redlb[arrayindex], newredlb);
14883 redub[arrayindex] =
MIN(redub[arrayindex], newredub);
14890 assert(nconscontvars < ncontvars);
14892 conscontvars[nconscontvars] =
var;
14896 assert(0 <= contv && contv < ncontvars);
14897 hasimpliedpotential = hasimpliedpotential || isimplint[contv];
14902 if( hasimpliedpotential )
14904 if( nconscontvars > 1 || !integralcoefs )
14909 for(
i = 0;
i < nconscontvars;
i++ )
14913 assert(0 <= contv && contv < ncontvars);
14914 isimplint[contv] =
FALSE;
14928 assert(nconscontvars == 1);
14929 assert(0 <= contvarpos && contvarpos < consdata->
nvars);
14930 var = consdata->vars[contvarpos];
14931 val = consdata->vals[contvarpos];
14933 assert(0 <= contv && contv < ncontvars);
14934 assert(isimplint[contv]);
14938 isimplint[contv] =
FALSE;
14944 if(
obj * val >= 0.0 && lhsexists )
14949 if(
obj * val <= 0.0 && rhsexists )
14961 for( v = 0; v <
nvars; ++v )
14965 SCIP_Bool infeasible;
14966 SCIP_Bool tightened;
14991 SCIPdebugMsg(
scip,
"variable <%s> only locked down in linear constraints: dual presolve <%s>[%.15g,%.15g] <= %.15g\n",
14998 redub[v] =
MIN(redub[v], ub);
15020 SCIPdebugMsg(
scip,
"variable <%s> only locked up in linear constraints: dual presolve <%s>[%.15g,%.15g] >= %.15g\n",
15027 redlb[v] =
MAX(redlb[v], lb);
15038 SCIP_Bool infeasible;
15064 SCIPdebugMsg(
scip,
"dual presolve: converting continuous variable <%s>[%g,%g] to implicit integer\n",
15095 SCIP_Bool checkrelmaxabs;
15096 SCIP_Bool violated;
15108 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
15110 SCIPdebugMsg(
scip,
"Enforcement method of linear constraints for %s solution\n",
sol ==
NULL ?
"LP" :
"relaxation");
15118 for(
c = 0;
c < nusefulconss; ++
c )
15167 SCIP_Real constant = 0.0;
15184 nlocvars = consdata->nvars;
15189 for(
i = 0;
i < nlocvars; ++
i )
15191 vars[
i] = consdata->vars[
i];
15192 vals[
i] = consdata->vals[
i];
15196 lhs = consdata->lhs - constant;
15197 rhs = consdata->rhs - constant;
15207 for(
i = 0;
i < nlocvars; ++
i )
15215 cons, lhs, rhs, success) );
15280 conshdlrdata->naddconss = 0;
15283 for(
c = 0;
c < nconss; ++
c )
15308 for(
c = nconss - 1;
c >= 0; --
c )
15315 if( consdata->eventdata !=
NULL )
15389 for(
c = 0;
c < nconss;
c++ )
15408 rhs = consdata->rhs;
15409 lhs = consdata->lhs;
15413 for(
i = 0;
i < consdata->nvars;
i++ )
15419 if( consdata->nvars == 0 )
15439 if( consdata->nvars == 1 )
15449 if( consdata->nvars == 2 &&
SCIPisEQ(
scip, lhs, rhs) )
15459 if( consdata->nvars == 2 )
15464 if(
SCIPisEQ(
scip, consdata->vals[0], -consdata->vals[1])
15486 SCIP_Bool unmatched;
15492 scale =
REALABS(consdata->vals[0]);
15495 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15502 if( consdata->vals[
i] < 0.0 )
15510 b = rhs/scale + nnegbinvars;
15531 b = rhs/scale + nnegbinvars;
15556 b = lhs/scale + nnegbinvars;
15582 SCIP_Bool unmatched;
15586 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15594 b -= consdata->vals[
i];
15614 for(
i = 0;
i < consdata->nvars && !matched;
i++ )
15619 SCIPdebugMsg(
scip,
"classified as %s: ", matched ?
"BINPACKING" :
"KNAPSACK");
15635 SCIP_Bool unmatched;
15642 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15666 SCIP_Bool unmatched;
15669 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15702#ifdef SCIP_STATISTIC
15713#ifdef SCIP_STATISTIC
15721 for(
c = 0;
c < nconss; ++
c )
15731 if( consdata->upgraded )
15738 if(
SCIPisLT(
scip, consdata->maxactdelta, conshdlrdata->maxeasyactivitydelta) )
15743 SCIPstatisticMessage(
"below threshold: %d / %d ratio= %g\n", ngoodconss, nallconss, (100.0 * ngoodconss / nallconss));
15747 for(
c = 0;
c < nconss; ++
c )
15757 if( consdata->upgraded )
15782 for(
c = 0;
c < nconss; ++
c )
15800 for(
c = 0;
c < nconss; ++
c )
15807 if( consdata->row !=
NULL )
15812 if( consdata->nlrow !=
NULL )
15828 if( ncutsadded > 0 )
15831 "(restart) converted %d cuts from the global cut pool into linear constraints\n", ncutsadded);
15882 if( consdata->eventdata !=
NULL )
15910 if( (*consdata)->eventdata !=
NULL )
15950 SCIP_CALL(
consdataCreate(
scip, &targetdata, sourcedata->nvars, sourcedata->vars, sourcedata->vals, sourcedata->lhs, sourcedata->rhs) );
15957 for(n = targetdata->nvars - 1; n >= 0; --n )
15982 *infeasible =
FALSE;
15984 for(
c = 0;
c < nconss && !(*infeasible); ++
c )
15999 SCIP_Real loclowerbound;
16000 SCIP_Real glblowerbound;
16001 SCIP_Real cutoffbound;
16002 SCIP_Real maxbound;
16003 SCIP_Bool separatecards;
16026 if( (
depth == 0 && conshdlrdata->maxroundsroot >= 0 && nrounds >= conshdlrdata->maxroundsroot)
16027 || (
depth > 0 && conshdlrdata->maxrounds >= 0 && nrounds >= conshdlrdata->maxrounds) )
16031 maxsepacuts = (
depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);
16037 maxbound = glblowerbound + conshdlrdata->maxcardbounddist * (cutoffbound - glblowerbound);
16038 separatecards =
SCIPisLE(
scip, loclowerbound, maxbound);
16046 for(
c = 0;
c < nusefulconss && ncuts < maxsepacuts && !
cutoff; ++
c )
16055 else if( ncuts > 0 )
16092 if( (
depth == 0 && conshdlrdata->maxroundsroot >= 0 && nrounds >= conshdlrdata->maxroundsroot)
16093 || (
depth > 0 && conshdlrdata->maxrounds >= 0 && nrounds >= conshdlrdata->maxrounds) )
16097 maxsepacuts = (
depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);
16104 for(
c = 0;
c < nusefulconss && ncuts < maxsepacuts && !
cutoff; ++
c )
16113 else if( ncuts > 0 )
16146 SCIP_Bool checkrelmaxabs;
16147 SCIP_Bool violated;
16158 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
16163 if( objinfeasible )
16165 SCIPdebugMsg(
scip,
"-> pseudo solution is objective infeasible, return.\n");
16173 for(
c = 0;
c < nconss && !violated; ++
c )
16194 SCIP_Bool checkrelmaxabs;
16207 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
16214 SCIP_Bool violated =
FALSE;
16224 SCIP_Real activity;
16253 SCIP_Bool rangedrowpropagation =
FALSE;
16254 SCIP_Bool tightenbounds;
16272 tightenbounds =
TRUE;
16277 int tightenboundsfreq;
16282 tightenboundsfreq = propfreq * conshdlrdata->tightenboundsfreq;
16283 tightenbounds = (conshdlrdata->tightenboundsfreq >= 0)
16284 && ((tightenboundsfreq == 0 &&
depth == 0) || (tightenboundsfreq >= 1 && (
depth % tightenboundsfreq == 0)));
16287 rangedrowpropagation = conshdlrdata->rangedrowpropagation;
16289 rangedrowpropagation = rangedrowpropagation && (
depth <= conshdlrdata->rangedrowmaxdepth);
16290 rangedrowfreq = propfreq * conshdlrdata->rangedrowfreq;
16291 rangedrowpropagation = rangedrowpropagation && (conshdlrdata->rangedrowfreq >= 0)
16292 && ((rangedrowfreq == 0 &&
depth == 0) || (rangedrowfreq >= 1 && (
depth % rangedrowfreq == 0)));
16299 for(
i = 0;
i < nmarkedconss && !
cutoff;
i++ )
16303 conshdlrdata->maxeasyactivitydelta, conshdlrdata->sortvars, &
cutoff, &nchgbds) );
16309 else if( nchgbds > 0 )
16318#define MAXCONSPRESOLROUNDS 10
16326 SCIP_Real minactivity;
16327 SCIP_Real maxactivity;
16328 SCIP_Bool isminacttight;
16329 SCIP_Bool ismaxacttight;
16330 SCIP_Bool isminsettoinfinity;
16331 SCIP_Bool ismaxsettoinfinity;
16341 int firstupgradetry;
16353 oldnfixedvars = *nfixedvars;
16354 oldnaggrvars = *naggrvars;
16355 oldnchgbds = *nchgbds;
16356 oldndelconss = *ndelconss;
16357 oldnupgdconss = *nupgdconss;
16358 oldnchgcoefs = *nchgcoefs;
16359 oldnchgsides = *nchgsides;
16366 firstchange = INT_MAX;
16367 firstupgradetry = INT_MAX;
16371 SCIP_Bool infeasible;
16373 infeasible =
FALSE;
16383 consdata->lhs = consdata->rhs;
16387 if( consdata->eventdata ==
NULL )
16410 assert(consdata->removedfixings);
16417 if( firstchange == INT_MAX && consdata->changed )
16421 if( firstupgradetry == INT_MAX && !consdata->upgradetried )
16422 firstupgradetry =
c;
16425 if( consdata->presolved )
16443 consdata->presolved =
TRUE;
16460 SCIPdebugMsg(
scip,
" -> infeasibility detected during tightening sides\n");
16468 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16486 &isminsettoinfinity, &ismaxsettoinfinity);
16489 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16490 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16496 SCIPdebugMsg(
scip,
"linear constraint <%s> is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16497 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16501 if( !consdata->upgraded )
16507 SCIPdebugMsg(
scip,
"linear constraint <%s> left hand side is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16508 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16510 if( !consdata->upgraded )
16515 SCIPdebugMsg(
scip,
"linear constraint <%s> right hand side is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16516 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16518 if( !consdata->upgraded )
16523 if( consdata->nvars == 0 )
16527 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16533 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16538 if( !consdata->upgraded )
16548 if( conshdlrdata->simplifyinequalities )
16557 if( conshdlrdata->aggregatevariables )
16568 if( conshdlrdata->rangedrowpropagation )
16570 int lastnfixedvars;
16572 lastnfixedvars = *nfixedvars;
16577 if( lastnfixedvars < *nfixedvars )
16588 nfixedvars, nchgbds, &
cutoff) );
16595 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16601 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16606 if( !consdata->upgraded )
16631 if( firstchange == INT_MAX && consdata->changed )
16635 if( firstupgradetry == INT_MAX && !consdata->upgradetried )
16636 firstupgradetry =
c;
16644 conshdlrdata->singlevarstuffing, &
cutoff, nfixedvars, nchgbds) );
16647 if( consdata->nvars == 0 )
16651 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16657 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16662 if( !consdata->upgraded )
16675 assert(firstchange >= 0);
16677 if( firstchange < nconss && conshdlrdata->presolusehashing )
16681 ndelconss, nchgsides) );
16684 if( firstchange < nconss && conshdlrdata->presolpairwise )
16688 int firstchangenew;
16689 SCIP_Longint npaircomparisons;
16691 npaircomparisons = 0;
16692 oldndelconss = *ndelconss;
16693 oldnchgsides = *nchgsides;
16694 oldnchgcoefs = *nchgcoefs;
16700 firstchangenew = -1;
16701 for(
c = 0;
c < nconss; ++
c )
16704 if(
c == firstchange )
16705 firstchangenew = nusefulconss;
16711 usefulconss[nusefulconss] = conss[
c];
16714 firstchange = firstchangenew;
16715 assert(firstchangenew >= 0 && firstchangenew <= nusefulconss);
16720 if( usefulconss[
c] ==
NULL )
16727 &
cutoff, ndelconss, nchgsides, nchgcoefs) );
16729 if( npaircomparisons > conshdlrdata->nmincomparisons )
16731 assert(npaircomparisons > 0);
16732 if( ((*ndelconss - oldndelconss) + (*nchgsides - oldnchgsides)/2.0 + (*nchgcoefs - oldnchgcoefs)/10.0) / ((SCIP_Real) npaircomparisons) < conshdlrdata->mingainpernmincomp )
16734 oldndelconss = *ndelconss;
16735 oldnchgsides = *nchgsides;
16736 oldnchgcoefs = *nchgcoefs;
16737 npaircomparisons = 0;
16748 if( !
cutoff && firstupgradetry < nconss
16749 && *nfixedvars == oldnfixedvars && *naggrvars == oldnaggrvars && *nchgbds == oldnchgbds && *ndelconss == oldndelconss
16750 && *nupgdconss == oldnupgdconss && *nchgcoefs == oldnchgcoefs && *nchgsides == oldnchgsides
16777 if( consdata->upgradetried )
16780 if( !consdata->presolved )
16783 consdata->upgradetried =
TRUE;
16789 if( upgdcons !=
NULL )
16799 assert(!consdata->upgraded);
16800 consdata->upgraded =
TRUE;
16806 || !conshdlrdata->presolpairwise
16807 || (conshdlrdata->maxaggrnormscale == 0.0) )
16819 else if( *nfixedvars > oldnfixedvars || *naggrvars > oldnaggrvars || *nchgbds > oldnchgbds || *ndelconss > oldndelconss
16820 || *nupgdconss > oldnupgdconss || *nchgcoefs > oldnchgcoefs || *nchgsides > oldnchgsides )
16861 for(
i = 0;
i < consdata->nvars; ++
i )
16925 SCIP_Real* sourcecoefs;
16926 const char* consname;
16945 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
valid) );
16960 char** firstoperator,
16961 char** secondoperator,
16971 *firstoperator =
NULL;
16972 *secondoperator =
NULL;
16978 while( *curr && *success )
16980 SCIP_Bool found =
FALSE;
16991 if( curr[1] ==
'=' )
17000 if( strncmp(curr,
"[free]", 6) == 0 )
17015 if( *firstoperator ==
NULL )
17017 *firstoperator = curr;
17021 if( *secondoperator !=
NULL )
17026 else if( strncmp(*firstoperator,
"<=", 2) != 0 )
17028 SCIPerrorMessage(
"Two operators in line that is not a ranged row: %s", str);
17031 else if( strncmp(curr,
"<=", 2) != 0 )
17033 SCIPerrorMessage(
"Bad second operator, expected ranged row specification: %s", str);
17037 *secondoperator = curr;
17047 if( *firstoperator ==
NULL )
17069 SCIP_Bool operatorsuccess;
17084 (*success) =
FALSE;
17099 if( ! operatorsuccess )
17102 varstrptr = (
char *)str;
17103 lhsstrptr = rhsstrptr =
NULL;
17110 assert(firstop[1] ==
'=');
17112 if( secondop !=
NULL )
17114 assert(secondop[0] ==
'<' && secondop[1] ==
'=');
17115 lhsstrptr = (
char *)str;
17116 varstrptr = firstop + 2;
17117 rhsstrptr = secondop + 2;
17123 varstrptr = (
char *)str;
17124 rhsstrptr = firstop + 2;
17128 assert(firstop[1] ==
'=');
17131 lhsstrptr = firstop + 2;
17134 assert(firstop[1] ==
'=');
17137 rhsstrptr = firstop + 2;
17138 lhsstrptr = firstop + 2;
17141 assert(strncmp(firstop,
"[free]", 6) == 0);
17147 SCIPerrorMessage(
"Parsing has wrong operator character '%c', should be one of <=>[", *firstop);
17152 if( lhsstrptr !=
NULL )
17156 SCIPerrorMessage(
"error parsing left hand side number from <%s>\n", lhsstrptr);
17161 if( rhsstrptr == lhsstrptr )
17166 if( rhsstrptr !=
NULL && rhsstrptr != lhsstrptr )
17170 SCIPerrorMessage(
"error parsing right hand side number from <%s>\n", lhsstrptr);
17185 if( *success && requsize > coefssize )
17188 coefssize = requsize;
17193 assert(!*success || requsize <= coefssize);
17203 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
17222 if( varssize < consdata->
nvars )
17223 (*success) =
FALSE;
17245 (*nvars) = consdata->nvars;
17289 cons = eventdata->cons;
17303 SCIP_Real oldbound;
17304 SCIP_Real newbound;
17308 varpos = eventdata->varpos;
17314 val = consdata->vals[varpos];
17333 consdata->presolved =
FALSE;
17334 consdata->rangedrowpropagated = 0;
17342 if( consdata->maxactdeltavar ==
var )
17345 consdata->maxactdeltavar =
NULL;
17349 if( consdata->boundstightened > 0)
17351 switch( eventtype )
17355 consdata->boundstightened = 0;
17359 consdata->boundstightened = 0;
17381 delta =
REALABS(val) * domain;
17383 if( delta > consdata->maxactdelta )
17385 consdata->maxactdelta = delta;
17386 consdata->maxactdeltavar =
var;
17393 consdata->presolved =
FALSE;
17394 consdata->removedfixings =
FALSE;
17395 consdata->rangedrowpropagated = 0;
17398 if( consdata->maxactdeltavar ==
var )
17401 consdata->maxactdeltavar =
NULL;
17409 consdata->presolved =
FALSE;
17413 SCIP_Real oldbound;
17414 SCIP_Real newbound;
17418 varpos = eventdata->varpos;
17424 val = consdata->vals[varpos];
17426 consdata->rangedrowpropagated = 0;
17441 consdata->indexsorted =
FALSE;
17443 consdata->coefsorted =
FALSE;
17459 consdata->varsdeleted =
TRUE;
17482 assert(bdchginfos !=
NULL || nbdchginfos == 0);
17498 for(
i = 0;
i < nbdchginfos; ++
i )
17519 if(
i == nbdchginfos )
17532 if( upgdcons !=
NULL )
17568 assert(upgdconsssize > 0);
17606 consdata->checkabsolute =
TRUE;
17634 eventExecLinear,
NULL) );
17638 conflictExecLinear,
NULL) );
17646 consEnfolpLinear, consEnfopsLinear, consCheckLinear, consLockLinear,
17688 "multiplier on propagation frequency, how often the bounds are tightened (-1: never, 0: only at root)",
17692 "maximal number of separation rounds per node (-1: unlimited)",
17696 "maximal number of separation rounds per node in the root node (-1: unlimited)",
17700 "maximal number of cuts separated per separation round",
17704 "maximal number of cuts separated per separation round in the root node",
17708 "should pairwise constraint comparison be performed in presolving?",
17712 "should hash table be used for detecting redundant constraints in advance",
17716 "number for minimal pairwise presolve comparisons",
17720 "minimal gain per minimal pairwise presolve comparisons to repeat pairwise comparison round",
17724 "maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint aggregation)",
17728 "maximum activity delta to run easy propagation on linear constraint (faster, but numerically less stable)",
17732 "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts",
17736 "should all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value?",
17740 "should presolving search for aggregations in equations",
17744 "should presolving try to simplify inequalities",
17748 "should dual presolving steps be performed?",
17752 "should stuffing of singleton continuous variables be performed?",
17756 "should single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable?",
17759 "constraints/" CONSHDLR_NAME "/sortvars",
"apply binaries sorting in decr. order of coeff abs value?",
17763 "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)?",
17767 "should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP?",
17771 "should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP?",
17775 "should presolving try to detect subsets of constraints parallel to the objective function?",
17779 "should presolving and propagation try to improve bounds, detect infeasibility, and extract sub-constraints from ranged rows and equations?",
17783 "should presolving and propagation extract sub-constraints from ranged rows and equations?",
17787 "maximum depth to apply ranged row propagation",
17791 "frequency for applying ranged row propagation",
17795 "should multi-aggregations only be performed if the constraint can be removed afterwards?",
17799 "maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation",
17803 "maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation",
17807 "should Cliques be extracted?",
17818 const char* conshdlrname
17833 if( conshdlr ==
NULL )
17877 SCIP_Bool separate,
17887 SCIP_Bool modifiable,
17893 SCIP_Bool removable,
17895 SCIP_Bool stickingatnode
17909 if( conshdlr ==
NULL )
17915 for( j = 0; j <
nvars; ++j )
17931 SCIP_Real* consvals;
17932 SCIP_Real constant = 0.0;
17944 if( requiredsize > nconsvars )
17950 assert(requiredsize <= nconsvars);
17956 if( constant < 0.0 )
17963 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);
17973 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);
17989 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);
17999 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);
18043 if( check || enforce )
18046 for(n = consdata->nvars - 1; n >= 0; --n )
18052 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
18053 local, modifiable, dynamic, removable, stickingatnode) );
18093 SCIP_Real* sourcecoefs,
18101 SCIP_Bool separate,
18106 SCIP_Bool modifiable,
18108 SCIP_Bool removable,
18109 SCIP_Bool stickingatnode,
18118 SCIP_Real constant;
18134 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
18142 if( sourcecoefs !=
NULL )
18149 for( v = 0; v <
nvars; ++v )
18162 if( requiredsize >
nvars )
18173 for( v = 0; v <
nvars; ++v )
18183 for( v = 0; v <
nvars && success; ++v )
18205 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
18242 SCIP_Real* consvals;
18243 SCIP_Real constant = 0.0;
18260 if( requiredsize > nconsvars )
18266 assert(requiredsize <= nconsvars);
18272 lhs = consdata->lhs;
18273 rhs = consdata->rhs;
18279 if( constant < 0.0 )
18352 for( v = nconsvars - 1; v >= 0; --v )
18406 SCIPerrorMessage(
"method may only be called during problem creation stage for original constraints and variables\n");
18413 vars = consdata->vars;
18486 return consdata->lhs;
18510 return consdata->rhs;
18573 return consdata->nvars;
18597 return consdata->vars;
18621 return consdata->vals;
18650 if( consdata->row !=
NULL )
18678 if( consdata->row !=
NULL )
18706 if( consdata->row !=
NULL )
18734 if( consdata->row !=
NULL )
18763 return consdata->row;
18780 SCIP_Real poscoeffsum;
18781 SCIP_Real negcoeffsum;
18782 SCIP_Bool infeasible;
18783 SCIP_Bool integral;
18832 if( consdata->upgraded )
18836 if( consdata->row !=
NULL )
18840 SCIPerrorMessage(
"cannot upgrade linear constraint that is already stored as row in the LP\n");
18892 for(
i = 0;
i < consdata->nvars; ++
i )
18894 var = consdata->vars[
i];
18895 val = consdata->vals[
i];
18963 poscoeffsum += val;
18965 negcoeffsum += val;
18972 SCIPdebugMsg(
scip,
"upgrading linear constraint <%s> (%d upgrade methods):\n",
18974 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",
18975 nposbin, nnegbin, nposint, nnegint, nposimpl, nnegimpl, nposcont, nnegcont,
18976 ncoeffspone, ncoeffsnone, ncoeffspint, ncoeffsnint, ncoeffspfrac, ncoeffsnfrac,
18977 poscoeffsum, negcoeffsum, integral);
18980 for(
i = 0;
i < conshdlrdata->nlinconsupgrades && *upgdcons ==
NULL; ++
i )
18982 if( conshdlrdata->linconsupgrades[
i]->active )
18984 SCIP_CALL( conshdlrdata->linconsupgrades[
i]->linconsupgd(
scip, cons, consdata->nvars,
18985 consdata->vars, consdata->vals, consdata->lhs, consdata->rhs,
18986 nposbin, nnegbin, nposint, nnegint, nposimpl, nnegimpl, nposimplbin, nnegimplbin, nposcont, nnegcont,
18987 ncoeffspone, ncoeffsnone, ncoeffspint, ncoeffsnint, ncoeffspfrac, ncoeffsnfrac,
18988 poscoeffsum, negcoeffsum, integral,
18994 if( *upgdcons !=
NULL )
19008 SCIP_Bool onlychecked,
19009 SCIP_Bool* infeasible
19018 if( conshdlr ==
NULL )
19022 *infeasible =
FALSE;
19027 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_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)
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)
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