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);
10913 assert(!bestislhs || lhsexists);
10914 assert(bestislhs || rhsexists);
10916 bestvar = consdata->vars[bestpos];
10917 bestval = consdata->vals[bestpos];
10933 for( j = 0; j < consdata->nvars; ++j )
10937 aggrvars[naggrs] = consdata->vars[j];
10938 aggrcoefs[naggrs] = -consdata->vals[j]/consdata->vals[bestpos];
10945 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: too large aggregation coefficients\n");
10958 aggrcoefs[naggrs] =
SCIPfloor(
scip, aggrcoefs[naggrs]+0.5);
10993 assert(!samevar || (supinf > 0 && infinf > 0));
10995 aggrconst = (bestislhs ? consdata->lhs/bestval : consdata->rhs/bestval);
10998 assert(naggrs == consdata->nvars-1);
11007 aggregated =
FALSE;
11008 infeasible =
FALSE;
11011 if( (samevar && supinf == 1 && infinf == 1) || (!samevar && (supinf == 0 || infinf == 0)) )
11022 for( j = 0; j < naggrs; ++j)
11031 assert(!infeasiblevartypechg);
11040 SCIPdebugMsg(
scip,
"do not perform multi-aggregation: infimum and supremum are both infinite\n");
11059 if( !consdata->upgraded )
11074#define CONTWEIGHT 8
11153 lhs = consdata->lhs;
11154 vars = consdata->vars;
11155 vals = consdata->vals;
11156 nvars = consdata->nvars;
11165 for( v = 0; v <
nvars && noddvars < 3; ++v )
11180 if( noddvars == 0 )
11192 if( noddvars == 1 )
11196 SCIPdebugMsg(
scip,
"linear constraint <%s>: try fixing variable <%s> to <%g>\n",
11216 else if( noddvars == 2 )
11225 SCIPdebugMsg(
scip,
"linear constraint <%s>: try aggregation of variables <%s> and <%s>\n",
11229 lhsodd ? 1.0 : 0.0, &infeasible, &redundant, &aggregated) );
11270 while( success && consdata->nvars >= 1 );
11299 if( vartype2 != vartype1 )
11309 value =
REALABS(consdata->vals[ind2]) -
REALABS(consdata->vals[ind1]);
11312 return (value > 0 ? +1 : (value < 0 ? -1 : 0));
11349 nvars = consdata->nvars;
11355 lhs = consdata->lhs;
11356 rhs = consdata->rhs;
11365 vals = consdata->vals;
11366 vars = consdata->vars;
11374 for( v =
nvars - 1; v >= 0; --v )
11380 secondminval = minval;
11383 else if( secondminval > vals[v] || secondminval ==
SCIP_INVALID )
11384 secondminval = vals[v];
11398 for( v =
nvars - 1; v >= 0; --v )
11402 (*nchgcoefs) +=
nvars;
11485 *infeasible =
FALSE;
11497 nvars = consdata->nvars;
11521 consdata->normalized =
FALSE;
11529 if( !consdata->normalized )
11532 lhs = consdata->lhs;
11533 rhs = consdata->rhs;
11547 SCIPdebug( oldnchgcoefs = *nchgcoefs; )
11548 SCIPdebug( oldnchgsides = *nchgsides; )
11551 if( haslhs && hasrhs )
11557 assert(haslhs != hasrhs);
11573 consdata->indexsorted =
FALSE;
11574 consdata->coefsorted =
FALSE;
11576 vars = consdata->vars;
11577 vals = consdata->vals;
11600 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
11603 if( isminsettoinfinity || ismaxsettoinfinity )
11608 assert(maxact > minact);
11614 side = haslhs ? lhs : rhs;
11615 minactsub = minact;
11616 maxactsub = maxact;
11685 for(
w = 0;
w < v; ++
w )
11693 maxactsub -= ub * vals[
w];
11694 minactsub -= lb * vals[
w];
11695 assert(maxactsub > minactsub);
11726 maxactsub -= ub * vals[0];
11727 minactsub -= lb * vals[0];
11731 maxactsub -= lb * vals[0];
11732 minactsub -= ub * vals[0];
11734 assert(maxactsub > minactsub);
11739 allcoefintegral =
TRUE;
11742 for( ; v <
nvars - 1; ++v )
11749 allcoefintegral =
FALSE;
11768 maxactsub -= ub * vals[v];
11769 minactsub -= lb * vals[v];
11773 maxactsub -= lb * vals[v];
11774 minactsub -= ub * vals[v];
11791 rredundant = hasrhs && maxactsub <= siderest &&
SCIPisFeasGT(
scip, minactsub, siderest - gcd);
11792 lredundant = haslhs &&
SCIPisFeasLT(
scip, maxactsub, siderest) && minactsub >= siderest - gcd;
11795 if( offsetv == -1 && (rredundant || lredundant) )
11821 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",
11822 v,
nvars, minactsub, maxactsub, redundant, hasrhs, siderest, gcd, offsetv);
11829 rredundant = hasrhs && maxactsub <= siderest &&
SCIPisFeasGT(
scip, minactsub, siderest - gcd);
11830 lredundant = haslhs &&
SCIPisFeasLT(
scip, maxactsub, siderest) && minactsub >= siderest - gcd;
11833 if( v <
nvars && numericsok && (redundant || (offsetv == -1 && (rredundant || lredundant))) )
11854 tmpmaxactsub += ub * vals[
w];
11855 tmpminactsub += lb * vals[
w];
11859 tmpmaxactsub += lb * vals[
w];
11860 tmpminactsub += ub * vals[
w];
11862 assert(tmpmaxactsub >= tmpminactsub);
11882 (haslhs && tmpmaxactsub < siderest &&
SCIPisFeasGE(
scip, tmpminactsub, siderest - gcd)));
11885 SCIPdebugMsg(
scip,
"removing %d last variables from constraint <%s>, because they never change anything on the feasibility of this constraint\n",
11893 (*nchgcoefs) += (
nvars - v);
11901 assert(vals == consdata->vals);
11916 rhs = consdata->rhs;
11923 lhs = consdata->lhs;
11934 nvars = consdata->nvars;
11937 allcoefintegral =
TRUE;
11941 for(
w = offsetv + 1;
w <
nvars; ++
w )
11950 if( offsetv >= 0 && gcd == 1 )
11960 for( v =
nvars - 1; v > offsetv; --v )
11968 allcoefintegral =
FALSE;
11994 if( candpos == -1 )
12004 assert(v > offsetv || candpos > offsetv);
12010 candpos =
nvars - 1;
12013 if( gcd > 1 && allcoefintegral && !redundant )
12016 allcoefintegral =
FALSE;
12020 if( offsetv >= 0 && gcd > 1 && allcoefintegral )
12031 for(
w = offsetv + 1;
w <
nvars; ++
w )
12049 restcoef = ((
SCIP_Longint)(vals[candpos] + feastol)) % gcd;
12056 if( restcoef > rest )
12057 newcoef = vals[candpos] - restcoef + gcd;
12059 newcoef = vals[candpos] - restcoef;
12064 if( rest == 0 || restcoef < rest )
12065 newcoef = vals[candpos] - restcoef;
12067 newcoef = vals[candpos] - restcoef + gcd;
12077 notchangable =
TRUE;
12118 for(
w = offsetv;
w >= 0; --
w )
12124 (*nchgcoefs) += (offsetv + 1);
12127 if( !notchangable )
12131 assert(vals == consdata->vals);
12137 nvars = consdata->nvars;
12142 lhs = consdata->lhs;
12143 rhs = consdata->rhs;
12157 allcoefintegral =
TRUE;
12159 for( v =
nvars - 1; v >= 0; --v )
12164 allcoefintegral =
FALSE;
12181 if( allcoefintegral )
12192 for( v =
nvars - 1; v >= 0; --v )
12228 SCIPdebugMsg(
scip,
"rounding all non-integral coefficients and the right hand side down\n");
12233 for( v =
nvars - 1; v >= 0; --v )
12270 if( allcoefintegral )
12285 for( v =
nvars - 1; v >= 0; --v )
12333 SCIPdebugMsg(
scip,
"rounding all non-integral coefficients and the left hand side down\n");
12338 for( v =
nvars - 1; v >= 0; --v )
12376 assert(vals == consdata->vals);
12381 rhs = consdata->rhs;
12382 lhs = consdata->lhs;
12389 nvars = consdata->nvars;
12393 allcoefintegral =
TRUE;
12396 for( v =
nvars - 1; v >= 0; --v )
12403 if( !allcoefintegral )
12423 SCIPdebug( oldnchgcoefs = *nchgcoefs; )
12424 SCIPdebug( oldnchgsides = *nchgsides; )
12439 for( v =
nvars - 1; v >= 0; --v )
12446 if( foundbin == -1 )
12474 foundbin =
nvars - 1;
12477 if( gcd == 1 || foundbin == -1)
12480 assert((onlybin && gcd == -1) || (!onlybin && gcd > 1));
12488 for( v = foundbin; v >= 0; --v )
12517 if( candpos == -1 )
12525 if( onlybin && v == foundbin - 1 )
12526 candpos2 = foundbin;
12531 if( onlybin && candpos == v + 1 && candpos2 == v + 2 )
12536 candpos = candpos2;
12579 if( vals[candpos] < 0 )
12581 restcoef = ((
SCIP_Longint)(vals[candpos] - feastol)) % gcd;
12586 restcoef = ((
SCIP_Longint)(vals[candpos] + feastol)) % gcd;
12600 if( restcoef > rest )
12601 newcoef = vals[candpos] - restcoef + gcd;
12603 newcoef = vals[candpos] - restcoef;
12615 if( rest == 0 || restcoef < rest )
12616 newcoef = vals[candpos] - restcoef;
12618 newcoef = vals[candpos] - restcoef + gcd;
12622 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));
12639 assert(vals == consdata->vals);
12646 rhs = consdata->rhs;
12647 lhs = consdata->lhs;
12651 nvars = consdata->nvars;
12653 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));
12655 while(
nvars >= 2 );
12675 int* diffidx0minus1,
12676 int* diffidx1minus0,
12678 int commonidxweight,
12679 int diffidx0minus1weight,
12680 int diffidx1minus0weight,
12711 assert(nvarscommon >= 1);
12712 assert(commonidxweight >= nvarscommon);
12719 *infeasible =
FALSE;
12726 assert(consdata0->nvars >= 1);
12728 assert(diffidx0minus1weight >= consdata0->nvars - nvarscommon);
12733 assert(consdata1->nvars >= 1);
12735 assert(diffidx1minus0weight >= consdata1->nvars - nvarscommon);
12737 *aggregated =
FALSE;
12743 bestvarweight = commonidxweight + diffidx0minus1weight;
12744 bestnvars = consdata0->nvars;
12746 bestscalarsum = 0.0;
12747 commonvarlindependent =
TRUE;
12748 for( v = 0; v < nvarscommon; ++v )
12750 assert(consdata0->vars[commonidx0[v]] == consdata1->vars[commonidx1[v]]);
12751 a = consdata1->vals[commonidx1[v]];
12752 b = -consdata0->vals[commonidx0[v]];
12758 varweight = diffidx0minus1weight + diffidx1minus0weight;
12759 nvars = consdata0->nvars + consdata1->nvars - 2*nvarscommon;
12761 betterscalarsum = (scalarsum < bestscalarsum);
12762 for(
i = 0;
i < nvarscommon
12763 && (varweight < bestvarweight || (varweight == bestvarweight && betterscalarsum)); ++
i )
12765 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12772 if( varweight < bestvarweight || (varweight == bestvarweight && betterscalarsum) )
12775 bestvarweight = varweight;
12777 bestscalarsum = scalarsum;
12784 if( commonvarlindependent && v > 0 )
12786 consdata1->vals[commonidx1[v]] * consdata0->vals[commonidx0[0]],
12787 consdata1->vals[commonidx1[0]] * consdata0->vals[commonidx0[v]]);
12804 if( consdata1->vals[commonidx1[bestv]] > 0.0 )
12806 a = consdata1->vals[commonidx1[bestv]];
12807 b = -consdata0->vals[commonidx0[bestv]];
12811 a = -consdata1->vals[commonidx1[bestv]];
12812 b = consdata0->vals[commonidx0[bestv]];
12821 assert(commonvarlindependent);
12822 if( consdata1->vals[commonidx1[0]] > 0.0 )
12824 a = consdata1->vals[commonidx1[0]];
12825 b = -consdata0->vals[commonidx0[0]];
12829 a = -consdata1->vals[commonidx1[0]];
12830 b = consdata0->vals[commonidx0[0]];
12851 SCIPdebug( bestvarweight = diffidx0minus1weight + diffidx1minus0weight; )
12852 bestnvars = consdata0->nvars + consdata1->nvars - 2*nvarscommon;
12855 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> := %.15g*<%s> + %.15g*<%s> -> nvars: %d -> %d, weight: %d -> %d\n",
12857 consdata0->nvars, bestnvars, commonidxweight + diffidx0minus1weight, bestvarweight);
12867 if( !commonvarlindependent )
12869 for(
i = 0;
i < nvarscommon; ++
i )
12871 assert(0 <= commonidx0[
i] && commonidx0[
i] < consdata0->nvars);
12872 assert(0 <= commonidx1[
i] && commonidx1[
i] < consdata1->nvars);
12874 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12877 assert(newnvars < bestnvars);
12878 newvars[newnvars] = consdata0->vars[commonidx0[
i]];
12879 newvals[newnvars] = aggrcoef;
12888 for(
i = 0;
i < nvarscommon; ++
i )
12890 assert(0 <= commonidx0[
i] && commonidx0[
i] < consdata0->nvars);
12891 assert(0 <= commonidx1[
i] && commonidx1[
i] < consdata1->nvars);
12893 aggrcoef =
a * consdata0->vals[commonidx0[
i]] +
b * consdata1->vals[commonidx1[
i]];
12900 for(
i = 0;
i < consdata0->nvars - nvarscommon; ++
i )
12902 assert(0 <= diffidx0minus1[
i] && diffidx0minus1[
i] < consdata0->nvars);
12904 aggrcoef =
a * consdata0->vals[diffidx0minus1[
i]];
12906 assert(newnvars < bestnvars);
12907 newvars[newnvars] = consdata0->vars[diffidx0minus1[
i]];
12908 newvals[newnvars] = aggrcoef;
12913 for(
i = 0;
i < consdata1->nvars - nvarscommon; ++
i )
12915 assert(0 <= diffidx1minus0[
i] && diffidx1minus0[
i] < consdata1->nvars);
12917 aggrcoef =
b * consdata1->vals[diffidx1minus0[
i]];
12919 assert(newnvars < bestnvars);
12920 newvars[newnvars] = consdata1->vars[diffidx1minus0[
i]];
12921 newvals[newnvars] = aggrcoef;
12924 assert(newnvars == bestnvars);
12932 newlhs =
a * consdata0->lhs +
b * consdata1->lhs;
12936 newrhs =
a * consdata0->rhs +
b * consdata1->rhs;
12949 newconsdata->upgraded = consdata0->upgraded;
12965 if( !consdata0->upgraded )
12966 (*nchgcoefs) += consdata0->nvars + consdata1->nvars - nvarscommon;
12967 *aggregated =
TRUE;
13011 assert(consdata1->indexsorted);
13012 assert(consdata2->indexsorted);
13022 if( consdata1->nvars != consdata2->nvars )
13026 for(
i = 0;
i < consdata1->nvars; ++
i )
13028 if( consdata1->vars[
i] != consdata2->vars[
i] )
13046 for(
i = 0;
i < consdata1->nvars; ++
i )
13048 SCIP_Real scale = consdata2->vals[
i] / consdata1->vals[
i];
13050 if( minscale > scale )
13058 if( maxscale < scale )
13088 assert(consdata->nvars > 0);
13090 assert(consdata->indexsorted);
13097 return SCIPhashFour(consdata->nvars, minidx, mididx, maxidx);
13115 return (((
unsigned int)consdata->upgraded)<<31) + (
unsigned int)
SCIPconsGetPos(cons);
13129 int* nparallelconss
13133 unsigned int querykey;
13135 *nparallelconss = 0;
13142 if( conskey < querykey )
13144 parallelconss[(*nparallelconss)++] = *querycons;
13145 *querycons = parallelcons;
13146 querykey = conskey;
13150 parallelconss[(*nparallelconss)++] = parallelcons;
13161 if( *querycons == parallelcons )
13197 int nparallelconss;
13210 hashtablesize = nconss;
13212 hashGetKeyLinearcons, hashKeyEqLinearcons, hashKeyValLinearcons, (
void*)
scip) );
13217 for(
c = 0;
c < nconss; ++
c )
13239 assert(consdata0->indexsorted);
13248 if( nparallelconss != 0 )
13258 lhs = consdata0->lhs;
13259 rhs = consdata0->rhs;
13261 for(
i = 0;
i < nparallelconss; ++
i )
13267 consdel = parallelconss[
i];
13281 assert(consdata0->nvars >= 1 && consdata0->nvars == consdatadel->nvars);
13283 assert(consdatadel->indexsorted);
13284 assert(consdata0->vars[0] == consdatadel->vars[0]);
13286 scale = consdata0->vals[0] / consdatadel->vals[0];
13294 assert(consdata0->validmaxabsval);
13295 assert(consdatadel->validmaxabsval);
13297 SCIP_Real scale0 = 1.0 / consdata0->maxabsval;
13300 for( k = 0; k < consdata0->nvars; ++k )
13302 assert(
SCIPisEQ(
scip, scale0 * consdata0->vals[k], scaledel * consdatadel->vals[k]));
13310 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with equal coefficients into single ranged row\n",
13316 lhs =
MAX(scale * consdatadel->lhs, lhs);
13319 rhs =
MIN(scale * consdatadel->rhs, rhs);
13324 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with negated coefficients into single ranged row\n",
13330 lhs =
MAX(scale * consdatadel->rhs, lhs);
13333 rhs =
MIN(scale * consdatadel->lhs, rhs);
13340 assert( ! consdata0->upgraded || consdatadel->upgraded );
13342 if( !consdatadel->upgraded )
13356 rhs = (lhs + rhs)/2;
13365 if( consdata0->changed &&
SCIPconsGetPos(cons0) < *firstchange )
13371#ifdef SCIP_MORE_DEBUG
13404 int* diffidx0minus1;
13405 int* diffidx1minus0;
13406 uint64_t possignature0;
13407 uint64_t negsignature0;
13410 int diffidx1minus0size;
13418 assert(firstchange <= chkind);
13425 cons0 = conss[chkind];
13432 assert(consdata0->nvars >= 1);
13433 cons0isequality =
SCIPisEQ(
scip, consdata0->lhs, consdata0->rhs);
13440 possignature0 = consdata0->possignature;
13441 negsignature0 = consdata0->negsignature;
13448 diffidx1minus0size = consdata0->nvars;
13450 cons0lhs = consdata0->lhs;
13451 cons0rhs = consdata0->rhs;
13452 cons0upgraded = consdata0->upgraded;
13455 cons0changed = consdata0->changed;
13456 consdata0->changed =
FALSE;
13457 for(
c = (cons0changed ? 0 : firstchange);
c < chkind && !(*cutoff) && conss[chkind] !=
NULL; ++
c )
13461 uint64_t possignature1;
13462 uint64_t negsignature1;
13474 int commonidxweight;
13475 int diffidx0minus1weight;
13476 int diffidx1minus0weight;
13480 assert(cons0lhs == consdata0->lhs);
13481 assert(cons0rhs == consdata0->rhs);
13482 assert(cons0upgraded == consdata0->upgraded);
13487 if( cons1 ==
NULL )
13501 if( !cons0changed && !consdata1->changed )
13506 if( cons0upgraded && consdata1->upgraded )
13509 assert(consdata1->nvars >= 1);
13516 possignature1 = consdata1->possignature;
13517 negsignature1 = consdata1->negsignature;
13520 coefsequal = (possignature0 == possignature1) && (negsignature0 == negsignature1);
13521 coefsnegated = (possignature0 == negsignature1) && (negsignature0 == possignature1);
13522 cons0dominateslhs =
SCIPisGE(
scip, cons0lhs, consdata1->lhs)
13523 && ((possignature0 | possignature1) == possignature1)
13524 && ((negsignature0 | negsignature1) == negsignature0);
13525 cons1dominateslhs =
SCIPisGE(
scip, consdata1->lhs, cons0lhs)
13526 && ((possignature0 | possignature1) == possignature0)
13527 && ((negsignature0 | negsignature1) == negsignature1);
13528 cons0dominatesrhs =
SCIPisLE(
scip, cons0rhs, consdata1->rhs)
13529 && ((possignature0 | possignature1) == possignature0)
13530 && ((negsignature0 | negsignature1) == negsignature1);
13531 cons1dominatesrhs =
SCIPisLE(
scip, consdata1->rhs, cons0rhs)
13532 && ((possignature0 | possignature1) == possignature1)
13533 && ((negsignature0 | negsignature1) == negsignature0);
13534 cons1isequality =
SCIPisEQ(
scip, consdata1->lhs, consdata1->rhs);
13535 tryaggregation = (cons0isequality || cons1isequality) && (maxaggrnormscale > 0.0);
13536 if( !cons0dominateslhs && !cons1dominateslhs && !cons0dominatesrhs && !cons1dominatesrhs
13537 && !coefsequal && !coefsnegated && !tryaggregation )
13541 if( tryaggregation && consdata1->nvars > diffidx1minus0size )
13544 diffidx1minus0size = consdata1->nvars;
13570 commonidxweight = 0;
13572 diffidx0minus1weight = 0;
13574 diffidx1minus0weight = 0;
13577 while( (v0 < consdata0->
nvars || v1 < consdata1->
nvars)
13578 && (cons0dominateslhs || cons1dominateslhs || cons0dominatesrhs || cons1dominatesrhs
13579 || coefsequal || coefsnegated || tryaggregation) )
13587 if( v0 < consdata0->
nvars && v1 < consdata1->
nvars )
13588 varcmp =
SCIPvarCompare(consdata0->vars[v0], consdata1->vars[v1]);
13589 else if( v0 < consdata0->
nvars )
13598 var = consdata0->vars[v0];
13599 val0 = consdata0->vals[v0];
13601 if( tryaggregation )
13603 diffidx0minus1[nvars0minus1] = v0;
13608 coefsequal =
FALSE;
13609 coefsnegated =
FALSE;
13614 var = consdata1->vars[v1];
13616 val1 = consdata1->vals[v1];
13617 if( tryaggregation )
13619 diffidx1minus0[nvars1minus0] = v1;
13624 coefsequal =
FALSE;
13625 coefsnegated =
FALSE;
13630 assert(consdata0->vars[v0] == consdata1->vars[v1]);
13631 var = consdata0->vars[v0];
13632 val0 = consdata0->vals[v0];
13633 val1 = consdata1->vals[v1];
13634 if( tryaggregation )
13636 commonidx0[nvarscommon] = v0;
13637 commonidx1[nvarscommon] = v1;
13643 coefsequal = coefsequal && (
SCIPisEQ(
scip, val0, val1));
13644 coefsnegated = coefsnegated && (
SCIPisEQ(
scip, val0, -val1));
13661 cons0dominatesrhs =
FALSE;
13662 cons1dominateslhs =
FALSE;
13666 cons0dominateslhs =
FALSE;
13667 cons1dominatesrhs =
FALSE;
13674 cons0dominateslhs =
FALSE;
13675 cons1dominatesrhs =
FALSE;
13679 cons0dominatesrhs =
FALSE;
13680 cons1dominateslhs =
FALSE;
13686 if( coefsequal || coefsnegated )
13701 SCIPdebugMsg(
scip,
"aggregate linear constraints <%s> and <%s> with %s coefficients into single ranged row\n",
13709 lhs =
MAX(consdata0->lhs, consdata1->lhs);
13710 rhs =
MIN(consdata0->rhs, consdata1->rhs);
13715 lhs =
MAX(consdata0->lhs, -consdata1->rhs);
13716 rhs =
MIN(consdata0->rhs, -consdata1->lhs);
13727 if( consdata0->upgraded )
13729 assert(!consdata1->upgraded);
13732 consdatastay = consdata1;
13736 consdatadel = consdata0;
13737 consinddel = chkind;
13743 consdatastay = consdata0;
13747 consdatadel = consdata1;
13754 if( !consdata0->upgraded )
13756 assert(consstay == cons0);
13757 cons0lhs = consdata0->lhs;
13758 cons0rhs = consdata0->rhs;
13764 assert( !consdatastay->upgraded );
13767 conss[consinddel] =
NULL;
13768 if( !consdatadel->upgraded )
13776 if( cons1dominateslhs && (!cons0isequality || cons1dominatesrhs ||
SCIPisInfinity(
scip, consdata0->rhs) ) )
13779 SCIPdebugMsg(
scip,
"left hand side of linear constraint <%s> is dominated by <%s>:\n",
13796 cons0lhs = consdata0->lhs;
13797 cons0isequality =
FALSE;
13798 if( !consdata0->upgraded )
13807 else if( cons0dominateslhs && (!cons1isequality || cons0dominatesrhs ||
SCIPisInfinity(
scip, consdata1->rhs)) )
13810 SCIPdebugMsg(
scip,
"left hand side of linear constraint <%s> is dominated by <%s>:\n",
13827 cons1isequality =
FALSE;
13828 if( !consdata1->upgraded )
13837 if( cons1dominatesrhs && (!cons0isequality || cons1dominateslhs ||
SCIPisInfinity(
scip, -consdata0->lhs)) )
13840 SCIPdebugMsg(
scip,
"right hand side of linear constraint <%s> is dominated by <%s>:\n",
13857 cons0rhs = consdata0->rhs;
13858 cons0isequality =
FALSE;
13859 if( !consdata0->upgraded )
13868 else if( cons0dominatesrhs && (!cons1isequality || cons0dominateslhs ||
SCIPisInfinity(
scip, -consdata1->lhs)) )
13871 SCIPdebugMsg(
scip,
"right hand side of linear constraint <%s> is dominated by <%s>:\n",
13888 cons1isequality =
FALSE;
13889 if( !consdata1->upgraded )
13905 conss[chkind] =
NULL;
13906 if( !consdata0->upgraded )
13921 if( !consdata1->upgraded )
13934 if( tryaggregation )
13938 assert(consdata0->nvars == nvarscommon + nvars0minus1);
13939 assert(consdata1->nvars == nvarscommon + nvars1minus0);
13941 aggregated =
FALSE;
13942 if( cons1isequality && !consdata0->upgraded && commonidxweight > diffidx1minus0weight )
13946 nvarscommon, commonidxweight, diffidx0minus1weight, diffidx1minus0weight, maxaggrnormscale,
13947 nchgcoefs, &aggregated,
cutoff) );
13957 conss[chkind] =
NULL;
13960 if( !aggregated && cons0isequality && !consdata1->upgraded && commonidxweight > diffidx0minus1weight )
13964 nvarscommon, commonidxweight, diffidx1minus0weight, diffidx0minus1weight, maxaggrnormscale,
13965 nchgcoefs, &aggregated,
cutoff) );
14040 if( singlevarstuffing )
14043 &isminsettoinfinity, &ismaxsettoinfinity);
14049 isminsettoinfinity =
FALSE;
14050 ismaxsettoinfinity =
FALSE;
14058 rhs = -consdata->lhs;
14060 maxactivity = -minactivity;
14061 ismaxsettoinfinity = isminsettoinfinity;
14066 rhs = consdata->rhs;
14070 nvars = consdata->nvars;
14071 vars = consdata->vars;
14072 vals = consdata->vals;
14075 if( singletonstuffing )
14077 for( v = 0; v <
nvars; ++v )
14093 assert(singletonstuffing);
14101 mincondactivity = 0.0;
14102 maxcondactivity = 0.0;
14104 for( v = 0; v <
nvars; ++v )
14110 val = factor * vals[v];
14127 maxcondactivity += val * lb;
14128 mincondactivity += val * lb;
14129 swapped[v] =
FALSE;
14130 ratios[nsingletons] =
obj / val;
14131 varpos[nsingletons] = v;
14146 maxcondactivity += val * ub;
14147 mincondactivity += val * ub;
14149 ratios[nsingletons] =
obj / val;
14150 varpos[nsingletons] = v;
14167 maxcondactivity += val * lb;
14168 mincondactivity += val * lb;
14185 maxcondactivity += val * ub;
14186 mincondactivity += val * ub;
14202 maxcondactivity += val * ub;
14203 mincondactivity += val * lb;
14207 maxcondactivity += val * lb;
14208 mincondactivity += val * ub;
14212 if( tryfixing && nsingletons > 0 && (
SCIPisGT(
scip, rhs, maxcondactivity) ||
SCIPisLE(
scip, rhs, mincondactivity)) )
14217 int oldnfixedvars = *nfixedvars;
14218 int oldnchgbds = *nchgbds;
14224 for( v = 0; v < nsingletons; ++v )
14228 val = factor * vals[idx];
14233 assert((val < 0) == swapped[idx]);
14248 delta = -(lb - ub) * val;
14250 delta = (ub - lb) * val;
14300 maxcondactivity += delta;
14301 mincondactivity += delta;
14305 if( *nfixedvars - oldnfixedvars > 0 || *nchgbds - oldnchgbds > 0 )
14307 SCIPdebugMsg(
scip,
"### stuffing fixed %d variables and changed %d bounds\n", *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds);
14346 if( singlevarstuffing && !ismaxsettoinfinity )
14351 int bestindex = -1;
14352 int bestuplocks = 0;
14353 int bestdownlocks = 1;
14356 SCIPdebug(
int oldnfixedvars = *nfixedvars; )
14357 SCIPdebug(
int oldnchgbds = *nchgbds; )
14360 for( v = 0; v <
nvars; ++v )
14364 val = factor * vals[v];
14392 if( ratio > bestratio || ((ratio == bestratio) && downlocks == 0 && (bestdownlocks > 0
14397 if( bestindex != -1 )
14400 if( bestuplocks > 1 )
14407 secondbestratio = bestratio;
14410 bestdownlocks = downlocks;
14411 bestuplocks = uplocks;
14418 if( bestdownlocks > 0 && bestuplocks > 1 )
14433 if( ratio > secondbestratio )
14435 secondbestratio = ratio;
14441 if( bestindex != -1 && bestdownlocks == 0 )
14448 val = factor * vals[bestindex];
14461 SCIP_Real activitydelta = (maxactivity - rhs) - (bestvarfloor * -val);
14466 bounddelta =
SCIPceil(
scip, (maxactivity - rhs)/-val);
14470 bounddelta = (maxactivity - rhs)/-val;
14472 tryfixing = tryfixing &&
SCIPisLE(
scip, bounddelta, ub - lb);
14498 SCIP_Real activitydelta = (maxactivity - rhs) - (bestvarfloor * val);
14507 bounddelta = (maxactivity - rhs)/val;
14509 tryfixing = tryfixing &&
SCIPisLE(
scip, bounddelta, ub - lb);
14538 for( v = 0; v <
nvars; ++v )
14546 SCIPdebugMsg(
scip,
"<= %g\n", factor > 0 ? consdata->rhs : -consdata->lhs);
14548 for( v = 0; v <
nvars; ++v )
14550 if( v == bestindex )
14553 if( factor * vals[v] < 0 )
14573 SCIPdebug(
SCIPdebugMsg(
scip,
"### new stuffing fixed %d vars, tightened %d bounds\n", *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds); )
14657 for( v = 0; v <
nvars; ++v )
14669 for( v = 0; v < ncontvars; v++ )
14696 for(
c = 0;
c < nconss; ++
c )
14723 for(
i = 0;
i < consdata->nvars; ++
i )
14727 var = consdata->vars[
i];
14732 assert(0 <= contv && contv < ncontvars);
14733 isimplint[contv] =
FALSE;
14746 hasimpliedpotential =
FALSE;
14749 for(
i = 0;
i < consdata->nvars; ++
i )
14763 var = consdata->vars[
i];
14765 val = consdata->vals[
i];
14780 isminsettoinfinity =
TRUE;
14781 ismaxsettoinfinity =
TRUE;
14787 &ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);
14793 assert((ismintight || isminsettoinfinity) && (ismaxtight || ismaxsettoinfinity));
14808 newredlb = redlb[arrayindex];
14809 newredub = redub[arrayindex];
14815 nlocksdown[arrayindex] += nlockspos;
14816 newredlb = (isminsettoinfinity ?
SCIPinfinity(
scip) : (consdata->lhs - minresactivity)/val);
14821 nlocksup[arrayindex] += nlockspos;
14822 newredub = (ismaxsettoinfinity ? -
SCIPinfinity(
scip) : (consdata->rhs - maxresactivity)/val);
14830 nlocksup[arrayindex] += nlockspos;
14831 newredub = (isminsettoinfinity ? -
SCIPinfinity(
scip) : (consdata->lhs - minresactivity)/val);
14836 nlocksdown[arrayindex] += nlockspos;
14837 newredlb = (ismaxsettoinfinity ?
SCIPinfinity(
scip) : (consdata->rhs - maxresactivity)/val);
14851 redlb[arrayindex] =
MAX(redlb[arrayindex], newredlb);
14852 redub[arrayindex] =
MIN(redub[arrayindex], newredub);
14859 assert(nconscontvars < ncontvars);
14861 conscontvars[nconscontvars] =
var;
14865 assert(0 <= contv && contv < ncontvars);
14866 hasimpliedpotential = hasimpliedpotential || isimplint[contv];
14871 if( hasimpliedpotential )
14873 if( nconscontvars > 1 || !integralcoefs )
14878 for(
i = 0;
i < nconscontvars;
i++ )
14882 assert(0 <= contv && contv < ncontvars);
14883 isimplint[contv] =
FALSE;
14897 assert(nconscontvars == 1);
14898 assert(0 <= contvarpos && contvarpos < consdata->
nvars);
14899 var = consdata->vars[contvarpos];
14900 val = consdata->vals[contvarpos];
14902 assert(0 <= contv && contv < ncontvars);
14903 assert(isimplint[contv]);
14907 isimplint[contv] =
FALSE;
14913 if(
obj * val >= 0.0 && lhsexists )
14918 if(
obj * val <= 0.0 && rhsexists )
14930 for( v = 0; v <
nvars; ++v )
14960 SCIPdebugMsg(
scip,
"variable <%s> only locked down in linear constraints: dual presolve <%s>[%.15g,%.15g] <= %.15g\n",
14967 redub[v] =
MIN(redub[v], ub);
14989 SCIPdebugMsg(
scip,
"variable <%s> only locked up in linear constraints: dual presolve <%s>[%.15g,%.15g] >= %.15g\n",
14996 redlb[v] =
MAX(redlb[v], lb);
15033 SCIPdebugMsg(
scip,
"dual presolve: converting continuous variable <%s>[%g,%g] to implicit integer\n",
15077 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
15079 SCIPdebugMsg(
scip,
"Enforcement method of linear constraints for %s solution\n",
sol ==
NULL ?
"LP" :
"relaxation");
15087 for(
c = 0;
c < nusefulconss; ++
c )
15153 nlocvars = consdata->nvars;
15158 for(
i = 0;
i < nlocvars; ++
i )
15160 vars[
i] = consdata->vars[
i];
15161 vals[
i] = consdata->vals[
i];
15165 lhs = consdata->lhs - constant;
15166 rhs = consdata->rhs - constant;
15176 for(
i = 0;
i < nlocvars; ++
i )
15184 cons, lhs, rhs, success) );
15249 conshdlrdata->naddconss = 0;
15252 for(
c = 0;
c < nconss; ++
c )
15277 for(
c = nconss - 1;
c >= 0; --
c )
15284 if( consdata->eventdata !=
NULL )
15358 for(
c = 0;
c < nconss;
c++ )
15377 rhs = consdata->rhs;
15378 lhs = consdata->lhs;
15382 for(
i = 0;
i < consdata->nvars;
i++ )
15388 if( consdata->nvars == 0 )
15408 if( consdata->nvars == 1 )
15418 if( consdata->nvars == 2 &&
SCIPisEQ(
scip, lhs, rhs) )
15428 if( consdata->nvars == 2 )
15433 if(
SCIPisEQ(
scip, consdata->vals[0], -consdata->vals[1])
15461 scale =
REALABS(consdata->vals[0]);
15464 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15471 if( consdata->vals[
i] < 0.0 )
15479 b = rhs/scale + nnegbinvars;
15500 b = rhs/scale + nnegbinvars;
15525 b = lhs/scale + nnegbinvars;
15555 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15563 b -= consdata->vals[
i];
15583 for(
i = 0;
i < consdata->nvars && !matched;
i++ )
15588 SCIPdebugMsg(
scip,
"classified as %s: ", matched ?
"BINPACKING" :
"KNAPSACK");
15611 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15638 for(
i = 0;
i < consdata->nvars && !unmatched;
i++ )
15671#ifdef SCIP_STATISTIC
15682#ifdef SCIP_STATISTIC
15690 for(
c = 0;
c < nconss; ++
c )
15700 if( consdata->upgraded )
15707 if(
SCIPisLT(
scip, consdata->maxactdelta, conshdlrdata->maxeasyactivitydelta) )
15712 SCIPstatisticMessage(
"below threshold: %d / %d ratio= %g\n", ngoodconss, nallconss, (100.0 * ngoodconss / nallconss));
15716 for(
c = 0;
c < nconss; ++
c )
15726 if( consdata->upgraded )
15751 for(
c = 0;
c < nconss; ++
c )
15769 for(
c = 0;
c < nconss; ++
c )
15776 if( consdata->row !=
NULL )
15781 if( consdata->nlrow !=
NULL )
15797 if( ncutsadded > 0 )
15800 "(restart) converted %d cuts from the global cut pool into linear constraints\n", ncutsadded);
15851 if( consdata->eventdata !=
NULL )
15879 if( (*consdata)->eventdata !=
NULL )
15919 SCIP_CALL(
consdataCreate(
scip, &targetdata, sourcedata->nvars, sourcedata->vars, sourcedata->vals, sourcedata->lhs, sourcedata->rhs) );
15926 for(n = targetdata->nvars - 1; n >= 0; --n )
15951 *infeasible =
FALSE;
15953 for(
c = 0;
c < nconss && !(*infeasible); ++
c )
15995 if( (
depth == 0 && conshdlrdata->maxroundsroot >= 0 && nrounds >= conshdlrdata->maxroundsroot)
15996 || (
depth > 0 && conshdlrdata->maxrounds >= 0 && nrounds >= conshdlrdata->maxrounds) )
16000 maxsepacuts = (
depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);
16006 maxbound = glblowerbound + conshdlrdata->maxcardbounddist * (cutoffbound - glblowerbound);
16007 separatecards =
SCIPisLE(
scip, loclowerbound, maxbound);
16015 for(
c = 0;
c < nusefulconss && ncuts < maxsepacuts && !
cutoff; ++
c )
16024 else if( ncuts > 0 )
16061 if( (
depth == 0 && conshdlrdata->maxroundsroot >= 0 && nrounds >= conshdlrdata->maxroundsroot)
16062 || (
depth > 0 && conshdlrdata->maxrounds >= 0 && nrounds >= conshdlrdata->maxrounds) )
16066 maxsepacuts = (
depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);
16073 for(
c = 0;
c < nusefulconss && ncuts < maxsepacuts && !
cutoff; ++
c )
16082 else if( ncuts > 0 )
16127 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
16132 if( objinfeasible )
16134 SCIPdebugMsg(
scip,
"-> pseudo solution is objective infeasible, return.\n");
16142 for(
c = 0;
c < nconss && !violated; ++
c )
16176 checkrelmaxabs = conshdlrdata->checkrelmaxabs;
16241 tightenbounds =
TRUE;
16246 int tightenboundsfreq;
16251 tightenboundsfreq = propfreq * conshdlrdata->tightenboundsfreq;
16252 tightenbounds = (conshdlrdata->tightenboundsfreq >= 0)
16253 && ((tightenboundsfreq == 0 &&
depth == 0) || (tightenboundsfreq >= 1 && (
depth % tightenboundsfreq == 0)));
16256 rangedrowpropagation = conshdlrdata->rangedrowpropagation;
16258 rangedrowpropagation = rangedrowpropagation && (
depth <= conshdlrdata->rangedrowmaxdepth);
16259 rangedrowfreq = propfreq * conshdlrdata->rangedrowfreq;
16260 rangedrowpropagation = rangedrowpropagation && (conshdlrdata->rangedrowfreq >= 0)
16261 && ((rangedrowfreq == 0 &&
depth == 0) || (rangedrowfreq >= 1 && (
depth % rangedrowfreq == 0)));
16268 for(
i = 0;
i < nmarkedconss && !
cutoff;
i++ )
16272 conshdlrdata->maxeasyactivitydelta, conshdlrdata->sortvars, &
cutoff, &nchgbds) );
16278 else if( nchgbds > 0 )
16287#define MAXCONSPRESOLROUNDS 10
16310 int firstupgradetry;
16322 oldnfixedvars = *nfixedvars;
16323 oldnaggrvars = *naggrvars;
16324 oldnchgbds = *nchgbds;
16325 oldndelconss = *ndelconss;
16326 oldnupgdconss = *nupgdconss;
16327 oldnchgcoefs = *nchgcoefs;
16328 oldnchgsides = *nchgsides;
16335 firstchange = INT_MAX;
16336 firstupgradetry = INT_MAX;
16342 infeasible =
FALSE;
16352 consdata->lhs = consdata->rhs;
16356 if( consdata->eventdata ==
NULL )
16379 assert(consdata->removedfixings);
16386 if( firstchange == INT_MAX && consdata->changed )
16390 if( firstupgradetry == INT_MAX && !consdata->upgradetried )
16391 firstupgradetry =
c;
16394 if( consdata->presolved )
16412 consdata->presolved =
TRUE;
16429 SCIPdebugMsg(
scip,
" -> infeasibility detected during tightening sides\n");
16437 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16455 &isminsettoinfinity, &ismaxsettoinfinity);
16458 SCIPdebugMsg(
scip,
"linear constraint <%s> is infeasible: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16459 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16465 SCIPdebugMsg(
scip,
"linear constraint <%s> is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16466 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16470 if( !consdata->upgraded )
16476 SCIPdebugMsg(
scip,
"linear constraint <%s> left hand side is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n",
16477 SCIPconsGetName(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);
16479 if( !consdata->upgraded )
16484 SCIPdebugMsg(
scip,
"linear constraint <%s> right 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 if( consdata->nvars == 0 )
16496 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16502 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16507 if( !consdata->upgraded )
16517 if( conshdlrdata->simplifyinequalities )
16526 if( conshdlrdata->aggregatevariables )
16537 if( conshdlrdata->rangedrowpropagation )
16539 int lastnfixedvars;
16541 lastnfixedvars = *nfixedvars;
16546 if( lastnfixedvars < *nfixedvars )
16557 nfixedvars, nchgbds, &
cutoff) );
16564 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16570 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16575 if( !consdata->upgraded )
16600 if( firstchange == INT_MAX && consdata->changed )
16604 if( firstupgradetry == INT_MAX && !consdata->upgradetried )
16605 firstupgradetry =
c;
16613 conshdlrdata->singlevarstuffing, &
cutoff, nfixedvars, nchgbds) );
16616 if( consdata->nvars == 0 )
16620 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n",
16626 SCIPdebugMsg(
scip,
"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n",
16631 if( !consdata->upgraded )
16644 assert(firstchange >= 0);
16646 if( firstchange < nconss && conshdlrdata->presolusehashing )
16650 ndelconss, nchgsides) );
16653 if( firstchange < nconss && conshdlrdata->presolpairwise )
16657 int firstchangenew;
16660 npaircomparisons = 0;
16661 oldndelconss = *ndelconss;
16662 oldnchgsides = *nchgsides;
16663 oldnchgcoefs = *nchgcoefs;
16669 firstchangenew = -1;
16670 for(
c = 0;
c < nconss; ++
c )
16673 if(
c == firstchange )
16674 firstchangenew = nusefulconss;
16680 usefulconss[nusefulconss] = conss[
c];
16683 firstchange = firstchangenew;
16684 assert(firstchangenew >= 0 && firstchangenew <= nusefulconss);
16689 if( usefulconss[
c] ==
NULL )
16696 &
cutoff, ndelconss, nchgsides, nchgcoefs) );
16698 if( npaircomparisons > conshdlrdata->nmincomparisons )
16700 assert(npaircomparisons > 0);
16701 if( ((*ndelconss - oldndelconss) + (*nchgsides - oldnchgsides)/2.0 + (*nchgcoefs - oldnchgcoefs)/10.0) / ((
SCIP_Real) npaircomparisons) < conshdlrdata->mingainpernmincomp )
16703 oldndelconss = *ndelconss;
16704 oldnchgsides = *nchgsides;
16705 oldnchgcoefs = *nchgcoefs;
16706 npaircomparisons = 0;
16717 if( !
cutoff && firstupgradetry < nconss
16718 && *nfixedvars == oldnfixedvars && *naggrvars == oldnaggrvars && *nchgbds == oldnchgbds && *ndelconss == oldndelconss
16719 && *nupgdconss == oldnupgdconss && *nchgcoefs == oldnchgcoefs && *nchgsides == oldnchgsides
16746 if( consdata->upgradetried )
16749 if( !consdata->presolved )
16752 consdata->upgradetried =
TRUE;
16758 if( upgdcons !=
NULL )
16768 assert(!consdata->upgraded);
16769 consdata->upgraded =
TRUE;
16775 || !conshdlrdata->presolpairwise
16776 || (conshdlrdata->maxaggrnormscale == 0.0) )
16788 else if( *nfixedvars > oldnfixedvars || *naggrvars > oldnaggrvars || *nchgbds > oldnchgbds || *ndelconss > oldndelconss
16789 || *nupgdconss > oldnupgdconss || *nchgcoefs > oldnchgcoefs || *nchgsides > oldnchgsides )
16830 for(
i = 0;
i < consdata->nvars; ++
i )
16895 const char* consname;
16914 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
valid) );
16929 char** firstoperator,
16930 char** secondoperator,
16940 *firstoperator =
NULL;
16941 *secondoperator =
NULL;
16947 while( *curr && *success )
16960 if( curr[1] ==
'=' )
16969 if( strncmp(curr,
"[free]", 6) == 0 )
16984 if( *firstoperator ==
NULL )
16986 *firstoperator = curr;
16990 if( *secondoperator !=
NULL )
16995 else if( strncmp(*firstoperator,
"<=", 2) != 0 )
16997 SCIPerrorMessage(
"Two operators in line that is not a ranged row: %s", str);
17000 else if( strncmp(curr,
"<=", 2) != 0 )
17002 SCIPerrorMessage(
"Bad second operator, expected ranged row specification: %s", str);
17006 *secondoperator = curr;
17016 if( *firstoperator ==
NULL )
17053 (*success) =
FALSE;
17068 if( ! operatorsuccess )
17071 varstrptr = (
char *)str;
17072 lhsstrptr = rhsstrptr =
NULL;
17079 assert(firstop[1] ==
'=');
17081 if( secondop !=
NULL )
17083 assert(secondop[0] ==
'<' && secondop[1] ==
'=');
17084 lhsstrptr = (
char *)str;
17085 varstrptr = firstop + 2;
17086 rhsstrptr = secondop + 2;
17092 varstrptr = (
char *)str;
17093 rhsstrptr = firstop + 2;
17097 assert(firstop[1] ==
'=');
17100 lhsstrptr = firstop + 2;
17103 assert(firstop[1] ==
'=');
17106 rhsstrptr = firstop + 2;
17107 lhsstrptr = firstop + 2;
17110 assert(strncmp(firstop,
"[free]", 6) == 0);
17116 SCIPerrorMessage(
"Parsing has wrong operator character '%c', should be one of <=>[", *firstop);
17121 if( lhsstrptr !=
NULL )
17125 SCIPerrorMessage(
"error parsing left hand side number from <%s>\n", lhsstrptr);
17130 if( rhsstrptr == lhsstrptr )
17135 if( rhsstrptr !=
NULL && rhsstrptr != lhsstrptr )
17139 SCIPerrorMessage(
"error parsing right hand side number from <%s>\n", lhsstrptr);
17154 if( *success && requsize > coefssize )
17157 coefssize = requsize;
17162 assert(!*success || requsize <= coefssize);
17172 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
17191 if( varssize < consdata->
nvars )
17192 (*success) =
FALSE;
17214 (*nvars) = consdata->nvars;
17258 cons = eventdata->cons;
17277 varpos = eventdata->varpos;
17283 val = consdata->vals[varpos];
17302 consdata->presolved =
FALSE;
17303 consdata->rangedrowpropagated = 0;
17311 if( consdata->maxactdeltavar ==
var )
17314 consdata->maxactdeltavar =
NULL;
17318 if( consdata->boundstightened > 0)
17320 switch( eventtype )
17324 consdata->boundstightened = 0;
17328 consdata->boundstightened = 0;
17350 delta =
REALABS(val) * domain;
17352 if( delta > consdata->maxactdelta )
17354 consdata->maxactdelta = delta;
17355 consdata->maxactdeltavar =
var;
17362 consdata->presolved =
FALSE;
17363 consdata->removedfixings =
FALSE;
17364 consdata->rangedrowpropagated = 0;
17367 if( consdata->maxactdeltavar ==
var )
17370 consdata->maxactdeltavar =
NULL;
17378 consdata->presolved =
FALSE;
17387 varpos = eventdata->varpos;
17393 val = consdata->vals[varpos];
17395 consdata->rangedrowpropagated = 0;
17410 consdata->indexsorted =
FALSE;
17412 consdata->coefsorted =
FALSE;
17428 consdata->varsdeleted =
TRUE;
17451 assert(bdchginfos !=
NULL || nbdchginfos == 0);
17467 for(
i = 0;
i < nbdchginfos; ++
i )
17488 if(
i == nbdchginfos )
17501 if( upgdcons !=
NULL )
17537 assert(upgdconsssize > 0);
17575 consdata->checkabsolute =
TRUE;
17603 eventExecLinear,
NULL) );
17607 conflictExecLinear,
NULL) );
17615 consEnfolpLinear, consEnfopsLinear, consCheckLinear, consLockLinear,
17657 "multiplier on propagation frequency, how often the bounds are tightened (-1: never, 0: only at root)",
17661 "maximal number of separation rounds per node (-1: unlimited)",
17665 "maximal number of separation rounds per node in the root node (-1: unlimited)",
17669 "maximal number of cuts separated per separation round",
17673 "maximal number of cuts separated per separation round in the root node",
17677 "should pairwise constraint comparison be performed in presolving?",
17681 "should hash table be used for detecting redundant constraints in advance",
17685 "number for minimal pairwise presolve comparisons",
17689 "minimal gain per minimal pairwise presolve comparisons to repeat pairwise comparison round",
17693 "maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint aggregation)",
17697 "maximum activity delta to run easy propagation on linear constraint (faster, but numerically less stable)",
17701 "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts",
17705 "should all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value?",
17709 "should presolving search for aggregations in equations",
17713 "should presolving try to simplify inequalities",
17717 "should dual presolving steps be performed?",
17721 "should stuffing of singleton continuous variables be performed?",
17725 "should single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable?",
17728 "constraints/" CONSHDLR_NAME "/sortvars",
"apply binaries sorting in decr. order of coeff abs value?",
17732 "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)?",
17736 "should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP?",
17740 "should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP?",
17744 "should presolving try to detect subsets of constraints parallel to the objective function?",
17748 "should presolving and propagation try to improve bounds, detect infeasibility, and extract sub-constraints from ranged rows and equations?",
17752 "should presolving and propagation extract sub-constraints from ranged rows and equations?",
17756 "maximum depth to apply ranged row propagation",
17760 "frequency for applying ranged row propagation",
17764 "should multi-aggregations only be performed if the constraint can be removed afterwards?",
17768 "maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation",
17772 "maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation",
17776 "should Cliques be extracted?",
17787 const char* conshdlrname
17802 if( conshdlr ==
NULL )
17878 if( conshdlr ==
NULL )
17884 for( j = 0; j <
nvars; ++j )
17913 if( requiredsize > nconsvars )
17919 assert(requiredsize <= nconsvars);
17925 if( constant < 0.0 )
17932 SCIPerrorMessage(
"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite left hand side of the constraint\n", name);
17942 SCIPerrorMessage(
"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite right hand side of the constraint\n", name);
17958 SCIPerrorMessage(
"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite left hand side of the constraint\n", name);
17968 SCIPerrorMessage(
"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite right hand side of the constraint\n", name);
18012 if( check || enforce )
18015 for(n = consdata->nvars - 1; n >= 0; --n )
18021 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
18022 local, modifiable, dynamic, removable, stickingatnode) );
18103 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
18111 if( sourcecoefs !=
NULL )
18118 for( v = 0; v <
nvars; ++v )
18131 if( requiredsize >
nvars )
18142 for( v = 0; v <
nvars; ++v )
18152 for( v = 0; v <
nvars && success; ++v )
18174 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
18229 if( requiredsize > nconsvars )
18235 assert(requiredsize <= nconsvars);
18241 lhs = consdata->lhs;
18242 rhs = consdata->rhs;
18248 if( constant < 0.0 )
18321 for( v = nconsvars - 1; v >= 0; --v )
18375 SCIPerrorMessage(
"method may only be called during problem creation stage for original constraints and variables\n");
18382 vars = consdata->vars;
18455 return consdata->lhs;
18479 return consdata->rhs;
18542 return consdata->nvars;
18566 return consdata->vars;
18590 return consdata->vals;
18619 if( consdata->row !=
NULL )
18647 if( consdata->row !=
NULL )
18675 if( consdata->row !=
NULL )
18703 if( consdata->row !=
NULL )
18732 return consdata->row;
18801 if( consdata->upgraded )
18805 if( consdata->row !=
NULL )
18809 SCIPerrorMessage(
"cannot upgrade linear constraint that is already stored as row in the LP\n");
18861 for(
i = 0;
i < consdata->nvars; ++
i )
18863 var = consdata->vars[
i];
18864 val = consdata->vals[
i];
18932 poscoeffsum += val;
18934 negcoeffsum += val;
18941 SCIPdebugMsg(
scip,
"upgrading linear constraint <%s> (%d upgrade methods):\n",
18943 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",
18944 nposbin, nnegbin, nposint, nnegint, nposimpl, nnegimpl, nposcont, nnegcont,
18945 ncoeffspone, ncoeffsnone, ncoeffspint, ncoeffsnint, ncoeffspfrac, ncoeffsnfrac,
18946 poscoeffsum, negcoeffsum, integral);
18949 for(
i = 0;
i < conshdlrdata->nlinconsupgrades && *upgdcons ==
NULL; ++
i )
18951 if( conshdlrdata->linconsupgrades[
i]->active )
18953 SCIP_CALL( conshdlrdata->linconsupgrades[
i]->linconsupgd(
scip, cons, consdata->nvars,
18954 consdata->vars, consdata->vals, consdata->lhs, consdata->rhs,
18955 nposbin, nnegbin, nposint, nnegint, nposimpl, nnegimpl, nposimplbin, nnegimplbin, nposcont, nnegcont,
18956 ncoeffspone, ncoeffsnone, ncoeffspint, ncoeffsnint, ncoeffspfrac, ncoeffsnfrac,
18957 poscoeffsum, negcoeffsum, integral,
18963 if( *upgdcons !=
NULL )
18987 if( conshdlr ==
NULL )
18991 *infeasible =
FALSE;
18996 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