77#define CONSHDLR_NAME "orbisack"
78#define CONSHDLR_DESC "symmetry breaking constraint handler for orbisacks"
79#define CONSHDLR_SEPAPRIORITY +40100
80#define CONSHDLR_ENFOPRIORITY -1005200
81#define CONSHDLR_CHECKPRIORITY -1005200
82#define CONSHDLR_SEPAFREQ 5
83#define CONSHDLR_PROPFREQ 5
84#define CONSHDLR_EAGERFREQ -1
86#define CONSHDLR_MAXPREROUNDS -1
87#define CONSHDLR_DELAYSEPA FALSE
88#define CONSHDLR_DELAYPROP FALSE
89#define CONSHDLR_NEEDSCONS TRUE
91#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
92#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_EXHAUSTIVE
95#define DEFAULT_ORBISEPARATION FALSE
96#define DEFAULT_COVERSEPARATION TRUE
99#define DEFAULT_COEFFBOUND 1000000.0
100#define DEFAULT_PPORBISACK TRUE
101#define DEFAULT_FORCECONSCOPY FALSE
114struct SCIP_ConshdlrData
116 SCIP_Bool coverseparation;
117 SCIP_Bool orbiseparation;
118 SCIP_Real coeffbound;
119 SCIP_Bool checkpporbisack;
121 SCIP_Bool forceconscopy;
130 SCIP_Bool ismodelcons;
150 nrows = (*consdata)->nrows;
168 SCIP_Bool ismodelcons
182 for (
i = 0;
i < nrows; ++
i)
190 (*consdata)->nrows = nrows;
191 (*consdata)->ismodelcons = ismodelcons;
198 for (
i = 0;
i < nrows; ++
i)
237 for (
i = 0;
i < nrows; ++
i)
254 for (
i = nrows - 1;
i >= 0; --
i)
273 SCIP_Bool* infeasible
290 assert( consdata->nrows > 0 );
294 vars1 = consdata->vars1;
295 vars2 = consdata->vars2;
297 tmpvars[0] = vars1[0];
298 tmpvars[1] = vars2[0];
325 SCIP_Bool* infeasible
343 for (
i = 0;
i < nrows; ++
i)
377 SCIP_Bool* infeasible
402 for (
i = 0;
i < nrows; ++
i)
409 for (
i = 0;
i < nrows; ++
i)
477 SCIP_Bool* infeasible
496 for (
i = 0;
i < nrows; ++
i)
533 SCIP_Bool coverseparation,
534 SCIP_Real coeffbound,
536 SCIP_Bool* infeasible
554 assert( coeffbound >= 0.0 );
572 for (
i = 2;
i < nrows; ++
i)
598 while (
basement < nrows - 1 && ! *infeasible )
643 if ( rhs > coeffbound || -
coeff1[0] > coeffbound ||
coeff2[0] > coeffbound )
646 if ( ! coverseparation )
685 SCIP_Bool* infeasible,
756 SCIP_Bool* infeasible,
791 assert( consdata->nrows > 0 );
793 nrows = consdata->nrows;
794 vars1 = consdata->vars1;
795 vars2 = consdata->vars2;
798 for (
i = 0;
i < nrows; ++
i)
862 *found = *found || tightened;
874 *found = *found || tightened;
923 *found = *found || tightened;
939 *found = *found || tightened;
965 SCIP_Bool infeasible =
FALSE;
980 if ( conshdlrdata->orbiseparation )
982 SCIP_CALL(
separateOrbisack(
scip, cons, nrows, vars1, vars2,
vals1,
vals2,
FALSE, conshdlrdata->coeffbound, &
ngen1, &infeasible) );
985 if ( ! infeasible && conshdlrdata->coverseparation )
1098 *infeasible =
FALSE;
1105 for (
c = 0;
c < nconss; ++
c)
1137 conshdlrdata->maxnrows = 0;
1140 for (
c = 0;
c < nconss; ++
c)
1150 if ( consdata->nrows > conshdlrdata->maxnrows )
1151 conshdlrdata->maxnrows = consdata->nrows;
1187 nvals = conshdlrdata->maxnrows;
1194 for (
c = 0;
c < nconss; ++
c)
1246 nvals = conshdlrdata->maxnrows;
1253 for (
c = 0;
c < nconss; ++
c)
1260 assert( consdata->nrows <= nvals );
1287 SCIP_Bool infeasible =
FALSE;
1313 nvals = conshdlrdata->maxnrows;
1320 for (
c = 0;
c < nconss; ++
c)
1328 if ( !consdata->ismodelcons )
1332 assert( consdata->nrows <= nvals );
1376 SCIPdebugMsg(
scip,
"Enforcing method for orbisack constraints (pseudo solutions) ...\n");
1384 for (
c = 0;
c < nconss; ++
c)
1390 assert( consdata->nrows > 0 );
1395 if ( !consdata->ismodelcons )
1416 SCIP_Bool infeasible =
FALSE;
1442 nvals = conshdlrdata->maxnrows;
1449 for (
c = 0;
c < nconss; ++
c)
1457 if ( !consdata->ismodelcons )
1461 assert( consdata->nrows <= nvals );
1508 for (
c = 0;
c < nconss; ++
c)
1514 assert( consdata->nrows > 0 );
1521 if ( !consdata->ismodelcons )
1554 SCIPdebugMsg(
scip,
"Propagation method of orbisack constraint handler.\n");
1557 for (
c = 0;
c < nconss; ++
c)
1559 SCIP_Bool infeasible =
FALSE;
1560 SCIP_Bool found =
FALSE;
1593 SCIPdebugMsg(
scip,
"Presolving method of orbisack constraint handler. Propagating orbisack inequalities.\n");
1598 for (
c = 0;
c < nconss; ++
c)
1600 SCIP_Bool infeasible =
FALSE;
1601 SCIP_Bool found =
FALSE;
1618 *nfixedvars +=
ngen;
1645 SCIPdebugMsg(
scip,
"Propagation resolution method of orbisack constraint handler.\n");
1651 assert( consdata->nrows > 0 );
1655 vars1 = consdata->vars1;
1656 vars2 = consdata->vars2;
1659 varrow = inferinfo % consdata->nrows;
1660 infrow = inferinfo / consdata->nrows;
1765 assert( consdata->nrows > 0 );
1769 nrows = consdata->nrows;
1770 vars1 = consdata->vars1;
1771 vars2 = consdata->vars2;
1773 for (
i = 0;
i < nrows; ++
i)
1819 if ( !
sourcedata->ismodelcons && !conshdlrdata->forceconscopy )
1832 for (
i = 0;
i < nrows && *
valid; ++
i)
1848 for (
i = 0;
i < nrows && *
valid; ++
i)
1862 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
1895 if(
strncmp(s,
"partOrbisack(", 13) == 0 )
1900 else if(
strncmp(s,
"packOrbisack(", 13) == 0 )
1904 if(
strncmp(s,
"fullOrbisack(", 13) != 0 )
1906 SCIPerrorMessage(
"Syntax error - expected \"fullOrbisack(\", \"partOrbisack\" or \"packOrbisacj\": %s\n", s);
1953 if( nrows > maxnrows )
1958 assert( nrows <= maxnrows );
1961 vars1[nrows-1] =
var;
1964 vars2[nrows-1] =
var;
1969 if( *s ==
',' || *s ==
'.' )
2006 assert( consdata->nrows > 0 );
2008 vars1 = consdata->vars1;
2009 vars2 = consdata->vars2;
2010 nrows = consdata->nrows;
2016 for (
i = 0;
i < nrows; ++
i)
2055 for (
i = 0;
i < nrows; ++
i)
2068 else if (
val1 == 1 )
2106 for (
i = 0;
i < consdata->nrows; ++
i)
2108 vars[cnt++] = consdata->vars1[
i];
2109 vars[cnt++] = consdata->vars2[
i];
2129 (*nvars) = 2 * consdata->nrows;
2173 "Separate cover inequalities for orbisacks?",
2177 "Separate orbisack inequalities?",
2181 "Maximum size of coefficients for orbisack inequalities",
2186 "Upgrade orbisack constraints to packing/partioning orbisacks?",
2190 "Whether orbisack constraints should be forced to be copied to sub SCIPs.",
2214 SCIP_Bool ismodelcons,
2227 SCIP_Bool modifiable,
2233 SCIP_Bool removable,
2235 SCIP_Bool stickingatnode
2250 if ( conshdlr ==
NULL )
2273 for (
i = 0;
i < nrows; ++
i)
2286 2,
FALSE,
TRUE,
TRUE, ismodelcons, initial, separate, enforce, check,
propagate, local,
2287 modifiable, dynamic, removable, stickingatnode) );
2289 for (
i = 0;
i < nrows; ++
i)
2298 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
2299 local, modifiable, dynamic, removable, stickingatnode) );
2321 SCIP_Bool ismodelcons
static SCIP_RETCODE initLP(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
#define DEFAULT_ORBISEPARATION
#define CONSHDLR_PROP_TIMING
#define DEFAULT_FORCECONSCOPY
#define CONSHDLR_MAXPREROUNDS
#define CONSHDLR_SEPAPRIORITY
#define DEFAULT_PPORBISACK
static SCIP_RETCODE separateOrbisackCovers(SCIP *scip, SCIP_CONS *cons, int nrows, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, SCIP_Real *vals1, SCIP_Real *vals2, int *ngen, SCIP_Bool *infeasible)
#define DEFAULT_COVERSEPARATION
static SCIP_RETCODE addOrbisackCover(SCIP *scip, SCIP_CONS *cons, int nrows, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, SCIP_Real *coeffs1, SCIP_Real *coeffs2, SCIP_Real rhs, SCIP_Bool *infeasible)
static SCIP_RETCODE separateInequalities(SCIP *scip, SCIP_RESULT *result, SCIP_CONS *cons, int nrows, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, SCIP_Real *vals1, SCIP_Real *vals2)
static SCIP_RETCODE addOrbisackInequality(SCIP *scip, SCIP_CONS *cons, int nrows, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, SCIP_Real *coeffs1, SCIP_Real *coeffs2, SCIP_Real rhs, SCIP_Bool *infeasible)
#define CONSHDLR_PROPFREQ
#define CONSHDLR_PRESOLTIMING
static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)
static SCIP_RETCODE packingUpgrade(SCIP *scip, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, int nrows, SCIP_Bool *success, SCIP_Bool *isparttype)
#define CONSHDLR_EAGERFREQ
static SCIP_RETCODE separateOrbisack(SCIP *scip, SCIP_CONS *cons, int nrows, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, SCIP_Real *vals1, SCIP_Real *vals2, SCIP_Bool coverseparation, SCIP_Real coeffbound, int *ngen, SCIP_Bool *infeasible)
#define CONSHDLR_ENFOPRIORITY
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, int nrows, SCIP_Bool ismodelcons)
#define CONSHDLR_DELAYSEPA
static SCIP_RETCODE checkFeasible(SCIP *scip, SCIP_VAR **vars1, SCIP_VAR **vars2, int nrows, int start, SCIP_Bool *infeasible, int *infeasiblerow)
#define DEFAULT_COEFFBOUND
#define CONSHDLR_DELAYPROP
static SCIP_RETCODE propVariables(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, SCIP_Bool *found, int *ngen)
constraint handler for orbisack constraints
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 SCIPcreateConsBasicOrbisack(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR **vars1, SCIP_VAR **vars2, int nrows, SCIP_Bool ispporbisack, SCIP_Bool isparttype, SCIP_Bool ismodelcons)
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 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 SCIPincludeConshdlrOrbisack(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)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
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_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_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_CONSHDLR * SCIPconsGetHdlr(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)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#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 SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
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_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 SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
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)
SCIP_Real SCIPvarGetLbLocal(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 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 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 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_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
@ SCIP_ORBITOPETYPE_PACKING
@ SCIP_ORBITOPETYPE_PARTITIONING
enum SCIP_OrbitopeType SCIP_ORBITOPETYPE