65#define CONSHDLR_NAME "setppc"
66#define CONSHDLR_DESC "set partitioning / packing / covering constraints"
67#define CONSHDLR_SEPAPRIORITY +700000
68#define CONSHDLR_ENFOPRIORITY -700000
69#define CONSHDLR_CHECKPRIORITY -700000
70#define CONSHDLR_SEPAFREQ 0
71#define CONSHDLR_PROPFREQ 1
72#define CONSHDLR_EAGERFREQ 100
74#define CONSHDLR_MAXPREROUNDS -1
75#define CONSHDLR_DELAYSEPA FALSE
76#define CONSHDLR_DELAYPROP FALSE
77#define CONSHDLR_NEEDSCONS TRUE
79#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_ALWAYS
80#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
82#define LINCONSUPGD_PRIORITY +700000
83#define NONLINCONSUPGD_PRIORITY +700000
85#define EVENTHDLR_NAME "setppc"
86#define EVENTHDLR_DESC "bound change event handler for set partitioning / packing / covering constraints"
88#define CONFLICTHDLR_NAME "setppc"
89#define CONFLICTHDLR_DESC "conflict handler creating set covering constraints"
90#define CONFLICTHDLR_PRIORITY LINCONSUPGD_PRIORITY
92#define DEFAULT_PRESOLPAIRWISE TRUE
94#define HASHSIZE_SETPPCCONS 500
95#define DEFAULT_PRESOLUSEHASHING TRUE
96#define NMINCOMPARISONS 200000
97#define MINGAINPERNMINCOMPARISONS 1e-06
99#define DEFAULT_RANDSEED 3
104#define MINBRANCHWEIGHT 0.3
105#define MAXBRANCHWEIGHT 0.7
107#define DEFAULT_NPSEUDOBRANCHES 2
108#define DEFAULT_DUALPRESOLVING TRUE
110#define DEFAULT_CLIQUELIFTING FALSE
114#define DEFAULT_ADDVARIABLESASCLIQUES FALSE
117#define DEFAULT_CLIQUESHRINKING TRUE
128struct SCIP_ConshdlrData
135 SCIP_Longint nsetpart;
142 SCIP_Bool updatedsetppctype;
143 SCIP_Bool cliquelifting;
144 SCIP_Bool enablecliquelifting;
145 SCIP_Bool cliqueshrinking;
148 SCIP_Bool addvariablesascliques;
152 SCIP_Bool presolpairwise;
153 SCIP_Bool presolusehashing;
154 SCIP_Bool dualpresolving;
168 unsigned int setppctype:2;
169 unsigned int sorted:1;
170 unsigned int cliqueadded:1;
171 unsigned int validsignature:1;
172 unsigned int changed:1;
173 unsigned int varsdeleted:1;
174 unsigned int merged:1;
175 unsigned int presolpropagated:1;
176 unsigned int existmultaggr:1;
177 unsigned int catchevents:1;
320 switch( consdata->setppctype )
352 switch( consdata->setppctype )
390 (*conshdlrdata)->eventhdlr = eventhdlr;
391 (*conshdlrdata)->nsetpart = 0;
437 varuses = conshdlrdata->varuses;
511 for( v = 0; v < consdata->nvars; ++v )
531 for( v = 0; v < consdata->nvars; ++v )
549 assert(consdata->nvars <= consdata->varssize);
551 if( num > consdata->varssize )
579 (*consdata)->signature = 0;
580 (*consdata)->row =
NULL;
581 (*consdata)->nlrow =
NULL;
582 (*consdata)->existmultaggr =
FALSE;
583 (*consdata)->catchevents =
FALSE;
584 (*consdata)->nfixedzeros = 0;
585 (*consdata)->nfixedones = 0;
594#ifdef SCIP_DISABLED_CODE
606 for( v = 0; v <
nvars; ++v )
612 (*consdata)->nfixedones++;
614 (*consdata)->nfixedzeros++;
619 (*consdata)->varssize =
k;
620 (*consdata)->nvars =
k;
635 (*consdata)->varssize =
nvars;
636 (*consdata)->nvars =
nvars;
645 for( v = 0; v < (*consdata)->nvars; v++ )
656 for( v = 0; v < (*consdata)->nvars; v++ )
665 (*consdata)->vars =
NULL;
666 (*consdata)->varssize = 0;
667 (*consdata)->nvars = 0;
669 (*consdata)->setppctype = setppctype;
670 (*consdata)->sorted = (
nvars <= 1);
671 (*consdata)->cliqueadded =
FALSE;
672 (*consdata)->validsignature =
FALSE;
673 (*consdata)->changed =
TRUE;
674 (*consdata)->varsdeleted =
FALSE;
675 (*consdata)->merged =
FALSE;
676 (*consdata)->presolpropagated =
FALSE;
716 if( (*consdata)->row !=
NULL )
722 if( (*consdata)->nlrow !=
NULL )
728 for( v = 0; v < (*consdata)->nvars; v++ )
751 if( consdata->nvars == 0 )
758 switch( consdata->setppctype )
785 if( !consdata->validsignature )
789 consdata->signature = 0;
790 for(
i = 0;
i < consdata->nvars; ++
i )
792 consdata->validsignature =
TRUE;
795 return consdata->signature;
806 if( !consdata->sorted )
808 if( consdata->nvars <= 1 )
809 consdata->sorted =
TRUE;
813 consdata->sorted =
TRUE;
822 for( v = 0; v < consdata->nvars; ++v )
859 for(
i = 0;
i < consdata->nvars; ++
i )
874 ++(conshdlrdata->nsetpart);
875 assert(conshdlrdata->nsetpart >= 0);
879 --(conshdlrdata->nsetpart);
880 assert(conshdlrdata->nsetpart >= 0);
885 consdata->setppctype = setppctype;
890 for(
i = 0;
i < consdata->nvars; ++
i )
898 conshdlrdata->updatedsetppctype =
TRUE;
922 var = consdata->vars[pos];
945 consdata->nfixedzeros++;
950 consdata->presolpropagated =
FALSE;
953 if( consdata->nfixedzeros >= consdata->nvars - 1 )
961 consdata->nfixedones++;
965 consdata->presolpropagated =
FALSE;
992 var = consdata->vars[pos];
1002 consdata->nfixedzeros--;
1004 consdata->nfixedones--;
1023 if( consdata->catchevents ==
TRUE )
1027 for(
i = 0;
i < consdata->nvars; ++
i )
1032 consdata->catchevents =
TRUE;
1051 if( consdata->catchevents ==
FALSE )
1055 for(
i = 0;
i < consdata->nvars; ++
i )
1060 consdata->catchevents =
FALSE;
1074 SCIP_Bool transformed;
1093 consdata->vars[consdata->nvars] =
var;
1095 if( consdata->validsignature )
1097 consdata->sorted = (consdata->nvars == 1);
1098 consdata->changed =
TRUE;
1117 if( consdata->catchevents )
1123 consdata->existmultaggr =
TRUE;
1138 if( consdata->row !=
NULL )
1143 consdata->merged =
FALSE;
1144 consdata->cliqueadded =
FALSE;
1167 var = consdata->vars[pos];
1187 if( consdata->catchevents )
1193 if( consdata->nvars == 1 )
1195 consdata->presolpropagated =
FALSE;
1200 if( consdata->row !=
NULL )
1206 if( pos != consdata->nvars - 1 )
1208 consdata->vars[pos] = consdata->vars[consdata->nvars-1];
1209 consdata->sorted =
FALSE;
1212 consdata->validsignature =
FALSE;
1213 consdata->changed =
TRUE;
1293 SCIP_Bool infeasible;
1329 assert(consdata->nfixedones == 0);
1330 assert(consdata->nfixedzeros == 0);
1332 nvars = consdata->nvars;
1341 vars = consdata->vars;
1346 switch( setppctype )
1371 for( v = 0; v <
nvars; ++v )
1426 for( v =
nvars - 1; v >= 0; --v )
1471 for( v =
nvars - 1; v >= 0; --v )
1603 if( consdata->nvars <= 1 )
1605 consdata->merged =
TRUE;
1609 assert(consdata->vars !=
NULL || consdata->nvars == 0);
1614 consdata->sorted =
FALSE;
1617 for( v = consdata->nvars - 1; v > 0; --v )
1627 var1 = consdata->vars[v];
1637 var2 = consdata->vars[v-1];
1649 SCIP_Bool infeasible;
1663 for(
i = consdata->nvars - 1;
i >= 0; --
i )
1664 if(
i != v &&
i != (v-1) )
1669 SCIPdebugMsg(
scip,
"setppc constraint <%s>: infeasible fixing <%s> == 0\n",
1696 SCIPdebugMsg(
scip,
"setppc constraint <%s>: infeasible fixing <%s> == %g\n",
1712 consdata->changed =
TRUE;
1715 consdata->merged =
TRUE;
1749 consdata->existmultaggr =
FALSE;
1756 var = consdata->vars[v];
1777 SCIP_Real constant = 0.0;
1806 for(
v2 = nconsvars - 1;
v2 >= 0; --
v2 )
1821 for(
v2 = consdata->nvars - 1;
v2 > v; --
v2 )
1828 if(
v2 == v && nconsvars == 0 )
1833 if( nfixedvars !=
NULL )
1839 for(
v2 = consdata->nvars - 1;
v2 >= 0; --
v2 )
1841 if( consdata->vars[
v2] !=
var )
1849 SCIPdebugMsg(
scip,
"setppc constraint <%s>: infeasible fixing <%s> == 0\n",
1885 for(
v2 = nconsvars - 1;
v2 >= 0; --
v2 )
1907 size =
MAX(nconsvars, 1) + consdata->nvars - 1;
1913 nconsvars = consdata->nvars;
1916 for(
k = consdata->nvars - 1;
k >= 0; --
k )
1918 consvars[
k] = consdata->vars[
k];
1941 rhs = 1.0 - constant;
1945 lhs = 1.0 - constant;
1946 rhs = 1.0 - constant;
1951 lhs = 1.0 - constant;
1973 if( ndelconss !=
NULL && naddconss !=
NULL )
2020 consdata->existmultaggr =
FALSE;
2049 for( v = 0; v < consdata->nvars; ++v )
2086 for( v = 0; v < consdata->nvars && n < 2; ++v )
2132 assert(consdata->nvars == 0 || consdata->vars !=
NULL);
2133 assert(0 <= consdata->nfixedzeros && consdata->nfixedzeros <= consdata->nvars);
2134 assert(0 <= consdata->nfixedones && consdata->nfixedones <= consdata->nvars);
2142 if( consdata->nfixedones == 1 )
2155 if( consdata->nfixedzeros < consdata->nvars - 1 )
2162 SCIP_Bool infeasible;
2163 SCIP_Bool tightened;
2168 SCIPdebugMsg(
scip,
" -> fixing all other variables to zero in set packing/partitioning constraint <%s>\n",
2175 vars = consdata->vars;
2176 nvars = consdata->nvars;
2180 for( v = 0; v <
nvars && consdata->nfixedones == 1; ++v )
2220 if( consdata->nfixedones >= 2 )
2244 else if( consdata->nfixedzeros == consdata->nvars )
2252 assert(consdata->nfixedones == 0);
2279 else if( consdata->nfixedzeros == consdata->nvars - 1 && consdata->nfixedones == 0 )
2300 SCIP_Bool infeasible;
2301 SCIP_Bool tightened;
2306 vars = consdata->vars;
2307 nvars = consdata->nvars;
2308 for( v = 0; v <
nvars; ++v )
2315 SCIPdebugMsg(
scip,
" -> fixing remaining variable <%s> to one in set covering/partitioning constraint <%s>\n",
2326 assert(consdata->nfixedzeros == consdata->nvars - 1);
2327 assert(consdata->nfixedones == 1);
2333 assert(consdata->nfixedzeros + consdata->nfixedones <= consdata->nvars);
2357 vars = consdata->vars;
2358 nvars = consdata->nvars;
2373 switch( consdata->setppctype )
2418 switch( consdata->setppctype )
2461 if( consdata->row ==
NULL )
2496 if( consdata->nlrow ==
NULL )
2503 for(
i = 0;
i < consdata->nvars; ++
i )
2570 assert(consdata->nvars == 0 || consdata->vars !=
NULL);
2571 assert(0 <= consdata->nfixedzeros && consdata->nfixedzeros <= consdata->nvars);
2572 assert(0 <= consdata->nfixedones && consdata->nfixedones <= consdata->nvars);
2635 SCIP_Bool* infeasible,
2758 assert(consdata->nvars > 0);
2766 assert(minidx >= 0 && minidx <= maxidx);
2777 int*
const cliquepartition,
2782 int*
const nfixedvars,
2783 int*
const naddconss,
2784 int*
const ndelconss,
2785 int*
const nchgcoefs,
2809 if(
nbinvars == 0 || ncliques == 0 )
2822 for(
c = 0;
c < ncliques - 1; ++
c )
2837 if( cliquepartition[
c] == cliquepartition[v] )
2899 int*
const nfixedvars,
2900 int*
const ndelconss,
2901 int*
const nchgcoefs,
2926 for(
c = nconss - 1;
c >= 0; --
c )
2962 assert(consdata->nfixedones == 0);
2964 if( consdata->nvars == 0 )
3030 assert(consdata->merged);
3033 if( consdata->nvars > *maxnvars )
3034 *maxnvars = consdata->nvars;
3037 for( v = consdata->nvars - 1; v >= 0; --v )
3041 var = consdata->vars[v];
3104 SCIP_Bool found =
FALSE;
3207 SCIP_Bool
const aggregate,
3216 int*
const naggregations,
3223 int*
const nfixedvars,
3224 int*
const naggrvars,
3225 int*
const ndelconss,
3248 if( consdata->presolpropagated )
3251 consdata->presolpropagated =
TRUE;
3253 vars = consdata->vars;
3254 nvars = consdata->nvars;
3280 if( consdata->nfixedones > 1 )
3296 SCIPdebugMsg(
scip,
"set partitioning / packing constraint <%s> is infeasible, %d variables fixed to one\n",
SCIPconsGetName(cons), consdata->nfixedones);
3302 if( consdata->nfixedones == 1 )
3312 for( v =
nvars - 1; v >= 0; --v )
3322 SCIPdebugMsg(
scip,
"setppc constraint <%s>: infeasible fixing <%s> == 0\n",
3353 if( consdata->nfixedzeros ==
nvars )
3355 assert(consdata->nfixedones == 0);
3379 if( consdata->nfixedzeros + 1 ==
nvars )
3381 assert(consdata->nfixedones == 0);
3391 for( v =
nvars - 1; v >= 0; --v )
3402 SCIPdebugMsg(
scip,
"setppc constraint <%s>: infeasible fixing <%s> == 1\n",
3433 for( v =
nvars - 1; v >= 0; --v )
3443 SCIP_Bool redundant;
3471 SCIPdebugMsg(
scip,
"set partitioning constraint <%s>: aggregate <%s> + <%s> == 1\n",
3572 int*
const naggregations,
3577 int*
const nfixedvars,
3578 int*
const naggrvars,
3579 int*
const nchgcoefs,
3580 int*
const ndelconss,
3627 nvars = consdata->nvars;
3632 vars = consdata->vars;
3659 SCIP_CALL(
presolvePropagateCons(
scip,
cons1,
FALSE,
undoneaggrvars,
undoneaggrtypes, naggregations,
saggregations, nfixedvars, naggrvars, ndelconss,
cutoff) );
3699 assert(consdata->merged);
3794 for( ;
v1 >= 0; --
v1)
3865 assert(consdata->merged);
4038 assert(consdata->merged);
4142 for( ;
v1 >= 0; --
v1)
4226 assert(consdata->merged);
4343 SCIP_CALL(
presolvePropagateCons(
scip,
constostay,
FALSE,
NULL,
NULL,
NULL,
NULL, nfixedvars, naggrvars, ndelconss,
cutoff) );
4435 int*
const nfixedvars,
4436 int*
const ndelconss,
4474 nvars = consdata->nvars;
4481 vars = consdata->vars;
4487 for( v =
nvars - 1; v >= 0 &&
v1 >= 0; )
4515 assert(consdata->merged);
4640 assert(consdata->merged);
4643 for(
k = consdata->nvars - 1;
k >= 0; --
k )
4690 SCIPdebugMsg(
scip,
" -> deleting constraint <%s> number <%d> due to active and negated variable in the same clique constraint\n",
SCIPconsGetName(cons), arraypos);
4731 consdata->merged =
TRUE;
4743 vars = consdata->vars;
4744 nvars = consdata->nvars;
4749 if( (*maxnvars) <
nvars )
4751 while( (*maxnvars) <
nvars )
4766 for( ;
v1 >= 0; --
v1)
4850 consdata->merged =
TRUE;
4862 vars = consdata->vars;
4863 nvars = consdata->nvars;
4868 if( (*maxnvars) <
nvars )
4870 while( (*maxnvars) <
nvars )
4894 int const naggregations,
4895 int*
const naggrvars,
4902 SCIP_Bool redundant;
4909 assert(naggregations > 0);
4914 for(
a = 0;
a < naggregations; ++
a )
4977 int*
const nfixedvars,
4978 int*
const naggrvars,
4979 int*
const ndelconss,
4980 int*
const nchgcoefs,
5062 if( conshdlrdata->nclqpresolve == 0 && conshdlrdata->addvariablesascliques )
5066 int* cliquepartition;
5093 nrounds, nfixedvars, &naddconss, ndelconss, nchgcoefs,
cutoff) );
5098 *ndelconss -= naddconss;
5164 SCIP_CALL(
presolvePropagateCons(
scip,
cons0,
FALSE,
undoneaggrvars,
undoneaggrtypes, &naggregations, &
saggregations, nfixedvars, naggrvars, ndelconss,
cutoff) );
5185 consdata->sorted =
FALSE;
5218 nfixedvars, naggrvars, nchgcoefs, ndelconss,
cutoff) );
5238 consdata->sorted =
FALSE;
5242 if( consdata->nfixedones > 0 || consdata->nfixedzeros >
cons0fixedzeros )
5247 SCIP_CALL(
presolvePropagateCons(
scip,
cons0,
FALSE,
undoneaggrvars,
undoneaggrtypes, &naggregations, &
saggregations, nfixedvars, naggrvars, ndelconss,
cutoff) );
5274 if( conshdlrdata->nclqpresolve > 0 )
5332 consdata->sorted =
FALSE;
5359 nfixedvars, naggrvars, nchgcoefs, ndelconss,
cutoff) );
5403 if( *ndelconss < 0 )
5426 SCIP_Bool infeasible;
5458 if( !consdata->cliqueadded && consdata->nvars >= 2 )
5486 consdata->cliqueadded =
TRUE;
5501 SCIP_Bool* infeasible,
5518 SCIP_Bool redundant;
5531 *infeasible =
FALSE;
5536 if( pos ==
nvars - 1 )
5542 tmpvars[pos] = tmpvars[
nvars - 1];
5547 for( v =
nvars - 2; v >= 0; --v )
5550 SCIPdebugMsg(
scip,
"multi-aggregating binary variable <%s> (locks: [%d,%d]; to %d variables)\n",
5560 if( pos <
nvars - 1 )
5621 SCIP_Bool infeasible;
5623 SCIP_Bool donotaggr;
5624 SCIP_Bool donotmultaggr;
5667 if( (nuplocks == 1 && ndownlocks <= 1) || (nuplocks <= 1 && ndownlocks == 1) || (nuplocks <= 2 && ndownlocks <= 2 &&
SCIPvarGetNegatedVar(binvars[v]) !=
NULL) )
5695 assert(!donotaggr || !donotmultaggr);
5703 for(
c = 0;
c < nconss; ++
c )
5772 if( consdata->nvars < 2 )
5790 if( consdata->nvars == 0 )
5822 SCIP_Bool redundant;
5824 var = consdata->vars[0];
5832 if( nuplocks == 1 &&
objval <= 0 )
5856 var = consdata->vars[1];
5864 if( nuplocks == 1 &&
objval <= 0 )
5890 SCIP_Bool redundant;
5925 for( v = consdata->nvars - 1; v >= 0; --v )
5932 var = consdata->vars[v];
5940 assert(nuplocks >= 1 && ndownlocks >= 0);
5944 assert(nuplocks == 1 && ndownlocks <= 1);
5947 if( ndownlocks == 0 )
6018 assert(0 <= consindex && consindex < nconss);
6203 assert(0 <= consindex && consindex < nconss);
6259 SCIPdebugMsg(
scip,
"multi-aggregating in one set-partitioning or one set-packing constraint\n");
6285 SCIPdebugMsg(
scip,
"multi-aggregating in two set-partitioning or one set-partitioning and -packing constraint\n");
6304 assert(nuplocks >= 1 && ndownlocks >= 0);
6398 hashtablesize = nconss;
6404 for(
c = 0;
c < nconss; ++
c )
6438 SCIPdebugMsg(
scip,
"setppc constraints <%s> and <%s> have identical variable sets\n",
6489 SCIPdebugMsg(
scip,
" -> removing setppc constraint <%s> which is redundant to <%s>\n",
6808 SCIPdebugMsg(
scip,
"setppc constraints <%s> and <%s> have identical variable sets\n",
6884 for(
i = 0;
i < nconss;
i++ )
6889 if( consdata->varsdeleted )
6892 for( v = consdata->nvars - 1; v >= 0; v-- )
6899 consdata->varsdeleted =
FALSE;
6928 SCIPdebugMsg(
scip,
"Enforcing %d set partitioning / packing / covering constraints for %s solution\n", nconss,
6929 sol ==
NULL ?
"LP" :
"relaxation");
6999 SCIP_Bool modifiable,
7005 SCIP_Bool removable,
7007 SCIP_Bool stickingatnode
7020 if( conshdlr ==
NULL )
7022 SCIPerrorMessage(
"set partitioning / packing / covering constraint handler not found\n");
7039 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
7040 local, modifiable, dynamic, removable, stickingatnode) );
7047 ++(conshdlrdata->nsetpart);
7048 assert(conshdlrdata->nsetpart >= 0);
7086 SCIP_Bool modifiable,
7092 SCIP_Bool removable,
7094 SCIP_Bool stickingatnode
7110 for( v = 0; v <
nvars; ++v )
7112 if(
mult * vals[v] > 0.0 )
7123 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
7229 int nbilinexprterms;
7246 if( nvarexprs != 2 )
7272 if( nbilinexprterms != 1 )
7276 if( nquadexprs != 2 )
7293 coefx = lincoef + sqrcoef;
7296 coefy = lincoef + sqrcoef;
7407 conshdlrdata->noldfixedvars = 0;
7408 conshdlrdata->noldimpls = 0;
7409 conshdlrdata->noldcliques = 0;
7410 conshdlrdata->noldupgrs = 0;
7411 conshdlrdata->nclqpresolve = 0;
7412 conshdlrdata->updatedsetppctype =
FALSE;
7413 conshdlrdata->enablecliquelifting =
TRUE;
7428 for(
c = 0;
c < nconss; ++
c )
7448 for(
c = 0;
c < nconss; ++
c )
7465 for(
c = 0;
c < nconss; ++
c )
7470 if( consdata->row !=
NULL )
7475 if( consdata->nlrow !=
NULL )
7503 --(conshdlrdata->nsetpart);
7504 assert(conshdlrdata->nsetpart >= 0);
7559 ++(conshdlrdata->nsetpart);
7560 assert(conshdlrdata->nsetpart >= 0);
7576 *infeasible =
FALSE;
7578 for(
c = 0;
c < nconss && !(*infeasible); ++
c )
7689 SCIP_Real branchweight;
7707 varuses = conshdlrdata->varuses;
7762 branchweight += solval;
7782 branchweight -= solval;
7874 if( conshdlrdata->npseudobranches <= 1 )
7879 if( npseudocands == 0 )
7882 varuses = conshdlrdata->varuses;
7895 for(
i = 0;
i < npseudocands; ++
i )
7948 for(
j = 0;
j <
i; ++
j )
7969 SCIPdebugMsg(
scip,
"branched on pseudo solution: %d children\n", nchildren);
8008 SCIP_Bool infeasible;
8028 SCIPdebugMsg(
scip,
"pseudo enforcing %d set partitioning / packing / covering constraints\n", nconss);
8049 else if( infeasible )
8095 SCIP_Real sum = 0.0;
8100 for( v = 0; v < consdata->nvars; ++v )
8150 int naddconss, ndelconss;
8155 naddconss = ndelconss = 0;
8173 else if( nfixedvars > 0 )
8212 conshdlrdata->enablecliquelifting = conshdlrdata->enablecliquelifting || conshdlrdata->updatedsetppctype
8214 || conshdlrdata->noldcliques !=
SCIPgetNCliques(
scip) || conshdlrdata->noldupgrs != nconss;
8220 conshdlrdata->updatedsetppctype =
FALSE;
8277 if( consdata->nfixedzeros > 0 )
8294 SCIP_CALL(
presolvePropagateCons(
scip, cons,
TRUE,
NULL,
NULL,
NULL,
NULL, nfixedvars, naggrvars, ndelconss, &
cutoff) );
8307 if( consdata->nfixedzeros > 0 )
8336 if( !consdata->cliqueadded && consdata->nvars >= 2 )
8366 naggrvars, ndelconss, nchgcoefs, nchgsides, &
cutoff) );
8395 ++(conshdlrdata->nclqpresolve);
8406 conshdlrdata->noldfixedvars = *nfixedvars + *naggrvars;
8408 conshdlrdata->enablecliquelifting =
FALSE;
8414 if( conshdlrdata->presolpairwise )
8457 conshdlrdata->noldupgrs = nconss - (*ndelconss -
startdelconss);
8479 SCIPdebugMsg(
scip,
"conflict resolving method of set partitioning / packing / covering constraint handler\n");
8495 for( v = 0; v < consdata->nvars; ++v )
8497 if( consdata->vars[v] !=
infervar )
8520 if( inferinfo >= 0 )
8527 for( v = 0; v < consdata->nvars; ++v )
8557 switch( consdata->setppctype )
8560 nlocksdown = nlockspos + nlocksneg;
8561 nlocksup = nlockspos + nlocksneg;
8564 nlocksdown = nlocksneg;
8565 nlocksup = nlockspos;
8568 nlocksdown = nlockspos;
8569 nlocksup = nlocksneg;
8576 for(
i = 0;
i < consdata->nvars; ++
i )
8593 SCIPdebugMsg(
scip,
"activation information for set partitioning / packing / covering constraint <%s>\n",
8602 if( consdata->nfixedones >= 1 || consdata->nfixedzeros >= consdata->nvars - 1 )
8631 SCIPdebugMsg(
scip,
"deactivation information for set partitioning / packing / covering constraint <%s>\n",
8706 const char* consname;
8745 lhs, rhs, varmap, consmap,
8746 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
valid) );
8822 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
8826 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
8830 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
8876 (*nvars) = consdata->nvars;
8911 consdata->nfixedones++;
8914 consdata->nfixedones--;
8917 consdata->nfixedzeros++;
8920 consdata->nfixedzeros--;
8923 consdata->varsdeleted =
TRUE;
8926 if( consdata->merged )
8936 consdata->merged =
FALSE;
8939 if( !consdata->existmultaggr )
8945 consdata->existmultaggr =
TRUE;
8952 assert(0 <= consdata->nfixedzeros && consdata->nfixedzeros <= consdata->nvars);
8953 assert(0 <= consdata->nfixedones && consdata->nfixedones <= consdata->nvars);
8957 if( consdata->nfixedones >= 1 || consdata->nfixedzeros >= consdata->nvars - 1 )
8959 consdata->presolpropagated =
FALSE;
8964 consdata->presolpropagated =
FALSE;
8990 assert(bdchginfos !=
NULL || nbdchginfos == 0);
9003 if( nbdchginfos == 2 )
9043 SCIP_Bool infeasible;
9052 SCIPdebugMsg(
scip,
"new clique of conflict constraint %s led to infeasibility\n", consname);
9066 for(
i = 0;
i < nbdchginfos; ++
i )
9083 if(
i == nbdchginfos )
9165 if( conshdlrdata->conshdlrlinear !=
NULL )
9179 "number of children created in pseudo branching (0: disable pseudo branching)",
9183 "should pairwise constraint comparison be performed in presolving?",
9187 "should hash table be used for detecting redundant constraints in advance",
9191 "should dual presolving steps be performed?",
9195 " should we try to lift variables into other clique constraints, fix variables, aggregate them, and also shrink the amount of variables in clique constraints",
9199 "should we try to generate extra cliques out of all binary variables to maybe fasten redundant constraint detection",
9203 "should we try to shrink the number of variables in a clique constraints, by replacing more than one variable by only one",
9231 SCIP_Bool modifiable,
9237 SCIP_Bool removable,
9239 SCIP_Bool stickingatnode
9245 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode);
9289 SCIP_Bool modifiable,
9295 SCIP_Bool removable,
9297 SCIP_Bool stickingatnode
9303 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode);
9347 SCIP_Bool modifiable,
9353 SCIP_Bool removable,
9355 SCIP_Bool stickingatnode
9361 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode);
9397 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9418 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9426 return consdata->nvars;
9441 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9449 return consdata->vars;
9464 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9486 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9494 if( consdata->row !=
NULL )
9512 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9520 if( consdata->row !=
NULL )
9540 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9548 return consdata->row;
9563 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9571 return consdata->nfixedones;
9587 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9595 return consdata->nfixedzeros;
9602 SCIP_Bool* infeasible,
9615 if( conshdlr ==
NULL )
9622 *infeasible =
FALSE;
9628 for(
i = nconss - 1;
i > 0; --
i )
Constraint handler for linear constraints in their most general form, .
constraint handler for nonlinear constraints specified by algebraic expressions
static int setppcCompare(SCIP_CONS *const cons1, SCIP_CONS *const cons2)
static SCIP_RETCODE collectCliqueConss(SCIP *const scip, SCIP_CONS **const conss, int const nconss, SCIP_CONS **const usefulconss, int *const nusefulconss, int *const nfixedvars, int *const ndelconss, int *const nchgcoefs, SCIP_Bool *const cutoff)
static SCIP_RETCODE conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)
static SCIP_RETCODE addCoef(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
static SCIP_RETCODE consdataPrint(SCIP *scip, SCIP_CONSDATA *consdata, FILE *file)
#define DEFAULT_DUALPRESOLVING
static SCIP_RETCODE dropEvent(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONFLICTHDLR_PRIORITY
#define CONFLICTHDLR_NAME
static SCIP_RETCODE addCut(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff)
#define CONSHDLR_CHECKPRIORITY
static SCIP_RETCODE mergeMultiples(SCIP *scip, SCIP_CONS *cons, int *nfixedvars, int *ndelconss, int *nchgcoefs, SCIP_Bool *cutoff)
static SCIP_RETCODE liftCliqueVariables(SCIP *const scip, SCIP_CONS *const cons, int const arraypos, SCIP_VAR **const usefulvars, int *const nusefulvars, int const endidx, SCIP_Bool **cliquevalues, SCIP_HASHMAP *const vartoindex, int *const varnconss, int *const maxnvarconsidx, int **const varconsidxs, int *const maxnvars, int *const nadded, SCIP_Bool *const chgcons, int *const nfixedvars, int *const ndelconss, SCIP_Bool *const cutoff)
static SCIP_RETCODE createConsSetppc(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_SETPPCTYPE setppctype, 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)
static SCIP_RETCODE createRow(SCIP *scip, SCIP_CONS *cons)
#define DEFAULT_NPSEUDOBRANCHES
#define CONSHDLR_PROP_TIMING
#define HASHSIZE_SETPPCCONS
#define CONFLICTHDLR_DESC
static SCIP_RETCODE unlockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
static SCIP_RETCODE createNormalizedSetppc(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, int mult, SCIP_SETPPCTYPE setppctype, 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)
static SCIP_RETCODE addCliqueDataEntry(SCIP *const scip, SCIP_VAR *const addvar, int const considx, SCIP_Bool const maybenew, SCIP_VAR **const usefulvars, int *const nusefulvars, SCIP_HASHMAP *const vartoindex, int *const varnconss, int *const maxnvarconsidx, int **const varconsidxs)
static SCIP_RETCODE addExtraCliques(SCIP *const scip, SCIP_VAR **const binvars, int const nbinvars, int *const cliquepartition, int const ncliques, SCIP_CONS **const usefulconss, int *const nusefulconss, int const nrounds, int *const nfixedvars, int *const naddconss, int *const ndelconss, int *const nchgcoefs, SCIP_Bool *const cutoff)
#define CONSHDLR_MAXPREROUNDS
static SCIP_RETCODE performAggregations(SCIP *const scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR **const undoneaggrvars, SCIP_Bool *const undoneaggrtypes, int const naggregations, int *const naggrvars, SCIP_Bool *const cutoff)
#define DEFAULT_PRESOLPAIRWISE
static SCIP_RETCODE performVarDeletions(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
#define CONSHDLR_SEPAPRIORITY
static SCIP_Bool checkCons(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol)
static SCIP_RETCODE consdataCreateTransformed(SCIP *scip, SCIP_CONSDATA **consdata, int nvars, SCIP_VAR **vars, SCIP_SETPPCTYPE setppctype)
#define DEFAULT_CLIQUELIFTING
static SCIP_RETCODE setSetppcType(SCIP *scip, SCIP_CONS *cons, SCIP_SETPPCTYPE setppctype)
static SCIP_RETCODE analyzeConflictOne(SCIP *scip, SCIP_CONS *cons)
static int setppcCompare2(SCIP_CONS *const cons1, SCIP_CONS *const cons2)
static SCIP_RETCODE collectCliqueData(SCIP *const scip, SCIP_CONS **const usefulconss, int const nusefulconss, SCIP_VAR **const usefulvars, int *const nusefulvars, SCIP_HASHMAP *const vartoindex, int *const varnconss, int *const maxnvarconsidx, int **const varconsidxs, int *const maxnvars)
static SCIP_RETCODE lockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
static SCIP_RETCODE preprocessCliques(SCIP *const scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS **const conss, int const nconss, int const nrounds, int *const firstchange, int *const firstclique, int *const lastclique, int *const nfixedvars, int *const naggrvars, int *const ndelconss, int *const nchgcoefs, SCIP_Bool *const cutoff)
static SCIP_RETCODE consdataEnsureVarsSize(SCIP *scip, SCIP_CONSDATA *consdata, int num)
#define DEFAULT_ADDVARIABLESASCLIQUES
#define NONLINCONSUPGD_PRIORITY
static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool lpfeas, SCIP_Bool *cutoff, SCIP_Bool *separated, SCIP_Bool *reduceddom)
static SCIP_RETCODE applyFixings(SCIP *scip, SCIP_CONS *cons, int *naddconss, int *ndelconss, int *nfixedvars, SCIP_Bool *cutoff)
static SCIP_RETCODE removeDoubleAndSingletonsAndPerformDualpresolve(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool dualpresolvingenabled, SCIP_Bool linearconshdlrexist, int *nfixedvars, int *naggrvars, int *ndelconss, int *nchgcoefs, int *nchgsides, SCIP_Bool *cutoff)
#define DEFAULT_PRESOLUSEHASHING
static void deleteCliqueDataEntry(SCIP_VAR *const var, int const considx, SCIP_HASHMAP *const vartoindex, int *const varnconss, int **const varconsidxs)
static uint64_t consdataGetSignature(SCIP_CONSDATA *consdata)
static SCIP_RETCODE delCoefPos(SCIP *scip, SCIP_CONS *cons, int pos)
#define MINGAINPERNMINCOMPARISONS
static SCIP_RETCODE analyzeConflictZero(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE multiAggregateBinvar(SCIP *scip, SCIP_Bool linearconshdlrexist, SCIP_VAR **vars, int nvars, int pos, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
static SCIP_RETCODE dualPresolving(SCIP *scip, SCIP_CONS *cons, int *nfixedvars, int *ndelconss, SCIP_RESULT *result)
#define CONSHDLR_PROPFREQ
#define CONSHDLR_PRESOLTIMING
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)
#define CONSHDLR_EAGERFREQ
static SCIP_RETCODE enforcePseudo(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, SCIP_Bool *infeasible, SCIP_Bool *reduceddom, SCIP_Bool *solvelp)
static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE checkForOverlapping(SCIP *const scip, SCIP_CONS *const cons, int const considx, int const endidx, SCIP_CONS **const usefulconss, int const nusefulconss, SCIP_VAR **const usefulvars, int *const nusefulvars, SCIP_HASHMAP *const vartoindex, int *const varnconss, int *const maxnvarconsidx, int **const varconsidxs, int *const countofoverlapping, SCIP_Bool const shrinking, SCIP_Bool *const chgcons, SCIP_VAR **undoneaggrvars, SCIP_Bool *undoneaggrtypes, int *const naggregations, int *const saggregations, int *const nfixedvars, int *const naggrvars, int *const nchgcoefs, int *const ndelconss, SCIP_Bool *const cutoff)
static SCIP_RETCODE processFixings(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, SCIP_Bool *addcut, SCIP_Bool *mustcheck)
#define CONSHDLR_ENFOPRIORITY
static SCIP_RETCODE processContainedCons(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1, SCIP_Bool *cutoff, int *nfixedvars, int *ndelconss, int *nchgsides)
static SCIP_RETCODE dropAllEvents(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)
#define DEFAULT_CLIQUESHRINKING
static SCIP_RETCODE catchAllEvents(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)
#define LINCONSUPGD_PRIORITY
#define CONSHDLR_DELAYSEPA
static SCIP_RETCODE detectRedundantConstraints(SCIP *scip, BMS_BLKMEM *blkmem, SCIP_CONS **conss, int nconss, int *firstchange, int *ndelconss, int *nchgsides)
static SCIP_RETCODE addCliques(SCIP *scip, SCIP_CONS **conss, int nconss, int firstclique, int lastclique, int *naddconss, int *ndelconss, int *nchgbds, SCIP_Bool *cutoff)
static SCIP_RETCODE removeRedundantCons(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1, int *ndelconss)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, int nvars, SCIP_VAR **vars, SCIP_SETPPCTYPE setppctype)
static SCIP_RETCODE fixAdditionalVars(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1, SCIP_Bool *cutoff, int *nfixedvars)
static SCIP_RETCODE presolvePropagateCons(SCIP *const scip, SCIP_CONS *const cons, SCIP_Bool const aggregate, SCIP_VAR **undoneaggrvars, SCIP_Bool *undoneaggrtypes, int *const naggregations, int *const saggregations, int *const nfixedvars, int *const naggrvars, int *const ndelconss, SCIP_Bool *const cutoff)
#define CONSHDLR_DELAYPROP
static SCIP_RETCODE catchEvent(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)
static SCIP_RETCODE removeRedundantConstraints(SCIP *scip, SCIP_CONS **conss, int firstchange, int chkind, SCIP_Bool *cutoff, int *nfixedvars, int *ndelconss, int *nchgsides)
Constraint handler for the set partitioning / packing / covering constraints .
SCIP_RETCODE SCIPcheckQuadraticNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *isquadratic)
SCIP_RETCODE SCIPincludeLinconsUpgrade(SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)
#define SCIP_DECL_NONLINCONSUPGD(x)
SCIP_RETCODE SCIPcleanupConssSetppc(SCIP *scip, SCIP_Bool onlychecked, SCIP_Bool *infeasible, int *naddconss, int *ndelconss, int *nchgcoefs, int *nfixedvars)
SCIP_RETCODE SCIPcreateConsBasicSetpart(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars)
SCIP_RETCODE SCIPincludeConsUpgradeNonlinear(SCIP *scip, SCIP_DECL_NONLINCONSUPGD((*nlconsupgd)), int priority, SCIP_Bool active, const char *conshdlrname)
int SCIPgetNFixedzerosSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_ROW * SCIPgetRowSetppc(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsSetpack(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_VAR ** SCIPgetVarsSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_EXPR * SCIPgetExprNonlinear(SCIP_CONS *cons)
int SCIPgetNFixedonesSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetRhsNonlinear(SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBasicSetcover(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars)
SCIP_RETCODE SCIPaddCoefSetppc(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
enum SCIP_SetppcType SCIP_SETPPCTYPE
#define SCIP_DECL_LINCONSUPGD(x)
SCIP_RETCODE SCIPcopyConsLinear(SCIP *scip, SCIP_CONS **cons, SCIP *sourcescip, const char *name, int nvars, SCIP_VAR **sourcevars, SCIP_Real *sourcecoefs, SCIP_Real lhs, SCIP_Real rhs, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, 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 global, SCIP_Bool *valid)
SCIP_SETPPCTYPE SCIPgetTypeSetppc(SCIP *scip, SCIP_CONS *cons)
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 SCIPcreateConsSetcover(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_Real SCIPgetLhsNonlinear(SCIP_CONS *cons)
SCIP_Real SCIPgetDualsolSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBasicSetpack(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars)
SCIP_Real SCIPgetDualfarkasSetppc(SCIP *scip, SCIP_CONS *cons)
@ SCIP_SETPPCTYPE_PARTITIONING
@ SCIP_SETPPCTYPE_COVERING
@ SCIP_SETPPCTYPE_PACKING
SCIP_RETCODE SCIPincludeConshdlrSetppc(SCIP *scip)
SCIP_Bool SCIPisConsCompressionEnabled(SCIP *scip)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNIntVars(SCIP *scip)
int SCIPgetNImplVars(SCIP *scip)
int SCIPgetNContVars(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
int SCIPgetNFixedVars(SCIP *scip)
int SCIPgetNBinVars(SCIP *scip)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)
SCIP_RETCODE SCIPhashmapRemove(SCIP_HASHMAP *hashmap, void *origin)
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
#define SCIPhashFour(a, b, c, d)
SCIP_RETCODE SCIPhashtableCreate(SCIP_HASHTABLE **hashtable, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)
void * SCIPhashtableRetrieve(SCIP_HASHTABLE *hashtable, void *key)
SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)
#define SCIPhashSignature64(a)
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
SCIP_RETCODE SCIPaddConflict(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
#define SCIPdebugMsgPrint
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int 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)
void SCIPrandomPermuteArray(SCIP_RANDNUMGEN *randnumgen, void **array, int begin, int end)
SCIP_Real SCIPcalcNodeselPriority(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdir, SCIP_Real targetvalue)
SCIP_Real SCIPcalcChildEstimate(SCIP *scip, SCIP_VAR *var, SCIP_Real targetvalue)
SCIP_RETCODE SCIPgetLPBranchCands(SCIP *scip, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)
SCIP_RETCODE SCIPgetPseudoBranchCands(SCIP *scip, SCIP_VAR ***pseudocands, int *npseudocands, int *npriopseudocands)
SCIP_RETCODE SCIPcreateChild(SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)
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 SCIPincludeConflicthdlrBasic(SCIP *scip, SCIP_CONFLICTHDLR **conflicthdlrptr, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONS ** SCIPconshdlrGetCheckConss(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 SCIPsetConshdlrInit(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)
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrDelvars(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)
int SCIPconsGetPos(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(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 SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLockedType(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_RETCODE SCIPunmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsAdded(SCIP_CONS *cons)
SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
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)
int SCIPgetIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx)
SCIP_RETCODE SCIPcreateIntarray(SCIP *scip, SCIP_INTARRAY **intarray)
SCIP_RETCODE SCIPincIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx, int incval)
SCIP_RETCODE SCIPfreeIntarray(SCIP *scip, SCIP_INTARRAY **intarray)
SCIP_RETCODE SCIPsetIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx, int val)
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_VAR * SCIPeventGetVar(SCIP_EVENT *event)
void SCIPexprGetQuadraticBilinTerm(SCIP_EXPR *expr, int termidx, SCIP_EXPR **expr1, SCIP_EXPR **expr2, SCIP_Real *coef, int *pos2, SCIP_EXPR **prodexpr)
void SCIPexprGetQuadraticData(SCIP_EXPR *expr, SCIP_Real *constant, int *nlinexprs, SCIP_EXPR ***linexprs, SCIP_Real **lincoefs, int *nquadexprs, int *nbilinexprs, SCIP_Real **eigenvalues, SCIP_Real **eigenvectors)
SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)
void SCIPexprGetQuadraticQuadTerm(SCIP_EXPR *quadexpr, int termidx, SCIP_EXPR **expr, SCIP_Real *lincoef, SCIP_Real *sqrcoef, int *nadjbilin, int **adjbilin, SCIP_EXPR **sqrexpr)
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#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 SCIPdelNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
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_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Real SCIProwGetDualfarkas(SCIP_ROW *row)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_Real SCIProwGetDualsol(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)
int SCIPgetNImplications(SCIP *scip)
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
int SCIPgetNRuns(SCIP *scip)
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPinfinity(SCIP *scip)
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_Real SCIPfeastol(SCIP *scip)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPgetChildren(SCIP *scip, SCIP_NODE ***children, int *nchildren)
int SCIPvarCompareActiveAndNegated(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
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 SCIPcalcCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
SCIP_RETCODE SCIPvarGetAggregatedObj(SCIP_VAR *var, SCIP_Real *aggrobj)
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 SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
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 SCIPmultiaggregateVar(SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Bool SCIPdoNotMultaggr(SCIP *scip)
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 SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_Bool SCIPhaveVarsCommonClique(SCIP *scip, SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
int SCIPgetNCliques(SCIP *scip)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)
SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
SCIP_RETCODE SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIP_Bool SCIPsortedvecFindDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
void SCIPsortedvecInsertDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int *len, int *pos)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPskipSpace(char **s)
SCIPfreeRandom(scip, &heurdata->randnumgen)
SCIPcreateRandom(scip, &heurdata->randnumgen, DEFAULT_RANDSEED, TRUE))
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
static const SCIP_Real scalars[]
memory allocation routines
#define BMScopyMemoryArray(ptr, source, num)
#define BMSclearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for conflict analysis handlers
public methods for managing constraints
public methods for managing events
public methods for LP management
public methods for message output
#define SCIPdebugPrintCons(x, y, z)
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 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 random numbers
public methods for solutions
public methods for querying solving statistics
public methods for SCIP variables
#define SCIP_DECL_CONFLICTEXEC(x)
@ 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_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_CONSINITLP(x)
#define SCIP_DECL_CONSEXITPRE(x)
#define SCIP_DECL_CONSLOCK(x)
#define SCIP_DECL_CONSCOPY(x)
#define SCIP_DECL_CONSINIT(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)
#define SCIP_DECL_CONSDELVARS(x)
#define SCIP_EVENTTYPE_BOUNDCHANGED
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_UBTIGHTENED
#define SCIP_EVENTTYPE_VARFIXED
#define SCIP_EVENTTYPE_VARDELETED
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_LBRELAXED
#define SCIP_EVENTTYPE_BOUNDTIGHTENED
#define SCIP_EVENTTYPE_LBTIGHTENED
#define SCIP_EVENTTYPE_UBRELAXED
@ SCIP_BRANCHDIR_DOWNWARDS
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_TRANSFORMING
#define SCIP_PRESOLTIMING_MEDIUM
#define SCIP_PRESOLTIMING_EXHAUSTIVE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR
enum SCIP_LockType SCIP_LOCKTYPE