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;
4557 if( infeasible !=
NULL )
4558 *infeasible =
FALSE;
4563 if( consdata->eventdata ==
NULL )
4579 if( !consdata->removedfixings )
4589 lhssubtrahend = 0.0;
4590 rhssubtrahend = 0.0;
4596 while( v < consdata->
nvars )
4618 if(
var != consdata->vars[v] )
4626 lhssubtrahend += constant;
4628 rhssubtrahend += constant;
4648 for(
i = 0;
i < naggrvars; ++
i )
4653 constant += scalar * aggrconstant;
4663 if( constant < 0.0 )
4667 if( infeasible !=
NULL )
4679 lhssubtrahend += constant;
4686 if( constant > 0.0 )
4690 if( infeasible !=
NULL )
4702 rhssubtrahend += constant;
4723 if( infeasible !=
NULL )
4755 if( infeasible !=
NULL )
4778 consdata->removedfixings =
TRUE;
4791 assert(consdata->removedfixings);
4795 for( v = 0; v < consdata->nvars; ++v )
4830 vars = consdata->vars;
4831 vals = consdata->vals;
4832 nvars = consdata->nvars;
4838 assert((infervar ==
NULL) == (inferpos == -1));
4839 assert(inferpos == -1 ||
vars[inferpos] == infervar);
4861 if( infervar !=
NULL )
4866 &ismintight,
NULL, &isminsettoinfinity,
NULL);
4869 NULL, &ismaxtight,
NULL, &ismaxsettoinfinity);
4875 &ismintight,
NULL, &isminsettoinfinity,
NULL);
4878 NULL, &ismaxtight,
NULL, &ismaxsettoinfinity);
4882 if( (reasonisrhs && !isminsettoinfinity && ismintight) || (!reasonisrhs && !ismaxsettoinfinity && ismaxtight) )
4887 resactisinf =
FALSE;
4892 if( infervar !=
NULL )
4904 rescap = consdata->rhs - minresactivity;
4914 rescap = consdata->lhs - maxresactivity;
4917 if( reasonisrhs == (vals[inferpos] > 0.0) )
4923 rescap = (reasonisrhs ? consdata->rhs - minresactivity : consdata->lhs - maxresactivity);
4942 if( reasonisrhs == (vals[
i] > 0.0) )
4970 if( reasonisrhs == (vals[
i] > 0.0) )
5008 vars = consdata->vars;
5009 nvars = consdata->nvars;
5012 assert((infervar ==
NULL) == (inferpos == -1));
5014 assert(inferpos == -1 ||
vars[inferpos] == infervar);
5017 for( v =
nvars - 1; v >= 0; --v )
5022 if(
vars[v] == infervar )
5068 for( v =
nvars - 1; v >= 0; --v )
5130 vars = consdata->vars;
5131 nvars = consdata->nvars;
5133 vals = consdata->vals;
5140 if( inferpos >=
nvars ||
vars[inferpos] != infervar )
5144 for( inferpos = 0; inferpos <
nvars &&
vars[inferpos] != infervar; ++inferpos )
5186 SCIPerrorMessage(
"invalid inference information %d in linear constraint <%s> at position %d for %s bound of variable <%s>\n",
5234 infcountmin = consdata->minactivityneginf
5235 + consdata->minactivityposinf
5236 + consdata->minactivityneghuge
5237 + consdata->minactivityposhuge;
5238 infcountmax = consdata->maxactivityneginf
5239 + consdata->maxactivityposinf
5240 + consdata->maxactivityneghuge
5241 + consdata->maxactivityposhuge;
5243 if( infcountmin > 1 && infcountmax > 1 )
5274 var = consdata->vars[pos];
5284 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newub=%.15g\n",
5286 QUAD_TO_DBL(consdata->minactivity),
QUAD_TO_DBL(consdata->maxactivity), consdata->lhs, consdata->rhs, newub);
5295 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5303 else if( tightened )
5306 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
5313 consdata->upgradetried =
FALSE;
5344 var = consdata->vars[pos];
5354 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
5356 QUAD_TO_DBL(consdata->minactivity),
QUAD_TO_DBL(consdata->maxactivity), consdata->lhs, consdata->rhs, newlb);
5365 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5373 else if( tightened )
5376 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
5383 consdata->upgradetried =
FALSE;
5423 var = consdata->vars[pos];
5430 val = consdata->vals[pos];
5431 lhs = consdata->lhs;
5432 rhs = consdata->rhs;
5442 if( !consdata->validactivities )
5444 assert(consdata->validactivities);
5445 if( !consdata->validminact )
5447 assert(consdata->validminact);
5458 assert(consdata->validminact);
5463 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, minactivity=%.15g > rhs=%.15g\n",
5478 alpha = val * (ub - lb);
5486 newub = lb + (slack / val);
5492 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5510 if( !consdata->validmaxact )
5514 assert(consdata->validmaxact);
5519 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, maxactivity=%.15g < lhs=%.15g\n",
5534 alpha = val * (ub - lb);
5542 newlb = ub - (slack / val);
5548 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5565 assert(consdata->validminact);
5570 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, minactivity=%.15g > rhs=%.15g\n",
5585 alpha = val * (lb - ub);
5593 newlb = ub + slack / val;
5599 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5616 if( !consdata->validmaxact )
5620 assert(consdata->validmaxact);
5625 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, maxactivity=%.15g < lhs=%.15g\n",
5640 alpha = val * (lb - ub);
5648 newub = lb - (slack / val);
5654 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
5778 if( consdata->rangedrowpropagated == 2 )
5782 if( consdata->nvars < 3 )
5799 consdata->rangedrowpropagated = 2;
5806 if( consdata->rangedrowpropagated > 0 )
5809 consdata->rangedrowpropagated = 1;
5814 for( v = consdata->nvars - 1; v >= 0; --v )
5832 lhs = consdata->lhs - fixedact;
5833 rhs = consdata->rhs - fixedact;
5834 nunfixedvars = consdata->nvars - nfixedconsvars;
5879 absval =
REALABS(consdata->vals[v]);
5881 if( absminbincoef > absval )
5882 absminbincoef = absval;
5886 possiblegcd =
FALSE;
5887 infcheckvars[ninfcheckvars] = consdata->vars[v];
5888 infcheckvals[ninfcheckvars] = consdata->vals[v];
5904 if( v == consdata->nvars )
5908 if( ncontvars + 2 > nunfixedvars )
5921 for( ; v < consdata->nvars; ++v )
5930 absval =
REALABS(consdata->vals[v]);
5932 if( absminbincoef > absval )
5933 absminbincoef = absval;
5943 possiblegcd =
FALSE;
5944 infcheckvars[ninfcheckvars] = consdata->vars[v];
5945 infcheckvals[ninfcheckvars] = consdata->vals[v];
5961 infcheckvars[ninfcheckvars] = consdata->vars[v];
5962 infcheckvals[ninfcheckvars] = consdata->vals[v];
5977 if( ninfcheckvars == 0 )
5982 minactinfvarsinvalid =
FALSE;
5983 maxactinfvarsinvalid =
FALSE;
5984 maxactinfvars = 0.0;
5985 minactinfvars = 0.0;
5988 for( v = ninfcheckvars - 1; v >= 0; --v )
5995 if( infcheckvals[v] < 0.0 )
5996 maxactinfvarsinvalid =
TRUE;
5998 minactinfvarsinvalid =
TRUE;
6002 if( infcheckvals[v] < 0.0 )
6003 maxactinfvars += infcheckvals[v] * lb;
6005 minactinfvars += infcheckvals[v] * lb;
6010 if( infcheckvals[v] > 0.0 )
6011 maxactinfvarsinvalid =
TRUE;
6013 minactinfvarsinvalid =
TRUE;
6017 if( infcheckvals[v] > 0.0 )
6018 maxactinfvars += infcheckvals[v] * ub;
6020 minactinfvars += infcheckvals[v] * ub;
6025 minactinfvarsinvalid =
TRUE;
6027 maxactinfvarsinvalid =
TRUE;
6029 if( minactinfvarsinvalid || maxactinfvarsinvalid )
6032 assert(!minactinfvarsinvalid && !maxactinfvarsinvalid);
6034 SCIPdebugMsg(
scip,
"minactinfvarsinvalid = %u, minactinfvars = %g, maxactinfvarsinvalid = %u, maxactinfvars = %g, gcd = %lld, ninfcheckvars = %d, ncontvars = %d\n",
6035 minactinfvarsinvalid, minactinfvars, maxactinfvarsinvalid, maxactinfvars, gcd, ninfcheckvars, ncontvars);
6060 else if( ncontvars == 0 )
6067 v = ninfcheckvars - 1;
6071 for( ; v >= 0 && gcdinfvars >= 2; --v )
6079 SCIPdebugMsg(
scip,
"gcdinfvars =%lld, possiblegcd = %u\n", gcdinfvars, possiblegcd);
6082 if( gcdinfvars >= 1 )
6095 value2 = value + gcd * (
SCIPceil(
scip, (lhs - value) / gcd));
6116 value += gcdinfvars;
6118 assert(nsols < 2 || minvalue <= maxvalue);
6131 value2 = value + gcd * (
SCIPfloor(
scip, (rhs - value) / gcd));
6142 assert(maxvalue > minvalue);
6145 value -= gcdinfvars;
6147 assert(maxvalue > secondsolval);
6150 SCIPdebugMsg(
scip,
"here nsols %s %d, minsolvalue = %g, maxsolvalue = %g, ninfcheckvars = %d, nunfixedvars = %d\n",
6151 nsols > 2 ?
">=" :
"=", nsols, minvalue, maxvalue, ninfcheckvars, nunfixedvars);
6156 SCIPdebugMsg(
scip,
"gcdinfvars = %lld, gcd = %lld, correctedlhs = %g, correctedrhs = %g\n",
6157 gcdinfvars, gcd, lhs, rhs);
6168 else if( nsols == 1 )
6170 assert(minvalue == maxvalue);
6173 if( ninfcheckvars == 1 )
6179 SCIPdebugMsg(
scip,
"fixing single variable <%s> with bounds [%.15g,%.15g] to %.15g\n",
6200 if( ninfcheckvars == nunfixedvars - 1 )
6207 assert(ninfcheckvars > 0);
6210 for( v = 0; v < consdata->nvars - 1; ++v )
6214 if(
w >= ninfcheckvars || consdata->vars[v] != infcheckvars[
w] )
6220 assert((nfixedconsvars == 0) ? (consdata->nvars - v - 1 == ninfcheckvars -
w) :
TRUE);
6222 for( ; v2 < consdata->nvars && w2 < ninfcheckvars; ++v2 )
6227 assert(consdata->vars[v2] == infcheckvars[w2]);
6230 assert(w2 == ninfcheckvars);
6236 if( consdata->vals[v] < 0 )
6245 SCIPdebugMsg(
scip,
"fixing variable <%s> with bounds [%.15g,%.15g] to %.15g\n",
6258 consdata->vars[v],
bound) );
6274 assert(v == consdata->nvars - 1);
6277 if( consdata->vals[v] < 0 )
6286 SCIPdebugMsg(
scip,
"fixing variable <%s> with bounds [%.15g,%.15g] to %.15g\n",
6299 consdata->vars[v],
bound) );
6314 ++conshdlrdata->naddconss;
6319 maxvalue, maxvalue,
TRUE,
TRUE,
TRUE,
FALSE,
TRUE,
TRUE,
FALSE,
FALSE,
TRUE,
FALSE) );
6336 if( ninfcheckvars == 1 )
6344 if( infcheckvals[0] < 0 )
6346 newlb = maxvalue/infcheckvals[0];
6347 newub = minvalue/infcheckvals[0];
6351 newlb = minvalue/infcheckvals[0];
6352 newub = maxvalue/infcheckvals[0];
6359 SCIPdebugMsg(
scip,
"tightening lower bound of variable <%s> from %g to %g\n",
6380 SCIPdebugMsg(
scip,
"tightening upper bound of variable <%s> from %g to %g\n",
6399 else if( ninfcheckvars == nunfixedvars - 1 )
6407 assert(ninfcheckvars > 0);
6408 assert(minvalue < maxvalue);
6411 for( v = 0; v < consdata->nvars - 1; ++v )
6415 if(
w >= ninfcheckvars || consdata->vars[v] != infcheckvars[
w] )
6421 assert((nfixedconsvars == 0) ? (consdata->nvars - v - 1 == ninfcheckvars -
w) :
TRUE);
6423 for( ; v2 < consdata->nvars && w2 < ninfcheckvars; ++v2 )
6428 assert(consdata->vars[v2] == infcheckvars[w2]);
6431 assert(w2 == ninfcheckvars);
6437 if( consdata->vals[v] < 0 )
6439 newlb =
SCIPfloor(
scip, (rhs - minvalue) / consdata->vals[v]);
6440 newub =
SCIPfloor(
scip, (lhs - maxvalue) / consdata->vals[v]);
6444 newlb =
SCIPceil(
scip, (lhs - maxvalue) / consdata->vals[v]);
6445 newub =
SCIPceil(
scip, (rhs - minvalue) / consdata->vals[v]);
6452 SCIPdebugMsg(
scip,
"tightening lower bound of variable <%s> from %g to %g\n",
6464 consdata->vars[v], newlb) );
6474 SCIPdebugMsg(
scip,
"tightening upper bound of variable <%s> from %g to %g\n",
6486 consdata->vars[v], newub) );
6503 assert(v == consdata->nvars - 1);
6506 if( consdata->vals[v] < 0 )
6508 newlb =
SCIPfloor(
scip, (rhs - minvalue) / consdata->vals[v]);
6509 newub =
SCIPfloor(
scip, (lhs - maxvalue) / consdata->vals[v]);
6513 newlb =
SCIPceil(
scip, (lhs - maxvalue) / consdata->vals[v]);
6514 newub =
SCIPceil(
scip, (rhs - minvalue) / consdata->vals[v]);
6521 SCIPdebugMsg(
scip,
"tightening lower bound of variable <%s> from %g to %g\n",
6542 SCIPdebugMsg(
scip,
"tightening upper bound of variable <%s> from %g to %g\n",
6571 assert(maxvalue > minvalue);
6587 ++conshdlrdata->naddconss;
6606 else if( addartconss && ncontvars < ninfcheckvars )
6613 for( v = 0; v < consdata->nvars; ++v )
6625 if( consdata->vals[v] > 0.0 )
6626 maxact += consdata->vals[v];
6628 minact += consdata->vals[v];
6636 if( consdata->vals[v] > 0.0 )
6681 newlhs = lhs - maxact;
6682 newrhs = rhs - minact;
6687 ++conshdlrdata->naddconss;
6751 var = consdata->vars[pos];
6757 val = consdata->vals[pos];
6758 lhs = consdata->lhs;
6759 rhs = consdata->rhs;
6761 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
6781 newub = (rhs - minresactivity)/val;
6790 if( activityunreliable )
6793 newub = (rhs - minresactivity)/val;
6799 if( !activityunreliable )
6802 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newub=%.15g\n",
6805 &infeasible, &tightened) );
6808 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6823 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
6835 newlb = (lhs - maxresactivity)/val;
6843 newlb = (lhs - maxresactivity)/val;
6852 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
6855 &infeasible, &tightened) );
6858 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6872 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
6888 newlb = (rhs - minresactivity)/val;
6895 if( activityunreliable )
6898 newlb = (rhs - minresactivity)/val;
6905 if( !activityunreliable )
6908 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
6911 &infeasible, &tightened) );
6914 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6928 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
6940 newub = (lhs - maxresactivity)/val;
6948 newub = (lhs - maxresactivity)/val;
6957 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g], newub=%.15g\n",
6960 &infeasible, &tightened) );
6963 SCIPdebugMsg(
scip,
"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n",
6977 SCIPdebugMsg(
scip,
"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n",
6987#define MAXTIGHTENROUNDS 10
7001 unsigned int tightenmode;
7007 int oldnchgbdstotal;
7039 nvars = consdata->nvars;
7049 if( !force && (consdata->boundstightened >= tightenmode) )
7056 assert(consdata->coefsorted);
7084 &isminsettoinfinity, &ismaxsettoinfinity);
7097 easycase =
SCIPisLT(
scip, consdata->maxactdelta, maxeasyactivitydelta);
7104 oldnchgbdstotal = *nchgbds;
7107 for( nrounds = 0; (force || consdata->boundstightened < tightenmode) && nrounds <
MAXTIGHTENROUNDS; ++nrounds )
7116 assert(consdata->coefsorted);
7120 consdata->boundstightened = (
unsigned int)tightenmode;
7126 while( v <
nvars && v != lastchange && !(*
cutoff) )
7128 oldnchgbds = *nchgbds;
7140 if( *nchgbds > oldnchgbds )
7145 else if( consdata->coefsorted && v < consdata->
nbinvars - 1
7147 v = consdata->nbinvars;
7154 *nchgbds - oldnchgbdstotal, nrounds);
7155 oldnchgbdstotal += oldnchgbds;
7160 if( force &&
SCIPisEQ(
scip, consdata->lhs, consdata->rhs) )
7198 if( consdata->row !=
NULL )
7210 SCIPdebugMsg(
scip,
" consdata activity=%.15g (lhs=%.15g, rhs=%.15g, row=%p, checklprows=%u, rowinlp=%u, sol=%p, hascurrentnodelp=%u)\n",
7211 activity, consdata->lhs, consdata->rhs, (
void*)consdata->row, checklprows,
7216 lhsviol = consdata->lhs - activity;
7217 rhsviol = activity - consdata->rhs;
7221 if( (lhsviol > 0) && (lhsviol > rhsviol) )
7226 else if( rhsviol > 0 )
7251 if( !checkrelmaxabs )
7275 for( v = 0; v < consdata->nvars; ++v )
7277 if( consdata->vals !=
NULL )
7279 coef = consdata->vals[v];
7285 absval =
REALABS( coef * solval );
7286 maxabs =
MAX( maxabs, absval );
7293 if( (consdata->lhs - activity) <= (1e-15 * maxabs) )
7295 SCIPdebugMsg(
scip,
" lhs violated due to random noise: violation=%16.9g, maxabs=%16.9g\n",
7296 consdata->lhs - activity, maxabs);
7310 SCIPdebugMsg(
scip,
" lhs violated absolutely (violation=%16.9g), but feasible when using relative tolerance w.r.t. maximum absolute value (%16.9g)\n",
7311 consdata->lhs - activity, maxabs);
7347 if( (activity - consdata->rhs) <= (1e-15 * maxabs) )
7349 SCIPdebugMsg(
scip,
" rhs violated due to random noise: violation=%16.9g, maxabs=%16.9g\n",
7350 activity - consdata->rhs, maxabs);
7364 SCIPdebugMsg(
scip,
" rhs violated absolutely (violation=%16.9g), but feasible when using relative tolerance w.r.t. maximum absolute value (%16.9g)\n",
7365 activity - consdata->rhs, maxabs);
7399 else if( consdata->checkabsolute &&
7467 if( consdata->row ==
NULL )
7484 if( consdata->nvars == 0 )
7506 assert( pr == 0 || cr == 0 );
7532 if( consdata->nlrow ==
NULL )
7534 assert(consdata->lhs <= consdata->rhs);
7591 if( !separateall &&
sol ==
NULL )
7604 consdata->vals, +1.0, consdata->rhs,
sol,
cutoff, ncuts) );
7612 consdata->vals, -1.0, -consdata->lhs,
sol,
cutoff, ncuts) );
7622 consdata->vals, +1.0, consdata->rhs,
sol,
cutoff, ncuts) );
7627 consdata->vals, -1.0, -consdata->lhs,
sol,
cutoff, ncuts) );
7632 if( *ncuts > oldncuts )
7671 if( consdata->eventdata ==
NULL )
7703 oldnchgbds = *nchgbds;
7707 if( *nchgbds > oldnchgbds )
7714 if( rangedrowpropagation && tightenbounds && !(*
cutoff) )
7734 if( nfixedvars > 0 )
7735 *nchgbds += 2*nfixedvars;
7742 &isminsettoinfinity, &ismaxsettoinfinity);
7746 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible (rhs): activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7747 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7757 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible (lhs): activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7758 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7768 SCIPdebugMsg(
scip,
"linear constraint <%s> is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
7769 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
7772 if( consdata->nvars > 0 )
7814 for( v = 0; v < consdata->nvars; ++v )
7817 var = consdata->vars[v];
7829 SCIPdebugMsg(
scip,
"converting variable <%s> with fixed bounds [%.15g,%.15g] into fixed variable fixed at %.15g\n",
7853 assert(consdata->removedfixings);
7858#define MAX_CLIQUE_NONZEROS_PER_CONS 1000000
7950 int cliquenonzerosadded;
7967 if( consdata->nvars < 2 )
7976 if( !consdata->implsadded )
7994 nvars = consdata->nvars;
7995 vars = consdata->vars;
7996 vals = consdata->vals;
7999 if( !consdata->validactivities )
8001 assert(consdata->validactivities);
8005 finitenegminact = (consdata->glbminactivityneginf == 0 && consdata->glbminactivityneghuge == 0);
8006 finitenegmaxact = (consdata->glbmaxactivityneginf == 0 && consdata->maxactivityneghuge == 0);
8007 finiteposminact = (consdata->glbminactivityposinf == 0 && consdata->glbminactivityposhuge == 0);
8008 finiteposmaxact = (consdata->glbmaxactivityposinf == 0 && consdata->glbmaxactivityposhuge == 0);
8009 finiteminact = (finitenegminact && finiteposminact);
8010 finitemaxact = (finitenegmaxact && finiteposmaxact);
8012 if( (finiterhs || finitelhs) && (finitenegminact || finiteposminact || finitenegmaxact || finiteposmaxact) )
8017 int oldnchgbds = *nchgbds;
8023 if( (finitenegminact || finiteposminact) && !consdata->validglbminact )
8026 assert(consdata->validglbminact);
8029 if( (finitenegmaxact || finiteposmaxact) && !consdata->validglbmaxact )
8032 assert(consdata->validglbmaxact);
8034 assert(consdata->validglbminact || consdata->validglbmaxact);
8039 for( v =
nvars - 1; v >= 0; --v )
8047 if( value > maxabscontrib )
8049 maxabscontrib = value;
8060 if( value > maxabscontrib )
8062 maxabscontrib = value;
8073 if( !
SCIPisEQ(
scip, maxabscontrib, 1.0) && !allbinary )
8079 if( finiterhs && finiteminact &&
SCIPisEQ(
scip,
QUAD_TO_DBL(consdata->glbminactivity), consdata->rhs - maxabscontrib) )
8081 for( v =
nvars - 1; v >= 0; --v )
8093 *nchgbds += nbdchgs;
8100 *nchgbds += nbdchgs;
8120 if( finitelhs && finitemaxact &&
SCIPisEQ(
scip,
QUAD_TO_DBL(consdata->glbmaxactivity), consdata->lhs - maxabscontrib) )
8122 for( v =
nvars - 1; v >= 0; --v )
8134 *nchgbds += nbdchgs;
8141 *nchgbds += nbdchgs;
8160 SCIPdebugMsg(
scip,
"extracted %d implications from constraint %s which led to %d bound changes, %scutoff detetcted\n", nimpls,
SCIPconsGetName(cons), *nchgbds - oldnchgbds, *
cutoff ?
"" :
"no ");
8166 if( *nchgbds - oldnchgbds > 0 )
8187 consdata->implsadded =
TRUE;
8191 if( consdata->cliquesadded )
8194 consdata->cliquesadded =
TRUE;
8195 cliquenonzerosadded = 0;
8201 nvars = consdata->nvars;
8202 vars = consdata->vars;
8203 vals = consdata->vals;
8208 if( !consdata->validactivities )
8210 assert(consdata->validactivities);
8214 finitenegminact = (consdata->glbminactivityneginf == 0 && consdata->glbminactivityneghuge == 0);
8215 finitenegmaxact = (consdata->glbmaxactivityneginf == 0 && consdata->maxactivityneghuge == 0);
8216 finiteposminact = (consdata->glbminactivityposinf == 0 && consdata->glbminactivityposhuge == 0);
8217 finiteposmaxact = (consdata->glbmaxactivityposinf == 0 && consdata->glbmaxactivityposhuge == 0);
8218 finiteminact = (finitenegminact && finiteposminact);
8219 finitemaxact = (finitenegmaxact && finiteposmaxact);
8224 if( (finiterhs || finitelhs) && (finitenegminact || finiteposminact || finitenegmaxact || finiteposmaxact) )
8228 int nposbinvars = 0;
8229 int nnegbinvars = 0;
8230 int allonebinary = 0;
8245 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8246 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8264 if( allonebinary <
nvars && (nposbinvars >= 2 || nnegbinvars >= 2) )
8267 int oldnchgbds = *nchgbds;
8273 if( (finitenegminact || finiteposminact) && !consdata->validglbminact )
8276 assert(consdata->validglbminact);
8279 if( (finitenegmaxact || finiteposmaxact) && !consdata->validglbmaxact )
8282 assert(consdata->validglbmaxact);
8284 assert(consdata->validglbminact || consdata->validglbmaxact);
8290 if( finiterhs && finitenegminact && nposbinvars >= 2 )
8293 threshold = consdata->rhs -
QUAD_TO_DBL(consdata->glbminactivity);
8296#ifdef SCIP_DISABLED_CODE
8305 while( j < nposbinvars )
8319 *nchgbds += nbdchgs;
8321 cliquenonzerosadded += j;
8326 if( !stopped && !(*
cutoff) && j < nposbinvars )
8329 int lastfit = j - 2;
8336 while( lastfit >= 0 && j < nposbinvars )
8341 clqvars[lastfit + 1] = binvars[j];
8352 *nchgbds += nbdchgs;
8354 cliquenonzerosadded += (lastfit + 2);
8373 if( !stopped && !*
cutoff && *nchgbds - oldnchgbds > 0 )
8394 if( !consdata->validactivities )
8396 assert(consdata->validactivities);
8398 nvars = consdata->nvars;
8399 vars = consdata->vars;
8400 vals = consdata->vals;
8415 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8416 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8434 oldnchgbds = *nchgbds;
8438 if( !stopped && !(*
cutoff) && finitelhs && finiteposmaxact && nnegbinvars >= 2 )
8441 threshold = consdata->lhs -
QUAD_TO_DBL(consdata->glbmaxactivity);
8443 i = nposbinvars + nnegbinvars - 1;
8445#ifdef SCIP_DISABLED_CODE
8455 while( j >= nposbinvars )
8470 *nchgbds += nbdchgs;
8472 cliquenonzerosadded += (
i - j);
8477 if( !stopped && !(*
cutoff) && jstart >= nposbinvars )
8480 int lastfit = jstart + 1;
8488 while( lastfit <= i && j >= nposbinvars )
8493 assert(lastfit - jstart - 2 >= 0 && lastfit - jstart - 2 <
i);
8494 clqvars[lastfit - jstart - 2] = binvars[j];
8506 *nchgbds += nbdchgs;
8508 cliquenonzerosadded += (
i - lastfit + 2);
8527 if( !stopped && !*
cutoff && *nchgbds - oldnchgbds > 0 )
8548 if( !consdata->validactivities )
8550 assert(consdata->validactivities);
8552 nvars = consdata->nvars;
8553 vars = consdata->vars;
8554 vals = consdata->vals;
8569 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8570 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8588 oldnchgbds = *nchgbds;
8592 if( !(*
cutoff) && finiterhs && finiteminact && nnegbinvars >= 2 )
8601 threshold = consdata->rhs -
QUAD_TO_DBL(consdata->glbminactivity);
8603 i = nposbinvars + nnegbinvars - 1;
8606#ifdef SCIP_DISABLED_CODE
8616 while( j >= nposbinvars )
8631 *nchgbds += nbdchgs;
8633 cliquenonzerosadded += (
i - j);
8638 if( !stopped && !(*
cutoff) && jstart >= nposbinvars )
8641 int lastfit = j + 1;
8649 while( lastfit <= i && j >= nposbinvars )
8654 assert(lastfit - jstart - 2 >= 0 && lastfit - jstart - 2 <
i);
8655 clqvars[lastfit - jstart - 2] = binvars[j];
8667 *nchgbds += nbdchgs;
8669 cliquenonzerosadded += (
i - lastfit + 2);
8690 if( !stopped && !*
cutoff && *nchgbds - oldnchgbds > 0 )
8711 if( !consdata->validactivities )
8713 assert(consdata->validactivities);
8715 nvars = consdata->nvars;
8716 vars = consdata->vars;
8717 vals = consdata->vals;
8732 binvars[nposbinvars + nnegbinvars] =
vars[
i];
8733 binvarvals[nposbinvars + nnegbinvars] = vals[
i];
8753 if( !stopped && !(*
cutoff) && finitelhs && finitemaxact && nposbinvars >= 2 )
8762 threshold = consdata->lhs -
QUAD_TO_DBL(consdata->glbmaxactivity);
8766#ifdef SCIP_DISABLED_CODE
8776 while( j < nposbinvars )
8790 *nchgbds += nbdchgs;
8792 cliquenonzerosadded += j;
8797 if( !stopped && !(*
cutoff) && j < nposbinvars )
8800 int lastfit = j - 2;
8807 while( lastfit >= 0 && j < nposbinvars )
8812 clqvars[lastfit + 1] = binvars[j];
8823 *nchgbds += nbdchgs;
8825 cliquenonzerosadded += lastfit + 2;
8872 if( lhsclique || rhsclique )
8877 SCIPdebugMsg(
scip,
"linear constraint <%s>: adding clique with %d vars (%d pos, %d neg)\n",
8882 values[
i] = (rhsclique == (vals[
i] > 0.0));
8889 *nchgbds += nbdchgs;
8921 *infeasible =
FALSE;
8931 for(
i = 0;
i < consdata->nvars && integral; ++
i )
8952 SCIPdebugMsg(
scip,
"rounding sides=[%.15g,%.15g] of linear constraint <%s> with integral coefficients and variables only "
8953 "is infeasible\n", consdata->lhs, consdata->rhs,
SCIPconsGetName(cons));
8959 SCIPdebugMsg(
scip,
"linear constraint <%s>: make sides integral: sides=[%.15g,%.15g]\n",
8967 if( !consdata->upgraded )
8975 if( !consdata->upgraded )
8978 SCIPdebugMsg(
scip,
"linear constraint <%s>: new integral sides: sides=[%.15g,%.15g]\n",
9065 if( (consdata->validmaxabsval && consdata->maxabsval >
MAXVALRECOMP)
9066 || (consdata->validminabsval && consdata->minabsval <
MINVALRECOMP) )
9074 &isminsettoinfinity, &ismaxsettoinfinity);
9080 minleftactivity = 0.0;
9081 maxleftactivity = 0.0;
9088 var = consdata->vars[
i];
9089 val = consdata->vals[
i];
9101 if( isvarrelevant[
i] )
9109 lval = consdata->lhs - minactivity;
9110 rval = maxactivity - consdata->rhs;
9113 if( consdata->nvars == 2 )
9116 otherval = consdata->vals[1-
i];
9120 lval = consdata->lhs - val*lb;
9126 rval = val*ub - consdata->rhs;
9131 newval =
MAX3(lval, rval, 0.0);
9135 newlhs = consdata->lhs - val * lb;
9136 newlhs += newval * lb;
9137 newrhs = consdata->rhs - val * ub;
9138 newrhs += newval * ub;
9142 SCIPdebugMsg(
scip,
"linear constraint <%s>: change coefficient %+.15g<%s> to %+.15g<%s>, act=[%.15g,%.15g], side=[%.15g,%.15g]\n",
9144 maxactivity, consdata->lhs, consdata->rhs);
9160 &ismaxacttight, &isminsettoinfinity, &ismaxsettoinfinity);
9165 consdata->lhs, newlhs);
9175 consdata->rhs, newrhs);
9192 minleftactivity += val * lb;
9202 maxleftactivity += val * ub;
9212 if( isvarrelevant[
i] )
9220 lval = minactivity - consdata->lhs;
9221 rval = consdata->rhs - maxactivity;
9224 if( consdata->nvars == 2 )
9227 otherval = consdata->vals[1-
i];
9231 lval = val*ub - consdata->lhs;
9237 rval = consdata->rhs - val*lb;
9242 newval =
MIN3(lval, rval, 0.0);
9246 newlhs = consdata->lhs - val * ub;
9247 newlhs += newval * ub;
9248 newrhs = consdata->rhs - val * lb;
9249 newrhs += newval * lb;
9253 SCIPdebugMsg(
scip,
"linear constraint <%s>: change coefficient %+.15g<%s> to %+.15g<%s>, act=[%.15g,%.15g], side=[%.15g,%.15g]\n",
9255 maxactivity, consdata->lhs, consdata->rhs);
9271 &ismaxacttight, &isminsettoinfinity, &ismaxsettoinfinity);
9276 consdata->lhs, newlhs);
9286 consdata->rhs, newrhs);
9303 minleftactivity += val * ub;
9313 maxleftactivity += val * lb;
9322 minleftactivity, consdata->rhs);
9324 maxleftactivity, consdata->lhs);
9351 aggrlhs = consdata->lhs - minactivity + minleftactivity;
9352 aggrrhs = consdata->rhs - maxactivity + maxleftactivity;
9372 if( !isvarrelevant[
i] )
9375 var = consdata->vars[
i];
9376 val = consdata->vals[
i];
9381 SCIPdebugMsg(
scip,
"val = %g\tlhs = %g\trhs = %g\n", val, consdata->lhs, consdata->rhs);
9382 SCIPdebugMsg(
scip,
"linear constraint <%s>: remove variable <%s> from constraint since it is redundant\n",
9388 minleftactivitypart = val * lb;
9389 maxleftactivitypart = val * ub;
9393 minleftactivitypart = val * ub;
9394 maxleftactivitypart = val * lb;
9398 isvarrelevant[
i] = isvarrelevant[consdata->nvars - 1];
9403 newlhs = consdata->lhs - minleftactivitypart;
9404 newrhs = consdata->rhs - maxleftactivitypart;
9409 consdata->lhs, newlhs);
9419 consdata->rhs, newrhs);
9463 assert(consdata->nvars == 1);
9467 var = consdata->vars[0];
9468 val = consdata->vals[0];
9488 if( !consdata->upgraded )
9517 assert(consdata->nvars == 2);
9520 SCIPdebugMsg(
scip,
"linear constraint <%s>: aggregate %.15g<%s> + %.15g<%s> == %.15g\n",
9522 consdata->vals[1],
SCIPvarGetName(consdata->vars[1]), consdata->rhs);
9526 consdata->rhs, &infeasible, &redundant, &aggregated) );
9545 if( !consdata->upgraded )
9575 if( slackcoef > 0.0 )
9580 *newrhs = consdata->rhs - slackcoef * slackvarlb;
9584 *newlhs = consdata->lhs - slackcoef * slackvarub;
9591 *newlhs = consdata->rhs - slackcoef * slackvarlb;
9595 *newrhs = consdata->lhs - slackcoef * slackvarub;
9641 int maxnlocksremove;
9658 assert(consdata->nvars > 2);
9668 lhs = consdata->lhs;
9669 rhs = consdata->rhs;
9671 if( consdata->nvars == 3 )
9676 maxnlocksremove = 3;
9678 else if( consdata->nvars == 4 )
9683 maxnlocksremove = 2;
9688 maxnlocksremove = 1;
9707 vars = consdata->vars;
9708 vals = consdata->vals;
9711 bestnlocks = INT_MAX;
9712 bestremovescons =
FALSE;
9713 bestslackdomrng = 0.0;
9714 coefszeroone =
TRUE;
9715 coefsintegral =
TRUE;
9716 varsintegral =
TRUE;
9724 for( v = 0; v < consdata->nvars; ++v )
9748 if( absval < minabsval )
9750 if( absval > maxabsval )
9755 if( maxabsval / minabsval > conshdlrdata->maxmultaggrquot )
9759 coefszeroone = coefszeroone &&
SCIPisEQ(
scip, absval, 1.0);
9787 if( nlocks > maxnlocksremove )
9791 if( (iscont || (coefsintegral && varsintegral &&
SCIPisEQ(
scip, absval, 1.0))) &&
9805 slackdomrng = (varub - varlb)*absval;
9809 better = (slacktype > bestslacktype) || (bestslackpos == -1);
9810 if( !better && slacktype == bestslacktype )
9812 better = (nlocks < bestnlocks);
9813 if( nlocks == bestnlocks && !bestremovescons )
9816 equal = !better &&
SCIPisGE(
scip, slackdomrng, bestslackdomrng);
9820 if( better || equal )
9834 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
9839 if( !ismintight || !ismaxtight )
9859 if( conshdlrdata->multaggrremove && !removescons )
9863 if( bestremovescons && !removescons )
9869 if( !removescons && nlocks > maxnlocksstay )
9872 better = better || (!bestremovescons && removescons);
9876 bestslacktype = slacktype;
9877 bestnlocks = nlocks;
9878 bestslackdomrng = slackdomrng;
9879 bestremovescons = removescons;
9899 for( v = 0; v < consdata->nvars; ++v )
9901 if( v != bestslackpos )
9933 assert(!samevar || (supinf > 0 && infinf > 0));
9938 if( (samevar && (supinf > 1 || infinf > 1)) || (!samevar && supinf > 0 && infinf > 0) )
9940 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: infimum and supremum are both infinite\n");
9949 if( bestslackpos >= 0
9951 || (coefsintegral && varsintegral && nimplvars == 0)) )
9973 slackvar =
vars[bestslackpos];
9974 slackcoef = vals[bestslackpos];
9976 aggrconst = consdata->rhs/slackcoef;
9989 for( v = 0; v < consdata->nvars; ++v )
9991 scalars[v] = -consdata->vals[v]/slackcoef;
9994 SCIPdebugMsgPrint(
scip,
" %+.15g, bounds of <%s>: [%.15g,%.15g], nlocks=%d, maxnlocks=%d, removescons=%u\n",
9996 bestnlocks, bestremovescons ? maxnlocksremove : maxnlocksstay, bestremovescons);
10000 &infeasible, &aggregated) );
10017 if( bestremovescons )
10022 if( !consdata->upgraded )
10026 else if( ncontvars == 1 )
10030 assert(0 <= contvarpos && contvarpos < consdata->
nvars);
10040 SCIPdebugMsg(
scip,
"linear constraint <%s>: converting continuous variable <%s> to implicit integer variable\n",
10062 absval =
REALABS(vals[contvarpos]);
10073#ifdef WITH_DEBUG_SOLUTION
10074 if( SCIPdebugIsMainscip(
scip) )
10083 SCIPdebugMsg(
scip,
"linear constraint <%s>: aggregating continuous variable <%s> to newly created implicit integer variable <%s>, aggregation factor = %g\n",
10091 SCIPdebugMsg(
scip,
"infeasible aggregation of variable <%s> to implicit variable <%s>, domain is empty\n",
10113 consdata->boundstightened = 0;
10114 consdata->rangedrowpropagated = 0;
10115 consdata->presolved =
FALSE;
10118 else if( ncontvars == 0 && nimplvars == 0 &&
nintvars == 1 && !coefszeroone )
10126 assert(0 <= intvarpos && intvarpos < consdata->
nvars);
10135 SCIPdebugMsg(
scip,
"linear constraint <%s>: converting integer variable <%s> to implicit integer variable\n",
10170 vars = consdata->vars;
10171 nvars = consdata->nvars;
10175 for( v = 0; v <
nvars; ++v )
10199 val = consdata->vals[v];
10206 (*scale) = val / -
objval;
10218 (*scale) = val /
objval;
10254 nvars = consdata->nvars;
10263 (
nvars == nobjvars && (!conshdlrdata->detectcutoffbound || !conshdlrdata->detectlowerbound)) )
10266 offset = consdata->rhs;
10276 vars = consdata->vars;
10281 SCIPdebugMsg(
scip,
"linear equality constraint <%s> == %g (offset %g) is a subset of the objective function\n",
10289 for( v = 0; v <
nvars; ++v )
10373 nvars = consdata->nvars;
10388 if( nobjvars == 0 )
10403 if( conshdlrdata->detectcutoffbound && rhsfinite )
10407 primalbound = (consdata->rhs - offset) / scale;
10409 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a cutoff bound <%g>\n",
10415 if( conshdlrdata->detectlowerbound && lhsfinite )
10419 lowerbound = (consdata->lhs - offset) / scale;
10421 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a lower bound <%g>\n",
10427 if( (conshdlrdata->detectcutoffbound && (conshdlrdata->detectlowerbound || !lhsfinite)) ||
10428 (conshdlrdata->detectlowerbound && !rhsfinite) )
10437 if( conshdlrdata->detectlowerbound && rhsfinite )
10441 lowerbound = (consdata->rhs - offset) / scale;
10443 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a lower bound <%g>\n",
10449 if( conshdlrdata->detectcutoffbound && lhsfinite )
10453 primalbound = (consdata->lhs - offset) / scale;
10455 SCIPdebugMsg(
scip,
"constraint <%s> is parallel to objective function and provides a cutoff bound <%g>\n",
10461 if( (conshdlrdata->detectcutoffbound && (conshdlrdata->detectlowerbound || !rhsfinite)) ||
10462 (conshdlrdata->detectlowerbound && !lhsfinite) )
10499 assert(consdata->removedfixings);
10506 if( consdata->nvars == 1 )
10511 else if( consdata->nvars == 2 )
10545 for( v = 0; v < consdata->nvars; ++v )
10575 *minval = -maxresactivity;
10577 *minval = (side - maxresactivity)/val;
10580 *maxval = -minresactivity;
10582 *maxval = (side - minresactivity)/val;
10587 *minval = minresactivity;
10589 *minval = (side - minresactivity)/val;
10592 *maxval = maxresactivity;
10594 *maxval = (side - maxresactivity)/val;
10663 if( consdata->nvars <= 2 )
10664 maxotherlocks = INT_MAX;
10665 else if( consdata->nvars == 3 )
10667 else if( consdata->nvars == 4 )
10673 if( lhsexists && rhsexists && maxotherlocks < INT_MAX )
10678 for(
i = 0;
i < consdata->nvars && bestisint; ++
i )
10690 val = consdata->vals[
i];
10694 if( absval < minabsval )
10695 minabsval = absval;
10696 if( absval > maxabsval )
10697 maxabsval = absval;
10700 if( maxabsval / minabsval > conshdlrdata->maxdualmultaggrquot )
10703 var = consdata->vars[
i];
10707 if( bestpos >= 0 && isint )
10719 val = consdata->vals[
i];
10756 if( agglhs || aggrhs )
10769 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
10776 assert((ismintight || isminsettoinfinity) && (ismaxtight || ismaxsettoinfinity));
10791 recalculated =
FALSE;
10792 oldmaxresactivity = maxresactivity;
10793 oldminresactivity = minresactivity;
10799 recalculated = !
SCIPisEQ(
scip, oldminresactivity, minresactivity);
10800 isminsettoinfinity =
TRUE;
10807 recalculated = recalculated || !
SCIPisEQ(
scip, oldmaxresactivity, maxresactivity);
10808 ismaxsettoinfinity =
TRUE;
10851 recalculated =
FALSE;
10852 oldmaxresactivity = maxresactivity;
10853 oldminresactivity = minresactivity;
10859 recalculated = !
SCIPisEQ(
scip, oldminresactivity, minresactivity);
10866 recalculated = recalculated || !
SCIPisEQ(
scip, oldmaxresactivity, maxresactivity);
10914 assert(!bestislhs || lhsexists);
10915 assert(bestislhs || rhsexists);
10917 bestvar = consdata->vars[bestpos];
10918 bestval = consdata->vals[bestpos];
10935 for( j = 0; j < consdata->nvars; ++j )
10941 aggrvars[naggrs] = consdata->vars[j];
10942 aggrcoefs[naggrs] = -consdata->vals[j]/consdata->vals[bestpos];
10945 absaggrcoef =
REALABS(aggrcoefs[naggrs]);
10948 if( absaggrcoef < epsilon )
10950 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: too large aggregation coefficients\n");
10963 aggrcoefs[naggrs] =
SCIPfloor(
scip, aggrcoefs[naggrs]+0.5);
10998 assert(!samevar || (supinf > 0 && infinf > 0));
11000 aggrconst = (bestislhs ? consdata->lhs/bestval : consdata->rhs/bestval);
11003 assert(naggrs == consdata->nvars-1);
11012 aggregated =
FALSE;
11013 infeasible =
FALSE;
11016 if( (samevar && supinf == 1 && infinf == 1) || (!samevar && (supinf == 0 || infinf == 0)) )
11030 for( j = 0; j < naggrs; ++j)
11039 assert(!infeasiblevartypechg);
11048 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: infimum and supremum are both infinite\n");
11067 if( !consdata->upgraded )
11082#define CONTWEIGHT 8
11161 lhs = consdata->lhs;
11162 vars = consdata->vars;
11163 vals = consdata->vals;
11164 nvars = consdata->nvars;
11173 for( v = 0; v <
nvars && noddvars < 3; ++v )
11188 if( noddvars == 0 )
11200 if( noddvars == 1 )
11204 SCIPdebugMsg(
scip,
"linear constraint <%s>: try fixing variable <%s> to <%g>\n",
11224 else if( noddvars == 2 )
11233 SCIPdebugMsg(
scip,
"linear constraint <%s>: try aggregation of variables <%s> and <%s>\n",
11237 lhsodd ? 1.0 : 0.0, &infeasible, &redundant, &aggregated) );
11278 while( success && consdata->nvars >= 1 );
11307 if( vartype2 != vartype1 )
11317 value =
REALABS(consdata->vals[ind2]) -
REALABS(consdata->vals[ind1]);
11320 return (value > 0 ? +1 : (value < 0 ? -1 : 0));
11357 nvars = consdata->nvars;
11363 lhs = consdata->lhs;
11364 rhs = consdata->rhs;
11373 vals = consdata->vals;
11374 vars = consdata->vars;
11382 for( v =
nvars - 1; v >= 0; --v )
11388 secondminval = minval;
11391 else if( secondminval > vals[v] || secondminval ==
SCIP_INVALID )
11392 secondminval = vals[v];
11406 for( v =
nvars - 1; v >= 0; --v )
11410 (*nchgcoefs) +=
nvars;
11493 *infeasible =
FALSE;
11505 nvars = consdata->nvars;
11529 consdata->normalized =
FALSE;
11537 if( !consdata->normalized )
11540 lhs = consdata->lhs;
11541 rhs = consdata->rhs;
11555 SCIPdebug( oldnchgcoefs = *nchgcoefs; )
11556 SCIPdebug( oldnchgsides = *nchgsides; )
11559 if( haslhs && hasrhs )
11565 assert(haslhs != hasrhs);
11581 consdata->indexsorted =
FALSE;
11582 consdata->coefsorted =
FALSE;
11584 vars = consdata->vars;
11585 vals = consdata->vals;
11608 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
11611 if( isminsettoinfinity || ismaxsettoinfinity )
11616 assert(maxact > minact);
11622 side = haslhs ? lhs : rhs;
11623 minactsub = minact;
11624 maxactsub = maxact;
11693 for(
w = 0;
w < v; ++
w )
11701 maxactsub -= ub * vals[
w];
11702 minactsub -= lb * vals[
w];
11703 assert(maxactsub > minactsub);
11734 maxactsub -= ub * vals[0];
11735 minactsub -= lb * vals[0];
11739 maxactsub -= lb * vals[0];
11740 minactsub -= ub * vals[0];
11742 assert(maxactsub > minactsub);
11747 allcoefintegral =
TRUE;
11750 for( ; v <
nvars - 1; ++v )
11757 allcoefintegral =
FALSE;
11776 maxactsub -= ub * vals[v];
11777 minactsub -= lb * vals[v];
11781 maxactsub -= lb * vals[v];
11782 minactsub -= ub * vals[v];
11799 rredundant = hasrhs && maxactsub <= siderest &&
SCIPisFeasGT(
scip, minactsub, siderest - gcd);
11800 lredundant = haslhs &&
SCIPisFeasLT(
scip, maxactsub, siderest) && minactsub >= siderest - gcd;
11803 if( offsetv == -1 && (rredundant || lredundant) )
11829 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",
11830 v,
nvars, minactsub, maxactsub, redundant, hasrhs, siderest, gcd, offsetv);
11837 rredundant = hasrhs && maxactsub <= siderest &&
SCIPisFeasGT(
scip, minactsub, siderest - gcd);
11838 lredundant = haslhs &&
SCIPisFeasLT(
scip, maxactsub, siderest) && minactsub >= siderest - gcd;
11841 if( v <
nvars && numericsok && (redundant || (offsetv == -1 && (rredundant || lredundant))) )
11862 tmpmaxactsub += ub * vals[
w];
11863 tmpminactsub += lb * vals[
w];
11867 tmpmaxactsub += lb * vals[
w];
11868 tmpminactsub += ub * vals[
w];
11870 assert(tmpmaxactsub >= tmpminactsub);
11890 (haslhs && tmpmaxactsub < siderest &&
SCIPisFeasGE(
scip, tmpminactsub, siderest - gcd)));
11893 SCIPdebugMsg(
scip,
"removing %d last variables from constraint <%s>, because they never change anything on the feasibility of this constraint\n",
11901 (*nchgcoefs) += (
nvars - v);
11909 assert(vals == consdata->vals);
11924 rhs = consdata->rhs;
11931 lhs = consdata->lhs;
11942 nvars = consdata->nvars;
11945 allcoefintegral =
TRUE;
11949 for(
w = offsetv + 1;
w <
nvars; ++
w )
11958 if( offsetv >= 0 && gcd == 1 )
11968 for( v =
nvars - 1; v > offsetv; --v )
11976 allcoefintegral =
FALSE;
12002 if( candpos == -1 )
12012 assert(v > offsetv || candpos > offsetv);
12018 candpos =
nvars - 1;
12021 if( gcd > 1 && allcoefintegral && !redundant )
12024 allcoefintegral =
FALSE;
12028 if( offsetv >= 0 && gcd > 1 && allcoefintegral )
12039 for(
w = offsetv + 1;
w <
nvars; ++
w )
12057 restcoef = ((
SCIP_Longint)(vals[candpos] + feastol)) % gcd;
12064 if( restcoef > rest )
12065 newcoef = vals[candpos] - restcoef + gcd;
12067 newcoef = vals[candpos] - restcoef;
12072 if( rest == 0 || restcoef < rest )
12073 newcoef = vals[candpos] - restcoef;
12075 newcoef = vals[candpos] - restcoef + gcd;
12085 notchangable =
TRUE;
12126 for(
w = offsetv;
w >= 0; --
w )
12132 (*nchgcoefs) += (offsetv + 1);
12135 if( !notchangable )
12139 assert(vals == consdata->vals);
12145 nvars = consdata->nvars;
12150 lhs = consdata->lhs;
12151 rhs = consdata->rhs;
12165 allcoefintegral =
TRUE;
12167 for( v =
nvars - 1; v >= 0; --v )
12172 allcoefintegral =
FALSE;
12189 if( allcoefintegral )
12200 for( v =
nvars - 1; v >= 0; --v )
12236 SCIPdebugMsg(
scip,
"rounding all non-integral coefficients and the right hand side down\n");
12241 for( v =
nvars - 1; v >= 0; --v )
12278 if( allcoefintegral )
12293 for( v =
nvars - 1; v >= 0; --v )
12341 SCIPdebugMsg(
scip,
"rounding all non-integral coefficients and the left hand side down\n");
12346 for( v =
nvars - 1; v >= 0; --v )
12384 assert(vals == consdata->vals);
12389 rhs = consdata->rhs;
12390 lhs = consdata->lhs;
12397 nvars = consdata->nvars;
12401 allcoefintegral =
TRUE;
12404 for( v =
nvars - 1; v >= 0; --v )
12411 if( !allcoefintegral )
12431 SCIPdebug( oldnchgcoefs = *nchgcoefs; )
12432 SCIPdebug( oldnchgsides = *nchgsides; )
12447 for( v =
nvars - 1; v >= 0; --v )
12454 if( foundbin == -1 )
12482 foundbin =
nvars - 1;
12485 if( gcd == 1 || foundbin == -1)
12488 assert((onlybin && gcd == -1) || (!onlybin && gcd > 1));
12496 for( v = foundbin; v >= 0; --v )
12525 if( candpos == -1 )
12533 if( onlybin && v == foundbin - 1 )
12534 candpos2 = foundbin;
12539 if( onlybin && candpos == v + 1 && candpos2 == v + 2 )
12544 candpos = candpos2;
12587 if( vals[candpos] < 0 )
12589 restcoef = ((
SCIP_Longint)(vals[candpos] - feastol)) % gcd;
12594 restcoef = ((
SCIP_Longint)(vals[candpos] + feastol)) % gcd;
12608 if( restcoef > rest )
12609 newcoef = vals[candpos] - restcoef + gcd;
12611 newcoef = vals[candpos] - restcoef;
12623 if( rest == 0 || restcoef < rest )
12624 newcoef = vals[candpos] - restcoef;
12626 newcoef = vals[candpos] - restcoef + gcd;
12630 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));
12647 assert(vals == consdata->vals);
12654 rhs = consdata->rhs;
12655 lhs = consdata->lhs;
12659 nvars = consdata->nvars;
12661 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));
12663 while(
nvars >= 2 );
12683 int* diffidx0minus1,
12684 int* diffidx1minus0,
12686 int commonidxweight,
12687 int diffidx0minus1weight,
12688 int diffidx1minus0weight,
12719 assert(nvarscommon >= 1);
12720 assert(commonidxweight >= nvarscommon);
12727 *infeasible =
FALSE;
12734 assert(consdata0->nvars >= 1);
12736 assert(diffidx0minus1weight >= consdata0->nvars - nvarscommon);
12741 assert(consdata1->nvars >= 1);
12743 assert(diffidx1minus0weight >= consdata1->nvars - nvarscommon);
12745 *aggregated =
FALSE;
12751 bestvarweight = commonidxweight + diffidx0minus1weight;
12752 bestnvars = consdata0->nvars;
12754 bestscalarsum = 0.0;
12755 commonvarlindependent =
TRUE;
12756 for( v = 0; v < nvarscommon; ++v )
12758 assert(consdata0->vars[commonidx0[v]] == consdata1->vars[commonidx1[v]]);
12759 a = consdata1->vals[commonidx1[v]];
12760 b = -consdata0->vals[commonidx0[v]];
12766 varweight = diffidx0minus1weight + diffidx1minus0weight;
12767 nvars = consdata0->nvars + consdata1->nvars - 2*nvarscommon;
12769 betterscalarsum = (scalarsum < bestscalarsum);
12770 for(
i = 0;
i < nvarscommon
12771 && (varweight < bestvarweight || (varweight == bestvarweight && betterscalarsum)); ++
i )
12773 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12780 if( varweight < bestvarweight || (varweight == bestvarweight && betterscalarsum) )
12783 bestvarweight = varweight;
12785 bestscalarsum = scalarsum;
12792 if( commonvarlindependent && v > 0 )
12794 consdata1->vals[commonidx1[v]] * consdata0->vals[commonidx0[0]],
12795 consdata1->vals[commonidx1[0]] * consdata0->vals[commonidx0[v]]);
12812 if( consdata1->vals[commonidx1[bestv]] > 0.0 )
12814 a = consdata1->vals[commonidx1[bestv]];
12815 b = -consdata0->vals[commonidx0[bestv]];
12819 a = -consdata1->vals[commonidx1[bestv]];
12820 b = consdata0->vals[commonidx0[bestv]];
12829 assert(commonvarlindependent);
12830 if( consdata1->vals[commonidx1[0]] > 0.0 )
12832 a = consdata1->vals[commonidx1[0]];
12833 b = -consdata0->vals[commonidx0[0]];
12837 a = -consdata1->vals[commonidx1[0]];
12838 b = consdata0->vals[commonidx0[0]];
12859 SCIPdebug( bestvarweight = diffidx0minus1weight + diffidx1minus0weight; )
12860 bestnvars = consdata0->nvars + consdata1->nvars - 2*nvarscommon;
12863 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> := %.15g*<%s> + %.15g*<%s> -> nvars: %d -> %d, weight: %d -> %d\n",
12865 consdata0->nvars, bestnvars, commonidxweight + diffidx0minus1weight, bestvarweight);
12875 if( !commonvarlindependent )
12877 for(
i = 0;
i < nvarscommon; ++
i )
12879 assert(0 <= commonidx0[
i] && commonidx0[
i] < consdata0->nvars);
12880 assert(0 <= commonidx1[
i] && commonidx1[
i] < consdata1->nvars);
12882 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12885 assert(newnvars < bestnvars);
12886 newvars[newnvars] = consdata0->vars[commonidx0[
i]];
12887 newvals[newnvars] = aggrcoef;
12896 for(
i = 0;
i < nvarscommon; ++
i )
12898 assert(0 <= commonidx0[
i] && commonidx0[
i] < consdata0->nvars);
12899 assert(0 <= commonidx1[
i] && commonidx1[
i] < consdata1->nvars);
12901 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12908 for(
i = 0;
i < consdata0->nvars - nvarscommon; ++
i )
12910 assert(0 <= diffidx0minus1[
i] && diffidx0minus1[
i] < consdata0->nvars);
12912 aggrcoef =
a * consdata0->vals[diffidx0minus1[
i]];
12914 assert(newnvars < bestnvars);
12915 newvars[newnvars] = consdata0->vars[diffidx0minus1[
i]];
12916 newvals[newnvars] = aggrcoef;
12921 for(
i = 0;
i < consdata1->nvars - nvarscommon; ++
i )
12923 assert(0 <= diffidx1minus0[
i] && diffidx1minus0[
i] < consdata1->nvars);
12925 aggrcoef =
b * consdata1->vals[diffidx1minus0[
i]];
12927 assert(newnvars < bestnvars);
12928 newvars[newnvars] = consdata1->vars[diffidx1minus0[
i]];
12929 newvals[newnvars] = aggrcoef;
12932 assert(newnvars == bestnvars);
12940 newlhs =
a * consdata0->lhs +
b * consdata1->lhs;
12944 newrhs =
a * consdata0->rhs +
b * consdata1->rhs;
12957 newconsdata->upgraded = consdata0->upgraded;
12973 if( !consdata0->upgraded )
12974 (*nchgcoefs) += consdata0->nvars + consdata1->nvars - nvarscommon;
12975 *aggregated =
TRUE;
13019 assert(consdata1->indexsorted);
13020 assert(consdata2->indexsorted);
13030 if( consdata1->nvars != consdata2->nvars )
13034 for(
i = 0;
i < consdata1->nvars; ++
i )
13036 if( consdata1->vars[
i] != consdata2->vars[
i] )
13054 for(
i = 0;
i < consdata1->nvars; ++
i )
13056 SCIP_Real scale = consdata2->vals[
i] / consdata1->vals[
i];
13058 if( minscale > scale )
13066 if( maxscale < scale )
13096 assert(consdata->nvars > 0);
13098 assert(consdata->indexsorted);
13105 return SCIPhashFour(consdata->nvars, minidx, mididx, maxidx);
13123 return (((
unsigned int)consdata->upgraded)<<31) + (
unsigned int)
SCIPconsGetPos(cons);
13137 int* nparallelconss
13141 unsigned int querykey;
13143 *nparallelconss = 0;
13150 if( conskey < querykey )
13152 parallelconss[(*nparallelconss)++] = *querycons;
13153 *querycons = parallelcons;
13154 querykey = conskey;
13158 parallelconss[(*nparallelconss)++] = parallelcons;
13169 if( *querycons == parallelcons )
13205 int nparallelconss;
13218 hashtablesize = nconss;
13220 hashGetKeyLinearcons, hashKeyEqLinearcons, hashKeyValLinearcons, (
void*)
scip) );
13225 for(
c = 0;
c < nconss; ++
c )
13247 assert(consdata0->indexsorted);
13256 if( nparallelconss != 0 )
13266 lhs = consdata0->lhs;
13267 rhs = consdata0->rhs;
13269 for(
i = 0;
i < nparallelconss; ++
i )
13275 consdel = parallelconss[
i];
13289 assert(consdata0->nvars >= 1 && consdata0->nvars == consdatadel->nvars);
13291 assert(consdatadel->indexsorted);
13292 assert(consdata0->vars[0] == consdatadel->vars[0]);
13294 scale = consdata0->vals[0] / consdatadel->vals[0];
13302 assert(consdata0->validmaxabsval);
13303 assert(consdatadel->validmaxabsval);
13305 SCIP_Real scale0 = 1.0 / consdata0->maxabsval;
13308 for( k = 0; k < consdata0->nvars; ++k )
13310 assert(
SCIPisEQ(
scip, scale0 * consdata0->vals[k], scaledel * consdatadel->vals[k]));
13318 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with equal coefficients into single ranged row\n",
13324 lhs =
MAX(scale * consdatadel->lhs, lhs);
13327 rhs =
MIN(scale * consdatadel->rhs, rhs);
13332 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with negated coefficients into single ranged row\n",
13338 lhs =
MAX(scale * consdatadel->rhs, lhs);
13341 rhs =
MIN(scale * consdatadel->lhs, rhs);
13348 assert( ! consdata0->upgraded || consdatadel->upgraded );
13350 if( !consdatadel->upgraded )
13364 rhs = (lhs + rhs)/2;
13373 if( consdata0->changed &&
SCIPconsGetPos(cons0) < *firstchange )
13379#ifdef SCIP_MORE_DEBUG
13412 int* diffidx0minus1;
13413 int* diffidx1minus0;
13414 uint64_t possignature0;
13415 uint64_t negsignature0;
13418 int diffidx1minus0size;
13426 assert(firstchange <= chkind);
13433 cons0 = conss[chkind];
13440 assert(consdata0->nvars >= 1);
13441 cons0isequality =
SCIPisEQ(
scip, consdata0->lhs, consdata0->rhs);
13448 possignature0 = consdata0->possignature;
13449 negsignature0 = consdata0->negsignature;
13456 diffidx1minus0size = consdata0->nvars;
13458 cons0lhs = consdata0->lhs;
13459 cons0rhs = consdata0->rhs;
13460 cons0upgraded = consdata0->upgraded;
13463 cons0changed = consdata0->changed;
13464 consdata0->changed =
FALSE;
13465 for(
c = (cons0changed ? 0 : firstchange);
c < chkind && !(*cutoff) && conss[chkind] !=
NULL; ++
c )
13469 uint64_t possignature1;
13470 uint64_t negsignature1;
13482 int commonidxweight;
13483 int diffidx0minus1weight;
13484 int diffidx1minus0weight;
13488 assert(cons0lhs == consdata0->lhs);
13489 assert(cons0rhs == consdata0->rhs);
13490 assert(cons0upgraded == consdata0->upgraded);
13495 if( cons1 ==
NULL )
13509 if( !cons0changed && !consdata1->changed )
13514 if( cons0upgraded && consdata1->upgraded )
13517 assert(consdata1->nvars >= 1);
13524 possignature1 = consdata1->possignature;
13525 negsignature1 = consdata1->negsignature;
13528 coefsequal = (possignature0 == possignature1) && (negsignature0 == negsignature1);
13529 coefsnegated = (possignature0 == negsignature1) && (negsignature0 == possignature1);
13530 cons0dominateslhs =
SCIPisGE(
scip, cons0lhs, consdata1->lhs)
13531 && ((possignature0 | possignature1) == possignature1)
13532 && ((negsignature0 | negsignature1) == negsignature0);
13533 cons1dominateslhs =
SCIPisGE(
scip, consdata1->lhs, cons0lhs)
13534 && ((possignature0 | possignature1) == possignature0)
13535 && ((negsignature0 | negsignature1) == negsignature1);
13536 cons0dominatesrhs =
SCIPisLE(
scip, cons0rhs, consdata1->rhs)
13537 && ((possignature0 | possignature1) == possignature0)
13538 && ((negsignature0 | negsignature1) == negsignature1);
13539 cons1dominatesrhs =
SCIPisLE(
scip, consdata1->rhs, cons0rhs)
13540 && ((possignature0 | possignature1) == possignature1)
13541 && ((negsignature0 | negsignature1) == negsignature0);
13542 cons1isequality =
SCIPisEQ(
scip, consdata1->lhs, consdata1->rhs);
13543 tryaggregation = (cons0isequality || cons1isequality) && (maxaggrnormscale > 0.0);
13544 if( !cons0dominateslhs && !cons1dominateslhs && !cons0dominatesrhs && !cons1dominatesrhs
13545 && !coefsequal && !coefsnegated && !tryaggregation )
13549 if( tryaggregation && consdata1->nvars > diffidx1minus0size )
13552 diffidx1minus0size = consdata1->nvars;
13578 commonidxweight = 0;
13580 diffidx0minus1weight = 0;
13582 diffidx1minus0weight = 0;
13585 while( (v0 < consdata0->
nvars || v1 < consdata1->
nvars)
13586 && (cons0dominateslhs || cons1dominateslhs || cons0dominatesrhs || cons1dominatesrhs
13587 || coefsequal || coefsnegated || tryaggregation) )
13595 if( v0 < consdata0->
nvars && v1 < consdata1->
nvars )
13596 varcmp =
SCIPvarCompare(consdata0->vars[v0], consdata1->vars[v1]);
13597 else if( v0 < consdata0->
nvars )
13606 var = consdata0->vars[v0];
13607 val0 = consdata0->vals[v0];
13609 if( tryaggregation )
13611 diffidx0minus1[nvars0minus1] = v0;
13616 coefsequal =
FALSE;
13617 coefsnegated =
FALSE;
13622 var = consdata1->vars[v1];
13624 val1 = consdata1->vals[v1];
13625 if( tryaggregation )
13627 diffidx1minus0[nvars1minus0] = v1;
13632 coefsequal =
FALSE;
13633 coefsnegated =
FALSE;
13638 assert(consdata0->vars[v0] == consdata1->vars[v1]);
13639 var = consdata0->vars[v0];
13640 val0 = consdata0->vals[v0];
13641 val1 = consdata1->vals[v1];
13642 if( tryaggregation )
13644 commonidx0[nvarscommon] = v0;
13645 commonidx1[nvarscommon] = v1;
13651 coefsequal = coefsequal && (
SCIPisEQ(
scip, val0, val1));
13652 coefsnegated = coefsnegated && (
SCIPisEQ(
scip, val0, -val1));
13669 cons0dominatesrhs =
FALSE;
13670 cons1dominateslhs =
FALSE;
13674 cons0dominateslhs =
FALSE;
13675 cons1dominatesrhs =
FALSE;
13682 cons0dominateslhs =
FALSE;
13683 cons1dominatesrhs =
FALSE;
13687 cons0dominatesrhs =
FALSE;
13688 cons1dominateslhs =
FALSE;
13694 if( coefsequal || coefsnegated )
13709 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with %s coefficients into single ranged row\n",
13717 lhs =
MAX(consdata0->lhs, consdata1->lhs);
13718 rhs =
MIN(consdata0->rhs, consdata1->rhs);
13723 lhs =
MAX(consdata0->lhs, -consdata1->rhs);
13724 rhs =
MIN(consdata0->rhs, -consdata1->lhs);
13735 if( consdata0->upgraded )
13737 assert(!consdata1->upgraded);
13740 consdatastay = consdata1;
13744 consdatadel = consdata0;
13745 consinddel = chkind;
13751 consdatastay = consdata0;
13755 consdatadel = consdata1;
13762 if( !consdata0->upgraded )
13764 assert(consstay == cons0);
13765 cons0lhs = consdata0->lhs;
13766 cons0rhs = consdata0->rhs;
13772 assert( !consdatastay->upgraded );
13775 conss[consinddel] =
NULL;
13776 if( !consdatadel->upgraded )
13784 if( cons1dominateslhs && (!cons0isequality || cons1dominatesrhs ||
SCIPisInfinity(
scip, consdata0->rhs) ) )
13787 SCIPdebugMsg(
scip,
"left hand side of linear constraint <%s> is dominated by <%s>:\n",
13804 cons0lhs = consdata0->lhs;
13805 cons0isequality =
FALSE;
13806 if( !consdata0->upgraded )
13815 else if( cons0dominateslhs && (!cons1isequality || cons0dominatesrhs ||
SCIPisInfinity(
scip, consdata1->rhs)) )
13818 SCIPdebugMsg(
scip,
"left hand side of linear constraint <%s> is dominated by <%s>:\n",
13835 cons1isequality =
FALSE;
13836 if( !consdata1->upgraded )
13845 if( cons1dominatesrhs && (!cons0isequality || cons1dominateslhs ||
SCIPisInfinity(
scip, -consdata0->lhs)) )
13848 SCIPdebugMsg(
scip,
"right hand side of linear constraint <%s> is dominated by <%s>:\n",
13865 cons0rhs = consdata0->rhs;
13866 cons0isequality =
FALSE;
13867 if( !consdata0->upgraded )
13876 else if( cons0dominatesrhs && (!cons1isequality || cons0dominateslhs ||
SCIPisInfinity(
scip, -consdata1->lhs)) )
13879 SCIPdebugMsg(
scip,
"right hand side of linear constraint <%s> is dominated by <%s>:\n",
13896 cons1isequality =
FALSE;
13897 if( !consdata1->upgraded )
13913 conss[chkind] =
NULL;
13914 if( !consdata0->upgraded )
13929 if( !consdata1->upgraded )
13942 if( tryaggregation )
13946 assert(consdata0->nvars == nvarscommon + nvars0minus1);
13947 assert(consdata1->nvars == nvarscommon + nvars1minus0);
13949 aggregated =
FALSE;
13950 if( cons1isequality && !consdata0->upgraded && commonidxweight > diffidx1minus0weight )
13954 nvarscommon, commonidxweight, diffidx0minus1weight, diffidx1minus0weight, maxaggrnormscale,
13955 nchgcoefs, &aggregated,
cutoff) );
13965 conss[chkind] =
NULL;
13968 if( !aggregated && cons0isequality && !consdata1->upgraded && commonidxweight > diffidx0minus1weight )
13972 nvarscommon, commonidxweight, diffidx1minus0weight, diffidx0minus1weight, maxaggrnormscale,
13973 nchgcoefs, &aggregated,
cutoff) );
14048 if( singlevarstuffing )
14051 &isminsettoinfinity, &ismaxsettoinfinity);
14057 isminsettoinfinity =
FALSE;
14058 ismaxsettoinfinity =
FALSE;
14066 rhs = -consdata->lhs;
14068 maxactivity = -minactivity;
14069 ismaxsettoinfinity = isminsettoinfinity;
14074 rhs = consdata->rhs;
14078 nvars = consdata->nvars;
14079 vars = consdata->vars;
14080 vals = consdata->vals;
14083 if( singletonstuffing )
14085 for( v = 0; v <
nvars; ++v )
14101 assert(singletonstuffing);
14109 mincondactivity = 0.0;
14110 maxcondactivity = 0.0;
14112 for( v = 0; v <
nvars; ++v )
14118 val = factor * vals[v];
14135 maxcondactivity += val * lb;
14136 mincondactivity += val * lb;
14137 swapped[v] =
FALSE;
14138 ratios[nsingletons] =
obj / val;
14139 varpos[nsingletons] = v;
14154 maxcondactivity += val * ub;
14155 mincondactivity += val * ub;
14157 ratios[nsingletons] =
obj / val;
14158 varpos[nsingletons] = v;
14175 maxcondactivity += val * lb;
14176 mincondactivity += val * lb;
14193 maxcondactivity += val * ub;
14194 mincondactivity += val * ub;
14210 maxcondactivity += val * ub;
14211 mincondactivity += val * lb;
14215 maxcondactivity += val * lb;
14216 mincondactivity += val * ub;
14220 if( tryfixing && nsingletons > 0 && (
SCIPisGT(
scip, rhs, maxcondactivity) ||
SCIPisLE(
scip, rhs, mincondactivity)) )
14225 int oldnfixedvars = *nfixedvars;
14226 int oldnchgbds = *nchgbds;
14232 for( v = 0; v < nsingletons; ++v )
14236 val = factor * vals[idx];
14241 assert((val < 0) == swapped[idx]);
14256 delta = -(lb - ub) * val;
14258 delta = (ub - lb) * val;
14308 maxcondactivity += delta;
14309 mincondactivity += delta;
14313 if( *nfixedvars - oldnfixedvars > 0 || *nchgbds - oldnchgbds > 0 )
14315 SCIPdebugMsg(
scip,
"### stuffing fixed %d variables and changed %d bounds\n", *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds);
14354 if( singlevarstuffing && !ismaxsettoinfinity )
14359 int bestindex = -1;
14360 int bestuplocks = 0;
14361 int bestdownlocks = 1;
14364 SCIPdebug(
int oldnfixedvars = *nfixedvars; )
14365 SCIPdebug(
int oldnchgbds = *nchgbds; )
14368 for( v = 0; v <
nvars; ++v )
14372 val = factor * vals[v];
14400 if( ratio > bestratio || ((ratio == bestratio) && downlocks == 0 && (bestdownlocks > 0
14405 if( bestindex != -1 )
14408 if( bestuplocks > 1 )
14415 secondbestratio = bestratio;
14418 bestdownlocks = downlocks;
14419 bestuplocks = uplocks;
14426 if( bestdownlocks > 0 && bestuplocks > 1 )
14441 if( ratio > secondbestratio )
14443 secondbestratio = ratio;
14449 if( bestindex != -1 && bestdownlocks == 0 )
14456 val = factor * vals[bestindex];
14469 SCIP_Real activitydelta = (maxactivity - rhs) - (bestvarfloor * -val);
14474 bounddelta =
SCIPceil(
scip, (maxactivity - rhs)/-val);
14478 bounddelta = (maxactivity - rhs)/-val;
14480 tryfixing = tryfixing &&
SCIPisLE(
scip, bounddelta, ub - lb);
14506 SCIP_Real activitydelta = (maxactivity - rhs) - (bestvarfloor * val);
14515 bounddelta = (maxactivity - rhs)/val;
14517 tryfixing = tryfixing &&
SCIPisLE(
scip, bounddelta, ub - lb);
14546 for( v = 0; v <
nvars; ++v )
14554 SCIPdebugMsg(
scip,
"<= %g\n", factor > 0 ? consdata->rhs : -consdata->lhs);
14556 for( v = 0; v <
nvars; ++v )
14558 if( v == bestindex )
14561 if( factor * vals[v] < 0 )
14581 SCIPdebug(
SCIPdebugMsg(
scip,
"### new stuffing fixed %d vars, tightened %d bounds\n", *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds); )
14665 for( v = 0; v <
nvars; ++v )
14677 for( v = 0; v < ncontvars; v++ )
14704 for(
c = 0;
c < nconss; ++
c )
14731 for(
i = 0;
i < consdata->nvars; ++
i )
14735 var = consdata->vars[
i];
14740 assert(0 <= contv && contv < ncontvars);
14741 isimplint[contv] =
FALSE;
14754 hasimpliedpotential =
FALSE;
14757 for(
i = 0;
i < consdata->nvars; ++
i )
14771 var = consdata->vars[
i];
14773 val = consdata->vals[
i];
14788 isminsettoinfinity =
TRUE;
14789 ismaxsettoinfinity =
TRUE;
14795 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
14801 assert((ismintight || isminsettoinfinity) && (ismaxtight || ismaxsettoinfinity));
14816 newredlb = redlb[arrayindex];
14817 newredub = redub[arrayindex];
14823 nlocksdown[arrayindex] += nlockspos;
14824 newredlb = (isminsettoinfinity ?
SCIPinfinity(
scip) : (consdata->lhs - minresactivity)/val);
14829 nlocksup[arrayindex] += nlockspos;
14830 newredub = (ismaxsettoinfinity ? -
SCIPinfinity(
scip) : (consdata->rhs - maxresactivity)/val);
14838 nlocksup[arrayindex] += nlockspos;
14839 newredub = (isminsettoinfinity ? -
SCIPinfinity(
scip) : (consdata->lhs - minresactivity)/val);
14844 nlocksdown[arrayindex] += nlockspos;
14845 newredlb = (ismaxsettoinfinity ?
SCIPinfinity(
scip) : (consdata->rhs - maxresactivity)/val);
14859 redlb[arrayindex] =
MAX(redlb[arrayindex], newredlb);
14860 redub[arrayindex] =
MIN(redub[arrayindex], newredub);
14867 assert(nconscontvars < ncontvars);
14869 conscontvars[nconscontvars] =
var;
14873 assert(0 <= contv && contv < ncontvars);
14874 hasimpliedpotential = hasimpliedpotential || isimplint[contv];
14879 if( hasimpliedpotential )
14881 if( nconscontvars > 1 || !integralcoefs )
14886 for(
i = 0;
i < nconscontvars;
i++ )
14890 assert(0 <= contv && contv < ncontvars);
14891 isimplint[contv] =
FALSE;
14905 assert(nconscontvars == 1);
14906 assert(0 <= contvarpos && contvarpos < consdata->
nvars);
14907 var = consdata->vars[contvarpos];
14908 val = consdata->vals[contvarpos];
14910 assert(0 <= contv && contv < ncontvars);
14911 assert(isimplint[contv]);
14915 isimplint[contv] =
FALSE;
14921 if(
obj * val >= 0.0 && lhsexists )
14926 if(
obj * val <= 0.0 && rhsexists )
14938 for( v = 0; v <
nvars; ++v )
14968 SCIPdebugMsg(
scip,
"variable <%s> only locked down in linear constraints: dual presolve <%s>[%.15g,%.15g] <= %.15g\n",
14975 redub[v] =
MIN(redub[v], ub);
14997 SCIPdebugMsg(
scip,
"variable <%s> only locked up in linear constraints: dual presolve <%s>[%.15g,%.15g] >= %.15g\n",
15004 redlb[v] =
MAX(redlb[v], lb);
15041 SCIPdebugMsg(
scip,
"dual presolve: converting continuous variable <%s>[%g,%g] to implicit integer\n",
15085 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
15087 SCIPdebugMsg(
scip,
"Enforcement method of linear constraints for %s solution\n",
sol ==
NULL ?
"LP" :
"relaxation");
15095 for(
c = 0;
c < nusefulconss; ++
c )
15161 nlocvars = consdata->nvars;
15166 for(
i = 0;
i < nlocvars; ++
i )
15168 vars[
i] = consdata->vars[
i];
15169 vals[
i] = consdata->vals[
i];
15173 lhs = consdata->lhs - constant;
15174 rhs = consdata->rhs - constant;
15184 for(
i = 0;
i < nlocvars; ++
i )
15192 cons, lhs, rhs, success) );
15257 conshdlrdata->naddconss = 0;
15260 for(
c = 0;
c < nconss; ++
c )
15285 for(
c = nconss - 1;
c >= 0; --
c )
15292 if( consdata->eventdata !=
NULL )
15366 for(
c = 0;
c < nconss;
c++ )
15385 rhs = consdata->rhs;
15386 lhs = consdata->lhs;
15390 for(
i = 0;
i < consdata->nvars;
i++ )
15396 if( consdata->nvars == 0 )
15416 if( consdata->nvars == 1 )
15426 if( consdata->nvars == 2 &&
SCIPisEQ(
scip, lhs, rhs) )
15436 if( consdata->nvars == 2 )
15441 if(
SCIPisEQ(
scip, consdata->vals[0], -consdata->vals[1])
15469 scale =
REALABS(consdata->vals[0]);
15472 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15479 if( consdata->vals[
i] < 0.0 )
15487 b = rhs/scale + nnegbinvars;
15508 b = rhs/scale + nnegbinvars;
15533 b = lhs/scale + nnegbinvars;
15563 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15571 b -= consdata->vals[
i];
15591 for(
i = 0;
i < consdata->nvars && !matched;
i++ )
15596 SCIPdebugMsg(
scip,
"classified as %s: ", matched ?
"BINPACKING" :
"KNAPSACK");
15619 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15646 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15679#ifdef SCIP_STATISTIC
15690#ifdef SCIP_STATISTIC
15698 for(
c = 0;
c < nconss; ++
c )
15708 if( consdata->upgraded )
15715 if(
SCIPisLT(
scip, consdata->maxactdelta, conshdlrdata->maxeasyactivitydelta) )
15720 SCIPstatisticMessage(
"below threshold: %d / %d ratio= %g\n", ngoodconss, nallconss, (100.0 * ngoodconss / nallconss));
15724 for(
c = 0;
c < nconss; ++
c )
15734 if( consdata->upgraded )
15759 for(
c = 0;
c < nconss; ++
c )
15777 for(
c = 0;
c < nconss; ++
c )
15784 if( consdata->row !=
NULL )
15789 if( consdata->nlrow !=
NULL )
15805 if( ncutsadded > 0 )
15808 "(restart) converted %d cuts from the global cut pool into linear constraints\n", ncutsadded);
15859 if( consdata->eventdata !=
NULL )
15887 if( (*consdata)->eventdata !=
NULL )
15927 SCIP_CALL(
consdataCreate(
scip, &targetdata, sourcedata->nvars, sourcedata->vars, sourcedata->vals, sourcedata->lhs, sourcedata->rhs) );
15934 for(n = targetdata->nvars - 1; n >= 0; --n )
15959 *infeasible =
FALSE;
15961 for(
c = 0;
c < nconss && !(*infeasible); ++
c )
16003 if( (
depth == 0 && conshdlrdata->maxroundsroot >= 0 && nrounds >= conshdlrdata->maxroundsroot)
16004 || (
depth > 0 && conshdlrdata->maxrounds >= 0 && nrounds >= conshdlrdata->maxrounds) )
16008 maxsepacuts = (
depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);
16014 maxbound = glblowerbound + conshdlrdata->maxcardbounddist * (cutoffbound - glblowerbound);
16015 separatecards =
SCIPisLE(
scip, loclowerbound, maxbound);
16023 for(
c = 0;
c < nusefulconss && ncuts < maxsepacuts && !
cutoff; ++
c )
16032 else if( ncuts > 0 )
16069 if( (
depth == 0 && conshdlrdata->maxroundsroot >= 0 && nrounds >= conshdlrdata->maxroundsroot)
16070 || (
depth > 0 && conshdlrdata->maxrounds >= 0 && nrounds >= conshdlrdata->maxrounds) )
16074 maxsepacuts = (
depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);
16081 for(
c = 0;
c < nusefulconss && ncuts < maxsepacuts && !
cutoff; ++
c )
16090 else if( ncuts > 0 )
16135 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
16140 if( objinfeasible )
16142 SCIPdebugMsg(
scip,
"-> pseudo solution is objective infeasible, return.\n");
16150 for(
c = 0;
c < nconss && !violated; ++
c )
16184 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
16249 tightenbounds =
TRUE;
16254 int tightenboundsfreq;
16259 tightenboundsfreq = propfreq * conshdlrdata->tightenboundsfreq;
16260 tightenbounds = (conshdlrdata->tightenboundsfreq >= 0)
16261 && ((tightenboundsfreq == 0 &&
depth == 0) || (tightenboundsfreq >= 1 && (
depth % tightenboundsfreq == 0)));
16264 rangedrowpropagation = conshdlrdata->rangedrowpropagation;
16266 rangedrowpropagation = rangedrowpropagation && (
depth <= conshdlrdata->rangedrowmaxdepth);
16267 rangedrowfreq = propfreq * conshdlrdata->rangedrowfreq;
16268 rangedrowpropagation = rangedrowpropagation && (conshdlrdata->rangedrowfreq >= 0)
16269 && ((rangedrowfreq == 0 &&
depth == 0) || (rangedrowfreq >= 1 && (
depth % rangedrowfreq == 0)));
16276 for(
i = 0;
i < nmarkedconss && !
cutoff;
i++ )
16280 conshdlrdata->maxeasyactivitydelta, conshdlrdata->sortvars, &
cutoff, &nchgbds) );
16286 else if( nchgbds > 0 )
16295#define MAXCONSPRESOLROUNDS 10
16318 int firstupgradetry;
16330 oldnfixedvars = *nfixedvars;
16331 oldnaggrvars = *naggrvars;
16332 oldnchgbds = *nchgbds;
16333 oldndelconss = *ndelconss;
16334 oldnupgdconss = *nupgdconss;
16335 oldnchgcoefs = *nchgcoefs;
16336 oldnchgsides = *nchgsides;
16343 firstchange = INT_MAX;
16344 firstupgradetry = INT_MAX;
16350 infeasible =
FALSE;
16360 consdata->lhs = consdata->rhs;
16364 if( consdata->eventdata ==
NULL )
16387 assert(consdata->removedfixings);
16394 if( firstchange == INT_MAX && consdata->changed )
16398 if( firstupgradetry == INT_MAX && !consdata->upgradetried )
16399 firstupgradetry =
c;
16402 if( consdata->presolved )
16420 consdata->presolved =
TRUE;
16437 SCIPdebugMsg(
scip,
" -> infeasibility detected during tightening sides\n");
16445 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16463 &isminsettoinfinity, &ismaxsettoinfinity);
16466 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16467 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16473 SCIPdebugMsg(
scip,
"linear constraint <%s> is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16474 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16478 if( !consdata->upgraded )
16484 SCIPdebugMsg(
scip,
"linear constraint <%s> left hand side is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16485 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16487 if( !consdata->upgraded )
16492 SCIPdebugMsg(
scip,
"linear constraint <%s> right hand side is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16493 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16495 if( !consdata->upgraded )
16500 if( consdata->nvars == 0 )
16504 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16510 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16515 if( !consdata->upgraded )
16525 if( conshdlrdata->simplifyinequalities )
16534 if( conshdlrdata->aggregatevariables )
16545 if( conshdlrdata->rangedrowpropagation )
16547 int lastnfixedvars;
16549 lastnfixedvars = *nfixedvars;
16554 if( lastnfixedvars < *nfixedvars )
16565 nfixedvars, nchgbds, &
cutoff) );
16572 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16578 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16583 if( !consdata->upgraded )
16608 if( firstchange == INT_MAX && consdata->changed )
16612 if( firstupgradetry == INT_MAX && !consdata->upgradetried )
16613 firstupgradetry =
c;
16621 conshdlrdata->singlevarstuffing, &
cutoff, nfixedvars, nchgbds) );
16624 if( consdata->nvars == 0 )
16628 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16634 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16639 if( !consdata->upgraded )
16652 assert(firstchange >= 0);
16654 if( firstchange < nconss && conshdlrdata->presolusehashing )
16658 ndelconss, nchgsides) );
16661 if( firstchange < nconss && conshdlrdata->presolpairwise )
16665 int firstchangenew;
16668 npaircomparisons = 0;
16669 oldndelconss = *ndelconss;
16670 oldnchgsides = *nchgsides;
16671 oldnchgcoefs = *nchgcoefs;
16677 firstchangenew = -1;
16678 for(
c = 0;
c < nconss; ++
c )
16681 if(
c == firstchange )
16682 firstchangenew = nusefulconss;
16688 usefulconss[nusefulconss] = conss[
c];
16691 firstchange = firstchangenew;
16692 assert(firstchangenew >= 0 && firstchangenew <= nusefulconss);
16697 if( usefulconss[
c] ==
NULL )
16704 &
cutoff, ndelconss, nchgsides, nchgcoefs) );
16706 if( npaircomparisons > conshdlrdata->nmincomparisons )
16708 assert(npaircomparisons > 0);
16709 if( ((*ndelconss - oldndelconss) + (*nchgsides - oldnchgsides)/2.0 + (*nchgcoefs - oldnchgcoefs)/10.0) / ((
SCIP_Real) npaircomparisons) < conshdlrdata->mingainpernmincomp )
16711 oldndelconss = *ndelconss;
16712 oldnchgsides = *nchgsides;
16713 oldnchgcoefs = *nchgcoefs;
16714 npaircomparisons = 0;
16725 if( !
cutoff && firstupgradetry < nconss
16726 && *nfixedvars == oldnfixedvars && *naggrvars == oldnaggrvars && *nchgbds == oldnchgbds && *ndelconss == oldndelconss
16727 && *nupgdconss == oldnupgdconss && *nchgcoefs == oldnchgcoefs && *nchgsides == oldnchgsides
16754 if( consdata->upgradetried )
16757 if( !consdata->presolved )
16760 consdata->upgradetried =
TRUE;
16766 if( upgdcons !=
NULL )
16776 assert(!consdata->upgraded);
16777 consdata->upgraded =
TRUE;
16783 || !conshdlrdata->presolpairwise
16784 || (conshdlrdata->maxaggrnormscale == 0.0) )
16796 else if( *nfixedvars > oldnfixedvars || *naggrvars > oldnaggrvars || *nchgbds > oldnchgbds || *ndelconss > oldndelconss
16797 || *nupgdconss > oldnupgdconss || *nchgcoefs > oldnchgcoefs || *nchgsides > oldnchgsides )
16838 for(
i = 0;
i < consdata->nvars; ++
i )
16903 const char* consname;
16922 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
valid) );
16937 char** firstoperator,
16938 char** secondoperator,
16948 *firstoperator =
NULL;
16949 *secondoperator =
NULL;
16955 while( *curr && *success )
16968 if( curr[1] ==
'=' )
16977 if( strncmp(curr,
"[free]", 6) == 0 )
16992 if( *firstoperator ==
NULL )
16994 *firstoperator = curr;
16998 if( *secondoperator !=
NULL )
17003 else if( strncmp(*firstoperator,
"<=", 2) != 0 )
17005 SCIPerrorMessage(
"Two operators in line that is not a ranged row: %s", str);
17008 else if( strncmp(curr,
"<=", 2) != 0 )
17010 SCIPerrorMessage(
"Bad second operator, expected ranged row specification: %s", str);
17014 *secondoperator = curr;
17024 if( *firstoperator ==
NULL )
17061 (*success) =
FALSE;
17076 if( ! operatorsuccess )
17079 varstrptr = (
char *)str;
17080 lhsstrptr = rhsstrptr =
NULL;
17087 assert(firstop[1] ==
'=');
17089 if( secondop !=
NULL )
17091 assert(secondop[0] ==
'<' && secondop[1] ==
'=');
17092 lhsstrptr = (
char *)str;
17093 varstrptr = firstop + 2;
17094 rhsstrptr = secondop + 2;
17100 varstrptr = (
char *)str;
17101 rhsstrptr = firstop + 2;
17105 assert(firstop[1] ==
'=');
17108 lhsstrptr = firstop + 2;
17111 assert(firstop[1] ==
'=');
17114 rhsstrptr = firstop + 2;
17115 lhsstrptr = firstop + 2;
17118 assert(strncmp(firstop,
"[free]", 6) == 0);
17124 SCIPerrorMessage(
"Parsing has wrong operator character '%c', should be one of <=>[", *firstop);
17129 if( lhsstrptr !=
NULL )
17133 SCIPerrorMessage(
"error parsing left hand side number from <%s>\n", lhsstrptr);
17138 if( rhsstrptr == lhsstrptr )
17143 if( rhsstrptr !=
NULL && rhsstrptr != lhsstrptr )
17147 SCIPerrorMessage(
"error parsing right hand side number from <%s>\n", lhsstrptr);
17162 if( *success && requsize > coefssize )
17165 coefssize = requsize;
17170 assert(!*success || requsize <= coefssize);
17180 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
17199 if( varssize < consdata->
nvars )
17200 (*success) =
FALSE;
17222 (*nvars) = consdata->nvars;
17266 cons = eventdata->cons;
17285 varpos = eventdata->varpos;
17291 val = consdata->vals[varpos];
17310 consdata->presolved =
FALSE;
17311 consdata->rangedrowpropagated = 0;
17319 if( consdata->maxactdeltavar ==
var )
17322 consdata->maxactdeltavar =
NULL;
17326 if( consdata->boundstightened > 0)
17328 switch( eventtype )
17332 consdata->boundstightened = 0;
17336 consdata->boundstightened = 0;
17358 delta =
REALABS(val) * domain;
17360 if( delta > consdata->maxactdelta )
17362 consdata->maxactdelta = delta;
17363 consdata->maxactdeltavar =
var;
17370 consdata->presolved =
FALSE;
17371 consdata->removedfixings =
FALSE;
17372 consdata->rangedrowpropagated = 0;
17375 if( consdata->maxactdeltavar ==
var )
17378 consdata->maxactdeltavar =
NULL;
17386 consdata->presolved =
FALSE;
17395 varpos = eventdata->varpos;
17401 val = consdata->vals[varpos];
17403 consdata->rangedrowpropagated = 0;
17418 consdata->indexsorted =
FALSE;
17420 consdata->coefsorted =
FALSE;
17436 consdata->varsdeleted =
TRUE;
17459 assert(bdchginfos !=
NULL || nbdchginfos == 0);
17475 for(
i = 0;
i < nbdchginfos; ++
i )
17496 if(
i == nbdchginfos )
17509 if( upgdcons !=
NULL )
17545 assert(upgdconsssize > 0);
17583 consdata->checkabsolute =
TRUE;
17611 eventExecLinear,
NULL) );
17615 conflictExecLinear,
NULL) );
17623 consEnfolpLinear, consEnfopsLinear, consCheckLinear, consLockLinear,
17665 "multiplier on propagation frequency, how often the bounds are tightened (-1: never, 0: only at root)",
17669 "maximal number of separation rounds per node (-1: unlimited)",
17673 "maximal number of separation rounds per node in the root node (-1: unlimited)",
17677 "maximal number of cuts separated per separation round",
17681 "maximal number of cuts separated per separation round in the root node",
17685 "should pairwise constraint comparison be performed in presolving?",
17689 "should hash table be used for detecting redundant constraints in advance",
17693 "number for minimal pairwise presolve comparisons",
17697 "minimal gain per minimal pairwise presolve comparisons to repeat pairwise comparison round",
17701 "maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint aggregation)",
17705 "maximum activity delta to run easy propagation on linear constraint (faster, but numerically less stable)",
17709 "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts",
17713 "should all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value?",
17717 "should presolving search for aggregations in equations",
17721 "should presolving try to simplify inequalities",
17725 "should dual presolving steps be performed?",
17729 "should stuffing of singleton continuous variables be performed?",
17733 "should single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable?",
17736 "constraints/" CONSHDLR_NAME "/sortvars",
"apply binaries sorting in decr. order of coeff abs value?",
17740 "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)?",
17744 "should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP?",
17748 "should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP?",
17752 "should presolving try to detect subsets of constraints parallel to the objective function?",
17756 "should presolving and propagation try to improve bounds, detect infeasibility, and extract sub-constraints from ranged rows and equations?",
17760 "should presolving and propagation extract sub-constraints from ranged rows and equations?",
17764 "maximum depth to apply ranged row propagation",
17768 "frequency for applying ranged row propagation",
17772 "should multi-aggregations only be performed if the constraint can be removed afterwards?",
17776 "maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation",
17780 "maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation",
17784 "should Cliques be extracted?",
17795 const char* conshdlrname
17810 if( conshdlr ==
NULL )
17886 if( conshdlr ==
NULL )
17892 for( j = 0; j <
nvars; ++j )
17921 if( requiredsize > nconsvars )
17927 assert(requiredsize <= nconsvars);
17933 if( constant < 0.0 )
17940 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);
17950 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);
17966 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);
17976 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);
18020 if( check || enforce )
18023 for(n = consdata->nvars - 1; n >= 0; --n )
18029 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
18030 local, modifiable, dynamic, removable, stickingatnode) );
18111 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
18119 if( sourcecoefs !=
NULL )
18126 for( v = 0; v <
nvars; ++v )
18139 if( requiredsize >
nvars )
18150 for( v = 0; v <
nvars; ++v )
18160 for( v = 0; v <
nvars && success; ++v )
18182 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
18237 if( requiredsize > nconsvars )
18243 assert(requiredsize <= nconsvars);
18249 lhs = consdata->lhs;
18250 rhs = consdata->rhs;
18256 if( constant < 0.0 )
18329 for( v = nconsvars - 1; v >= 0; --v )
18383 SCIPerrorMessage(
"method may only be called during problem creation stage for original constraints and variables\n");
18390 vars = consdata->vars;
18463 return consdata->lhs;
18487 return consdata->rhs;
18550 return consdata->nvars;
18574 return consdata->vars;
18598 return consdata->vals;
18627 if( consdata->row !=
NULL )
18655 if( consdata->row !=
NULL )
18683 if( consdata->row !=
NULL )
18711 if( consdata->row !=
NULL )
18740 return consdata->row;
18809 if( consdata->upgraded )
18813 if( consdata->row !=
NULL )
18817 SCIPerrorMessage(
"cannot upgrade linear constraint that is already stored as row in the LP\n");
18869 for(
i = 0;
i < consdata->nvars; ++
i )
18871 var = consdata->vars[
i];
18872 val = consdata->vals[
i];
18940 poscoeffsum += val;
18942 negcoeffsum += val;
18949 SCIPdebugMsg(
scip,
"upgrading linear constraint <%s> (%d upgrade methods):\n",
18951 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",
18952 nposbin, nnegbin, nposint, nnegint, nposimpl, nnegimpl, nposcont, nnegcont,
18953 ncoeffspone, ncoeffsnone, ncoeffspint, ncoeffsnint, ncoeffspfrac, ncoeffsnfrac,
18954 poscoeffsum, negcoeffsum, integral);
18957 for(
i = 0;
i < conshdlrdata->nlinconsupgrades && *upgdcons ==
NULL; ++
i )
18959 if( conshdlrdata->linconsupgrades[
i]->active )
18961 SCIP_CALL( conshdlrdata->linconsupgrades[
i]->linconsupgd(
scip, cons, consdata->nvars,
18962 consdata->vars, consdata->vals, consdata->lhs, consdata->rhs,
18963 nposbin, nnegbin, nposint, nnegint, nposimpl, nnegimpl, nposimplbin, nnegimplbin, nposcont, nnegcont,
18964 ncoeffspone, ncoeffsnone, ncoeffspint, ncoeffsnint, ncoeffspfrac, ncoeffsnfrac,
18965 poscoeffsum, negcoeffsum, integral,
18971 if( *upgdcons !=
NULL )
18995 if( conshdlr ==
NULL )
18999 *infeasible =
FALSE;
19004 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_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_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_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_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)
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