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;
205 if ( (*consdata)->usedynamicprop && (*consdata)->rowindexmap !=
NULL )
210 p = (*consdata)->nspcons;
211 q = (*consdata)->nblocks;
212 for (
int i = 0;
i <
p; ++
i)
220 if ( (*consdata)->usedynamicprop )
248 SCIP_Bool resolveprop,
249 SCIP_Bool usedynamicprop,
250 SCIP_Bool ismodelcons,
251 SCIP_Bool mayinteract
260 if ( usedynamicprop )
275 if ( usedynamicprop )
281 for (
i = 0;
i < nspcons; ++
i)
287 (*consdata)->roworder[
i] =
i;
289 if ( usedynamicprop )
291 (*consdata)->rowused[
i] =
FALSE;
294 (*consdata)->nrowsused = 0;
296 (*consdata)->tmpvals =
NULL;
297 (*consdata)->tmpvars =
NULL;
298 (*consdata)->nspcons = nspcons;
299 (*consdata)->nblocks = nblocks;
300 (*consdata)->orbitopetype = orbitopetype;
301 (*consdata)->resolveprop = resolveprop;
302 (*consdata)->istrianglefixed =
FALSE;
303 (*consdata)->ismodelcons = ismodelcons;
304 (*consdata)->mayinteract = mayinteract;
305 (*consdata)->usedynamicprop = usedynamicprop;
313 for (
i = 0;
i < nspcons; ++
i)
318 for (
j = 0;
j < nblocks; ++
j)
322 if ( usedynamicprop )
342 SCIP_Bool mayinteract
367 if (
npprows >= 3 && ! mayinteract )
378 for (
i =
r;
i < *nrows - 1; ++
i)
413 assert( consdata->nspcons > 0 );
414 assert( consdata->nblocks > 0 );
417 for (
j = 0;
j < consdata->nblocks; ++
j)
421 for (
i = 0;
i < consdata->nspcons; ++
i)
423 for (
j = 0;
j < consdata->nblocks; ++
j)
432 for (
j = 0;
j < consdata->nblocks; ++
j)
458 for (
k = 0;
k <
p; ++
k)
461 for (
l = 0;
l <
q; ++
l)
466 for (
l =
j;
l <
q; ++
l)
482 if ( cases[
p1][
p2] == 1 )
490 if ( cases[
p1][
p2] == 3 )
499 for (
l = 0;
l <
q; ++
l)
503 for (
k = 0;
k <
p; ++
k)
505 for (
l = 0;
l <
q; ++
l)
531 for (
l = 0;
l <
q; ++
l)
535 for (
k = 0;
k <
p; ++
k)
557 assert( consdata->nspcons > 0 );
558 assert( consdata->nblocks > 0 );
562 for (
i = 0;
i < consdata->nspcons; ++
i)
564 for (
j = 0;
j < consdata->nblocks; ++
j)
602 for (
i = 0;
i < nspcons; ++
i)
604 for (
j = 0;
j < nblocks; ++
j)
608 weights[
i][
j] = -1.0;
616 minvalue = vals[0][0];
617 weights[0][0] = minvalue;
622 if ( nspcons < nblocks )
630 minvalue = vals[
j][
j];
635 weights[
j][
j] = minvalue;
639 for (
i = 1;
i < nspcons; ++
i)
641 weights[
i][0] = weights[
i-1][0] + vals[
i][0];
646 for (
i = 2;
i < nspcons; ++
i)
648 for (
j = 1;
j < nblocks &&
j <
i; ++
j)
680 SCIP_Bool* infeasible,
701 assert( consdata->nspcons > 0 );
702 assert( consdata->nblocks > 0 );
708 if ( consdata->istrianglefixed )
711 nspcons = consdata->nspcons;
712 nblocks = consdata->nblocks;
713 vars = consdata->vars;
718 if ( nspcons < nblocks )
724 for (
j =
i+1;
j < nblocks; ++
j)
731 SCIPdebugMsg(
scip,
"The problem is infeasible: some variable in the upper right triangle is fixed to 1.\n");
742 if ( *nfixedvars > 0 )
752 consdata->istrianglefixed =
TRUE;
765 SCIP_Bool* infeasible,
790 assert( consdata->nspcons > 0 );
791 assert( consdata->nblocks > 0 );
803 nspcons = consdata->nspcons;
804 nblocks = consdata->nblocks;
805 vars = consdata->vars;
806 vals = consdata->vals;
807 tmpvars = consdata->tmpvars;
808 tmpvals = consdata->tmpvals;
809 weights = consdata->weights;
810 cases = consdata->cases;
813 if ( ! consdata->istrianglefixed )
818 if ( *nfixedvars > 0 )
826 for (
i = 1;
i < nspcons && ! (*infeasible); ++
i)
863 tmpvals[
nvars] = 1.0;
875 if (cases[
p1][
p2] == 1)
882 tmpvals[
nvars] = -1.0;
884 weight += vals[
p1][
p2];
885 if ( cases[
p1][
p2] == 3 )
924 SCIP_Bool* infeasible,
953 assert( consdata->nspcons > 0 );
954 assert( consdata->nblocks > 0 );
957 nspcons = consdata->nspcons;
958 nblocks = consdata->nblocks;
959 vars = consdata->vars;
960 orbitopetype = consdata->orbitopetype;
965 if ( ! consdata->istrianglefixed )
997 for (
i = 1;
i < nspcons; ++
i)
1035 SCIPdebugMsg(
scip,
" -> Infeasible node: all variables in row %d are fixed to 0.\n",
i);
1073 SCIPdebugMsg(
scip,
" -> Infeasible node: row %d, leftmost nonzero at %d, rightmost 1 at %d\n",
1078 SCIPdebugMsg(
scip,
" -> Infeasible node: row %d, 1 at %d, rightmost position for 1 at %d\n",
1119 for (
k = 1;
k <
i; ++
k)
1144 SCIP_Bool tightened;
1184 for (
k = 1;
k <
i; ++
k)
1227 for (
i = s+1;
i < nspcons; ++
i)
1236 assert( -1 <= beta && beta < nblocks );
1240 SCIP_Bool tightened;
1256 assert( !(*infeasible) );
1324 for (
i = 0;
i < nboundchgs; ++
i)
1381 SCIP_Bool* infeasible,
1391 *infeasible =
FALSE;
1399 assert( nrowsused <= m );
1405 for (
j = n - 2;
j >= 0; --
j)
1411 for (
i = 0;
i < nrowsused; ++
i)
1439 for (
i = 0;
i < nrowsused; ++
i)
1480 SCIP_Bool* infeasible,
1490 *infeasible =
FALSE;
1498 assert( nrowsused <= m );
1501 for (
j = 1;
j < n; ++
j)
1507 for (
i = 0;
i < nrowsused; ++
i)
1535 for (
i = 0;
i < nrowsused; ++
i)
1574 SCIP_Bool* infeasible,
1596 *infeasible =
FALSE;
1608 assert( consdata->nspcons > 0 );
1609 assert( consdata->nblocks > 0 );
1613 m = consdata->nspcons;
1614 n = consdata->nblocks;
1615 vars = consdata->vars;
1621 consdata->roworder, m, n, &(consdata->nrowsused)) );
1624 if ( consdata->nrowsused == 0 )
1627 nrowsused = consdata->nrowsused;
1631 roworder = consdata->roworder;
1637 for (
i = 0;
i < nrowsused; ++
i)
1642 for (
i = 0;
i < nrowsused; ++
i)
1648 for (
j = 0;
j < n; ++
j)
1662 if ( *infeasible ==
TRUE )
1669 for (
i = 0;
i < nrowsused; ++
i)
1674 for (
i = 0;
i < nrowsused; ++
i)
1680 for (
j = 0;
j < n; ++
j)
1700 for (
j = 0;
j < n; ++
j)
1702 for (
i = 0;
i < nrowsused; ++
i)
1716 cons, 0, infeasible, &
success) );
1725 for (
i = 0;
i < nrowsused; ++
i)
1730 for (
i = 0;
i < nrowsused; ++
i)
1743 SCIP_Bool* infeasible,
1758 orbitopetype = consdata->orbitopetype;
1763 consdata->usedynamicprop && !consdata->ismodelcons) );
1819 assert( consdata->nspcons > 0 );
1820 assert( consdata->nblocks > 0 );
1824 dynamic = consdata->usedynamicprop && !consdata->ismodelcons;
1825 m = consdata->nspcons;
1826 n = consdata->nblocks;
1827 vars = consdata->vars;
1832 assert( consdata->nrowsused > 0 );
1834 nrowsused = consdata->nrowsused;
1838 roworder = consdata->roworder;
1846 for (
i = 0;
i < nrowsused; ++
i)
1855 for (
i = 0;
i < nrowsused; ++
i)
1861 for (
j = 0;
j < n; ++
j)
1882 for (
i = 0;
i < nrowsused; ++
i)
1891 for (
i = 0;
i < nrowsused; ++
i)
1897 for (
j = 0;
j < n; ++
j)
1917 for (
j = 0;
j < n; ++
j)
1921 for (
i = 0;
i <= ub; ++
i)
1938 for (
i = 0;
i < nrowsused; ++
i)
1944 for (
i = 0;
i < nrowsused; ++
i)
1982 SCIP_Real** weights;
1998 assert( consdata->nspcons > 0 );
1999 assert( consdata->nblocks > 0 );
2004 assert( consdata->istrianglefixed );
2007 if ( ! consdata->resolveprop )
2010 nspcons = consdata->nspcons;
2011 nblocks = consdata->nblocks;
2012 vars = consdata->vars;
2013 vals = consdata->vals;
2014 weights = consdata->weights;
2015 orbitopetype = consdata->orbitopetype;
2016 cases = consdata->cases;
2018 SCIPdebugMsg(
scip,
"Propagation resolution method of orbitope constraint using orbitopal fixing\n");
2021 for (
i = 0;
i < nspcons; ++
i)
2051 assert( consdata->istrianglefixed );
2055 assert( inferinfo >= 0 && inferinfo < 2 * nspcons * nblocks );
2056 if ( inferinfo < nspcons * nblocks )
2065 i = (int) (inferinfo / nblocks);
2066 j = inferinfo % nblocks;
2073 SCIPdebugMsg(
scip,
" -> reason for x[%d][%d] = ... = x[%d][%d] = 0 was the following SC:\n",
i,
j,
i,
MIN(
i,nblocks));
2087 if ( cases[
p1][
p2] == 1 )
2102 if ( cases[
p1][
p2] == 3 )
2129 inferinfo -= nspcons * nblocks;
2130 i = (int) inferinfo / nblocks;
2131 j = inferinfo % nblocks;
2138 if ( weights[
i-1][
j-1] > 0.5 && weights[
i-1][
j-1] < 1.5 )
2158 if ( cases[
p1][
p2] == 1 )
2183 if ( cases[
p1][
p2] == 3 )
2201 for (
k = 0;
k <
j; ++
k)
2254 SCIP_Real** weights;
2268 assert( consdata->nspcons > 0 );
2269 assert( consdata->nblocks > 0 );
2275 if ( ! consdata->istrianglefixed )
2277 SCIP_Bool infeasible =
FALSE;
2286 if ( nfixedvars > 0 )
2293 nspcons = consdata->nspcons;
2294 nblocks = consdata->nblocks;
2295 vals = consdata->vals;
2296 weights = consdata->weights;
2297 cases = consdata->cases;
2304 assert( consdata->istrianglefixed );
2308 for (
i = 1;
i < nspcons; ++
i)
2310 SCIP_Real
bar = 0.0;
2352 SCIP_Real** weights;
2364 assert( consdata->nspcons > 0 );
2365 assert( consdata->nblocks > 0 );
2371 nspcons = consdata->nspcons;
2372 nblocks = consdata->nblocks;
2373 vars = consdata->vars;
2374 vals = consdata->vals;
2375 weights = consdata->weights;
2376 cases = consdata->cases;
2384 if ( ! consdata->istrianglefixed )
2391 if ( nspcons < nblocks )
2397 for (
j =
i+1;
j < nblocks; ++
j)
2413 for (
i = 1;
i < nspcons; ++
i)
2445 for (
l =
j;
l < nblocks; ++
l)
2460 if (cases[
p1][
p2] == 1)
2467 if ( cases[
p1][
p2] == 3 )
2512 assert( consdata->nspcons > 0 );
2513 assert( consdata->nblocks > 0 );
2514 assert( ! consdata->ismodelcons );
2516 vars = consdata->vars;
2517 nrows = consdata->nspcons;
2518 ncols = consdata->nblocks;
2528 for (
i = 0;
i < nrows; ++
i)
2552 SCIP_Bool* infeasible
2575 *infeasible =
FALSE;
2581 vars = consdata->vars;
2582 nrows = consdata->nspcons;
2583 ncols = consdata->nblocks;
2584 nrowsused = dynamic ? consdata->nrowsused : nrows;
2585 roworder = consdata->roworder;
2595 for (
j = 0;
j < ncols - 1 && ! *infeasible; ++
j)
2599 for (
i = 0;
i < nrowsused; ++
i)
2622 for (
k = 0;
k <=
i; ++
k)
2702 SCIP_Bool infeasible =
FALSE;
2713 for (
c = 0;
c < nconss && ! infeasible;
c++)
2728 if ( enforce && !consdata->ismodelcons )
2735 orbitopetype = consdata->orbitopetype;
2743 else if ( conshdlrdata->sepafullorbitope )
2759 else if ( nfixedvars > 0 )
2764 else if ( ncuts > 0 )
2783 SCIP_Bool* redundant
2802 assert( consdata->nspcons > 0 );
2803 assert( consdata->nblocks > 0 );
2805 vars = consdata->vars;
2806 nrows = consdata->nspcons;
2807 ncols = consdata->nblocks;
2810 for (
i = 0;
i < nrows; ++
i)
2812 for (
j = 0;
j < ncols; ++
j)
3002 for (
c = 0;
c < nconss; ++
c)
3017 if ( !consdata->ismodelcons )
3020 orbitopetype = consdata->orbitopetype;
3067 if ( !consdata->ismodelcons )
3070 orbitopetype = consdata->orbitopetype;
3094 SCIP_Bool infeasible =
FALSE;
3119 SCIPdebugMsg(
scip,
"Propagation via orbitopal fixing proved node to be infeasible.\n");
3121 else if ( nfixedvars > 0 )
3124 SCIPdebugMsg(
scip,
"Propagated %d variables via orbitopal fixing.\n", nfixedvars);
3129 SCIPdebugMsg(
scip,
"Propagation via orbitopal fixing did not find anything.\n");
3140 SCIP_Bool infeasible =
FALSE;
3143 SCIP_Bool redundant;
3151 noldfixedvars = *nfixedvars;
3157 for (
c = 0;
c < nconss && !infeasible; ++
c)
3175 SCIPdebugMsg(
scip,
"Orbitope constraint <%s> is redundant: it does not contain active variables\n",
3190 else if ( *nfixedvars > noldfixedvars )
3194 else if ( nconss > 0 )
3197 SCIPdebugMsg(
scip,
"Presolving via orbitopal fixing did not find anything.\n");
3220 orbitopetype = consdata->orbitopetype;
3255 assert( consdata->nspcons > 0 );
3256 assert( consdata->nblocks > 0 );
3261 nspcons = consdata->nspcons;
3262 nblocks = consdata->nblocks;
3263 vars = consdata->vars;
3266 for (
i = 0;
i < nspcons; ++
i)
3268 for (
j = 0;
j < nblocks; ++
j)
3295 assert( consdata->nspcons > 0 );
3296 assert( consdata->nblocks > 0 );
3299 nspcons = consdata->nspcons;
3300 nblocks = consdata->nblocks;
3301 vars = consdata->vars;
3302 orbitopetype = consdata->orbitopetype;
3306 switch ( orbitopetype )
3321 for (
i = 0;
i < nspcons; ++
i)
3323 for (
j = 0;
j < nblocks; ++
j)
3329 if (
i < nspcons-1 )
3375 if ( !
sourcedata->ismodelcons && !conshdlrdata->forceconscopy )
3387 for (
i = 0;
i < nspcons && *
valid; ++
i)
3391 for (
j = 0;
j < nblocks && *
valid; ++
j)
3408 initial, separate, enforce, check,
propagate,
3409 local, modifiable, dynamic, removable, stickingatnode) );
3414 for (
k =
i - 1;
k >= 0; --
k)
3446 if(
strncmp(s,
"partOrbitope(", 13) == 0 )
3448 else if(
strncmp(s,
"packOrbitope(", 13) == 0 )
3452 if(
strncmp(s,
"fullOrbitope(", 13) != 0 )
3454 SCIPerrorMessage(
"Syntax error - expected \"fullOrbitope(\", \"partOrbitope\" or \"packOrbitope\": %s\n", s);
3515 if( *s ==
'.' || *s ==
')' )
3524 else if( (
j < nblocks-1 ) == ( *s ==
'.' || *s ==
')' ) )
3539 if( *s ==
',' || *s ==
'.' )
3548 SCIP_CALL(
SCIPcreateConsOrbitope(
scip, cons, name,
vars, orbitopetype, nspcons, nblocks,
FALSE,
TRUE,
TRUE,
TRUE,
3549 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3551 for(
k = nspcons - 1;
k >= 0; --
k )
3580 for (
i = 0;
i < consdata->nspcons; ++
i)
3582 for (
j = 0;
j < consdata->nblocks; ++
j)
3583 vars[cnt++] = consdata->vars[
i][
j];
3603 (*nvars) = consdata->nblocks * consdata->nspcons;
3651 "Strengthen orbitope constraints to packing/partioning orbitopes?",
3655 "Whether we separate inequalities for full orbitopes?",
3659 "Whether orbitope constraints should be forced to be copied to sub SCIPs.",
3683 SCIP_Bool usedynamicprop,
3684 SCIP_Bool mayinteract,
3686 SCIP_Bool resolveprop,
3687 SCIP_Bool ismodelcons,
3700 SCIP_Bool modifiable,
3706 SCIP_Bool removable,
3708 SCIP_Bool stickingatnode
3719 if ( conshdlr ==
NULL )
3726 if ( usedynamicprop && mayinteract )
3729 other symmetry handling constraints. Ignore value of <usedynamicprop>.\n");
3741 for (
i = 0;
i < nspcons; ++
i)
3745 for (
j = 0;
j < nblocks; ++
j)
3789 resolveprop, usedynamicprop && ! mayinteract, ismodelcons, mayinteract) );
3792 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
3793 local, modifiable, dynamic, removable, stickingatnode) );
3811 SCIP_Bool usedynamicprop,
3812 SCIP_Bool resolveprop,
3813 SCIP_Bool ismodelcons,
3814 SCIP_Bool mayinteract
3819 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_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_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