87#define CONSHDLR_NAME "xor"
88#define CONSHDLR_DESC "constraint handler for xor constraints: r = xor(x1, ..., xn)"
89#define CONSHDLR_SEPAPRIORITY +850200
90#define CONSHDLR_ENFOPRIORITY -850200
91#define CONSHDLR_CHECKPRIORITY -850200
92#define CONSHDLR_SEPAFREQ 0
93#define CONSHDLR_PROPFREQ 1
94#define CONSHDLR_EAGERFREQ 100
96#define CONSHDLR_MAXPREROUNDS -1
97#define CONSHDLR_DELAYSEPA FALSE
98#define CONSHDLR_DELAYPROP FALSE
99#define CONSHDLR_NEEDSCONS TRUE
101#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
102#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_ALWAYS
104#define EVENTHDLR_NAME "xor"
105#define EVENTHDLR_DESC "event handler for xor constraints"
107#define LINCONSUPGD_PRIORITY +600000
109#define DEFAULT_PRESOLPAIRWISE TRUE
110#define DEFAULT_ADDEXTENDEDFORM FALSE
111#define DEFAULT_ADDFLOWEXTENDED FALSE
112#define DEFAULT_SEPARATEPARITY FALSE
113#define DEFAULT_GAUSSPROPFREQ 5
114#define HASHSIZE_XORCONS 500
115#define DEFAULT_PRESOLUSEHASHING TRUE
116#define NMINCOMPARISONS 200000
117#define MINGAINPERNMINCOMPARISONS 1e-06
118#define MAXXORCONSSSYSTEM 1000
119#define MAXXORVARSSYSTEM 1000
147 unsigned int deleteintvar:1;
148 unsigned int propagated:1;
149 unsigned int sorted:1;
150 unsigned int changed:1;
154struct SCIP_ConshdlrData
157 SCIP_Bool presolpairwise;
158 SCIP_Bool presolusehashing;
159 SCIP_Bool addextendedform;
160 SCIP_Bool addflowextended;
161 SCIP_Bool separateparity;
232 (*conshdlrdata)->eventhdlr = eventhdlr;
261 assert(watchedvar1 == -1 || watchedvar1 != watchedvar2);
262 assert(watchedvar1 != -1 || watchedvar2 == -1);
267 if( watchedvar1 == consdata->watchedvar2 || watchedvar2 == consdata->watchedvar1 )
271 tmp = consdata->watchedvar1;
272 consdata->watchedvar1 = consdata->watchedvar2;
273 consdata->watchedvar2 =
tmp;
274 tmp = consdata->filterpos1;
275 consdata->filterpos1 = consdata->filterpos2;
276 consdata->filterpos2 =
tmp;
278 assert(watchedvar1 == -1 || watchedvar1 != consdata->watchedvar2);
279 assert(watchedvar2 == -1 || watchedvar2 != consdata->watchedvar1);
282 if( consdata->watchedvar1 != -1 && consdata->watchedvar1 != watchedvar1 )
284 assert(consdata->filterpos1 != -1);
288 if( consdata->watchedvar2 != -1 && consdata->watchedvar2 != watchedvar2 )
290 assert(consdata->filterpos2 != -1);
296 if( watchedvar1 != -1 && watchedvar1 != consdata->watchedvar1 )
301 if( watchedvar2 != -1 && watchedvar2 != consdata->watchedvar2 )
308 consdata->watchedvar1 = watchedvar1;
309 consdata->watchedvar2 = watchedvar2;
323 assert(consdata->nvars <= consdata->varssize);
325 if( num > consdata->varssize )
357 (*consdata)->rhs = rhs;
358 (*consdata)->intvar = intvar;
360 (*consdata)->rows[
r] =
NULL;
361 (*consdata)->nvars =
nvars;
362 (*consdata)->varssize =
nvars;
363 (*consdata)->watchedvar1 = -1;
364 (*consdata)->watchedvar2 = -1;
365 (*consdata)->filterpos1 = -1;
366 (*consdata)->filterpos2 = -1;
367 (*consdata)->deleteintvar = (intvar ==
NULL);
368 (*consdata)->propagated =
FALSE;
369 (*consdata)->sorted =
FALSE;
370 (*consdata)->changed =
TRUE;
371 (*consdata)->extvars =
NULL;
372 (*consdata)->nextvars = 0;
373 (*consdata)->extvarssize = 0;
380 if( (*consdata)->intvar !=
NULL )
396 for( v = (*consdata)->nvars - 1; v >= 0; --v )
408 for(
int v = 0; v < (*consdata)->nvars; ++v )
415 if( (*consdata)->intvar !=
NULL )
437 if( consdata->rows[
r] !=
NULL )
465 if ( (*consdata)->nextvars > 0 )
468 for (
j = 0;
j < (*consdata)->extvarssize; ++
j)
470 if ( (*consdata)->extvars[
j] !=
NULL )
477 (*consdata)->nextvars = 0;
478 (*consdata)->extvarssize = 0;
483 assert((*consdata)->watchedvar1 == -1);
484 assert((*consdata)->watchedvar2 == -1);
491 if( (*consdata)->intvar !=
NULL )
528 if( consdata->intvar !=
NULL )
550 SCIP_Bool transformed;
570 if( consdata->intvar !=
NULL )
576 consdata->intvar =
var;
577 consdata->changed =
TRUE;
584 if( consdata->rows[0] !=
NULL )
586 SCIPerrorMessage(
"cannot change intvar of xor constraint after LP relaxation was created\n");
602 SCIP_Bool transformed;
622 consdata->vars[consdata->nvars] =
var;
624 consdata->sorted = (consdata->nvars == 1);
625 consdata->changed =
TRUE;
650 if( consdata->rows[0] !=
NULL )
652 SCIPerrorMessage(
"cannot add coefficients to xor constraint after LP relaxation was created\n");
691 if( consdata->watchedvar1 == pos )
695 if( consdata->watchedvar2 == pos )
700 assert(pos != consdata->watchedvar1);
701 assert(pos != consdata->watchedvar2);
704 consdata->vars[pos] = consdata->vars[consdata->nvars-1];
708 if( consdata->watchedvar1 == consdata->nvars )
709 consdata->watchedvar1 = pos;
710 if( consdata->watchedvar2 == consdata->nvars )
711 consdata->watchedvar2 = pos;
713 consdata->propagated =
FALSE;
714 consdata->sorted =
FALSE;
715 consdata->changed =
TRUE;
728 if( !consdata->sorted )
730 if( consdata->nvars <= 1 )
731 consdata->sorted =
TRUE;
738 if( consdata->watchedvar1 != -1 )
740 var1 = consdata->vars[consdata->watchedvar1];
742 consdata->watchedvar1 = -1;
743 if( consdata->watchedvar2 != -1 )
745 var2 = consdata->vars[consdata->watchedvar2];
747 consdata->watchedvar2 = -1;
750 assert(consdata->watchedvar1 == -1);
751 assert(consdata->watchedvar2 == -1);
756 consdata->sorted =
TRUE;
766 for( v = consdata->nvars - 1; v >= 0; --v )
768 if( consdata->vars[v] ==
var1 )
770 consdata->watchedvar1 = v;
771 if(
var2 ==
NULL || consdata->watchedvar2 != -1 )
774 else if( consdata->vars[v] ==
var2 )
777 consdata->watchedvar2 = v;
778 if( consdata->watchedvar1 != -1 )
782 assert(consdata->watchedvar1 != -1);
784 assert(consdata->watchedvar1 < consdata->nvars);
785 assert(consdata->watchedvar2 < consdata->nvars);
795 for( v = 0; v < consdata->nvars; ++v )
866 assert(consdata->nvars > 0);
870 assert(consdata->vars[consdata->nvars / 2] !=
NULL);
871 assert(consdata->vars[consdata->nvars - 1] !=
NULL);
903 assert(consdata->nvars == 0 || consdata->vars !=
NULL);
914 var = consdata->vars[v];
927 consdata->rhs = !consdata->rhs;
947 consdata->rhs = !consdata->rhs;
974 v = consdata->nvars-2;
977 if( consdata->vars[v] == consdata->vars[v+1] )
982 newvars[2] = consdata->vars[v];
986 SCIPdebugMsg(
scip,
"xor constraint <%s>: deleting pair of equal variables <%s>\n",
991 v =
MIN(v, consdata->nvars-1);
999 if( consdata->intvar !=
NULL )
1019 newvars[1] = consdata->intvar;
1041 SCIPdebugMsg(
scip,
"xor constraint <%s>: deleting pair of negated variables <%s> and <%s>\n",
1046 consdata->rhs = !consdata->rhs;
1047 v =
MIN(v, consdata->nvars-1);
1054 if( consdata->rhs && consdata->intvar !=
NULL )
1062 SCIP_Bool infeasible;
1063 SCIP_Bool redundant;
1116 newvars[0] = consdata->intvar;
1191 if ( consdata->extvars !=
NULL )
1195 if ( consdata->nvars <= 3 )
1200 assert( consdata->nextvars == 0 );
1201 assert( consdata->extvarssize == 0 );
1204 consdata->extvarssize = 4 * (consdata->nvars);
1208 for (
i = 0;
i < consdata->nvars; ++
i)
1216 SCIP_Real rhs = 0.0;
1217 SCIP_Bool infeasible =
FALSE;
1218 SCIP_Bool redundant =
FALSE;
1226 SCIP_CALL(
SCIPcreateVar(
scip, &
varnn, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1230 SCIP_CALL(
SCIPcreateVar(
scip, &
varns, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1246 if (
i == consdata->nvars-1 )
1248 if ( consdata->rhs )
1252 SCIP_CALL(
SCIPcreateVar(
scip, &
varns, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1256 SCIP_CALL(
SCIPcreateVar(
scip, &
varss, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1274 SCIP_CALL(
SCIPcreateVar(
scip, &
varnn, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1278 SCIP_CALL(
SCIPcreateVar(
scip, &
varsn, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1297 SCIP_CALL(
SCIPcreateVar(
scip, &
varnn, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1301 SCIP_CALL(
SCIPcreateVar(
scip, &
varns, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1305 SCIP_CALL(
SCIPcreateVar(
scip, &
varsn, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1309 SCIP_CALL(
SCIPcreateVar(
scip, &
varss, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1330 vars[cnt] = consdata->vars[
i];
1425 consdata->extvars[4*
i] =
varnn;
1426 consdata->extvars[4*
i + 1] =
varns;
1427 consdata->extvars[4*
i + 2] =
varsn;
1428 consdata->extvars[4*
i + 3] =
varss;
1431 ++(consdata->nextvars);
1433 ++(consdata->nextvars);
1435 ++(consdata->nextvars);
1437 ++(consdata->nextvars);
1497 if ( consdata->extvars !=
NULL )
1501 if ( consdata->nvars <= 3 )
1506 assert( consdata->nextvars == 0 );
1509 consdata->extvarssize = consdata->nvars;
1510 consdata->nextvars = consdata->nvars;
1514 for (
i = 0;
i < consdata->nvars; ++
i)
1516 SCIP_Bool infeasible =
FALSE;
1517 SCIP_Bool redundant =
FALSE;
1525 if (
i == consdata->nvars-1 )
1527 if ( consdata->rhs )
1541 SCIP_CALL(
SCIPcreateVar(
scip, &
artvar, name, lb, ub, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1564 vars[2] = consdata->vars[
i];
1581 vars[2] = consdata->vars[
i];
1598 vars[2] = consdata->vars[
i];
1615 vars[2] = consdata->vars[
i];
1629 consdata->extvars[
i] =
artvar;
1668 if( consdata->intvar ==
NULL )
1673 ub = consdata->nvars/2;
1679#ifdef WITH_DEBUG_SOLUTION
1686 for( v = consdata->nvars - 1; v >= 0; --v )
1689 count += (solval > 0.5 ? 1 : 0);
1691 assert((count - consdata->rhs) % 2 == 0);
1692 solval = (
SCIP_Real) ((count - consdata->rhs) / 2);
1704 rhsval = (consdata->rhs ? 1.0 : 0.0);
1710 else if( !consdata->rhs )
1716 for(
r = 0;
r < 3; ++
r )
1723 for( v = 0; v < 3; ++v )
1736 if( consdata->intvar !=
NULL )
1750 for(
r = 0;
r < 3; ++
r )
1757 for( v = 0; v < 3; ++v )
1770 if( consdata->intvar !=
NULL )
1787 SCIP_Bool* infeasible
1798 if( consdata->rows[0] ==
NULL )
1803 for(
r = 0;
r <
NROWS && !(*infeasible); ++
r )
1822 if( consdata->rows[0] ==
NULL )
1872 odd = consdata->rhs;
1874 for(
i = 0;
i < consdata->nvars; ++
i )
1878 odd = (
odd != (solval > 0.5));
1891 else if( consdata->intvar !=
NULL )
1901 if( *violated &&
sol ==
NULL )
1906 else if ( *violated &&
sol !=
NULL )
1957 SCIP_Bool separateparity,
1976 if( consdata->rows[0] ==
NULL )
1999 if ( separateparity && consdata->nvars > 3 )
2002 SCIP_Real maxval = -1.0;
2003 SCIP_Real minval = 2.0;
2004 SCIP_Real sum = 0.0;
2014 for (
j = 0;
j < consdata->nvars; ++
j)
2041 if ( (cnt - (
int) consdata->rhs) % 2 == 1 )
2047 SCIPdebugMsg(
scip,
"found violated parity cut (efficiacy: %f)\n", 1.0 - sum);
2054 for (
j = 0;
j < consdata->nvars; ++
j)
2082 SCIPdebugMsg(
scip,
"found violated parity cut (efficiacy: %f, minval: %f)\n", 1.0 - (sum - 1.0 + 2.0 * minval), minval);
2090 for (
j = 0;
j < consdata->nvars; ++
j)
2118 SCIPdebugMsg(
scip,
"found violated parity cut (efficiacy: %f, maxval: %f)\n", 1.0 - (sum + 1.0 - 2.0 * maxval), maxval);
2126 for (
j = 0;
j < consdata->nvars; ++
j)
2187 for (
i = 0;
i < m; ++
i)
2194 for (
i = 0;
i < m &&
i < n; ++
i)
2209 while (
k < m && A[
p[
k]][
j] == 0 )
2244 for (
k =
i+1;
k < m; ++
k)
2248 if ( A[
pk][s[
i]] != 0 )
2250 for (
j = s[
i];
j < n; ++
j)
2251 A[
pk][
j] = A[
pk][
j] ^ A[pi][
j];
2257 if (
i % 100 == 99 )
2297 for (
k = 0;
k < n; ++
k)
2301 for (
i =
r-1;
i >= 0; --
i)
2309 for (
k =
i+1;
k <
r; ++
k)
2312 if ( A[
p[
i]][s[
k]] != 0 )
2313 val = val ^
x[s[
k]];
2371 SCIPdebugMsg(
scip,
"Checking feasibility via the linear equation system over GF2 using Gauss.\n");
2383 for (
i = 0;
i < nconss; ++
i)
2394 for (
j = 0;
j < consdata->nvars; ++
j)
2398 var = consdata->vars[
j];
2431#ifdef SCIP_DISABLED_CODE
2438 for (
j = 0;
j < consdata->nvars; ++
j)
2446 if ( ( cnt - consdata->rhs ) % 2 != 0 )
2492 for (
i = 0;
i < nconss; ++
i)
2500 assert( consdata->nvars > 0 );
2507 for (
j = 0;
j < consdata->nvars; ++
j)
2512 var = consdata->vars[
j];
2638 SCIP_Bool tightened;
2639 SCIP_Bool infeasible;
2687 if ( heurtrysol !=
NULL )
2733 for (
i = 0;
i < nconss; ++
i)
2744 for (
j = 0;
j < consdata->nvars; ++
j)
2750 assert( !
noaggr || nones % 2 == (
int) consdata->rhs );
2751 if ( (
unsigned int) nones != consdata->rhs )
2753 val = (
SCIP_Real) (nones - (
int) consdata->rhs)/2;
2792 for (
i = nconss - 1;
i >= 0 ; --
i)
2797 if ( consdata->nvars == 0 )
2836 vars = consdata->vars;
2837 nvars = consdata->nvars;
2969 SCIP_Bool infeasible;
2970 SCIP_Bool tightened;
2994 vars = consdata->vars;
2995 nvars = consdata->nvars;
2998 if( consdata->propagated )
3011 watchedvar1 = consdata->watchedvar1;
3012 watchedvar2 = consdata->watchedvar2;
3015 if( watchedvar1 != -1 )
3020 if( watchedvar2 != -1 )
3027 if( watchedvar1 == -1 )
3029 watchedvar1 = watchedvar2;
3032 assert(watchedvar1 != -1 || watchedvar2 == -1);
3035 odd = consdata->rhs;
3039 if( watchedvar2 == -1 )
3055 if( watchedvar1 == -1 )
3057 assert(watchedvar2 == -1);
3060 else if( watchedvar2 == -1 && watchedvar1 !=
i )
3068 assert(watchedvar1 != -1 || watchedvar2 == -1);
3071 if( watchedvar1 == -1 )
3073 assert(watchedvar2 == -1);
3089 if ( consdata->intvar !=
NULL && !consdata->deleteintvar )
3094 assert( (nfixedones - (
int) consdata->rhs) % 2 == 0 );
3096 fixval = (nfixedones - (int) consdata->rhs)/2;
3104 SCIPdebugMsg(
scip,
"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n",
3115 SCIPdebugMsg(
scip,
"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n",
3153 if( watchedvar2 == -1 )
3155 assert(watchedvar1 != -1);
3158 SCIPdebugMsg(
scip,
"constraint <%s>: only one unfixed variable -> fix <%s> to %u\n",
3176 assert( (nfixedones - (
int) consdata->rhs) % 2 == 0 );
3178 fixval = (nfixedones - (int) consdata->rhs)/2;
3185 SCIPdebugMsg(
scip,
"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n",
3196 SCIPdebugMsg(
scip,
"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n",
3232 if ( consdata->intvar !=
NULL && !consdata->deleteintvar )
3241 assert(nfixedzeros == 0);
3370 consdata->propagated =
TRUE;
3390 SCIPdebugMsg(
scip,
"resolving fixations according to rule %d\n", (
int) proprule);
3435 vars = consdata->vars;
3436 nvars = consdata->nvars;
3442 if( !consdata->deleteintvar )
3446 if( !consdata->changed )
3582 SCIP_Bool infeasible;
3585 SCIPdebugMsg(
scip,
"all variables of xor constraints <%s> are in one clique, so fixed all variables to 0\n",
3589 for( v =
nvars - 1; v >= 0; --v )
3618 if( !consdata->rhs )
3626 for( v = 0; v <
nvars; ++v )
3662 if( consdata->intvar !=
NULL )
3664 SCIP_Bool infeasible;
3715 hashtablesize = nconss;
3722 for(
c = 0;
c < nconss; ++
c )
3769 SCIP_Bool infeasible;
3783 SCIP_Bool infeasible;
3833 SCIP_Bool redundant;
3835 SCIP_Bool infeasible;
3959 SCIP_Bool infeasible;
3961 SCIP_Bool redundant;
3989 SCIPdebugMsg(
scip,
"preprocess xor constraint pair <%s>[chg:%u] and <%s>[chg:%u]\n",
4229 SCIPdebugMsg(
scip,
"xor constraints <%s> and <%s> are redundant: delete <%s>\n",
4328 SCIPdebugMsg(
scip,
"xor constraint <%s> is superset of <%s> with parity %u\n",
4373 SCIPdebugMsg(
scip,
"xor constraint <%s> is subset of <%s> with parity %u\n",
4398 SCIPdebugMsg(
scip,
"xor constraints <%s> and <%s> yield sum %u == xor(<%s>,<%s>)\n",
4493 SCIP_Bool modifiable,
4499 SCIP_Bool removable,
4501 SCIP_Bool stickingatnode
4511 if( conshdlr ==
NULL )
4521 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
4522 local, modifiable, dynamic, removable, stickingatnode) );
4658 SCIP_Bool infeasible;
4659 SCIP_Bool redundant;
4805 for(
c = 0;
c < nconss; ++
c )
4828 for( v = (*consdata)->nvars - 1; v >= 0; --v )
4875 *infeasible =
FALSE;
4877 for(
i = 0;
i < nconss && !(*infeasible);
i++ )
4962 for(
i = 0;
i < nconss;
i++ )
4999 for(
i = 0;
i < nconss;
i++ )
5031 for(
i = 0;
i < nconss;
i++ )
5074 for( v = 0; v < consdata->nvars; ++v )
5080 if( consdata->intvar !=
NULL )
5122 else if( nfixedvars > 0 || nchgbds > 0 )
5133 freq = conshdlrdata->gausspropfreq;
5134 if ( (
depth == 0 && freq == 0) || (freq > 0 &&
depth % freq == 0) )
5159 for(
c = nconss - 1;
c >= 0; --
c )
5164 for( v = consdata->nvars - 1; v >= 0; --v )
5188 for(
c = 0;
c < nconss; ++
c )
5195 for( v = 0; v < consdata->nvars; ++v )
5214 SCIP_Bool redundant;
5247 consdata->propagated =
FALSE;
5266 assert(consdata->nvars >= 2);
5269 if( consdata->nvars == 2 )
5271 SCIPdebugMsg(
scip,
"xor constraint <%s> has only two unfixed variables, rhs=%u\n",
5280 if( !consdata->rhs )
5351 nfixedvars, naggrvars, ndelconss, naddconss, &
cutoff) );
5353 if( conshdlrdata->presolpairwise )
5358 lastndelconss = *ndelconss;
5367 &
cutoff, nfixedvars, naggrvars, ndelconss, naddconss, nchgcoefs) );
5373 lastndelconss = *ndelconss;
5395 int naddedconss = 0;
5402 if ( consdata->extvars !=
NULL )
5405 if ( conshdlrdata->addflowextended )
5413 (*naddconss) += naddedconss;
5444 for(
i = 0;
i < consdata->nvars; ++
i )
5450 if( consdata->intvar !=
NULL )
5481 const char* consname;
5507 if( intvar !=
NULL )
5523 targetintvar, initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable,
5555 targetintvar, initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable,
5621 str += *(
str+1) ==
'=' ? 2 : 1;
5651 if( intvar ==
NULL )
5669 if( intvar !=
NULL )
5673 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
5679 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
5707 if ( consdata->intvar !=
NULL )
5716 if ( consdata->intvar !=
NULL )
5717 vars[consdata->nvars] = consdata->intvar;
5719 if ( consdata->nextvars > 0 )
5722 cnt = consdata->nvars +
nintvar;
5723 for (
j = 0;
j < consdata->extvarssize; ++
j)
5725 if ( consdata->extvars[
j] !=
NULL )
5726 vars[cnt++] = consdata->extvars[
j];
5728 assert( cnt == consdata->nvars +
nintvar + consdata->nextvars );
5748 if( consdata->intvar ==
NULL )
5749 (*nvars) = consdata->nvars + consdata->nextvars;
5751 (*
nvars) = consdata->nvars + 1 + consdata->nextvars;
5780 consdata->sorted =
FALSE;
5783 consdata->propagated =
FALSE;
5845 "constraints/xor/presolpairwise",
5846 "should pairwise constraint comparison be performed in presolving?",
5850 "constraints/xor/presolusehashing",
5851 "should hash table be used for detecting redundant constraints in advance?",
5855 "constraints/xor/addextendedform",
5856 "should the extended formulation be added in presolving?",
5860 "constraints/xor/addflowextended",
5861 "should the extended flow formulation be added (nonsymmetric formulation otherwise)?",
5865 "constraints/xor/separateparity",
5866 "should parity inequalities be separated?",
5870 "constraints/xor/gausspropfreq",
5871 "frequency for applying the Gauss propagator",
5900 SCIP_Bool modifiable,
5906 SCIP_Bool removable,
5908 SCIP_Bool stickingatnode
5918 if( conshdlr ==
NULL )
5928 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
5929 local, modifiable, dynamic, removable, stickingatnode) );
5974 return consdata->nvars;
5997 return consdata->vars;
6020 return consdata->intvar;
6042 return consdata->rhs;
Constraint handler for linear constraints in their most general form, .
Constraint handler for the set partitioning / packing / covering constraints .
static SCIP_RETCODE addRelaxation(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
static SCIP_RETCODE consdataFreeRows(SCIP *scip, SCIP_CONSDATA *consdata)
static SCIP_RETCODE addCoef(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
#define DEFAULT_SEPARATEPARITY
static SCIP_RETCODE consdataSwitchWatchedvars(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int watchedvar1, int watchedvar2)
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
static SCIP_RETCODE addExtendedAsymmetricFormulation(SCIP *scip, SCIP_CONS *cons, int *naggrvars, int *naddedconss)
static SCIP_RETCODE checkSystemGF2(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_SOL *currentsol, SCIP_RESULT *result)
static SCIP_RETCODE delCoefPos(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)
#define CONSHDLR_CHECKPRIORITY
static SCIP_RETCODE setIntvar(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
static SCIP_RETCODE checkCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checklprows, SCIP_Bool *violated)
#define DEFAULT_ADDFLOWEXTENDED
static SCIP_RETCODE createRelaxation(SCIP *scip, SCIP_CONS *cons)
#define CONSHDLR_PROP_TIMING
static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)
#define DEFAULT_GAUSSPROPFREQ
static SCIP_RETCODE unlockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
#define CONSHDLR_MAXPREROUNDS
static SCIP_RETCODE cliquePresolve(SCIP *scip, SCIP_CONS *cons, int *nfixedvars, int *nchgcoefs, int *ndelconss, int *naddconss, SCIP_Bool *cutoff)
#define DEFAULT_PRESOLPAIRWISE
#define CONSHDLR_SEPAPRIORITY
static SCIP_RETCODE analyzeConflict(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, PROPRULE proprule)
static SCIP_Bool allRowsInLP(SCIP_CONSDATA *consdata)
#define MAXXORCONSSSYSTEM
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_Bool rhs, int nvars, SCIP_VAR **vars, SCIP_VAR *intvar)
static SCIP_RETCODE lockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
static SCIP_RETCODE consdataEnsureVarsSize(SCIP *scip, SCIP_CONSDATA *consdata, int num)
#define DEFAULT_PRESOLUSEHASHING
static void solveRowEchelonGF2(int m, int n, int r, int *p, int *s, Type **A, Type *b, Type *x)
static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE propagateCons(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, int *nfixedvars, int *nchgbds)
#define MINGAINPERNMINCOMPARISONS
static SCIP_RETCODE addExtendedFlowFormulation(SCIP *scip, SCIP_CONS *cons, int *naggrvars, int *naddedconss)
static SCIP_RETCODE addConflictBounds(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, SCIP_BDCHGIDX *bdchgidx, PROPRULE proprule)
#define CONSHDLR_PROPFREQ
static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool separateparity, SCIP_Bool *separated, SCIP_Bool *cutoff)
#define CONSHDLR_PRESOLTIMING
static SCIP_RETCODE detectRedundantConstraints(SCIP *scip, BMS_BLKMEM *blkmem, SCIP_CONS **conss, int nconss, int *firstchange, int *nchgcoefs, int *nfixedvars, int *naggrvars, int *ndelconss, int *naddconss, SCIP_Bool *cutoff)
static void consdataSort(SCIP_CONSDATA *consdata)
static SCIP_RETCODE preprocessConstraintPairs(SCIP *scip, SCIP_CONS **conss, int firstchange, int chkind, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *ndelconss, int *naddconss, int *nchgcoefs)
#define CONSHDLR_EAGERFREQ
#define DEFAULT_ADDEXTENDEDFORM
static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE createConsXorIntvar(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_Bool rhs, int nvars, SCIP_VAR **vars, SCIP_VAR *intvar, 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)
#define CONSHDLR_ENFOPRIORITY
#define LINCONSUPGD_PRIORITY
static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, PROPRULE proprule, SCIP_BDCHGIDX *bdchgidx, SCIP_RESULT *result)
#define CONSHDLR_DELAYSEPA
static int computeRowEchelonGF2(SCIP *scip, int m, int n, int *p, int *s, Type **A, Type *b)
static SCIP_RETCODE applyFixings(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int *nchgcoefs, int *naggrvars, int *naddconss, SCIP_Bool *cutoff)
#define CONSHDLR_DELAYPROP
static SCIP_RETCODE consdataPrint(SCIP *scip, SCIP_CONSDATA *consdata, FILE *file, SCIP_Bool endline)
Constraint handler for XOR constraints, .
#define SCIPdebugGetSolVal(scip, var, val)
#define SCIPdebugAddSolVal(scip, var, val)
#define SCIP_MAXTREEDEPTH
SCIP_RETCODE SCIPincludeLinconsUpgrade(SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)
int SCIPgetNVarsXor(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBasicXor(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_Bool rhs, int nvars, SCIP_VAR **vars)
SCIP_VAR * SCIPgetIntVarXor(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsXor(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_Bool rhs, 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 SCIPaddCoefSetppc(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
#define SCIP_DECL_LINCONSUPGD(x)
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_Bool SCIPgetRhsXor(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsXor(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPincludeConshdlrXor(SCIP *scip)
SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisPresolveFinished(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVars(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)
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)
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPheurPassSolAddSol(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL *sol)
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 SCIPswapPointers(void **pointer1, void **pointer2)
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)),)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(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_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_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_Bool SCIPconsIsModifiable(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_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
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)
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIPgetRowLPActivity(SCIP *scip, SCIP_ROW *row)
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 SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
void SCIPupdateSolConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
SCIP_RETCODE SCIPcheckSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *feasible)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
SCIP_Bool SCIPinRepropagation(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
int SCIPvarCompareActiveAndNegated(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
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 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_Real SCIPvarGetAggrConstant(SCIP_VAR *var)
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_Real SCIPvarGetAggrScalar(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetIndex(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_Bool SCIPvarIsRemovable(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_Real SCIPcomputeVarLbLocal(SCIP *scip, SCIP_VAR *var)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
SCIP_Real SCIPcomputeVarUbLocal(SCIP *scip, SCIP_VAR *var)
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
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_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortRealIntPtr(SCIP_Real *realarray, int *intarray, void **ptrarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPskipSpace(char **s)
SCIPfreeSol(scip, &heurdata->sol))
SCIPcreateSol(scip, &heurdata->sol, heur))
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
primal heuristic that tries a given solution
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 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 problem copies
public methods for cuts and aggregation rows
public methods for event handler plugins and event handlers
public methods for primal heuristic plugins and divesets
public methods for the LP relaxation, rows and columns
public methods for memory management
public methods for message handling
public methods for numerical tolerances
public methods for SCIP parameter handling
public methods for global and local (sub)problems
public methods for the probing mode
public methods for solutions
public methods for the branch-and-bound tree
public methods for SCIP variables
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSINITPRE(x)
#define SCIP_DECL_CONSDELETE(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSSEPALP(x)
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSRESPROP(x)
#define SCIP_DECL_CONSENFOPS(x)
#define SCIP_DECL_CONSPARSE(x)
#define SCIP_DECL_CONSTRANS(x)
#define SCIP_DECL_CONSPRESOL(x)
#define SCIP_DECL_CONSINITLP(x)
#define SCIP_DECL_CONSEXITPRE(x)
#define SCIP_DECL_CONSLOCK(x)
#define SCIP_DECL_CONSCOPY(x)
struct SCIP_ConsData SCIP_CONSDATA
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSHDLRCOPY(x)
#define SCIP_DECL_CONSEXITSOL(x)
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
#define SCIP_EVENTTYPE_BOUNDCHANGED
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_VARFIXED
#define SCIP_DECL_EVENTEXEC(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_INITPRESOLVE
@ SCIP_STAGE_EXITPRESOLVE
#define SCIP_PRESOLTIMING_MEDIUM
#define SCIP_PRESOLTIMING_EXHAUSTIVE
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
enum SCIP_Vartype SCIP_VARTYPE