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
157 SCIP_Bool checkpporbitope;
158 SCIP_Bool sepafullorbitope;
159 SCIP_Bool forceconscopy;
175 SCIP_Bool resolveprop;
176 SCIP_Bool istrianglefixed;
181 SCIP_Bool ismodelcons;
182 SCIP_Bool mayinteract;
184 SCIP_Bool usedynamicprop;
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 )
257 SCIP_Bool resolveprop,
258 SCIP_Bool usedynamicprop,
259 SCIP_Bool ismodelcons,
260 SCIP_Bool mayinteract
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)
361 SCIP_Bool mayinteract
386 if (
npprows >= 3 && ! mayinteract )
397 for (
i =
r;
i < *nrows - 1; ++
i)
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)
501 if ( cases[
p1][
p2] == 1 )
509 if ( 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)
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 )
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)
699 SCIP_Bool* infeasible,
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 )
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 )
771 consdata->istrianglefixed =
TRUE;
784 SCIP_Bool* infeasible,
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)
865 SCIP_Real weight = 0.0;
883 tmpvals[
nvars] = 1.0;
895 if (cases[
p1][
p2] == 1)
902 tmpvals[
nvars] = -1.0;
905 weight += vals[
p1][
p2];
907 if ( cases[
p1][
p2] == 3 )
945 SCIP_Bool* infeasible,
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 )
1018 for (
i = 1;
i < nspcons; ++
i)
1056 SCIPdebugMsg(
scip,
" -> Infeasible node: all variables in row %d are fixed to 0.\n",
i);
1094 SCIPdebugMsg(
scip,
" -> Infeasible node: row %d, leftmost nonzero at %d, rightmost 1 at %d\n",
1099 SCIPdebugMsg(
scip,
" -> Infeasible node: row %d, 1 at %d, rightmost position for 1 at %d\n",
1140 for (
k = 1;
k <
i; ++
k)
1165 SCIP_Bool tightened;
1205 for (
k = 1;
k <
i; ++
k)
1248 for (
i = s+1;
i < nspcons; ++
i)
1257 assert( -1 <= beta && beta < nblocks );
1261 SCIP_Bool tightened;
1277 assert( !(*infeasible) );
1345 for (
i = 0;
i < nboundchgs; ++
i)
1402 SCIP_Bool* infeasible,
1412 *infeasible =
FALSE;
1420 assert( nrowsused <= m );
1426 for (
j = n - 2;
j >= 0; --
j)
1432 for (
i = 0;
i < nrowsused; ++
i)
1460 for (
i = 0;
i < nrowsused; ++
i)
1501 SCIP_Bool* infeasible,
1511 *infeasible =
FALSE;
1519 assert( nrowsused <= m );
1522 for (
j = 1;
j < n; ++
j)
1528 for (
i = 0;
i < nrowsused; ++
i)
1556 for (
i = 0;
i < nrowsused; ++
i)
1595 SCIP_Bool* infeasible,
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)
1669 for (
j = 0;
j < n; ++
j)
1683 if ( *infeasible ==
TRUE )
1690 for (
i = 0;
i < nrowsused; ++
i)
1695 for (
i = 0;
i < nrowsused; ++
i)
1701 for (
j = 0;
j < n; ++
j)
1721 for (
j = 0;
j < n; ++
j)
1723 for (
i = 0;
i < nrowsused; ++
i)
1737 cons, 0, infeasible, &
success) );
1746 for (
i = 0;
i < nrowsused; ++
i)
1751 for (
i = 0;
i < nrowsused; ++
i)
1764 SCIP_Bool* infeasible,
1779 orbitopetype = consdata->orbitopetype;
1784 consdata->usedynamicprop && !consdata->ismodelcons) );
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;
1867 for (
i = 0;
i < nrowsused; ++
i)
1876 for (
i = 0;
i < nrowsused; ++
i)
1882 for (
j = 0;
j < n; ++
j)
1903 for (
i = 0;
i < nrowsused; ++
i)
1912 for (
i = 0;
i < nrowsused; ++
i)
1918 for (
j = 0;
j < n; ++
j)
1938 for (
j = 0;
j < n; ++
j)
1942 for (
i = 0;
i <= ub; ++
i)
1959 for (
i = 0;
i < nrowsused; ++
i)
1965 for (
i = 0;
i < nrowsused; ++
i)
2003 SCIP_Real** weights;
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)
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;
2094 SCIPdebugMsg(
scip,
" -> reason for x[%d][%d] = ... = x[%d][%d] = 0 was the following SC:\n",
i,
j,
i,
MIN(
i,nblocks));
2108 if ( cases[
p1][
p2] == 1 )
2123 if ( cases[
p1][
p2] == 3 )
2150 inferinfo -= nspcons * nblocks;
2151 i = (int) inferinfo / nblocks;
2152 j = inferinfo % nblocks;
2159 if ( weights[
i-1][
j-1] > 0.5 && weights[
i-1][
j-1] < 1.5 )
2179 if ( cases[
p1][
p2] == 1 )
2204 if ( cases[
p1][
p2] == 3 )
2222 for (
k = 0;
k <
j; ++
k)
2275 SCIP_Real** weights;
2289 assert( consdata->nspcons > 0 );
2290 assert( consdata->nblocks > 0 );
2296 if ( ! consdata->istrianglefixed )
2298 SCIP_Bool infeasible =
FALSE;
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)
2331 SCIP_Real
bar = 0.0;
2373 SCIP_Real** weights;
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 )
2418 for (
j =
i+1;
j < nblocks; ++
j)
2434 for (
i = 1;
i < nspcons; ++
i)
2466 for (
l =
j;
l < nblocks; ++
l)
2481 if (cases[
p1][
p2] == 1)
2488 if ( 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;
2549 for (
i = 0;
i < nrows; ++
i)
2573 SCIP_Bool* infeasible
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)
2643 for (
k = 0;
k <=
i; ++
k)
2723 SCIP_Bool infeasible =
FALSE;
2734 for (
c = 0;
c < nconss && ! infeasible;
c++)
2749 if ( enforce && !consdata->ismodelcons )
2756 orbitopetype = consdata->orbitopetype;
2764 else if ( conshdlrdata->sepafullorbitope )
2780 else if ( nfixedvars > 0 )
2785 else if ( ncuts > 0 )
2804 SCIP_Bool* redundant
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)
3023 for (
c = 0;
c < nconss; ++
c)
3038 if ( !consdata->ismodelcons )
3041 orbitopetype = consdata->orbitopetype;
3088 if ( !consdata->ismodelcons )
3091 orbitopetype = consdata->orbitopetype;
3115 SCIP_Bool infeasible =
FALSE;
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);
3150 SCIPdebugMsg(
scip,
"Propagation via orbitopal fixing did not find anything.\n");
3161 SCIP_Bool infeasible =
FALSE;
3164 SCIP_Bool redundant;
3172 noldfixedvars = *nfixedvars;
3178 for (
c = 0;
c < nconss && !infeasible; ++
c)
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 )
3396 if ( !
sourcedata->ismodelcons && !conshdlrdata->forceconscopy )
3408 for (
i = 0;
i < nspcons && *
valid; ++
i)
3412 for (
j = 0;
j < nblocks && *
valid; ++
j)
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);
3536 if( *s ==
'.' || *s ==
')' )
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 )
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;
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.",
3704 SCIP_Bool usedynamicprop,
3705 SCIP_Bool mayinteract,
3707 SCIP_Bool resolveprop,
3708 SCIP_Bool ismodelcons,
3721 SCIP_Bool modifiable,
3727 SCIP_Bool removable,
3729 SCIP_Bool stickingatnode
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) );
3832 SCIP_Bool usedynamicprop,
3833 SCIP_Bool resolveprop,
3834 SCIP_Bool ismodelcons,
3835 SCIP_Bool mayinteract
3840 resolveprop, ismodelcons, mayinteract,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE) );
constraint handler for orbisack constraints
static SCIP_RETCODE checkRedundantCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *redundant)
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
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)
#define CONSHDLR_CHECKPRIORITY
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)
#define CONSHDLR_PROP_TIMING
static SCIP_RETCODE separateSCIs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_Bool *infeasible, int *nfixedvars, int *ncuts)
#define DEFAULT_FORCECONSCOPY
#define CONSHDLR_MAXPREROUNDS
#define CONSHDLR_SEPAPRIORITY
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)
#define CONSHDLR_PROPFREQ
static SCIP_RETCODE separateCoversOrbisack(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool dynamic, int *ngen, SCIP_Bool *infeasible)
#define DEFAULT_PPORBITOPE
#define CONSHDLR_PRESOLTIMING
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)
#define CONSHDLR_EAGERFREQ
#define CONSHDLR_ENFOPRIORITY
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)
#define CONSHDLR_DELAYSEPA
static void copyValues(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol)
#define CONSHDLR_DELAYPROP
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)
#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)
#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)
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
@ SCIP_BOUNDCHGTYPE_BRANCHING