68#define CONSHDLR_NAME "setppc"
69#define CONSHDLR_DESC "set partitioning / packing / covering constraints"
70#define CONSHDLR_SEPAPRIORITY +700000
71#define CONSHDLR_ENFOPRIORITY -700000
72#define CONSHDLR_CHECKPRIORITY -700000
73#define CONSHDLR_SEPAFREQ 0
74#define CONSHDLR_PROPFREQ 1
75#define CONSHDLR_EAGERFREQ 100
77#define CONSHDLR_MAXPREROUNDS -1
78#define CONSHDLR_DELAYSEPA FALSE
79#define CONSHDLR_DELAYPROP FALSE
80#define CONSHDLR_NEEDSCONS TRUE
82#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_ALWAYS
83#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
85#define LINCONSUPGD_PRIORITY +700000
86#define NONLINCONSUPGD_PRIORITY +700000
88#define EVENTHDLR_NAME "setppc"
89#define EVENTHDLR_DESC "bound change event handler for set partitioning / packing / covering constraints"
91#define CONFLICTHDLR_NAME "setppc"
92#define CONFLICTHDLR_DESC "conflict handler creating set covering constraints"
93#define CONFLICTHDLR_PRIORITY LINCONSUPGD_PRIORITY
95#define DEFAULT_PRESOLPAIRWISE TRUE
97#define HASHSIZE_SETPPCCONS 500
98#define DEFAULT_PRESOLUSEHASHING TRUE
99#define NMINCOMPARISONS 200000
100#define MINGAINPERNMINCOMPARISONS 1e-06
102#define DEFAULT_RANDSEED 3
107#define MINBRANCHWEIGHT 0.3
108#define MAXBRANCHWEIGHT 0.7
110#define DEFAULT_NPSEUDOBRANCHES 2
111#define DEFAULT_DUALPRESOLVING TRUE
113#define DEFAULT_CLIQUELIFTING FALSE
117#define DEFAULT_ADDVARIABLESASCLIQUES FALSE
120#define DEFAULT_CLIQUESHRINKING TRUE
131struct SCIP_ConshdlrData
138 SCIP_Longint nsetpart;
145 SCIP_Bool updatedsetppctype;
146 SCIP_Bool cliquelifting;
147 SCIP_Bool enablecliquelifting;
148 SCIP_Bool cliqueshrinking;
151 SCIP_Bool addvariablesascliques;
155 SCIP_Bool presolpairwise;
156 SCIP_Bool presolusehashing;
157 SCIP_Bool dualpresolving;
171 unsigned int setppctype:2;
172 unsigned int sorted:1;
173 unsigned int cliqueadded:1;
174 unsigned int validsignature:1;
175 unsigned int changed:1;
176 unsigned int varsdeleted:1;
177 unsigned int merged:1;
178 unsigned int presolpropagated:1;
179 unsigned int existmultaggr:1;
180 unsigned int catchevents:1;
323 switch( consdata->setppctype )
355 switch( consdata->setppctype )
393 (*conshdlrdata)->eventhdlr = eventhdlr;
394 (*conshdlrdata)->nsetpart = 0;
440 varuses = conshdlrdata->varuses;
514 for( v = 0; v < consdata->nvars; ++v )
534 for( v = 0; v < consdata->nvars; ++v )
552 assert(consdata->nvars <= consdata->varssize);
554 if( num > consdata->varssize )
582 (*consdata)->signature = 0;
583 (*consdata)->row =
NULL;
584 (*consdata)->nlrow =
NULL;
585 (*consdata)->existmultaggr =
FALSE;
586 (*consdata)->catchevents =
FALSE;
587 (*consdata)->nfixedzeros = 0;
588 (*consdata)->nfixedones = 0;
597#ifdef SCIP_DISABLED_CODE
609 for( v = 0; v <
nvars; ++v )
615 (*consdata)->nfixedones++;
617 (*consdata)->nfixedzeros++;
622 (*consdata)->varssize =
k;
623 (*consdata)->nvars =
k;
638 (*consdata)->varssize =
nvars;
639 (*consdata)->nvars =
nvars;
648 for( v = 0; v < (*consdata)->nvars; v++ )
659 for( v = 0; v < (*consdata)->nvars; v++ )
668 (*consdata)->vars =
NULL;
669 (*consdata)->varssize = 0;
670 (*consdata)->nvars = 0;
672 (*consdata)->setppctype = setppctype;
673 (*consdata)->sorted = (
nvars <= 1);
674 (*consdata)->cliqueadded =
FALSE;
675 (*consdata)->validsignature =
FALSE;
676 (*consdata)->changed =
TRUE;
677 (*consdata)->varsdeleted =
FALSE;
678 (*consdata)->merged =
FALSE;
679 (*consdata)->presolpropagated =
FALSE;
719 if( (*consdata)->row !=
NULL )
725 if( (*consdata)->nlrow !=
NULL )
731 for( v = 0; v < (*consdata)->nvars; v++ )
754 if( consdata->nvars == 0 )
761 switch( consdata->setppctype )
788 if( !consdata->validsignature )
792 consdata->signature = 0;
793 for(
i = 0;
i < consdata->nvars; ++
i )
795 consdata->validsignature =
TRUE;
798 return consdata->signature;
809 if( !consdata->sorted )
811 if( consdata->nvars <= 1 )
812 consdata->sorted =
TRUE;
816 consdata->sorted =
TRUE;
825 for( v = 0; v < consdata->nvars; ++v )
862 for(
i = 0;
i < consdata->nvars; ++
i )
877 ++(conshdlrdata->nsetpart);
878 assert(conshdlrdata->nsetpart >= 0);
882 --(conshdlrdata->nsetpart);
883 assert(conshdlrdata->nsetpart >= 0);
888 consdata->setppctype = setppctype;
893 for(
i = 0;
i < consdata->nvars; ++
i )
901 conshdlrdata->updatedsetppctype =
TRUE;
925 var = consdata->vars[pos];
948 consdata->nfixedzeros++;
953 consdata->presolpropagated =
FALSE;
956 if( consdata->nfixedzeros >= consdata->nvars - 1 )
964 consdata->nfixedones++;
968 consdata->presolpropagated =
FALSE;
995 var = consdata->vars[pos];
1005 consdata->nfixedzeros--;
1007 consdata->nfixedones--;
1026 if( consdata->catchevents ==
TRUE )
1030 for(
i = 0;
i < consdata->nvars; ++
i )
1035 consdata->catchevents =
TRUE;
1054 if( consdata->catchevents ==
FALSE )
1058 for(
i = 0;
i < consdata->nvars; ++
i )
1063 consdata->catchevents =
FALSE;
1077 SCIP_Bool transformed;
1096 consdata->vars[consdata->nvars] =
var;
1098 if( consdata->validsignature )
1100 consdata->sorted = (consdata->nvars == 1);
1101 consdata->changed =
TRUE;
1120 if( consdata->catchevents )
1126 consdata->existmultaggr =
TRUE;
1141 if( consdata->row !=
NULL )
1146 consdata->merged =
FALSE;
1147 consdata->cliqueadded =
FALSE;
1170 var = consdata->vars[pos];
1190 if( consdata->catchevents )
1196 if( consdata->nvars == 1 )
1198 consdata->presolpropagated =
FALSE;
1203 if( consdata->row !=
NULL )
1209 if( pos != consdata->nvars - 1 )
1211 consdata->vars[pos] = consdata->vars[consdata->nvars-1];
1212 consdata->sorted =
FALSE;
1215 consdata->validsignature =
FALSE;
1216 consdata->changed =
TRUE;
1302 SCIP_Bool infeasible;
1339 assert(consdata->nfixedones == 0);
1340 assert(consdata->nfixedzeros == 0);
1342 nvars = consdata->nvars;
1351 vars = consdata->vars;
1356 switch( setppctype )
1384 for( v = 0; v <
nvars; ++v )
1453 SCIP_Bool redundant;
1479 for( v =
nvars - 1; v >= 0; --v )
1524 for( v =
nvars - 1; v >= 0; --v )
1656 if( consdata->nvars <= 1 )
1658 consdata->merged =
TRUE;
1662 assert(consdata->vars !=
NULL || consdata->nvars == 0);
1667 consdata->sorted =
FALSE;
1670 for( v = consdata->nvars - 1; v > 0; --v )
1680 var1 = consdata->vars[v];
1690 var2 = consdata->vars[v-1];
1702 SCIP_Bool infeasible;
1716 for(
i = consdata->nvars - 1;
i >= 0; --
i )
1717 if(
i != v &&
i != (v-1) )
1722 SCIPdebugMsg(
scip,
"setppc constraint <%s>: infeasible fixing <%s> == 0\n",
1749 SCIPdebugMsg(
scip,
"setppc constraint <%s>: infeasible fixing <%s> == %g\n",
1765 consdata->changed =
TRUE;
1768 consdata->merged =
TRUE;
1802 consdata->existmultaggr =
FALSE;
1809 var = consdata->vars[v];
1830 SCIP_Real constant = 0.0;
1859 for(
v2 = nconsvars - 1;
v2 >= 0; --
v2 )
1874 for(
v2 = consdata->nvars - 1;
v2 > v; --
v2 )
1881 if(
v2 == v && nconsvars == 0 )
1886 if( nfixedvars !=
NULL )
1892 for(
v2 = consdata->nvars - 1;
v2 >= 0; --
v2 )
1894 if( consdata->vars[
v2] !=
var )
1902 SCIPdebugMsg(
scip,
"setppc constraint <%s>: infeasible fixing <%s> == 0\n",
1938 for(
v2 = nconsvars - 1;
v2 >= 0; --
v2 )
1960 size =
MAX(nconsvars, 1) + consdata->nvars - 1;
1966 nconsvars = consdata->nvars;
1969 for(
k = consdata->nvars - 1;
k >= 0; --
k )
1971 consvars[
k] = consdata->vars[
k];
1994 rhs = 1.0 - constant;
1998 lhs = 1.0 - constant;
1999 rhs = 1.0 - constant;
2004 lhs = 1.0 - constant;
2026 if( ndelconss !=
NULL && naddconss !=
NULL )
2073 consdata->existmultaggr =
FALSE;
2102 for( v = 0; v < consdata->nvars; ++v )
2139 for( v = 0; v < consdata->nvars && n < 2; ++v )
2185 assert(consdata->nvars == 0 || consdata->vars !=
NULL);
2186 assert(0 <= consdata->nfixedzeros && consdata->nfixedzeros <= consdata->nvars);
2187 assert(0 <= consdata->nfixedones && consdata->nfixedones <= consdata->nvars);
2195 if( consdata->nfixedones == 1 )
2208 if( consdata->nfixedzeros < consdata->nvars - 1 )
2215 SCIP_Bool infeasible;
2216 SCIP_Bool tightened;
2221 SCIPdebugMsg(
scip,
" -> fixing all other variables to zero in set packing/partitioning constraint <%s>\n",
2228 vars = consdata->vars;
2229 nvars = consdata->nvars;
2233 for( v = 0; v <
nvars && consdata->nfixedones == 1; ++v )
2273 if( consdata->nfixedones >= 2 )
2297 else if( consdata->nfixedzeros == consdata->nvars )
2305 assert(consdata->nfixedones == 0);
2332 else if( consdata->nfixedzeros == consdata->nvars - 1 && consdata->nfixedones == 0 )
2353 SCIP_Bool infeasible;
2354 SCIP_Bool tightened;
2359 vars = consdata->vars;
2360 nvars = consdata->nvars;
2361 for( v = 0; v <
nvars; ++v )
2368 SCIPdebugMsg(
scip,
" -> fixing remaining variable <%s> to one in set covering/partitioning constraint <%s>\n",
2379 assert(consdata->nfixedzeros == consdata->nvars - 1);
2380 assert(consdata->nfixedones == 1);
2386 assert(consdata->nfixedzeros + consdata->nfixedones <= consdata->nvars);
2410 vars = consdata->vars;
2411 nvars = consdata->nvars;
2426 switch( consdata->setppctype )
2471 switch( consdata->setppctype )
2514 if( consdata->row ==
NULL )
2549 if( consdata->nlrow ==
NULL )
2556 for(
i = 0;
i < consdata->nvars; ++
i )
2623 assert(consdata->nvars == 0 || consdata->vars !=
NULL);
2624 assert(0 <= consdata->nfixedzeros && consdata->nfixedzeros <= consdata->nvars);
2625 assert(0 <= consdata->nfixedones && consdata->nfixedones <= consdata->nvars);
2688 SCIP_Bool* infeasible,
2811 assert(consdata->nvars > 0);
2819 assert(minidx >= 0 && minidx <= maxidx);
2830 int*
const cliquepartition,
2835 int*
const nfixedvars,
2836 int*
const naddconss,
2837 int*
const ndelconss,
2838 int*
const nchgcoefs,
2862 if(
nbinvars == 0 || ncliques == 0 )
2875 for(
c = 0;
c < ncliques - 1; ++
c )
2890 if( cliquepartition[
c] == cliquepartition[v] )
2952 int*
const nfixedvars,
2953 int*
const ndelconss,
2954 int*
const nchgcoefs,
2979 for(
c = nconss - 1;
c >= 0; --
c )
3015 assert(consdata->nfixedones == 0);
3017 if( consdata->nvars == 0 )
3083 assert(consdata->merged);
3086 if( consdata->nvars > *maxnvars )
3087 *maxnvars = consdata->nvars;
3090 for( v = consdata->nvars - 1; v >= 0; --v )
3094 var = consdata->vars[v];
3157 SCIP_Bool found =
FALSE;
3260 SCIP_Bool
const aggregate,
3269 int*
const naggregations,
3276 int*
const nfixedvars,
3277 int*
const naggrvars,
3278 int*
const ndelconss,
3301 if( consdata->presolpropagated )
3304 consdata->presolpropagated =
TRUE;
3306 vars = consdata->vars;
3307 nvars = consdata->nvars;
3333 if( consdata->nfixedones > 1 )
3349 SCIPdebugMsg(
scip,
"set partitioning / packing constraint <%s> is infeasible, %d variables fixed to one\n",
SCIPconsGetName(cons), consdata->nfixedones);
3355 if( consdata->nfixedones == 1 )
3365 for( v =
nvars - 1; v >= 0; --v )
3375 SCIPdebugMsg(
scip,
"setppc constraint <%s>: infeasible fixing <%s> == 0\n",
3406 if( consdata->nfixedzeros ==
nvars )
3408 assert(consdata->nfixedones == 0);
3432 if( consdata->nfixedzeros + 1 ==
nvars )
3434 assert(consdata->nfixedones == 0);
3444 for( v =
nvars - 1; v >= 0; --v )
3455 SCIPdebugMsg(
scip,
"setppc constraint <%s>: infeasible fixing <%s> == 1\n",
3486 for( v =
nvars - 1; v >= 0; --v )
3496 SCIP_Bool redundant;
3524 SCIPdebugMsg(
scip,
"set partitioning constraint <%s>: aggregate <%s> + <%s> == 1\n",
3625 int*
const naggregations,
3630 int*
const nfixedvars,
3631 int*
const naggrvars,
3632 int*
const nchgcoefs,
3633 int*
const ndelconss,
3680 nvars = consdata->nvars;
3685 vars = consdata->vars;
3712 SCIP_CALL(
presolvePropagateCons(
scip,
cons1,
FALSE,
undoneaggrvars,
undoneaggrtypes, naggregations,
saggregations, nfixedvars, naggrvars, ndelconss,
cutoff) );
3752 assert(consdata->merged);
3847 for( ;
v1 >= 0; --
v1)
3918 assert(consdata->merged);
4091 assert(consdata->merged);
4195 for( ;
v1 >= 0; --
v1)
4279 assert(consdata->merged);
4396 SCIP_CALL(
presolvePropagateCons(
scip,
constostay,
FALSE,
NULL,
NULL,
NULL,
NULL, nfixedvars, naggrvars, ndelconss,
cutoff) );
4488 int*
const nfixedvars,
4489 int*
const ndelconss,
4527 nvars = consdata->nvars;
4534 vars = consdata->vars;
4540 for( v =
nvars - 1; v >= 0 &&
v1 >= 0; )
4568 assert(consdata->merged);
4693 assert(consdata->merged);
4696 for(
k = consdata->nvars - 1;
k >= 0; --
k )
4743 SCIPdebugMsg(
scip,
" -> deleting constraint <%s> number <%d> due to active and negated variable in the same clique constraint\n",
SCIPconsGetName(cons), arraypos);
4784 consdata->merged =
TRUE;
4796 vars = consdata->vars;
4797 nvars = consdata->nvars;
4802 if( (*maxnvars) <
nvars )
4804 while( (*maxnvars) <
nvars )
4819 for( ;
v1 >= 0; --
v1)
4903 consdata->merged =
TRUE;
4915 vars = consdata->vars;
4916 nvars = consdata->nvars;
4921 if( (*maxnvars) <
nvars )
4923 while( (*maxnvars) <
nvars )
4947 int const naggregations,
4948 int*
const naggrvars,
4955 SCIP_Bool redundant;
4962 assert(naggregations > 0);
4967 for(
a = 0;
a < naggregations; ++
a )
5030 int*
const nfixedvars,
5031 int*
const naggrvars,
5032 int*
const ndelconss,
5033 int*
const nchgcoefs,
5115 if( conshdlrdata->nclqpresolve == 0 && conshdlrdata->addvariablesascliques )
5119 int* cliquepartition;
5146 nrounds, nfixedvars, &naddconss, ndelconss, nchgcoefs,
cutoff) );
5151 *ndelconss -= naddconss;
5217 SCIP_CALL(
presolvePropagateCons(
scip,
cons0,
FALSE,
undoneaggrvars,
undoneaggrtypes, &naggregations, &
saggregations, nfixedvars, naggrvars, ndelconss,
cutoff) );
5238 consdata->sorted =
FALSE;
5271 nfixedvars, naggrvars, nchgcoefs, ndelconss,
cutoff) );
5291 consdata->sorted =
FALSE;
5295 if( consdata->nfixedones > 0 || consdata->nfixedzeros >
cons0fixedzeros )
5300 SCIP_CALL(
presolvePropagateCons(
scip,
cons0,
FALSE,
undoneaggrvars,
undoneaggrtypes, &naggregations, &
saggregations, nfixedvars, naggrvars, ndelconss,
cutoff) );
5327 if( conshdlrdata->nclqpresolve > 0 )
5385 consdata->sorted =
FALSE;
5412 nfixedvars, naggrvars, nchgcoefs, ndelconss,
cutoff) );
5456 if( *ndelconss < 0 )
5479 SCIP_Bool infeasible;
5511 if( !consdata->cliqueadded && consdata->nvars >= 2 )
5539 consdata->cliqueadded =
TRUE;
5554 SCIP_Bool* infeasible,
5571 SCIP_Bool redundant;
5584 *infeasible =
FALSE;
5589 if( pos ==
nvars - 1 )
5595 tmpvars[pos] = tmpvars[
nvars - 1];
5600 for( v =
nvars - 2; v >= 0; --v )
5603 SCIPdebugMsg(
scip,
"multi-aggregating binary variable <%s> (locks: [%d,%d]; to %d variables)\n",
5613 if( pos <
nvars - 1 )
5674 SCIP_Bool infeasible;
5676 SCIP_Bool donotaggr;
5677 SCIP_Bool donotmultaggr;
5720 if( (nuplocks == 1 && ndownlocks <= 1) || (nuplocks <= 1 && ndownlocks == 1) || (nuplocks <= 2 && ndownlocks <= 2 &&
SCIPvarGetNegatedVar(binvars[v]) !=
NULL) )
5748 assert(!donotaggr || !donotmultaggr);
5756 for(
c = 0;
c < nconss; ++
c )
5825 if( consdata->nvars < 2 )
5843 if( consdata->nvars == 0 )
5875 SCIP_Bool redundant;
5877 var = consdata->vars[0];
5885 if( nuplocks == 1 &&
objval <= 0 )
5909 var = consdata->vars[1];
5917 if( nuplocks == 1 &&
objval <= 0 )
5943 SCIP_Bool redundant;
5978 for( v = consdata->nvars - 1; v >= 0; --v )
5985 var = consdata->vars[v];
5993 assert(nuplocks >= 1 && ndownlocks >= 0);
5997 assert(nuplocks == 1 && ndownlocks <= 1);
6000 if( ndownlocks == 0 )
6071 assert(0 <= consindex && consindex < nconss);
6256 assert(0 <= consindex && consindex < nconss);
6312 SCIPdebugMsg(
scip,
"multi-aggregating in one set-partitioning or one set-packing constraint\n");
6338 SCIPdebugMsg(
scip,
"multi-aggregating in two set-partitioning or one set-partitioning and -packing constraint\n");
6357 assert(nuplocks >= 1 && ndownlocks >= 0);
6451 hashtablesize = nconss;
6457 for(
c = 0;
c < nconss; ++
c )
6491 SCIPdebugMsg(
scip,
"setppc constraints <%s> and <%s> have identical variable sets\n",
6542 SCIPdebugMsg(
scip,
" -> removing setppc constraint <%s> which is redundant to <%s>\n",
6861 SCIPdebugMsg(
scip,
"setppc constraints <%s> and <%s> have identical variable sets\n",
6937 for(
i = 0;
i < nconss;
i++ )
6942 if( consdata->varsdeleted )
6945 for( v = consdata->nvars - 1; v >= 0; v-- )
6952 consdata->varsdeleted =
FALSE;
6981 SCIPdebugMsg(
scip,
"Enforcing %d set partitioning / packing / covering constraints for %s solution\n", nconss,
6982 sol ==
NULL ?
"LP" :
"relaxation");
7052 SCIP_Bool modifiable,
7058 SCIP_Bool removable,
7060 SCIP_Bool stickingatnode
7073 if( conshdlr ==
NULL )
7075 SCIPerrorMessage(
"set partitioning / packing / covering constraint handler not found\n");
7092 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
7093 local, modifiable, dynamic, removable, stickingatnode) );
7100 ++(conshdlrdata->nsetpart);
7101 assert(conshdlrdata->nsetpart >= 0);
7139 SCIP_Bool modifiable,
7145 SCIP_Bool removable,
7147 SCIP_Bool stickingatnode
7163 for( v = 0; v <
nvars; ++v )
7165 if(
mult * vals[v] > 0.0 )
7176 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
7282 int nbilinexprterms;
7299 if( nvarexprs != 2 )
7325 if( nbilinexprterms != 1 )
7329 if( nquadexprs != 2 )
7346 coefx = lincoef + sqrcoef;
7349 coefy = lincoef + sqrcoef;
7418 SCIP_Real constant = 0.0;
7440 for(
i = 0;
i < consdata->nvars; ++
i )
7442 vars[
i] = consdata->vars[
i];
7451 rhs = 1.0 - constant;
7453 lhs = 1.0 - constant;
7458 rhs = 1.0 - constant;
7459 lhs = 1.0 - constant;
7526 conshdlrdata->noldfixedvars = 0;
7527 conshdlrdata->noldimpls = 0;
7528 conshdlrdata->noldcliques = 0;
7529 conshdlrdata->noldupgrs = 0;
7530 conshdlrdata->nclqpresolve = 0;
7531 conshdlrdata->updatedsetppctype =
FALSE;
7532 conshdlrdata->enablecliquelifting =
TRUE;
7547 for(
c = 0;
c < nconss; ++
c )
7567 for(
c = 0;
c < nconss; ++
c )
7584 for(
c = 0;
c < nconss; ++
c )
7589 if( consdata->row !=
NULL )
7594 if( consdata->nlrow !=
NULL )
7622 --(conshdlrdata->nsetpart);
7623 assert(conshdlrdata->nsetpart >= 0);
7678 ++(conshdlrdata->nsetpart);
7679 assert(conshdlrdata->nsetpart >= 0);
7695 *infeasible =
FALSE;
7697 for(
c = 0;
c < nconss && !(*infeasible); ++
c )
7808 SCIP_Real branchweight;
7826 varuses = conshdlrdata->varuses;
7881 branchweight += solval;
7901 branchweight -= solval;
7993 if( conshdlrdata->npseudobranches <= 1 )
7998 if( npseudocands == 0 )
8001 varuses = conshdlrdata->varuses;
8014 for(
i = 0;
i < npseudocands; ++
i )
8067 for(
j = 0;
j <
i; ++
j )
8088 SCIPdebugMsg(
scip,
"branched on pseudo solution: %d children\n", nchildren);
8127 SCIP_Bool infeasible;
8147 SCIPdebugMsg(
scip,
"pseudo enforcing %d set partitioning / packing / covering constraints\n", nconss);
8168 else if( infeasible )
8214 SCIP_Real sum = 0.0;
8219 for( v = 0; v < consdata->nvars; ++v )
8269 int naddconss, ndelconss;
8274 naddconss = ndelconss = 0;
8292 else if( nfixedvars > 0 )
8331 conshdlrdata->enablecliquelifting = conshdlrdata->enablecliquelifting || conshdlrdata->updatedsetppctype
8333 || conshdlrdata->noldcliques !=
SCIPgetNCliques(
scip) || conshdlrdata->noldupgrs != nconss;
8339 conshdlrdata->updatedsetppctype =
FALSE;
8396 if( consdata->nfixedzeros > 0 )
8413 SCIP_CALL(
presolvePropagateCons(
scip, cons,
TRUE,
NULL,
NULL,
NULL,
NULL, nfixedvars, naggrvars, ndelconss, &
cutoff) );
8426 if( consdata->nfixedzeros > 0 )
8455 if( !consdata->cliqueadded && consdata->nvars >= 2 )
8485 naggrvars, ndelconss, nchgcoefs, nchgsides, &
cutoff) );
8514 ++(conshdlrdata->nclqpresolve);
8525 conshdlrdata->noldfixedvars = *nfixedvars + *naggrvars;
8526 conshdlrdata->enablecliquelifting =
FALSE;
8532 if( conshdlrdata->presolpairwise )
8575 conshdlrdata->noldupgrs = nconss - (*ndelconss -
startdelconss);
8597 SCIPdebugMsg(
scip,
"conflict resolving method of set partitioning / packing / covering constraint handler\n");
8613 for( v = 0; v < consdata->nvars; ++v )
8615 if( consdata->vars[v] !=
infervar )
8638 if( inferinfo >= 0 )
8645 for( v = 0; v < consdata->nvars; ++v )
8675 switch( consdata->setppctype )
8678 nlocksdown = nlockspos + nlocksneg;
8679 nlocksup = nlockspos + nlocksneg;
8682 nlocksdown = nlocksneg;
8683 nlocksup = nlockspos;
8686 nlocksdown = nlockspos;
8687 nlocksup = nlocksneg;
8694 for(
i = 0;
i < consdata->nvars; ++
i )
8711 SCIPdebugMsg(
scip,
"activation information for set partitioning / packing / covering constraint <%s>\n",
8720 if( consdata->nfixedones >= 1 || consdata->nfixedzeros >= consdata->nvars - 1 )
8749 SCIPdebugMsg(
scip,
"deactivation information for set partitioning / packing / covering constraint <%s>\n",
8824 const char* consname;
8863 lhs, rhs, varmap, consmap,
8864 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
valid) );
8940 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
8944 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
8948 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
8994 (*nvars) = consdata->nvars;
9047 consdata->nfixedones++;
9050 consdata->nfixedones--;
9053 consdata->nfixedzeros++;
9056 consdata->nfixedzeros--;
9059 consdata->varsdeleted =
TRUE;
9062 if( consdata->merged )
9072 consdata->merged =
FALSE;
9075 if( !consdata->existmultaggr )
9081 consdata->existmultaggr =
TRUE;
9088 assert(0 <= consdata->nfixedzeros && consdata->nfixedzeros <= consdata->nvars);
9089 assert(0 <= consdata->nfixedones && consdata->nfixedones <= consdata->nvars);
9093 if( consdata->nfixedones >= 1 || consdata->nfixedzeros >= consdata->nvars - 1 )
9095 consdata->presolpropagated =
FALSE;
9100 consdata->presolpropagated =
FALSE;
9126 assert(bdchginfos !=
NULL || nbdchginfos == 0);
9139 if( nbdchginfos == 2 )
9179 SCIP_Bool infeasible;
9188 SCIPdebugMsg(
scip,
"new clique of conflict constraint %s led to infeasibility\n", consname);
9202 for(
i = 0;
i < nbdchginfos; ++
i )
9219 if(
i == nbdchginfos )
9303 if( conshdlrdata->conshdlrlinear !=
NULL )
9317 "number of children created in pseudo branching (0: disable pseudo branching)",
9321 "should pairwise constraint comparison be performed in presolving?",
9325 "should hash table be used for detecting redundant constraints in advance",
9329 "should dual presolving steps be performed?",
9333 " should we try to lift variables into other clique constraints, fix variables, aggregate them, and also shrink the amount of variables in clique constraints",
9337 "should we try to generate extra cliques out of all binary variables to maybe fasten redundant constraint detection",
9341 "should we try to shrink the number of variables in a clique constraints, by replacing more than one variable by only one",
9369 SCIP_Bool modifiable,
9375 SCIP_Bool removable,
9377 SCIP_Bool stickingatnode
9383 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode);
9427 SCIP_Bool modifiable,
9433 SCIP_Bool removable,
9435 SCIP_Bool stickingatnode
9441 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode);
9485 SCIP_Bool modifiable,
9491 SCIP_Bool removable,
9493 SCIP_Bool stickingatnode
9499 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode);
9535 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9556 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9564 return consdata->nvars;
9579 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9587 return consdata->vars;
9602 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9624 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9632 if( consdata->row !=
NULL )
9650 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9658 if( consdata->row !=
NULL )
9678 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9686 return consdata->row;
9701 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9709 return consdata->nfixedones;
9725 SCIPerrorMessage(
"constraint is not a set partitioning / packing / covering constraint\n");
9733 return consdata->nfixedzeros;
9740 SCIP_Bool* infeasible,
9753 if( conshdlr ==
NULL )
9760 *infeasible =
FALSE;
9766 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)
static SCIP_RETCODE dualPresolving(SCIP *scip, SCIP_CONS *cons, int *nfixedvars, int *ndelconss, int *naggrvars, SCIP_RESULT *result)
#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 addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
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)
#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 .
#define SCIP_LONGINT_FORMAT
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,)
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 SCIPsetConshdlrInit(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
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)
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_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)
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
structs for symmetry computations
methods for dealing with symmetry detection graphs
#define SCIP_DECL_CONFLICTEXEC(x)
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
#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
enum SYM_Symtype SYM_SYMTYPE
#define SCIP_PRESOLTIMING_MEDIUM
#define SCIP_PRESOLTIMING_EXHAUSTIVE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR
enum SCIP_LockType SCIP_LOCKTYPE