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
151 nrows = (*consdata)->nrows;
154 for (
i = 0;
i < nrows; ++
i)
194 for (
i = 0;
i < nrows; ++
i)
202 (*consdata)->nrows = nrows;
203 (*consdata)->ismodelcons = ismodelcons;
210 for (
i = 0;
i < nrows; ++
i)
221 for (
i = 0;
i < nrows; ++
i)
256 for (
i = 0;
i < nrows; ++
i)
273 for (
i = nrows - 1;
i >= 0; --
i)
309 assert( consdata->nrows > 0 );
313 vars1 = consdata->vars1;
314 vars2 = consdata->vars2;
316 tmpvars[0] = vars1[0];
317 tmpvars[1] = vars2[0];
362 for (
i = 0;
i < nrows; ++
i)
421 for (
i = 0;
i < nrows; ++
i)
428 for (
i = 0;
i < nrows; ++
i)
452 lhs = lhs - vals1[
i];
465 lhs = lhs + vals2[
i];
515 for (
i = 0;
i < nrows; ++
i)
573 assert( coeffbound >= 0.0 );
591 for (
i = 2;
i < nrows; ++
i)
599 lhs = - vals1[0] + vals2[0];
605 lhs += - vals1[1] + vals2[1];
617 while ( basement < nrows - 1 && ! *infeasible )
619 valueA = lhs + vals1[basement] - vals1[basement + 1] + vals2[basement + 1] - rhs - 1.0;
620 valueB = lhs - vals2[basement] - vals1[basement + 1] + vals2[basement + 1] - rhs;
621 valueC = 2.0 * lhs + vals1[basement] - vals2[basement] - vals1[basement + 1] + vals2[basement + 1] - 2.0 * rhs;
624 if ( valueA >= valueB && valueA >= valueC )
627 coeff1[basement] = 0.0;
628 lhs += vals1[basement++];
629 coeff1[basement] = -1.0;
630 coeff2[basement] = 1.0;
631 lhs += - vals1[basement] + vals2[basement];
633 else if ( valueB >= valueA && valueB >= valueC )
635 coeff2[basement] = 0.0;
636 lhs -= vals2[basement++];
637 coeff1[basement] = -1.0;
638 coeff2[basement] = 1.0;
639 lhs += - vals1[basement] + vals2[basement];
645 for (
i = 0;
i < basement; ++
i)
647 coeff1[
i] = 2.0 * coeff1[
i];
648 coeff2[
i] = 2.0 * coeff2[
i];
649 lhs += coeff1[
i] * vals1[
i] + coeff2[
i] * vals2[
i];
651 coeff1[basement] = -1.0;
652 coeff2[basement] = 1.0;
653 lhs -= vals1[basement];
654 lhs += vals2[basement++];
655 coeff1[basement] = -1.0;
656 coeff2[basement] = 1.0;
657 lhs -= vals1[basement];
658 lhs += vals2[basement];
662 if ( rhs > coeffbound || -coeff1[0] > coeffbound || coeff2[0] > coeffbound )
665 if ( ! coverseparation )
722 for (
i = start;
i < nrows; ++
i)
789 int peekinfeasiblerow;
810 assert( consdata->nrows > 0 );
812 nrows = consdata->nrows;
813 vars1 = consdata->vars1;
814 vars2 = consdata->vars2;
817 for (
i = 0;
i < nrows; ++
i)
866 if ( peekinfeasible )
871 assert( peekinfeasiblerow >
i );
872 assert( peekinfeasiblerow < nrows );
881 *found = *found || tightened;
893 *found = *found || tightened;
942 *found = *found || tightened;
958 *found = *found || tightened;
999 if ( conshdlrdata->orbiseparation )
1001 SCIP_CALL(
separateOrbisack(
scip, cons, nrows, vars1, vars2, vals1, vals2,
FALSE, conshdlrdata->coeffbound, &ngen1, &infeasible) );
1004 if ( ! infeasible && conshdlrdata->coverseparation )
1015 if ( ngen1 + ngen2 > 0 )
1096 sourcedata->nrows, sourcedata->ismodelcons) );
1117 *infeasible =
FALSE;
1124 for (
c = 0;
c < nconss; ++
c)
1156 conshdlrdata->maxnrows = 0;
1159 for (
c = 0;
c < nconss; ++
c)
1169 if ( consdata->nrows > conshdlrdata->maxnrows )
1170 conshdlrdata->maxnrows = consdata->nrows;
1206 nvals = conshdlrdata->maxnrows;
1213 for (
c = 0;
c < nconss; ++
c)
1265 nvals = conshdlrdata->maxnrows;
1272 for (
c = 0;
c < nconss; ++
c)
1279 assert( consdata->nrows <= nvals );
1332 nvals = conshdlrdata->maxnrows;
1339 for (
c = 0;
c < nconss; ++
c)
1347 if ( !consdata->ismodelcons )
1351 assert( consdata->nrows <= nvals );
1395 SCIPdebugMsg(
scip,
"Enforcing method for orbisack constraints (pseudo solutions) ...\n");
1399 if ( objinfeasible || solinfeasible )
1403 for (
c = 0;
c < nconss; ++
c)
1409 assert( consdata->nrows > 0 );
1414 if ( !consdata->ismodelcons )
1461 nvals = conshdlrdata->maxnrows;
1468 for (
c = 0;
c < nconss; ++
c)
1476 if ( !consdata->ismodelcons )
1480 assert( consdata->nrows <= nvals );
1527 for (
c = 0;
c < nconss; ++
c)
1533 assert( consdata->nrows > 0 );
1540 if ( !consdata->ismodelcons )
1573 SCIPdebugMsg(
scip,
"Propagation method of orbisack constraint handler.\n");
1576 for (
c = 0;
c < nconss; ++
c)
1612 SCIPdebugMsg(
scip,
"Presolving method of orbisack constraint handler. Propagating orbisack inequalities.\n");
1617 for (
c = 0;
c < nconss; ++
c)
1637 *nfixedvars += ngen;
1664 SCIPdebugMsg(
scip,
"Propagation resolution method of orbisack constraint handler.\n");
1670 assert( consdata->nrows > 0 );
1674 vars1 = consdata->vars1;
1675 vars2 = consdata->vars2;
1678 varrow = inferinfo % consdata->nrows;
1679 infrow = inferinfo / consdata->nrows;
1682 assert( varrow < consdata->nrows );
1684 assert( infrow < consdata->nrows );
1687 for (
i = 0;
i < varrow; ++
i)
1702 for (
i = varrow + 1;
i < infrow; ++
i)
1728 assert( infervar == vars1[varrow] );
1740 assert( infervar == vars2[varrow] );
1784 assert( consdata->nrows > 0 );
1788 nrows = consdata->nrows;
1789 vars1 = consdata->vars1;
1790 vars2 = consdata->vars2;
1792 for (
i = 0;
i < nrows; ++
i)
1832 assert( sourcedata->nrows > 0 );
1838 if ( !sourcedata->ismodelcons && !conshdlrdata->forceconscopy )
1845 sourcevars1 = sourcedata->vars1;
1846 sourcevars2 = sourcedata->vars2;
1847 nrows = sourcedata->nrows;
1851 for (
i = 0;
i < nrows && *
valid; ++
i)
1867 for (
i = 0;
i < nrows && *
valid; ++
i)
1881 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
1914 if( strncmp(s,
"partOrbisack(", 13) == 0 )
1916 ispporbisack =
TRUE;
1919 else if( strncmp(s,
"packOrbisack(", 13) == 0 )
1920 ispporbisack =
TRUE;
1923 if( strncmp(s,
"fullOrbisack(", 13) != 0 )
1925 SCIPerrorMessage(
"Syntax error - expected \"fullOrbisack(\", \"partOrbisack\" or \"packOrbisacj\": %s\n", s);
1943 endptr = strchr(endptr,
')');
1945 if( endptr ==
NULL || !firstcolumn )
1960 if( firstcolumn == ( *s ==
'.' || *s ==
')' ) )
1972 if( nrows > maxnrows )
1977 assert( nrows <= maxnrows );
1980 vars1[nrows-1] =
var;
1983 vars2[nrows-1] =
var;
1985 firstcolumn = !firstcolumn;
1988 if( *s ==
',' || *s ==
'.' )
2025 assert( consdata->nrows > 0 );
2027 vars1 = consdata->vars1;
2028 vars2 = consdata->vars2;
2029 nrows = consdata->nrows;
2035 for (
i = 0;
i < nrows; ++
i)
2074 for (
i = 0;
i < nrows; ++
i)
2087 else if ( val1 == 1 )
2118 if ( varssize < 2 * consdata->nrows )
2125 for (
i = 0;
i < consdata->nrows; ++
i)
2127 vars[cnt++] = consdata->vars1[
i];
2128 vars[cnt++] = consdata->vars2[
i];
2148 (*nvars) = 2 * consdata->nrows;
2169 consEnfolpOrbisack, consEnfopsOrbisack, consCheckOrbisack, consLockOrbisack,
2192 "Separate cover inequalities for orbisacks?",
2196 "Separate orbisack inequalities?",
2200 "Maximum size of coefficients for orbisack inequalities",
2205 "Upgrade orbisack constraints to packing/partioning orbisacks?",
2209 "Whether orbisack constraints should be forced to be copied to sub SCIPs.",
2269 if ( conshdlr ==
NULL )
2279 if ( ! ispporbisack && conshdlrdata->checkpporbisack )
2284 ispporbisack =
TRUE;
2292 for (
i = 0;
i < nrows; ++
i)
2305 2,
FALSE,
TRUE,
TRUE, ismodelcons, initial, separate, enforce, check,
propagate, local,
2306 modifiable, dynamic, removable, stickingatnode) );
2308 for (
i = 0;
i < nrows; ++
i)
2317 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
2318 local, modifiable, dynamic, removable, stickingatnode) );
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
#define CONSHDLR_PROP_TIMING
#define CONSHDLR_MAXPREROUNDS
#define CONSHDLR_SEPAPRIORITY
#define CONSHDLR_PROPFREQ
#define CONSHDLR_PRESOLTIMING
#define CONSHDLR_EAGERFREQ
#define CONSHDLR_ENFOPRIORITY
#define CONSHDLR_DELAYSEPA
#define CONSHDLR_DELAYPROP
static SCIP_RETCODE initLP(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
#define DEFAULT_ORBISEPARATION
#define DEFAULT_FORCECONSCOPY
#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)
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)
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)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, int nrows, SCIP_Bool ismodelcons)
static SCIP_RETCODE checkFeasible(SCIP *scip, SCIP_VAR **vars1, SCIP_VAR **vars2, int nrows, int start, SCIP_Bool *infeasible, int *infeasiblerow)
#define DEFAULT_COEFFBOUND
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_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
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 SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
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)
struct SCIP_Cons SCIP_CONS
#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)
struct SCIP_Conshdlr SCIP_CONSHDLR
#define SCIP_DECL_CONSCOPY(x)
struct SCIP_ConsData SCIP_CONSDATA
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSHDLRCOPY(x)
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_ORBITOPETYPE_PACKING
@ SCIP_ORBITOPETYPE_PARTITIONING
enum SCIP_OrbitopeType SCIP_ORBITOPETYPE