86#define CONSHDLR_NAME "symresack"
87#define CONSHDLR_DESC "symmetry breaking constraint handler relying on symresacks"
88#define CONSHDLR_SEPAPRIORITY +40100
89#define CONSHDLR_ENFOPRIORITY -1005200
90#define CONSHDLR_CHECKPRIORITY -1005200
91#define CONSHDLR_SEPAFREQ 5
92#define CONSHDLR_PROPFREQ 5
93#define CONSHDLR_EAGERFREQ -1
95#define CONSHDLR_MAXPREROUNDS -1
96#define CONSHDLR_DELAYSEPA FALSE
97#define CONSHDLR_DELAYPROP FALSE
98#define CONSHDLR_NEEDSCONS TRUE
100#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
101#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_EXHAUSTIVE
103#define DEFAULT_PPSYMRESACK TRUE
104#define DEFAULT_CHECKMONOTONICITY TRUE
105#define DEFAULT_FORCECONSCOPY FALSE
114#define ISFIXED(x, bdchgidx) (SCIPvarGetUbAtIndex(x, bdchgidx, FALSE) - SCIPvarGetLbAtIndex(x, bdchgidx, FALSE) < 0.5)
123struct SCIP_ConshdlrData
125 SCIP_Bool checkppsymresack;
126 SCIP_Bool checkmonotonicity;
128 SCIP_Bool forceconscopy;
140 SCIP_Bool ismodelcons;
147 int** cycledecomposition;
170 nvars = (*consdata)->nvars;
177 assert( (*consdata)->ncycles == 0 );
178 assert( (*consdata)->cycledecomposition ==
NULL );
185 if ( (*consdata)->ndescentpoints > 0 )
192 if ( (*consdata)->ppupgrade )
194 for (
i = 0;
i < (*consdata)->ncycles; ++
i)
224 SCIP_Bool checkmonotonicity,
234 int** cycledecomposition;
243 int ndescentpoints = 0;
280 else if ( checkmonotonicity )
291 assert( checkmonotonicity );
328 descentpoints[
c++] =
j;
331 cycledecomposition[
curcycle][++cyclelength] =
j;
336 cycledecomposition[
curcycle][0] = cyclelength;
366 for (
j = 0;
j < cycledecomposition[
i][0]; ++
j)
368 var =
vars[cycledecomposition[
i][
j + 1]];
379 cyclelength = cycledecomposition[
i][0];
419 for (
k = 0;
k < cyclelength; ++
k)
428 assert( nfound <= cyclelength );
430 if ( nfound == cyclelength )
441 (*consdata)->ncycles =
ncycles;
442 (*consdata)->cycledecomposition = cycledecomposition;
443 (*consdata)->ndescentpoints = ndescentpoints;
444 (*consdata)->descentpoints = descentpoints;
479 SCIP_Bool ismodelcons
499 (*consdata)->debugcnt = 0;
502 (*consdata)->ndescentpoints = 0;
503 (*consdata)->descentpoints =
NULL;
504 (*consdata)->ismodelcons = ismodelcons;
533 (*consdata)->vars =
NULL;
534 (*consdata)->perm =
NULL;
535 (*consdata)->invperm =
NULL;
536 (*consdata)->ppupgrade =
FALSE;
537 (*consdata)->ncycles = 0;
538 (*consdata)->cycledecomposition =
NULL;
566 (*consdata)->vars =
vars;
567 (*consdata)->perm = perm;
573 invperm[perm[
i]] =
i;
575 (*consdata)->invperm = invperm;
580 if ( conshdlrdata->checkppsymresack )
585 (*consdata)->ppupgrade =
upgrade;
616 SCIP_Bool checkmonotonicity,
617 SCIP_Bool* infeasible
640 nvars = consdata->nvars;
647 vars = consdata->vars;
650 assert( consdata->invperm[0] != 0 );
667 if ( consdata->ppupgrade && ! *infeasible )
669 if ( checkmonotonicity )
673 int** cycledecomposition;
680 cycledecomposition = consdata->cycledecomposition;
690 assert( cycledecomposition[
i][0] > 0 );
701 for (
j = 0;
j <
i; ++
j)
746 descentpoints = consdata->descentpoints;
747 ndescentpoints = consdata->ndescentpoints;
748 perm = consdata->perm;
751 assert( ndescentpoints > 0 );
759 for (
j = 0;
j < ndescentpoints; ++
j)
771 for (
j = 0;
j < ndescentpoints; ++
j)
826 SCIP_Bool* infeasible,
941 SCIP_Bool* infeasible,
974 nvars = consdata->nvars;
982 vars = consdata->vars;
983 invperm = consdata->invperm;
1026 SCIPdebugMsg(
scip,
" -> node is feasible (could set pair to (1,0) and every earlier pair is constant).\n");
1039 SCIPdebugMsg(
scip,
" -> First entry is not fixed. Check if 0 is feasible.\n");
1048 SCIPdebugMsg(
scip,
" -> First entry is not fixed. 0 is not feasible. Fixing to 1.\n");
1050 FALSE, infeasible, &tightened) );
1066 SCIPdebugMsg(
scip,
" -> Second entry is not fixed. Check if 1 is feasible.\n");
1075 SCIPdebugMsg(
scip,
" -> Second entry is not fixed. 1 is not feasible. Fixing to 0.\n");
1077 FALSE, infeasible, &tightened) );
1100 SCIPdebugMsg(
scip,
" -> node infeasible (pair was fixed to (0,1) but there was no pair of type (1,0) before) ---> lexicographical order violated, infeasible.\n");
1107 for (
r = 0;
r <=
i; ++
r)
1170 SCIP_Bool* infeasible
1187 *infeasible =
FALSE;
1193 ++consdata->debugcnt;
1221 SCIP_Real* objective,
1342 SCIP_Real* objective,
1454 SCIP_Bool* infeasible
1467 *infeasible =
FALSE;
1474 if ( consdata->nvars < 2 )
1483 nvars = consdata->nvars;
1484 perm = consdata->perm;
1485 invperm = consdata->invperm;
1518 SCIP_Real rhs = -1.0;
1534 if ( ! *infeasible )
1566 if ( consdata->nvars < 2 )
1574 nvars = consdata->nvars;
1575 vars = consdata->vars;
1576 invperm = consdata->invperm;
1635 SCIP_Bool ismodelcons,
1648 SCIP_Bool modifiable,
1654 SCIP_Bool removable,
1656 SCIP_Bool stickingatnode
1677 if ( conshdlr ==
NULL )
1680 SCIPdebugMsg(
scip,
"Cannot check whether symresack constraint can be upgraded to orbisack constraint. ");
1696 if ( perm[perm[
i]] !=
i )
1717 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
1739 SCIP_Bool ismodelcons,
1752 SCIP_Bool modifiable,
1758 SCIP_Bool removable,
1760 SCIP_Bool stickingatnode
1774 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
1779 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
1888 consdata->vars =
NULL;
1889 consdata->nvars =
nvars;
1890 consdata->perm =
NULL;
1891 consdata->invperm =
NULL;
1893 consdata->ismodelcons =
sourcedata->ismodelcons;
1895 consdata->debugcnt = 0;
1897 consdata->ncycles = 0;
1898 consdata->cycledecomposition =
NULL;
1899 consdata->ndescentpoints = 0;
1900 consdata->descentpoints =
NULL;
1923 consdata->ndescentpoints =
sourcedata->ndescentpoints;
1960 *infeasible =
FALSE;
1970 for (
c = 0;
c < nconss; ++
c)
2001 conshdlrdata->maxnvars = 0;
2004 for (
c = 0;
c < nconss; ++
c)
2014 if ( consdata->nvars > conshdlrdata->maxnvars )
2015 conshdlrdata->maxnvars = consdata->nvars;
2051 maxnvars = conshdlrdata->maxnvars;
2057 for (
c = 0;
c < nconss; ++
c)
2059 SCIP_Bool infeasible =
FALSE;
2068 if ( consdata->nvars == 0 )
2072 assert( consdata->nvars <= maxnvars );
2121 maxnvars = conshdlrdata->maxnvars;
2127 for (
c = 0;
c < nconss; ++
c)
2129 SCIP_Bool infeasible =
FALSE;
2138 if ( consdata->nvars == 0 )
2142 assert( consdata->nvars <= maxnvars );
2183 SCIPdebugMsg(
scip,
"Enforcing method for symresack constraints (lp solutions) ...\n");
2199 maxnvars = conshdlrdata->maxnvars;
2205 for (
c = 0;
c < nconss; ++
c)
2207 SCIP_Bool infeasible =
FALSE;
2218 if ( !consdata->ismodelcons )
2221 if ( consdata->nvars == 0 )
2225 assert( consdata->nvars <= maxnvars );
2261 SCIPdebugMsg(
scip,
"Enforcing method for symresack constraints (pseudo solutions) ...\n");
2269 for (
c = 0;
c < nconss; ++
c)
2275 if ( !consdata->ismodelcons )
2304 SCIPdebugMsg(
scip,
"Enforcing method for symresack constraints (relaxation solutions) ...\n");
2320 maxnvars = conshdlrdata->maxnvars;
2326 for (
c = 0;
c < nconss; ++
c)
2328 SCIP_Bool infeasible =
FALSE;
2339 if ( !consdata->ismodelcons )
2342 if ( consdata->nvars == 0 )
2346 assert( consdata->nvars <= maxnvars );
2383 for (
c = 0;
c < nconss; ++
c)
2389 if ( !consdata->ismodelcons )
2419 SCIPdebugMsg(
scip,
"Propagation method of symresack constraint handler.\n");
2422 for (
c = 0;
c < nconss; ++
c)
2424 SCIP_Bool infeasible =
FALSE;
2467 SCIPdebugMsg(
scip,
"Presolving method of symresack constraint handler. Propagating symresack inequalities.\n");
2471 for (
c = 0;
c < nconss; ++
c)
2473 SCIP_Bool infeasible =
FALSE;
2483 if ( consdata->nvars == 0 )
2501 *nfixedvars +=
ngen;
2536 SCIPdebugMsg(
scip,
"Propagation resolution method of symresack constraint handler.\n");
2544 if ( consdata->nvars < 2 )
2550 vars = consdata->vars;
2551 nvars = consdata->nvars;
2552 perm = consdata->perm;
2553 invperm = consdata->invperm;
2593 if ( invperm[
i] >
i )
2706 if ( consdata->nvars < 2 )
2712 nvars = consdata->nvars;
2713 vars = consdata->vars;
2714 perm = consdata->perm;
2769 if ( !
sourcedata->ismodelcons && !conshdlrdata->forceconscopy )
2795 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
2827 if(
strncmp(s,
"symresack(", 10) != 0 )
2829 SCIPerrorMessage(
"Syntax error - expected \"symresack(\", but got '%s'", s);
2894 if(
nvars > maxnvars )
2952 SCIPerrorMessage(
"length of permutation is not equal to number of given variables.\n");
3006 if ( consdata->nvars < 2 )
3012 vars = consdata->vars;
3013 nvars = consdata->nvars;
3014 perm = consdata->perm;
3053 for (
i = 0;
i < consdata->nvars; ++
i)
3054 vars[cnt++] = consdata->vars[
i];
3075 (*nvars) = consdata->nvars;
3118 "Upgrade symresack constraints to packing/partioning symresacks?",
3123 "Check whether permutation is monotone when upgrading to packing/partioning symresacks?",
3127 "Whether symresack constraints should be forced to be copied to sub SCIPs.",
3152 SCIP_Bool ismodelcons,
3165 SCIP_Bool modifiable,
3171 SCIP_Bool removable,
3173 SCIP_Bool stickingatnode
3186 if ( conshdlr ==
NULL )
3196 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate && (! consdata->ppupgrade), enforce, check,
propagate,
3197 local, modifiable, dynamic, removable, stickingatnode) );
3217 SCIP_Bool ismodelcons
constraint handler for orbisack constraints
Constraint handler for the set partitioning / packing / covering constraints .
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
#define CONSHDLR_PROP_TIMING
#define DEFAULT_FORCECONSCOPY
#define CONSHDLR_MAXPREROUNDS
#define DEFAULT_CHECKMONOTONICITY
#define ISFIXED(x, bdchgidx)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA **consdata, SCIP_VAR *const *inputvars, int inputnvars, int *inputperm, SCIP_Bool ismodelcons)
static SCIP_RETCODE propVariables(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, int *ngen)
static SCIP_RETCODE initLP(SCIP *scip, SCIP_CONS *cons, SCIP_Bool checkmonotonicity, SCIP_Bool *infeasible)
#define CONSHDLR_SEPAPRIORITY
static SCIP_RETCODE checkSymresackSolution(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result, SCIP_Bool printreason)
static SCIP_RETCODE checkFeasible(SCIP *scip, SCIP_VAR **vars, int *invperm, int nvars, int start, int *tempfixings, int *tempfixentries, int numfixentriesinit, SCIP_Bool *infeasible, int *infeasibleentry)
static SCIP_RETCODE maximizeObjectiveSymresackCriticalEntry(SCIP *scip, int nvars, SCIP_Real *objective, int *perm, int *invperm, int crit, int *maxsolu)
static SCIP_RETCODE separateSymresackCovers(SCIP *scip, SCIP_CONS *cons, const SCIP_CONSDATA *consdata, SCIP_Real *vals, int *ngen, SCIP_Bool *infeasible)
#define CONSHDLR_PROPFREQ
static SCIP_RETCODE addSymresackInequality(SCIP *scip, SCIP_CONS *cons, int nvars, SCIP_VAR **vars, int *coeffs, SCIP_Real rhs, SCIP_Bool *infeasible)
#define CONSHDLR_PRESOLTIMING
static SCIP_RETCODE packingUpgrade(SCIP *scip, SCIP_CONSDATA **consdata, int *perm, SCIP_VAR **vars, int nvars, SCIP_Bool checkmonotonicity, SCIP_Bool *upgrade)
static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)
#define CONSHDLR_EAGERFREQ
#define DEFAULT_PPSYMRESACK
static SCIP_RETCODE maximizeObjectiveSymresackStrict(SCIP *scip, int nvars, SCIP_Real *objective, int *perm, int *invperm, int *maxcrit, SCIP_Real *maxsoluval)
#define CONSHDLR_ENFOPRIORITY
#define CONSHDLR_DELAYSEPA
static SCIP_RETCODE orbisackUpgrade(SCIP *scip, SCIP_CONS **cons, const char *name, int *perm, SCIP_VAR **inputvars, int nvars, SCIP_Bool *upgrade, 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)
#define CONSHDLR_DELAYPROP
constraint handler for symresack constraints
#define SCIP_DEFAULT_INFINITY
SCIP_RETCODE SCIPcreateSymbreakCons(SCIP *scip, SCIP_CONS **cons, const char *name, int *perm, SCIP_VAR **vars, int nvars, 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)
int SCIPgetNVarsSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_SETPPCTYPE SCIPgetTypeSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsOrbisack(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, int nrows, SCIP_Bool ispporbisack, SCIP_Bool isparttype, 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 SCIPcreateConsBasicSymresack(SCIP *scip, SCIP_CONS **cons, const char *name, int *perm, SCIP_VAR **vars, int nvars, SCIP_Bool ismodelcons)
SCIP_RETCODE SCIPcreateConsSymresack(SCIP *scip, SCIP_CONS **cons, const char *name, int *perm, SCIP_VAR **vars, int nvars, 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_SETPPCTYPE_PARTITIONING
@ SCIP_SETPPCTYPE_COVERING
@ SCIP_SETPPCTYPE_PACKING
SCIP_RETCODE SCIPincludeConshdlrSymresack(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_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
void SCIPinfoMessage(SCIP *scip, FILE *file, 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,)
int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)),)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitsol(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_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
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_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 SCIPfreeCleanBufferArray(scip, ptr)
#define SCIPallocCleanBufferArray(scip, ptr, num)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocClearBufferArray(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 SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
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 SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
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_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisGE(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 SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
int SCIPvarGetProbindex(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Real SCIPvarGetLbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
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)
void SCIPsortIntInt(int *intarray1, int *intarray2, int len)
SCIP_Bool SCIPstrToIntValue(const char *str, int *value, char **endptr)
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
public methods for managing constraints
public methods for message output
public data structures and miscellaneous methods
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 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 solutions
public methods for SCIP variables
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSDELETE(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSINITSOL(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSSEPALP(x)
#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_CONSINITLP(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