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
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
289 int linconsupgradessize;
290 int nlinconsupgrades;
291 int tightenboundsfreq;
323 int rangedrowmaxdepth;
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;
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;
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
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];
1625 int* activityposinf;
1626 int* activityneginf;
1627 int* activityposhuge;
1628 int* activityneghuge;
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)++;
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;
2016 if( consdata->validactivities )
2041 if( consdata->validactivities )
2064 if( consdata->validactivities )
2087 if( consdata->validactivities )
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 )
2163 if( delta > consdata->maxactdelta )
2165 consdata->maxactdelta = delta;
2166 consdata->maxactdeltavar =
var;
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;
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);
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;
2406 if( !consdata->validglbminact )
2408 assert(consdata->validglbminact);
2414 if( !consdata->validminact )
2416 assert(consdata->validminact);
2438 *issettoinfinity =
FALSE;
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;
2501 if( !consdata->validglbmaxact )
2503 assert(consdata->validglbmaxact);
2509 if( !consdata->validmaxact )
2511 assert(consdata->validmaxact);
2533 *issettoinfinity =
FALSE;
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);
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;
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);
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);
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];
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 )
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;
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;
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 )
4399 consdata->validmaxabsval =
FALSE;
4405 if( consdata->validminabsval )
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 )
4462 if( consdata->validminabsval )
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;
4565 if( infeasible !=
NULL )
4566 *infeasible =
FALSE;
4571 if( consdata->eventdata ==
NULL )
4587 if( !consdata->removedfixings )
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 )
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);
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) )
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",
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 )
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;
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",
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 )
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);
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 )
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 )
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 )
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 )
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;
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;
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;
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
7024 unsigned int tightenmode;
7030 int oldnchgbdstotal;
7062 nvars = consdata->nvars;
7072 if( !force && (consdata->boundstightened >= tightenmode) )
7079 assert(consdata->coefsorted);
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) )
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);
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 )
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 )
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
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) )
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) )
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) )
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;
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;
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",
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;
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);
9486 assert(consdata->nvars == 1);
9490 var = consdata->vars[0];
9491 val = consdata->vals[0];
9511 if( !consdata->upgraded )
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 )
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;
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))) &&
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 )
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)) )
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",
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;
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 )
10396 nvars = consdata->nvars;
10411 if( nobjvars == 0 )
10426 if( conshdlrdata->detectcutoffbound && rhsfinite )
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 )
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 )
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 )
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 )
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;
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 )
10792 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
10799 assert((ismintight || isminsettoinfinity) && (ismaxtight || ismaxsettoinfinity));
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;
10874 recalculated =
FALSE;
10875 oldmaxresactivity = maxresactivity;
10876 oldminresactivity = minresactivity;
10882 recalculated = !
SCIPisEQ(
scip, oldminresactivity, minresactivity);
10889 recalculated = recalculated || !
SCIPisEQ(
scip, oldmaxresactivity, maxresactivity);
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 )
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)) )
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
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));
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;
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);
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))) )
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 )
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;
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,
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]]);
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;
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;
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
13435 int* diffidx0minus1;
13436 int* diffidx1minus0;
13437 uint64_t possignature0;
13438 uint64_t negsignature0;
13441 int diffidx1minus0size;
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;
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 )
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) );
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)) )
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 )
14479 val = factor * vals[bestindex];
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);
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); )
14688 for( v = 0; v <
nvars; ++v )
14700 for( v = 0; v < ncontvars; v++ )
14727 for(
c = 0;
c < nconss; ++
c )
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 )
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 )
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);
15064 SCIPdebugMsg(
scip,
"dual presolve: converting continuous variable <%s>[%g,%g] to implicit integer\n",
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 )
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])
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;
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");
15642 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
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 )
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 )
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 )
16207 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
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
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;
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;
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 )
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 )
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 )
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;
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;
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 )
17909 if( conshdlr ==
NULL )
17915 for( j = 0; j <
nvars; ++j )
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) );
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) );
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;
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 )
19018 if( conshdlr ==
NULL )
19022 *infeasible =
FALSE;
19027 for(
i = 0;
i < nconss; ++
i )
#define DEFAULT_DUALPRESOLVING
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
#define CONSHDLR_PROP_TIMING
#define CONSHDLR_MAXPREROUNDS
#define DEFAULT_PRESOLPAIRWISE
#define CONSHDLR_SEPAPRIORITY
#define DEFAULT_PRESOLUSEHASHING
#define CONSHDLR_PROPFREQ
#define CONSHDLR_PRESOLTIMING
#define CONSHDLR_EAGERFREQ
#define CONSHDLR_ENFOPRIORITY
#define CONSHDLR_DELAYSEPA
#define CONSHDLR_DELAYPROP
#define CONFLICTHDLR_PRIORITY
#define CONFLICTHDLR_NAME
#define CONFLICTHDLR_DESC
struct InferInfo INFERINFO
#define DEFAULT_MAXSEPACUTSROOT
#define DEFAULT_MAXSEPACUTS
#define DEFAULT_DETECTCUTOFFBOUND
#define DEFAULT_MAXROUNDSROOT
#define DEFAULT_MAXCARDBOUNDDIST
#define DEFAULT_SIMPLIFYINEQUALITIES
#define DEFAULT_MAXROUNDS
#define DEFAULT_DETECTLOWERBOUND
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_EXTRACTCLIQUES
static void permSortConsdata(SCIP_CONSDATA *consdata, int *perm, int nvars)
static void consdataRecomputeMaxActivityDelta(SCIP *scip, SCIP_CONSDATA *consdata)
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)
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)
static SCIP_RETCODE conshdlrdataIncludeUpgrade(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_LINCONSUPGRADE *linconsupgrade)
static SCIP_RETCODE extractCliques(SCIP *scip, SCIP_CONS *cons, SCIP_Real maxeasyactivitydelta, SCIP_Bool sortvars, int *nfixedvars, int *nchgbds, SCIP_Bool *cutoff)
static 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)
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)
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)
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)
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_MAXAGGRNORMSCALE
static SCIP_RETCODE performVarDeletions(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
#define checkMaxActivityDelta(scip, consdata)
static SCIP_Bool isFiniteNonnegativeIntegral(SCIP *scip, SCIP_Real x)
#define DEFAULT_SINGLETONSTUFFING
static void consdataUpdateSignatures(SCIP_CONSDATA *consdata, int pos)
#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
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)
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)
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 DEFAULT_DETECTPARTIALOBJECTIVE
static SCIP_RETCODE enforceConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_RESULT *result)
static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)
static 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)
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)
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)
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)
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)
static SCIP_RETCODE checkPartialObjective(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata)
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)
struct SCIP_LinConsUpgrade SCIP_LINCONSUPGRADE
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
struct SCIP_Conflicthdlr SCIP_CONFLICTHDLR
#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)
struct SCIP_Cons SCIP_CONS
#define SCIP_DECL_CONSEXIT(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSINITSOL(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSSEPALP(x)
struct SYM_Graph SYM_GRAPH
#define SCIP_DECL_CONSENFORELAX(x)
struct SCIP_LinConsStats SCIP_LINCONSSTATS
#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)
struct SCIP_Conshdlr SCIP_CONSHDLR
#define SCIP_DECL_CONSCOPY(x)
#define SCIP_DECL_CONSINIT(x)
struct SCIP_ConsData SCIP_CONSDATA
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSHDLRCOPY(x)
#define SCIP_DECL_CONSEXITSOL(x)
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
enum SCIP_LinConstype SCIP_LINCONSTYPE
#define SCIP_DECL_CONSDELVARS(x)
struct SCIP_Eventhdlr SCIP_EVENTHDLR
#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
struct SCIP_Expr SCIP_EXPR
enum SCIP_BoundType SCIP_BOUNDTYPE
struct SCIP_HashMap SCIP_HASHMAP
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_SORTINDCOMP(x)
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
struct SCIP_HashTable SCIP_HASHTABLE
struct SCIP_NlRow SCIP_NLROW
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
struct SCIP_BdChgIdx SCIP_BDCHGIDX
@ 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