84#define CONSHDLR_NAME "linking"
85#define CONSHDLR_DESC "linking constraint x = sum_{i=1}^{n} c_i*y_i, y1+...+yn = 1, x real, y's binary"
87#define EVENTHDLR_NAME "linking"
88#define EVENTHDLR_DESC "event handler for linking constraints"
90#define CONSHDLR_SEPAPRIORITY 750000
91#define CONSHDLR_ENFOPRIORITY -2050000
92#define CONSHDLR_CHECKPRIORITY -750000
93#define CONSHDLR_SEPAFREQ 1
94#define CONSHDLR_PROPFREQ 1
95#define CONSHDLR_EAGERFREQ 100
96#define CONSHDLR_MAXPREROUNDS -1
97#define CONSHDLR_DELAYSEPA FALSE
98#define CONSHDLR_DELAYPROP FALSE
99#define CONSHDLR_NEEDSCONS TRUE
101#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
102#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_MEDIUM
105#define HASHSIZE_BINVARSCONS 500
106#define DEFAULT_LINEARIZE FALSE
128 unsigned int cliqueadded:1;
129 unsigned int sorted:1;
133struct SCIP_ConshdlrData
160 if( consdata->sorted )
164 SCIPsortRealPtr(consdata->vals, (
void**)consdata->binvars, consdata->nbinvars);
166 consdata->sorted =
TRUE;
204 (*conshdlrdata)->varmap =
NULL;
207 (*conshdlrdata)->eventhdlr = eventhdlr;
223 if( (*conshdlrdata)->varmap !=
NULL )
245 linkvar = consdata->linkvar;
246 binvars = consdata->binvars;
287 var = consdata->binvars[pos];
296 consdata->nfixedzeros++;
298 consdata->nfixedones++;
319 var = consdata->binvars[pos];
327 consdata->nfixedzeros--;
329 consdata->nfixedones--;
352 for(
i = 0;
i < consdata->nbinvars; ++
i )
378 for(
i = 0;
i < consdata->nbinvars; ++
i )
414 for(
b = 0;
b < consdata->nbinvars; ++
b )
446 assert(consdata->nbinvars == 0);
456 linkvar = consdata->linkvar;
479 consdata->binvars[0] = binvar;
480 consdata->vals[0] = lb;
494 consdata->binvars[
b] = binvar;
495 consdata->vals[
b] = lb +
b;
501 assert(consdata->nfixedzeros == 0);
502 assert(consdata->nfixedones == 0);
552 (*consdata)->linkvar = linkvar;
554 (*consdata)->sizebinvars =
nbinvars;
555 (*consdata)->row1 =
NULL;
556 (*consdata)->row2 =
NULL;
557 (*consdata)->nlrow1 =
NULL;
558 (*consdata)->nlrow2 =
NULL;
559 (*consdata)->cliqueadded =
FALSE;
562 (*consdata)->sorted =
FALSE;
563 (*consdata)->firstnonfixed = 0;
564 (*consdata)->lastnonfixed =
nbinvars - 1;
565 (*consdata)->nfixedzeros = 0;
566 (*consdata)->nfixedones = 0;
570 (*consdata)->binvars =
NULL;
571 (*consdata)->vals =
NULL;
625 assert((*consdata)->nbinvars == 0 || (*consdata)->binvars !=
NULL);
628 if( (*consdata)->row1 !=
NULL )
637 if( (*consdata)->nlrow1 !=
NULL )
646 for( v = 0; v < (*consdata)->nbinvars; ++v )
654 if( (*consdata)->sizebinvars > 0 )
662 assert((*consdata)->nfixedzeros == 0);
663 assert((*consdata)->nfixedones == 0);
740 linkvar = consdata->linkvar;
741 coef = consdata->vals[pos];
819 if( consdata->nfixedones > 0 || consdata->nfixedzeros >=
nbinvars-1 )
822 linkvar = consdata->linkvar;
825 binvars = consdata->binvars;
826 vals = consdata->vals;
835 for(
b = 0;
b < consdata->firstnonfixed; ++
b )
839 for(
b = consdata->lastnonfixed + 1;
b <
nbinvars; ++
b )
843 for(
b = consdata->firstnonfixed;
b <
nbinvars; ++
b )
852 SCIPdebugMsg(
scip,
"fix variable <%s> to zero due to the lower bound of the linking variable <%s> [%g,%g]\n",
868 consdata->firstnonfixed++;
875 for(
b = consdata->lastnonfixed;
b >= 0; --
b )
884 SCIPdebugMsg(
scip,
"fix variable <%s> to zero due to the upper bound of the linking variable <%s> [%g,%g]\n",
900 consdata->lastnonfixed--;
906 if( consdata->firstnonfixed > consdata->lastnonfixed )
912 *mustcheck = (*nchgbds) == 0;
919 if( consdata->firstnonfixed == consdata->lastnonfixed )
923 var = binvars[consdata->firstnonfixed];
925 SCIPdebugMsg(
scip,
"fix variable <%s> to one due to the fixed linking variable <%s> [%g,%g]\n",
961 vars = &consdata->binvars[consdata->firstnonfixed];
962 nvars = consdata->lastnonfixed - consdata->firstnonfixed + 1;
998 var = consdata->binvars[pos];
1022 if( pos != consdata->nbinvars - 1 )
1024 consdata->binvars[pos] = consdata->binvars[consdata->nbinvars-1];
1025 consdata->vals[pos] = consdata->vals[consdata->nbinvars-1];
1026 consdata->sorted =
FALSE;
1029 consdata->nbinvars--;
1051 assert(consdata->sorted);
1059 for(
b =
nbinvars - 1;
b > consdata->lastnonfixed; --
b )
1064 for(
b = consdata->firstnonfixed - 1;
b >= 0; --
b )
1069 for(
b = consdata->nbinvars - 1;
b >= 0; --
b )
1078 consdata->firstnonfixed = 0;
1079 consdata->lastnonfixed = consdata->nbinvars - 1;
1104 if( consdata->nfixedones > 1 || consdata->nfixedzeros >= consdata->nbinvars-1 )
1110 assert(consdata->sorted);
1112 linkvar = consdata->linkvar;
1113 binvars = consdata->binvars;
1114 vals = consdata->vals;
1119 for(
b = 0;
b < consdata->firstnonfixed; ++
b )
1127 for(
b = consdata->firstnonfixed;
b <
nbinvars; ++
b )
1132 consdata->firstnonfixed++;
1143 SCIPdebugMsg(
scip,
"conflict at <%s> due to bounds and fixed binvars: [lb,ub] = [%g,%g]; b= %d; coef = %g \n",
1153 for(
b = 0;
b < consdata->firstnonfixed; ++
b )
1171 for(
b = consdata->lastnonfixed + 1;
b <
nbinvars; ++
b )
1176 for(
b = consdata->lastnonfixed;
b >= 0; --
b )
1181 consdata->lastnonfixed--;
1192 SCIPdebugMsg(
scip,
"conflict at <%s> due to bounds and fixed binvars: [lb,ub] = [%g,%g]; b = %d; coef = %g,\n",
1202 for(
b = consdata->lastnonfixed + 1;
b <
nbinvars; ++
b )
1246 assert(consdata->nbinvars == 0 || consdata->binvars !=
NULL);
1247 assert(0 <= consdata->nfixedzeros && consdata->nfixedzeros <= consdata->nbinvars);
1248 assert(0 <= consdata->nfixedones && consdata->nfixedones <= consdata->nbinvars);
1254 assert(consdata->nbinvars > 1);
1259 if( consdata->nfixedones == 1 )
1265 if( consdata->nfixedzeros < consdata->nbinvars - 1 ||
1276 SCIPdebugMsg(
scip,
" -> fixing all other variables to zero due to the set partitioning condition <%s>\n",
1283 vars = consdata->binvars;
1284 nvars = consdata->nbinvars;
1286 fixedonefound =
FALSE;
1289 for( v = 0; v <
nvars && consdata->nfixedones == 1 && !(*cutoff); ++v )
1311 fixedonefound =
TRUE;
1321 assert(consdata->nfixedones >= 1 || fixedonefound);
1337 else if( consdata->nfixedones >= 2 )
1354 vars = consdata->binvars;
1355 nvars = consdata->nbinvars;
1362 for( v = 0; v <
nvars && n < 2; ++v )
1378 else if( consdata->nfixedzeros == consdata->nbinvars )
1385 assert(consdata->nfixedones == 0);
1402 vars = consdata->binvars;
1403 nvars = consdata->nbinvars;
1408 for( v = 0; v <
nvars; ++v )
1420 else if( consdata->nfixedzeros == consdata->nbinvars - 1 )
1427 assert(consdata->nfixedones == 0);
1437 vars = consdata->binvars;
1438 nvars = consdata->nbinvars;
1439 for( v = 0; v <
nvars && !(*cutoff); ++v )
1465 assert(consdata->nfixedzeros == consdata->nbinvars - 1);
1466 assert(consdata->nfixedones == 1);
1477 *mustcheck = (*nchgbds) == 0;
1479 assert(consdata->nfixedzeros + consdata->nfixedones <= consdata->nbinvars);
1512 assert(consdata->binvars !=
NULL || consdata->nbinvars == 0);
1515 assert(consdata->nbinvars > 1);
1518 binvars = consdata->binvars;
1519 vals = consdata->vals;
1526 for(
b = 0;
b <
nbinvars && setpartsum < setpartsumbound; ++
b )
1533 linksum += vals[
b] * solval;
1534 setpartsum += solval;
1539 absviol =
REALABS(linksum - linkvarval);
1545 absviol =
REALABS(setpartsum - 1.0);
1554#ifdef SCIP_DISABLED_CODE
1589 for(
c = 0;
c < nconss; ++
c )
1594 linkvar = consdata->linkvar;
1603 if( aggrcons !=
NULL )
1620 offset = consdata->offset;
1621 binvars = consdata->binvars;
1622 aggroffset = aggrconsdata->offset;
1623 aggrbinvars = aggrconsdata->binvars;
1625 nbinvars =
MIN(consdata->nbinvars + offset, aggrconsdata->nbinvars + shift + aggroffset);
1630 assert(
b + shift - aggroffset >= 0);
1636 &infeasible, &redundant, &aggregated) );
1677 assert(consdata->nbinvars > 1);
1691 for(
b = 0;
b < consdata->nbinvars; ++
b )
1698 assert( consdata->nbinvars > 0 );
1726 assert(consdata->nbinvars > 1);
1728 if( consdata->row1 ==
NULL )
1773 if( consdata->nlrow1 ==
NULL )
1794 for(
i = 0;
i < consdata->nbinvars; ++
i )
1839 assert(consdata->nbinvars > 1);
1853 if( mustcheck && !(*
cutoff) )
1873 feasibility =
MIN(feasibility, tmp);
1880 feasibility =
MIN(feasibility, tmp);
1986 SCIPdebugMsg(
scip,
"Enforcing %d linking constraints for %s solution\n", nconss,
sol ==
NULL ?
"LP" :
"relaxation");
1993 for(
c = 0;
c < nusefulconss && !
cutoff && nchgbds == 0; ++
c )
1999 for(
c = nusefulconss;
c < nconss && !
cutoff && !separated && nchgbds == 0; ++
c )
2007 else if( nchgbds > 0 )
2009 else if( separated )
2045 nlocvars = consdata->nbinvars + 1;
2051 for(
i = 0;
i < consdata->nbinvars; ++
i )
2053 vars[
i] = consdata->binvars[
i];
2054 vals[
i] = consdata->vals[
i];
2058 vars[consdata->nbinvars] = consdata->linkvar;
2059 vals[consdata->nbinvars] = -1.0;
2064 cons, -constant, -constant, success) );
2124 for(
c = 0;
c < nconss; ++
c )
2133 if( consdata->nbinvars <= 1 )
2138 else if( conshdlrdata->linearize )
2156 for(
c = 0;
c < nconss; ++
c )
2172 for(
c = 0;
c < nconss; ++
c )
2178 if( consdata->row1 !=
NULL )
2186 if( consdata->nlrow1 !=
NULL )
2259 sourcedata->linkvar, sourcedata->binvars, sourcedata->vals, sourcedata->nbinvars) );
2282 *infeasible =
FALSE;
2284 for(
c = 0;
c < nconss && !(*infeasible); ++
c )
2291 if( consdata->nbinvars <= 1 )
2315 SCIPdebugMsg(
scip,
"separating %d/%d linking constraints\n", nusefulconss, nconss);
2322 for(
c = 0;
c < nusefulconss && !
cutoff; ++
c )
2330 else if( nchgbds > 0 )
2332 else if( separated )
2362 for(
c = 0;
c < nusefulconss && !
cutoff; ++
c )
2370 else if( nchgbds > 0 )
2372 else if( separated )
2430 for(
c = 0;
c < nconss && !
cutoff && !solvelp; ++
c )
2437 else if( nchgbds > 0 )
2441 else if( infeasible )
2472 if( consdata->nbinvars > 1 && (checklprows || consdata->row1 ==
NULL || !
SCIProwIsInLP(consdata->row1)) )
2487 for(
b = 0;
b < consdata->nbinvars; ++
b )
2498 for(
b = 0;
b < consdata->nbinvars; ++
b )
2550 for(
c = 0;
c < nusefulconss && !
cutoff; ++
c )
2562 else if( nchgbds > 0 )
2598 oldnchgbds = *nchgbds;
2599 oldnaggrvars = *naggrvars;
2600 oldnfixedvars = *nfixedvars;
2601 oldndelconss = *ndelconss;
2608 firstchange = INT_MAX;
2609 firstclique = INT_MAX;
2633 assert(consdata->nbinvars > 1);
2636 if( consdata->nfixedones >= 2 )
2646 if( consdata->nfixedones == 1 )
2658 for( v = 0; v < consdata->nbinvars; ++v )
2660 var = consdata->binvars[v];
2711 if( consdata->nfixedzeros == consdata->nbinvars )
2716 assert(consdata->nfixedones == 0);
2723 if( consdata->nfixedzeros == consdata->nbinvars - 1 )
2734 assert(consdata->nfixedones == 0);
2742 for( v = 0; v < consdata->nbinvars &&
SCIPvarGetUbGlobal(consdata->binvars[v]) < 0.5; ++v );
2744 var = consdata->binvars[v];
2784 if( consdata->nfixedzeros == consdata->nbinvars - 2 )
2800 for( v = 0; v < consdata->nbinvars && var2 ==
NULL; ++v )
2802 var = consdata->binvars[v];
2821 SCIPdebugMsg(
scip,
"linking constraint <%s>: infeasible aggregation <%s> + <%s> == 1\n",
2840 if( !
cutoff && consdata->nbinvars == 1 )
2846 linkvar = consdata->linkvar;
2847 binvar = consdata->binvars[0];
2848 val = consdata->vals[0];
2850 SCIPdebugMsg(
scip,
"linking constraint <%s>: fix <%s> to %16.9g as only one binary variable remains",
2876 if( firstchange == INT_MAX )
2880 if( !consdata->cliqueadded && consdata->nbinvars >= 2 )
2882 if( firstclique == INT_MAX )
2906 if( !consdata->cliqueadded && consdata->nbinvars >= 3 )
2912 *nchgbds += ncliquebdchgs;
2920 consdata->cliqueadded =
TRUE;
2924#ifdef SCIP_DISABLED_CODE
2933 else if( oldndelconss < *ndelconss || oldnfixedvars < *nfixedvars || oldnchgbds < *nchgbds || oldnaggrvars < *naggrvars)
2953 linkvar = consdata->linkvar;
2958 if( inferinfo == -1 )
2972 for( v = 0; v < consdata->nbinvars; ++v )
2988 for( v = 0; v < consdata->nbinvars; ++v )
2990 if( consdata->binvars[v] != infervar )
2999 else if( inferinfo == -2 )
3011 else if( inferinfo == -3 )
3023 else if( inferinfo == -4 )
3032 assert(infervar == linkvar);
3035 binvars = consdata->binvars;
3037 vals = consdata->vals;
3051 else if( inferinfo == -5 )
3061 assert(infervar == linkvar);
3064 binvars = consdata->binvars;
3066 vals = consdata->vals;
3080 else if( inferinfo == -6 )
3098 assert(infervar == linkvar);
3129 for(
b = 0;
b < consdata->nbinvars; ++
b )
3184#ifdef SCIP_DISABLED_CODE
3195 if( consdata->nbinvars <= 1 )
3200 else if( conshdlrdata->linearize )
3231 const char* consname;
3248 nbinvars = sourceconsdata->nbinvars;
3249 linkvar = sourceconsdata->linkvar;
3287 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3322 if( linkvar ==
NULL )
3330 endptr = strchr(endptr,
'=');
3333 if( endptr ==
NULL )
3343 str += *(str+1) ==
'=' ? 2 : 1;
3354 if( strncmp(str,
"no binary variables yet", 24) != 0 )
3362 if( *success && requsize > varssize )
3365 varssize = requsize;
3370 assert(!*success || requsize <= varssize);
3388 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3406 if( varssize < consdata->
nbinvars + 1)
3413 vars[consdata->nbinvars] = consdata->linkvar;
3429 (*nvars) = consdata->nbinvars + 1;
3476 consdata->nfixedones++;
3479 consdata->nfixedones--;
3480 consdata->firstnonfixed = 0;
3481 consdata->lastnonfixed = consdata->nbinvars - 1;
3484 consdata->nfixedzeros++;
3487 consdata->firstnonfixed = 0;
3488 consdata->lastnonfixed = consdata->nbinvars - 1;
3489 consdata->nfixedzeros--;
3495 assert(0 <= consdata->nfixedzeros && consdata->nfixedzeros <= consdata->nbinvars);
3496 assert(0 <= consdata->nfixedones && consdata->nfixedones <= consdata->nbinvars);
3519 eventExecBinvar,
NULL) );
3527 consEnfolpLinking, consEnfopsLinking, consCheckLinking, consLockLinking,
3563 "constraints/" CONSHDLR_NAME "/linearize",
"this constraint will not propagate or separate, linear and setppc are used?",
3617 if( conshdlr ==
NULL )
3623 SCIPdebugMsg(
scip,
"create linking constraint for variable <%s> with %d binary variables (SCIP stage %d)\n",
3634 if( conshdlrdata->varmap ==
NULL )
3647 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3721 if( conshdlrdata->varmap !=
NULL )
3747 return consdata->linkvar;
3772 if( consdata->binvars ==
NULL )
3788 if( binvars !=
NULL )
3789 (*binvars) = consdata->binvars;
3791 (*nbinvars) = consdata->nbinvars;
3816 return consdata->nbinvars;
3840 return consdata->vals;
3865 if( binvars !=
NULL )
3866 *binvars = consdata->binvars;
3868 *vals = consdata->vals;
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
#define CONSHDLR_PROP_TIMING
#define CONSHDLR_MAXPREROUNDS
#define CONSHDLR_SEPAPRIORITY
#define DEFAULT_LINEARIZE
#define CONSHDLR_PROPFREQ
#define CONSHDLR_PRESOLTIMING
#define CONSHDLR_EAGERFREQ
#define CONSHDLR_ENFOPRIORITY
#define CONSHDLR_DELAYSEPA
#define CONSHDLR_DELAYPROP
static SCIP_RETCODE aggregateVariables(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars)
Constraint handler for linear constraints in their most general form, .
static SCIP_RETCODE consdataLinearize(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata)
static SCIP_RETCODE consdataPrint(SCIP *scip, SCIP_CONSDATA *consdata, FILE *file)
static SCIP_RETCODE analyzeConflict(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *linkvar, SCIP_VAR *binvar, SCIP_Bool lblinkvar, SCIP_Bool ublinkvar)
static SCIP_RETCODE enforcePseudo(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, SCIP_Bool *infeasible, int *nchgbds, SCIP_Bool *solvelp)
static SCIP_RETCODE addCuts(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff)
static SCIP_RETCODE catchAllEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE consFixLinkvar(SCIP *scip, SCIP_CONS *cons, int pos, SCIP_Bool *cutoff)
static SCIP_RETCODE dropEvent(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos)
static SCIP_RETCODE dropAllEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE removeFixedBinvars(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS *cons)
static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)
static SCIP_RETCODE processBinvarFixings(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool *addcut, SCIP_Bool *mustcheck)
static void * getHashmapKey(SCIP_VAR *var)
static SCIP_RETCODE lockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **binvars, int nbinvars)
static SCIP_Bool checkCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
static SCIP_RETCODE catchEvent(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos)
static SCIP_RETCODE processRealBoundChg(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool *mustcheck)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONSDATA **consdata, SCIP_VAR *linkvar, SCIP_VAR **binvars, SCIP_Real *vals, int nbinvars)
static SCIP_RETCODE consdataCreateBinvars(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool linearize)
static SCIP_RETCODE tightenedLinkvar(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_Bool *cutoff, int *nchgbds)
static SCIP_RETCODE createRows(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE delCoefPos(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS *cons, int pos)
static SCIP_RETCODE enforceConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_RESULT *result)
static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)
static void consdataSort(SCIP_CONSDATA *consdata)
static SCIP_RETCODE addNlrow(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *cutoff, SCIP_Bool *separated, int *nchgbds)
static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)
#define HASHSIZE_BINVARSCONS
constraint handler for linking binary variables to a linking (continuous or integer) variable
Constraint handler for the set partitioning / packing / covering constraints .
int SCIPgetNBinvarsLinking(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPgetBinvarsLinking(SCIP *scip, SCIP_CONS *cons, SCIP_VAR ***binvars, int *nbinvars)
SCIP_Bool SCIPexistsConsLinking(SCIP *scip, SCIP_VAR *linkvar)
SCIP_VAR * SCIPgetLinkvarLinking(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_CONS * SCIPgetConsLinking(SCIP *scip, SCIP_VAR *linkvar)
SCIP_RETCODE SCIPcreateConsLinking(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *linkvar, SCIP_VAR **binvars, SCIP_Real *vals, int nbinvars, 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 SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, 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 SCIPcreateConsSetpart(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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 SCIPcreateConsBasicLinking(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *linkvar, SCIP_VAR **binvars, SCIP_Real *vals, int nbinvars)
SCIP_Real * SCIPgetValsLinking(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPgetBinvarsDataLinking(SCIP_CONS *cons, SCIP_VAR ***binvars, SCIP_Real **vals, int *nbinvars)
SCIP_RETCODE SCIPincludeConshdlrLinking(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_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
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)
SCIP_RETCODE SCIPhashmapRemove(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
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)
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 SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
SCIP_RETCODE SCIPsetConshdlrEnable(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
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,)
SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(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 SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDeactive(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 SCIPsetConshdlrExitsol(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_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsTransformed(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)
SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)
SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsAdded(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_RETCODE SCIPdelNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
SCIP_RETCODE SCIPaddLinearCoefToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
SCIP_Bool SCIPnlrowIsInNLP(SCIP_NLROW *nlrow)
SCIP_RETCODE SCIPcreateNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_RETCODE SCIPaddVarsToRowSameCoef(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real val)
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 SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
void SCIPupdateSolLPConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPconvertRealToInt(SCIP *scip, SCIP_Real real)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPinRepropagation(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
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_Real SCIPvarGetAggrScalar(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetProbvar(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)
int SCIPvarGetIndex(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
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 SCIPgetVarLbAtIndex(SCIP *scip, 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 SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
void SCIPsortRealPtr(SCIP_Real *realarray, void **ptrarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPskipSpace(char **s)
SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
SCIP_RETCODE SCIPextendPermsymDetectionGraphLinear(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool *success)
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
memory allocation routines
#define BMScopyMemoryArray(ptr, source, num)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for managing constraints
public methods for managing events
public methods for LP management
public methods for message output
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for problem variables
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 event handler plugins and event handlers
public methods for the LP relaxation, rows and columns
public methods for memory management
public methods for message handling
public methods for nonlinear relaxation
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 the branch-and-bound tree
public methods for SCIP variables
structs for symmetry computations
methods for dealing with symmetry detection graphs
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSINITPRE(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)
struct SYM_Graph SYM_GRAPH
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSRESPROP(x)
#define SCIP_DECL_CONSACTIVE(x)
#define SCIP_DECL_CONSENFOPS(x)
#define SCIP_DECL_CONSPARSE(x)
#define SCIP_DECL_CONSTRANS(x)
#define SCIP_DECL_CONSDEACTIVE(x)
#define SCIP_DECL_CONSPRESOL(x)
#define SCIP_DECL_CONSENABLE(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_CONSEXITSOL(x)
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
struct SCIP_Eventhdlr SCIP_EVENTHDLR
#define SCIP_EVENTTYPE_BOUNDCHANGED
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_UBTIGHTENED
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_LBRELAXED
#define SCIP_EVENTTYPE_LBTIGHTENED
#define SCIP_EVENTTYPE_UBRELAXED
struct SCIP_HashMap SCIP_HASHMAP
struct SCIP_NlRow SCIP_NLROW
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_TRANSFORMING
enum SYM_Symtype SYM_SYMTYPE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED