129#define CONSHDLR_NAME "orbitope"
130#define CONSHDLR_DESC "symmetry breaking constraint handler relying on (partitioning/packing) orbitopes"
131#define CONSHDLR_SEPAPRIORITY +40100
132#define CONSHDLR_ENFOPRIORITY -1005200
133#define CONSHDLR_CHECKPRIORITY -1005200
134#define CONSHDLR_SEPAFREQ -1
135#define CONSHDLR_PROPFREQ 1
136#define CONSHDLR_EAGERFREQ -1
138#define CONSHDLR_MAXPREROUNDS -1
139#define CONSHDLR_DELAYSEPA FALSE
140#define CONSHDLR_DELAYPROP FALSE
141#define CONSHDLR_NEEDSCONS TRUE
143#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
144#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_MEDIUM
146#define DEFAULT_PPORBITOPE TRUE
147#define DEFAULT_SEPAFULLORBITOPE FALSE
148#define DEFAULT_FORCECONSCOPY FALSE
155struct SCIP_ConshdlrData
207 if ( (*consdata)->usedynamicprop && (*consdata)->rowindexmap !=
NULL )
212 p = (*consdata)->nspcons;
213 q = (*consdata)->nblocks;
214 for (
i = 0;
i < p; ++
i)
217 for (j = 0; j < q; ++j)
229 if ( (*consdata)->usedynamicprop )
269 if ( usedynamicprop )
284 if ( usedynamicprop )
290 for (
i = 0;
i < nspcons; ++
i)
296 (*consdata)->roworder[
i] =
i;
298 if ( usedynamicprop )
300 (*consdata)->rowused[
i] =
FALSE;
303 (*consdata)->nrowsused = 0;
305 (*consdata)->tmpvals =
NULL;
306 (*consdata)->tmpvars =
NULL;
307 (*consdata)->nspcons = nspcons;
308 (*consdata)->nblocks = nblocks;
309 (*consdata)->orbitopetype = orbitopetype;
310 (*consdata)->resolveprop = resolveprop;
311 (*consdata)->istrianglefixed =
FALSE;
312 (*consdata)->ismodelcons = ismodelcons;
313 (*consdata)->mayinteract = mayinteract;
314 (*consdata)->usedynamicprop = usedynamicprop;
322 for (
i = 0;
i < nspcons; ++
i)
327 for (j = 0; j < nblocks; ++j)
331 if ( usedynamicprop )
340 for (
i = 0;
i < nspcons; ++
i)
342 for (j = 0; j < nblocks; ++j)
386 if ( npprows >= 3 && ! mayinteract )
397 for (
i =
r;
i < *nrows - 1; ++
i)
412 if ( pprows !=
NULL )
432 assert( consdata->nspcons > 0 );
433 assert( consdata->nblocks > 0 );
436 for (j = 0; j < consdata->nblocks; ++j)
440 for (
i = 0;
i < consdata->nspcons; ++
i)
442 for (j = 0; j < consdata->nblocks; ++j)
451 for (j = 0; j < consdata->nblocks; ++j)
477 for (k = 0; k < p; ++k)
480 for (l = 0; l < q; ++l)
485 for (l = j; l < q; ++l)
496 assert( cases[p1][p2] != -1 );
498 assert( p2 >= 0 && p2 < j );
501 if ( cases[p1][p2] == 1 )
506 assert( cases[p1][p2] == 2 || cases[p1][p2] == 3 );
509 if ( cases[p1][p2] == 3 )
515 assert( cases[p1][p2] == 3 );
518 for (l = 0; l < q; ++l)
522 for (k = 0; k < p; ++k)
524 for (l = 0; l < q; ++l)
542 SCIPerrorMessage(
"unexpected matrix entry <%d>: should be -1, 0 or +1\n", M[k][l]);
550 for (l = 0; l < q; ++l)
554 for (k = 0; k < p; ++k)
576 assert( consdata->nspcons > 0 );
577 assert( consdata->nblocks > 0 );
581 for (
i = 0;
i < consdata->nspcons; ++
i)
583 for (j = 0; j < consdata->nblocks; ++j)
621 for (
i = 0;
i < nspcons; ++
i)
623 for (j = 0; j < nblocks; ++j)
627 weights[
i][j] = -1.0;
635 minvalue = vals[0][0];
636 weights[0][0] = minvalue;
641 if ( nspcons < nblocks )
644 for (j = 1; j < diagsize; ++j)
649 minvalue = vals[j][j];
654 weights[j][j] = minvalue;
658 for (
i = 1;
i < nspcons; ++
i)
660 weights[
i][0] = weights[
i-1][0] + vals[
i][0];
665 for (
i = 2;
i < nspcons; ++
i)
667 for (j = 1; j < nblocks && j <
i; ++j)
673 assert( cases[
i-1][j-1] != -1 );
675 weightleft = weights[
i-1][j-1];
676 weightright = vals[
i][j] + weights[
i-1][j];
681 weights[
i][j] = weightleft;
686 weights[
i][j] = weightright;
720 assert( consdata->nspcons > 0 );
721 assert( consdata->nblocks > 0 );
727 if ( consdata->istrianglefixed )
730 nspcons = consdata->nspcons;
731 nblocks = consdata->nblocks;
732 vars = consdata->vars;
737 if ( nspcons < nblocks )
741 for (
i = 0;
i < diagsize; ++
i)
743 for (j =
i+1; j < nblocks; ++j)
750 SCIPdebugMsg(
scip,
"The problem is infeasible: some variable in the upper right triangle is fixed to 1.\n");
761 if ( *nfixedvars > 0 )
763 SCIPdebugMsg(
scip,
"<%s>: %s fixed upper right triangle to 0 (fixed vars: %d).\n",
SCIPconsGetName(cons), fixedglobal ?
"globally" :
"locally", *nfixedvars);
771 consdata->istrianglefixed =
TRUE;
809 assert( consdata->nspcons > 0 );
810 assert( consdata->nblocks > 0 );
822 nspcons = consdata->nspcons;
823 nblocks = consdata->nblocks;
824 vars = consdata->vars;
825 vals = consdata->vals;
826 tmpvars = consdata->tmpvars;
827 tmpvals = consdata->tmpvals;
828 weights = consdata->weights;
829 cases = consdata->cases;
832 if ( ! consdata->istrianglefixed )
837 if ( *nfixedvars > 0 )
845 for (
i = 1;
i < nspcons && ! (*infeasible); ++
i)
851 lastcolumn = nblocks - 1;
852 if ( lastcolumn >
i )
857 for (j = lastcolumn; j > 0; --j)
880 for (l = j; l <= lastcolumn; ++l)
883 tmpvals[
nvars] = 1.0;
890 assert( cases[p1][p2] != -1 );
892 assert( p2 >= 0 && p2 < j );
895 if (cases[p1][p2] == 1)
900 assert( cases[p1][p2] == 2 || cases[p1][p2] == 3 );
902 tmpvals[
nvars] = -1.0;
905 weight += vals[p1][p2];
907 if ( cases[p1][p2] == 3 )
913 assert( cases[p1][p2] == 3 );
974 assert( consdata->nspcons > 0 );
975 assert( consdata->nblocks > 0 );
978 nspcons = consdata->nspcons;
979 nblocks = consdata->nblocks;
980 vars = consdata->vars;
981 orbitopetype = consdata->orbitopetype;
986 if ( ! consdata->istrianglefixed )
990 *nfixedvars += nfixed;
1000 printMatrix(
scip, consdata);
1012 lastoneprevrow = -1;
1018 for (
i = 1;
i < nspcons; ++
i)
1021 int firstnonzeroinrow;
1026 lastcolumn = nblocks - 1;
1027 if ( lastcolumn >
i )
1031 firstnonzeroinrow = -1;
1032 for (j = 0; j <= lastcolumn; ++j)
1039 firstnonzeroinrow = j;
1048 firstnonzeroinrow = j;
1056 SCIPdebugMsg(
scip,
" -> Infeasible node: all variables in row %d are fixed to 0.\n",
i);
1061 firstnonzeros[
i] = firstnonzeroinrow;
1063 assert( -1 <= firstnonzeroinrow && firstnonzeroinrow <= lastcolumn );
1067 assert( lastoneprevrow <= lastcolumn );
1071 assert( lastoneprevrow + 1 >= 0 );
1073 lastoneinrow = lastoneprevrow;
1076 lastoneinrow = lastoneprevrow + 1;
1077 frontiersteps[nsteps++] =
i;
1083 assert( lastoneinrow <= lastcolumn );
1084 lastones[
i] = lastoneinrow;
1087 if ( firstnonzeroinrow > lastoneinrow )
1094 SCIPdebugMsg(
scip,
" -> Infeasible node: row %d, leftmost nonzero at %d, rightmost 1 at %d\n",
1095 i, firstnonzeroinrow, lastoneinrow);
1099 SCIPdebugMsg(
scip,
" -> Infeasible node: row %d, 1 at %d, rightmost position for 1 at %d\n",
1100 i, firstnonzeroinrow, lastoneinrow);
1115 for (j = 0; j <= lastcolumn; ++j)
1128 if ( lastones[0] == -1 )
1140 for (k = 1; k <
i; ++k)
1143 l = lastones[k] + 1;
1146 if ( l <= nblocks-1 && l <= k && lastones[k-1] == lastones[k] )
1160 for (j = lastoneinrow+1; j <= lastcolumn; ++j)
1173 inferInfo =
i * nblocks + lastoneinrow + 1;
1182 SCIPdebugMsg(
scip,
" -> Infeasible node: row %d, 1 in column %d beyond rightmost position %d\n",
i, j, lastoneinrow);
1205 for (k = 1; k <
i; ++k)
1208 l = lastones[k] + 1;
1211 if ( l <= nblocks-1 && l <= k && lastones[k-1] == lastones[k] )
1227 lastoneprevrow = lastoneinrow;
1231 for (j = 0; j < nsteps; ++j)
1236 s = frontiersteps[j];
1237 lastoneinrow = lastones[s];
1239 assert( 0 <= lastoneinrow && lastoneinrow < nblocks );
1245 betaprev = lastoneinrow - 1;
1248 for (
i = s+1;
i < nspcons; ++
i)
1252 assert( betaprev + 1 >= 0 );
1256 beta = betaprev + 1;
1257 assert( -1 <= beta && beta < nblocks );
1259 if ( firstnonzeros[
i] > beta )
1274 inferInfo = nblocks * nspcons +
i * nblocks + firstnonzeros[
i];
1277 assert( !(*infeasible) );
1316 int* branchdecisions;
1317 int nbranchdecision;
1326 nbranchdecision = 0;
1345 for (
i = 0;
i < nboundchgs; ++
i)
1368 branchdecisions[nbranchdecision++] = rowidx;
1379 for (
i = nbranchdecision - 1;
i >= 0; --
i)
1381 if ( ! rowused[branchdecisions[
i]] )
1383 roworder[*maxrowlabel] = branchdecisions[
i];
1384 rowused[branchdecisions[
i]] =
TRUE;
1400 int* minfixedrowlexmin,
1412 *infeasible =
FALSE;
1416 assert( !resprop || minfixedrowlexmin !=
NULL );
1420 assert( nrowsused <= m );
1426 for (j = n - 2; j >= 0; --j)
1428 int maxdiscriminating = m;
1432 for (
i = 0;
i < nrowsused; ++
i)
1435 if ( minfixed == -1 && lexminfixes[
i][j] != 0 && lexminfixes[
i][j + 1] != 1 )
1437 assert( lexminfixes[
i][j + 1] == 0 );
1439 maxdiscriminating =
i;
1443 if ( minfixed == -1 && lexminfixes[
i][j] != lexminfixes[
i][j + 1] && lexminfixes[
i][j] != 2 )
1445 assert( lexminfixes[
i][j + 1] != 2 );
1450 if ( maxdiscriminating > minfixed )
1460 for (
i = 0;
i < nrowsused; ++
i)
1462 if ( lexminfixes[
i][j] == 2 )
1464 if (
i < maxdiscriminating || minfixed == -1 )
1465 lexminfixes[
i][j] = lexminfixes[
i][j + 1];
1466 else if (
i == maxdiscriminating )
1467 lexminfixes[
i][j] = 1;
1469 lexminfixes[
i][j] = 0;
1478 if ( minfixed == -1 )
1479 minfixedrowlexmin[j] = nrowsused - 1;
1481 minfixedrowlexmin[j] = minfixed;
1485 if ( minfixedrowlexmin[j + 1] < minfixedrowlexmin[j] )
1486 minfixedrowlexmin[j + 1] = minfixedrowlexmin[j];
1499 int* minfixedrowlexmax,
1511 *infeasible =
FALSE;
1515 assert( !resprop || minfixedrowlexmax !=
NULL );
1519 assert( nrowsused <= m );
1522 for (j = 1; j < n; ++j)
1524 int maxdiscriminating = m;
1528 for (
i = 0;
i < nrowsused; ++
i)
1531 if ( minfixed == -1 && lexmaxfixes[
i][j - 1] != 0 && lexmaxfixes[
i][j] != 1 )
1533 assert( lexmaxfixes[
i][j - 1] == 1 );
1535 maxdiscriminating =
i;
1539 if ( minfixed == -1 && lexmaxfixes[
i][j - 1] != lexmaxfixes[
i][j] && lexmaxfixes[
i][j] != 2 )
1541 assert( lexmaxfixes[
i][j - 1] != 2 );
1546 if ( maxdiscriminating > minfixed )
1556 for (
i = 0;
i < nrowsused; ++
i)
1558 if ( lexmaxfixes[
i][j] == 2 )
1560 if (
i < maxdiscriminating || minfixed == -1 )
1561 lexmaxfixes[
i][j] = lexmaxfixes[
i][j - 1];
1562 else if (
i == maxdiscriminating )
1563 lexmaxfixes[
i][j] = 0;
1565 lexmaxfixes[
i][j] = 1;
1574 if ( minfixed == -1 )
1575 minfixedrowlexmax[j] = nrowsused - 1;
1577 minfixedrowlexmax[j] = minfixed;
1581 if ( minfixedrowlexmax[j - 1] < minfixedrowlexmax[j] )
1582 minfixedrowlexmax[j - 1] = minfixedrowlexmax[j];
1617 *infeasible =
FALSE;
1629 assert( consdata->nspcons > 0 );
1630 assert( consdata->nblocks > 0 );
1634 m = consdata->nspcons;
1635 n = consdata->nblocks;
1636 vars = consdata->vars;
1642 consdata->roworder, m, n, &(consdata->nrowsused)) );
1645 if ( consdata->nrowsused == 0 )
1648 nrowsused = consdata->nrowsused;
1652 roworder = consdata->roworder;
1658 for (
i = 0;
i < nrowsused; ++
i)
1663 for (
i = 0;
i < nrowsused; ++
i)
1667 origrow = roworder[
i];
1669 for (j = 0; j < n; ++j)
1672 lexminfixes[
i][j] = 1;
1674 lexminfixes[
i][j] = 0;
1676 lexminfixes[
i][j] = 2;
1683 if ( *infeasible ==
TRUE )
1690 for (
i = 0;
i < nrowsused; ++
i)
1695 for (
i = 0;
i < nrowsused; ++
i)
1699 origrow = roworder[
i];
1701 for (j = 0; j < n; ++j)
1704 lexmaxfixes[
i][j] = 0;
1706 lexmaxfixes[
i][j] = 1;
1708 lexmaxfixes[
i][j] = 2;
1721 for (j = 0; j < n; ++j)
1723 for (
i = 0;
i < nrowsused; ++
i)
1727 origrow = roworder[
i];
1729 if ( lexminfixes[
i][j] != lexmaxfixes[
i][j] )
1737 cons, 0, infeasible, &success) );
1746 for (
i = 0;
i < nrowsused; ++
i)
1751 for (
i = 0;
i < nrowsused; ++
i)
1779 orbitopetype = consdata->orbitopetype;
1784 consdata->usedynamicprop && !consdata->ismodelcons) );
1821 int* minfixedrowlexmin;
1822 int* minfixedrowlexmax;
1840 assert( consdata->nspcons > 0 );
1841 assert( consdata->nblocks > 0 );
1845 dynamic = consdata->usedynamicprop && !consdata->ismodelcons;
1846 m = consdata->nspcons;
1847 n = consdata->nblocks;
1848 vars = consdata->vars;
1853 assert( consdata->nrowsused > 0 );
1855 nrowsused = consdata->nrowsused;
1859 roworder = consdata->roworder;
1861 assert( inferinfo <= consdata->nspcons );
1867 for (
i = 0;
i < nrowsused; ++
i)
1874 minfixedrowlexmin[n - 1] = -1;
1876 for (
i = 0;
i < nrowsused; ++
i)
1880 origrow = roworder[
i];
1882 for (j = 0; j < n; ++j)
1885 lexminfixes[
i][j] = 1;
1887 lexminfixes[
i][j] = 0;
1889 lexminfixes[
i][j] = 2;
1903 for (
i = 0;
i < nrowsused; ++
i)
1910 minfixedrowlexmax[0] = -1;
1912 for (
i = 0;
i < nrowsused; ++
i)
1916 origrow = roworder[
i];
1918 for (j = 0; j < n; ++j)
1921 lexmaxfixes[
i][j] = 0;
1923 lexmaxfixes[
i][j] = 1;
1925 lexmaxfixes[
i][j] = 2;
1938 for (j = 0; j < n; ++j)
1940 int ub =
MAX(minfixedrowlexmin[j], minfixedrowlexmax[j]);
1942 for (
i = 0;
i <= ub; ++
i)
1946 origrow = roworder[
i];
1959 for (
i = 0;
i < nrowsused; ++
i)
1965 for (
i = 0;
i < nrowsused; ++
i)
2019 assert( consdata->nspcons > 0 );
2020 assert( consdata->nblocks > 0 );
2025 assert( consdata->istrianglefixed );
2028 if ( ! consdata->resolveprop )
2031 nspcons = consdata->nspcons;
2032 nblocks = consdata->nblocks;
2033 vars = consdata->vars;
2034 vals = consdata->vals;
2035 weights = consdata->weights;
2036 orbitopetype = consdata->orbitopetype;
2037 cases = consdata->cases;
2039 SCIPdebugMsg(
scip,
"Propagation resolution method of orbitope constraint using orbitopal fixing\n");
2042 for (
i = 0;
i < nspcons; ++
i)
2047 lastcolumn = nblocks - 1;
2048 if ( lastcolumn >
i )
2050 for (j = 0; j <= lastcolumn; ++j)
2068 printMatrix(
scip, consdata);
2072 assert( consdata->istrianglefixed );
2076 assert( inferinfo >= 0 && inferinfo < 2 * nspcons * nblocks );
2077 if ( inferinfo < nspcons * nblocks )
2086 i = (int) (inferinfo / nblocks);
2087 j = inferinfo % nblocks;
2089 assert( 0 <= j && j < nblocks );
2092 assert( weights[
i-1][j-1] < 0.5 );
2094 SCIPdebugMsg(
scip,
" -> reason for x[%d][%d] = ... = x[%d][%d] = 0 was the following SC:\n",
i, j,
i,
MIN(
i,nblocks));
2103 assert( cases[p1][p2] != -1 );
2105 assert( p2 >= 0 && p2 < j );
2108 if ( cases[p1][p2] == 1 )
2113 assert( cases[p1][p2] == 2 || cases[p1][p2] == 3 );
2123 if ( cases[p1][p2] == 3 )
2129 assert( cases[p1][p2] == 3 );
2150 inferinfo -= nspcons * nblocks;
2151 i = (int) inferinfo / nblocks;
2152 j = inferinfo % nblocks;
2154 assert( 0 <= j && j < nblocks );
2159 if ( weights[
i-1][j-1] > 0.5 && weights[
i-1][j-1] < 1.5 )
2161 SCIPdebugMsg(
scip,
" -> reason for x[%d][%d] = 1 was the following SC:\n",
i, j);
2174 assert( cases[p1][p2] != -1 );
2176 assert( p2 >= 0 && p2 < j );
2179 if ( cases[p1][p2] == 1 )
2184 assert( cases[p1][p2] == 2 || cases[p1][p2] == 3 );
2199 assert( pos1 == -1 && pos2 == -1 );
2204 if ( cases[p1][p2] == 3 )
2210 assert( cases[p1][p2] == 3 );
2211 assert( pos1 >= 0 && pos2 >= 0 );
2222 for (k = 0; k < j; ++k)
2243 lastcolumn = nblocks - 1;
2244 if ( lastcolumn >
i )
2248 for (k = j; k <= lastcolumn; ++k)
2289 assert( consdata->nspcons > 0 );
2290 assert( consdata->nblocks > 0 );
2296 if ( ! consdata->istrianglefixed )
2307 if ( nfixedvars > 0 )
2314 nspcons = consdata->nspcons;
2315 nblocks = consdata->nblocks;
2316 vals = consdata->vals;
2317 weights = consdata->weights;
2318 cases = consdata->cases;
2325 assert( consdata->istrianglefixed );
2329 for (
i = 1;
i < nspcons; ++
i)
2334 lastcolumn = nblocks - 1;
2337 if ( lastcolumn >
i )
2341 for (j = lastcolumn; j > 0; --j)
2385 assert( consdata->nspcons > 0 );
2386 assert( consdata->nblocks > 0 );
2392 nspcons = consdata->nspcons;
2393 nblocks = consdata->nblocks;
2394 vars = consdata->vars;
2395 vals = consdata->vals;
2396 weights = consdata->weights;
2397 cases = consdata->cases;
2405 if ( ! consdata->istrianglefixed )
2412 if ( nspcons < nblocks )
2416 for (
i = 0;
i < diagsize; ++
i)
2418 for (j =
i+1; j < nblocks; ++j)
2434 for (
i = 1;
i < nspcons; ++
i)
2439 lastcolumn = nblocks - 1;
2442 if ( lastcolumn >
i )
2446 for (j = lastcolumn; j > 0; --j)
2466 for (l = j; l < nblocks; ++l)
2476 assert( cases[p1][p2] != -1 );
2478 assert( p2 >= 0 && p2 < j );
2481 if (cases[p1][p2] == 1)
2486 assert( cases[p1][p2] == 2 || cases[p1][p2] == 3 );
2488 if ( cases[p1][p2] == 3 )
2494 assert( cases[p1][p2] == 3 );
2533 assert( consdata->nspcons > 0 );
2534 assert( consdata->nblocks > 0 );
2535 assert( ! consdata->ismodelcons );
2537 vars = consdata->vars;
2538 nrows = consdata->nspcons;
2539 ncols = consdata->nblocks;
2547 for (j = 1; j < ncols && *feasible; ++j)
2549 for (
i = 0;
i < nrows; ++
i)
2551 vars1[
i] =
vars[
i][j - 1];
2596 *infeasible =
FALSE;
2602 vars = consdata->vars;
2603 nrows = consdata->nspcons;
2604 ncols = consdata->nblocks;
2605 nrowsused = dynamic ? consdata->nrowsused : nrows;
2606 roworder = consdata->roworder;
2616 for (j = 0; j < ncols - 1 && ! *infeasible; ++j)
2620 for (
i = 0;
i < nrowsused; ++
i)
2622 origrow = roworder[
i];
2625 assert( origrow < nrows );
2643 for (k = 0; k <=
i; ++k)
2647 origrow2 = roworder[k];
2734 for (
c = 0;
c < nconss && ! infeasible;
c++)
2738 int nconsfixedvars = 0;
2749 if ( enforce && !consdata->ismodelcons )
2756 orbitopetype = consdata->orbitopetype;
2762 nfixedvars += nconsfixedvars;
2764 else if ( conshdlrdata->sepafullorbitope )
2771 if (
c >= nusefulconss && (ncuts > 0 || nfixedvars > 0) )
2780 else if ( nfixedvars > 0 )
2785 else if ( ncuts > 0 )
2823 assert( consdata->nspcons > 0 );
2824 assert( consdata->nblocks > 0 );
2826 vars = consdata->vars;
2827 nrows = consdata->nspcons;
2828 ncols = consdata->nblocks;
2831 for (
i = 0;
i < nrows; ++
i)
2833 for (j = 0; j < ncols; ++j)
2914 sourcedata->orbitopetype, sourcedata->resolveprop, sourcedata->usedynamicprop, sourcedata->ismodelcons,
2915 sourcedata->mayinteract) );
3019 if ( objinfeasible || solinfeasible )
3023 for (
c = 0;
c < nconss; ++
c)
3038 if ( !consdata->ismodelcons )
3041 orbitopetype = consdata->orbitopetype;
3088 if ( !consdata->ismodelcons )
3091 orbitopetype = consdata->orbitopetype;
3127 for (
c = 0;
c < nusefulconss && !infeasible; ++
c)
3140 SCIPdebugMsg(
scip,
"Propagation via orbitopal fixing proved node to be infeasible.\n");
3142 else if ( nfixedvars > 0 )
3145 SCIPdebugMsg(
scip,
"Propagated %d variables via orbitopal fixing.\n", nfixedvars);
3147 else if ( nusefulconss > 0 )
3150 SCIPdebugMsg(
scip,
"Propagation via orbitopal fixing did not find anything.\n");
3172 noldfixedvars = *nfixedvars;
3178 for (
c = 0;
c < nconss && !infeasible; ++
c)
3188 *nfixedvars += nfixed;
3196 SCIPdebugMsg(
scip,
"Orbitope constraint <%s> is redundant: it does not contain active variables\n",
3211 else if ( *nfixedvars > noldfixedvars )
3215 else if ( nconss > 0 )
3218 SCIPdebugMsg(
scip,
"Presolving via orbitopal fixing did not find anything.\n");
3241 orbitopetype = consdata->orbitopetype;
3276 assert( consdata->nspcons > 0 );
3277 assert( consdata->nblocks > 0 );
3282 nspcons = consdata->nspcons;
3283 nblocks = consdata->nblocks;
3284 vars = consdata->vars;
3287 for (
i = 0;
i < nspcons; ++
i)
3289 for (j = 0; j < nblocks; ++j)
3316 assert( consdata->nspcons > 0 );
3317 assert( consdata->nblocks > 0 );
3320 nspcons = consdata->nspcons;
3321 nblocks = consdata->nblocks;
3322 vars = consdata->vars;
3323 orbitopetype = consdata->orbitopetype;
3327 switch ( orbitopetype )
3342 for (
i = 0;
i < nspcons; ++
i)
3344 for (j = 0; j < nblocks; ++j)
3350 if (
i < nspcons-1 )
3388 assert( sourcedata->nspcons > 0 );
3389 assert( sourcedata->nblocks > 0 );
3396 if ( !sourcedata->ismodelcons && !conshdlrdata->forceconscopy )
3403 nspcons = sourcedata->nspcons;
3404 nblocks = sourcedata->nblocks;
3405 sourcevars = sourcedata->vars;
3408 for (
i = 0;
i < nspcons && *
valid; ++
i)
3412 for (j = 0; j < nblocks && *
valid; ++j)
3427 vars, sourcedata->orbitopetype, nspcons, nblocks, sourcedata->usedynamicprop,
3428 sourcedata->resolveprop, sourcedata->ismodelcons, sourcedata->mayinteract,
3429 initial, separate, enforce, check,
propagate,
3430 local, modifiable, dynamic, removable, stickingatnode) );
3435 for (k =
i - 1; k >= 0; --k)
3467 if( strncmp(s,
"partOrbitope(", 13) == 0 )
3469 else if( strncmp(s,
"packOrbitope(", 13) == 0 )
3473 if( strncmp(s,
"fullOrbitope(", 13) != 0 )
3475 SCIPerrorMessage(
"Syntax error - expected \"fullOrbitope(\", \"partOrbitope\" or \"packOrbitope\": %s\n", s);
3499 endptr = strchr(endptr,
')');
3501 if( endptr ==
NULL || j > 0 )
3521 if( nspcons > maxnspcons )
3525 assert( nspcons <= maxnspcons );
3536 if( *s ==
'.' || *s ==
')' )
3538 else if( nblocks > maxnblocks )
3542 assert( nblocks <= maxnblocks );
3545 else if( ( j < nblocks-1 ) == ( *s ==
'.' || *s ==
')' ) )
3560 if( *s ==
',' || *s ==
'.' )
3569 SCIP_CALL(
SCIPcreateConsOrbitope(
scip, cons, name,
vars, orbitopetype, nspcons, nblocks,
FALSE,
TRUE,
TRUE,
TRUE,
3570 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3572 for( k = nspcons - 1; k >= 0; --k )
3593 if ( varssize < consdata->nblocks * consdata->nspcons )
3601 for (
i = 0;
i < consdata->nspcons; ++
i)
3603 for (j = 0; j < consdata->nblocks; ++j)
3604 vars[cnt++] = consdata->vars[
i][j];
3624 (*nvars) = consdata->nblocks * consdata->nspcons;
3650 consEnfolpOrbitope, consEnfopsOrbitope, consCheckOrbitope, consLockOrbitope,
3672 "Strengthen orbitope constraints to packing/partioning orbitopes?",
3676 "Whether we separate inequalities for full orbitopes?",
3680 "Whether orbitope constraints should be forced to be copied to sub SCIPs.",
3740 if ( conshdlr ==
NULL )
3747 if ( usedynamicprop && mayinteract )
3750 other symmetry handling constraints. Ignore value of <usedynamicprop>.\n");
3762 for (
i = 0;
i < nspcons; ++
i)
3766 for (j = 0; j < nblocks; ++j)
3810 resolveprop, usedynamicprop && ! mayinteract, ismodelcons, mayinteract) );
3813 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
3814 local, modifiable, dynamic, removable, stickingatnode) );
3840 resolveprop, ismodelcons, mayinteract,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE) );
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
#define CONSHDLR_PROP_TIMING
#define CONSHDLR_MAXPREROUNDS
#define CONSHDLR_SEPAPRIORITY
#define CONSHDLR_PROPFREQ
#define CONSHDLR_PRESOLTIMING
#define CONSHDLR_EAGERFREQ
#define CONSHDLR_ENFOPRIORITY
#define CONSHDLR_DELAYSEPA
#define CONSHDLR_DELAYPROP
#define DEFAULT_FORCECONSCOPY
constraint handler for orbisack constraints
static SCIP_RETCODE checkRedundantCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *redundant)
static SCIP_RETCODE propagatePackingPartitioningCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, int *nfixedvars)
static SCIP_RETCODE checkFullOrbitopeSolution(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool *feasible)
static SCIP_RETCODE enfopsPackingPartitioningOrbitopeSolution(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_CONS *cons, int inferinfo, SCIP_BDCHGIDX *bdchgidx, SCIP_RESULT *result)
static SCIP_RETCODE separateConstraints(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_RESULT *result, SCIP_Bool enforce)
static SCIP_RETCODE checkPackingPartitioningOrbitopeSolution(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result, SCIP_Bool printreason)
static SCIP_RETCODE separateSCIs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_Bool *infeasible, int *nfixedvars, int *ncuts)
static SCIP_RETCODE propagateCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, int *nfixedvars)
static SCIP_RETCODE resolvePropagationFullOrbitope(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, int inferinfo, SCIP_BDCHGIDX *bdchgidx, SCIP_RESULT *result)
static SCIP_RETCODE findLexMaxFace(SCIP_VAR ***vars, int **lexmaxfixes, int *minfixedrowlexmax, SCIP_Bool *infeasible, int m, int n, int nrowsused, SCIP_Bool resprop)
static SCIP_RETCODE strengthenOrbitopeConstraint(SCIP *scip, SCIP_VAR ***vars, int *nrows, int ncols, SCIP_ORBITOPETYPE *type, SCIP_Bool mayinteract)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_VAR ***vars, int nspcons, int nblocks, SCIP_ORBITOPETYPE orbitopetype, SCIP_Bool resolveprop, SCIP_Bool usedynamicprop, SCIP_Bool ismodelcons, SCIP_Bool mayinteract)
static SCIP_RETCODE findLexMinFace(SCIP_VAR ***vars, int **lexminfixes, int *minfixedrowlexmin, SCIP_Bool *infeasible, int m, int n, int nrowsused, SCIP_Bool resprop)
static SCIP_RETCODE separateCoversOrbisack(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool dynamic, int *ngen, SCIP_Bool *infeasible)
#define DEFAULT_PPORBITOPE
static SCIP_RETCODE propagateFullOrbitopeCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, int *nfixedvars, SCIP_Bool dynamic)
#define DEFAULT_SEPAFULLORBITOPE
static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)
static SCIP_RETCODE fixTriangle(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, int *nfixedvars)
static SCIP_RETCODE computeDynamicRowOrder(SCIP *scip, SCIP_HASHMAP *rowindexmap, SCIP_Bool *rowused, int *roworder, int nrows, int ncols, int *maxrowlabel)
static void computeSCTable(SCIP *scip, int nspcons, int nblocks, SCIP_Real **weights, int **cases, SCIP_Real **vals)
static void copyValues(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol)
constraint handler for (partitioning/packing/full) orbitope constraints w.r.t. the full symmetric gro...
Constraint handler for the set partitioning / packing / covering constraints .
SCIP_RETCODE SCIPcheckSolutionOrbisack(SCIP *scip, SCIP_SOL *sol, SCIP_VAR **vars1, SCIP_VAR **vars2, int nrows, SCIP_Bool printreason, SCIP_Bool *feasible)
SCIP_RETCODE SCIPcreateConsBasicOrbitope(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR ***vars, SCIP_ORBITOPETYPE orbitopetype, int nspcons, int nblocks, SCIP_Bool usedynamicprop, SCIP_Bool resolveprop, SCIP_Bool ismodelcons, SCIP_Bool mayinteract)
SCIP_RETCODE SCIPcreateConsOrbitope(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR ***vars, SCIP_ORBITOPETYPE orbitopetype, int nspcons, int nblocks, SCIP_Bool usedynamicprop, SCIP_Bool mayinteract, SCIP_Bool resolveprop, SCIP_Bool ismodelcons, 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_RETCODE SCIPincludeConshdlrOrbitope(SCIP *scip)
int SCIPgetSubscipDepth(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_STAGE SCIPgetStage(SCIP *scip)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
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)
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)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, 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,)
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 SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsEnforced(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)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
#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 SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_DOMCHG * SCIPnodeGetDomchg(SCIP_NODE *node)
SCIP_NODE * SCIPnodeGetParent(SCIP_NODE *node)
int SCIPnodeGetDepth(SCIP_NODE *node)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
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 SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPcreateEmptyRowConshdlr(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, 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_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_RETCODE SCIPisPackingPartitioningOrbitope(SCIP *scip, SCIP_VAR ***vars, int nrows, int ncols, SCIP_Bool **pprows, int *npprows, SCIP_ORBITOPETYPE *type)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisSumEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)
SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)
SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG *boundchg)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Real SCIPvarGetLbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
SCIP_Real SCIPvarGetUbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPskipSpace(char **s)
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
memory allocation routines
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for managing constraints
public methods for message output
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 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 SCIP variables
methods for handling symmetries
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSDELETE(x)
struct SCIP_Cons SCIP_CONS
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSSEPALP(x)
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSRESPROP(x)
#define SCIP_DECL_CONSENFOPS(x)
#define SCIP_DECL_CONSPARSE(x)
#define SCIP_DECL_CONSTRANS(x)
#define SCIP_DECL_CONSPRESOL(x)
#define SCIP_DECL_CONSLOCK(x)
struct SCIP_Conshdlr SCIP_CONSHDLR
#define SCIP_DECL_CONSCOPY(x)
struct SCIP_ConsData SCIP_CONSDATA
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSHDLRCOPY(x)
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
struct SCIP_HashMap SCIP_HASHMAP
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_TRANSFORMING
type definitions for symmetry computations
@ SCIP_ORBITOPETYPE_PACKING
@ SCIP_ORBITOPETYPE_PARTITIONING
enum SCIP_OrbitopeType SCIP_ORBITOPETYPE
struct SCIP_Node SCIP_NODE
union SCIP_DomChg SCIP_DOMCHG
struct SCIP_BoundChg SCIP_BOUNDCHG
struct SCIP_BdChgIdx SCIP_BDCHGIDX
@ SCIP_BOUNDCHGTYPE_BRANCHING