89#define CONSHDLR_NAME "xor"
90#define CONSHDLR_DESC "constraint handler for xor constraints: r = xor(x1, ..., xn)"
91#define CONSHDLR_SEPAPRIORITY +850200
92#define CONSHDLR_ENFOPRIORITY -850200
93#define CONSHDLR_CHECKPRIORITY -850200
94#define CONSHDLR_SEPAFREQ 0
95#define CONSHDLR_PROPFREQ 1
96#define CONSHDLR_EAGERFREQ 100
98#define CONSHDLR_MAXPREROUNDS -1
99#define CONSHDLR_DELAYSEPA FALSE
100#define CONSHDLR_DELAYPROP FALSE
101#define CONSHDLR_NEEDSCONS TRUE
103#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
104#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_ALWAYS
106#define EVENTHDLR_NAME "xor"
107#define EVENTHDLR_DESC "event handler for xor constraints"
109#define LINCONSUPGD_PRIORITY +600000
111#define DEFAULT_PRESOLPAIRWISE TRUE
112#define DEFAULT_ADDEXTENDEDFORM FALSE
113#define DEFAULT_ADDFLOWEXTENDED FALSE
114#define DEFAULT_SEPARATEPARITY FALSE
115#define DEFAULT_GAUSSPROPFREQ 5
116#define HASHSIZE_XORCONS 500
117#define DEFAULT_PRESOLUSEHASHING TRUE
118#define NMINCOMPARISONS 200000
119#define MINGAINPERNMINCOMPARISONS 1e-06
120#define MAXXORCONSSSYSTEM 1000
121#define MAXXORVARSSYSTEM 1000
149 unsigned int deleteintvar:1;
150 unsigned int propagated:1;
151 unsigned int sorted:1;
152 unsigned int changed:1;
156struct SCIP_ConshdlrData
159 SCIP_Bool presolpairwise;
160 SCIP_Bool presolusehashing;
161 SCIP_Bool addextendedform;
162 SCIP_Bool addflowextended;
163 SCIP_Bool separateparity;
234 (*conshdlrdata)->eventhdlr = eventhdlr;
263 assert(watchedvar1 == -1 || watchedvar1 != watchedvar2);
264 assert(watchedvar1 != -1 || watchedvar2 == -1);
269 if( watchedvar1 == consdata->watchedvar2 || watchedvar2 == consdata->watchedvar1 )
273 tmp = consdata->watchedvar1;
274 consdata->watchedvar1 = consdata->watchedvar2;
275 consdata->watchedvar2 =
tmp;
276 tmp = consdata->filterpos1;
277 consdata->filterpos1 = consdata->filterpos2;
278 consdata->filterpos2 =
tmp;
280 assert(watchedvar1 == -1 || watchedvar1 != consdata->watchedvar2);
281 assert(watchedvar2 == -1 || watchedvar2 != consdata->watchedvar1);
284 if( consdata->watchedvar1 != -1 && consdata->watchedvar1 != watchedvar1 )
286 assert(consdata->filterpos1 != -1);
290 if( consdata->watchedvar2 != -1 && consdata->watchedvar2 != watchedvar2 )
292 assert(consdata->filterpos2 != -1);
298 if( watchedvar1 != -1 && watchedvar1 != consdata->watchedvar1 )
303 if( watchedvar2 != -1 && watchedvar2 != consdata->watchedvar2 )
310 consdata->watchedvar1 = watchedvar1;
311 consdata->watchedvar2 = watchedvar2;
325 assert(consdata->nvars <= consdata->varssize);
327 if( num > consdata->varssize )
359 (*consdata)->rhs = rhs;
360 (*consdata)->intvar = intvar;
362 (*consdata)->rows[
r] =
NULL;
363 (*consdata)->nvars =
nvars;
364 (*consdata)->varssize =
nvars;
365 (*consdata)->watchedvar1 = -1;
366 (*consdata)->watchedvar2 = -1;
367 (*consdata)->filterpos1 = -1;
368 (*consdata)->filterpos2 = -1;
369 (*consdata)->deleteintvar = (intvar ==
NULL);
370 (*consdata)->propagated =
FALSE;
371 (*consdata)->sorted =
FALSE;
372 (*consdata)->changed =
TRUE;
373 (*consdata)->extvars =
NULL;
374 (*consdata)->nextvars = 0;
375 (*consdata)->extvarssize = 0;
382 if( (*consdata)->intvar !=
NULL )
398 for( v = (*consdata)->nvars - 1; v >= 0; --v )
410 for(
int v = 0; v < (*consdata)->nvars; ++v )
417 if( (*consdata)->intvar !=
NULL )
439 if( consdata->rows[
r] !=
NULL )
467 if ( (*consdata)->nextvars > 0 )
470 for (
j = 0;
j < (*consdata)->extvarssize; ++
j)
472 if ( (*consdata)->extvars[
j] !=
NULL )
479 (*consdata)->nextvars = 0;
480 (*consdata)->extvarssize = 0;
485 assert((*consdata)->watchedvar1 == -1);
486 assert((*consdata)->watchedvar2 == -1);
493 if( (*consdata)->intvar !=
NULL )
530 if( consdata->intvar !=
NULL )
552 SCIP_Bool transformed;
572 if( consdata->intvar !=
NULL )
578 consdata->intvar =
var;
579 consdata->changed =
TRUE;
586 if( consdata->rows[0] !=
NULL )
588 SCIPerrorMessage(
"cannot change intvar of xor constraint after LP relaxation was created\n");
604 SCIP_Bool transformed;
624 consdata->vars[consdata->nvars] =
var;
626 consdata->sorted = (consdata->nvars == 1);
627 consdata->changed =
TRUE;
652 if( consdata->rows[0] !=
NULL )
654 SCIPerrorMessage(
"cannot add coefficients to xor constraint after LP relaxation was created\n");
693 if( consdata->watchedvar1 == pos )
697 if( consdata->watchedvar2 == pos )
702 assert(pos != consdata->watchedvar1);
703 assert(pos != consdata->watchedvar2);
706 consdata->vars[pos] = consdata->vars[consdata->nvars-1];
710 if( consdata->watchedvar1 == consdata->nvars )
711 consdata->watchedvar1 = pos;
712 if( consdata->watchedvar2 == consdata->nvars )
713 consdata->watchedvar2 = pos;
715 consdata->propagated =
FALSE;
716 consdata->sorted =
FALSE;
717 consdata->changed =
TRUE;
730 if( !consdata->sorted )
732 if( consdata->nvars <= 1 )
733 consdata->sorted =
TRUE;
740 if( consdata->watchedvar1 != -1 )
742 var1 = consdata->vars[consdata->watchedvar1];
744 consdata->watchedvar1 = -1;
745 if( consdata->watchedvar2 != -1 )
747 var2 = consdata->vars[consdata->watchedvar2];
749 consdata->watchedvar2 = -1;
752 assert(consdata->watchedvar1 == -1);
753 assert(consdata->watchedvar2 == -1);
758 consdata->sorted =
TRUE;
768 for( v = consdata->nvars - 1; v >= 0; --v )
770 if( consdata->vars[v] ==
var1 )
772 consdata->watchedvar1 = v;
773 if(
var2 ==
NULL || consdata->watchedvar2 != -1 )
776 else if( consdata->vars[v] ==
var2 )
779 consdata->watchedvar2 = v;
780 if( consdata->watchedvar1 != -1 )
784 assert(consdata->watchedvar1 != -1);
786 assert(consdata->watchedvar1 < consdata->nvars);
787 assert(consdata->watchedvar2 < consdata->nvars);
797 for( v = 0; v < consdata->nvars; ++v )
868 assert(consdata->nvars > 0);
872 assert(consdata->vars[consdata->nvars / 2] !=
NULL);
873 assert(consdata->vars[consdata->nvars - 1] !=
NULL);
905 assert(consdata->nvars == 0 || consdata->vars !=
NULL);
916 var = consdata->vars[v];
929 consdata->rhs = !consdata->rhs;
949 consdata->rhs = !consdata->rhs;
976 v = consdata->nvars-2;
979 if( consdata->vars[v] == consdata->vars[v+1] )
984 newvars[2] = consdata->vars[v];
988 SCIPdebugMsg(
scip,
"xor constraint <%s>: deleting pair of equal variables <%s>\n",
993 v =
MIN(v, consdata->nvars-1);
1001 if( consdata->intvar !=
NULL )
1021 newvars[1] = consdata->intvar;
1043 SCIPdebugMsg(
scip,
"xor constraint <%s>: deleting pair of negated variables <%s> and <%s>\n",
1048 consdata->rhs = !consdata->rhs;
1049 v =
MIN(v, consdata->nvars-1);
1056 if( consdata->rhs && consdata->intvar !=
NULL )
1064 SCIP_Bool infeasible;
1065 SCIP_Bool redundant;
1118 newvars[0] = consdata->intvar;
1193 if ( consdata->extvars !=
NULL )
1197 if ( consdata->nvars <= 3 )
1202 assert( consdata->nextvars == 0 );
1203 assert( consdata->extvarssize == 0 );
1206 consdata->extvarssize = 4 * (consdata->nvars);
1210 for (
i = 0;
i < consdata->nvars; ++
i)
1218 SCIP_Real rhs = 0.0;
1219 SCIP_Bool infeasible =
FALSE;
1220 SCIP_Bool redundant =
FALSE;
1228 SCIP_CALL(
SCIPcreateVar(
scip, &
varnn, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1232 SCIP_CALL(
SCIPcreateVar(
scip, &
varns, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1248 if (
i == consdata->nvars-1 )
1250 if ( consdata->rhs )
1254 SCIP_CALL(
SCIPcreateVar(
scip, &
varns, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1258 SCIP_CALL(
SCIPcreateVar(
scip, &
varss, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1276 SCIP_CALL(
SCIPcreateVar(
scip, &
varnn, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1280 SCIP_CALL(
SCIPcreateVar(
scip, &
varsn, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1299 SCIP_CALL(
SCIPcreateVar(
scip, &
varnn, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1303 SCIP_CALL(
SCIPcreateVar(
scip, &
varns, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1307 SCIP_CALL(
SCIPcreateVar(
scip, &
varsn, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1311 SCIP_CALL(
SCIPcreateVar(
scip, &
varss, name, 0.0, 1.0, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1332 vars[cnt] = consdata->vars[
i];
1427 consdata->extvars[4*
i] =
varnn;
1428 consdata->extvars[4*
i + 1] =
varns;
1429 consdata->extvars[4*
i + 2] =
varsn;
1430 consdata->extvars[4*
i + 3] =
varss;
1433 ++(consdata->nextvars);
1435 ++(consdata->nextvars);
1437 ++(consdata->nextvars);
1439 ++(consdata->nextvars);
1499 if ( consdata->extvars !=
NULL )
1503 if ( consdata->nvars <= 3 )
1508 assert( consdata->nextvars == 0 );
1511 consdata->extvarssize = consdata->nvars;
1512 consdata->nextvars = consdata->nvars;
1516 for (
i = 0;
i < consdata->nvars; ++
i)
1518 SCIP_Bool infeasible =
FALSE;
1519 SCIP_Bool redundant =
FALSE;
1527 if (
i == consdata->nvars-1 )
1529 if ( consdata->rhs )
1543 SCIP_CALL(
SCIPcreateVar(
scip, &
artvar, name, lb, ub, 0.0,
SCIP_VARTYPE_IMPLINT,
SCIPconsIsInitial(cons),
SCIPconsIsRemovable(cons),
NULL,
NULL,
NULL,
NULL,
NULL) );
1566 vars[2] = consdata->vars[
i];
1583 vars[2] = consdata->vars[
i];
1600 vars[2] = consdata->vars[
i];
1617 vars[2] = consdata->vars[
i];
1631 consdata->extvars[
i] =
artvar;
1670 if( consdata->intvar ==
NULL )
1675 ub = consdata->nvars/2;
1681#ifdef WITH_DEBUG_SOLUTION
1688 for( v = consdata->nvars - 1; v >= 0; --v )
1691 count += (solval > 0.5 ? 1 : 0);
1693 assert((count - consdata->rhs) % 2 == 0);
1694 solval = (
SCIP_Real) ((count - consdata->rhs) / 2);
1706 rhsval = (consdata->rhs ? 1.0 : 0.0);
1712 else if( !consdata->rhs )
1718 for(
r = 0;
r < 3; ++
r )
1725 for( v = 0; v < 3; ++v )
1738 if( consdata->intvar !=
NULL )
1752 for(
r = 0;
r < 3; ++
r )
1759 for( v = 0; v < 3; ++v )
1772 if( consdata->intvar !=
NULL )
1789 SCIP_Bool* infeasible
1800 if( consdata->rows[0] ==
NULL )
1805 for(
r = 0;
r <
NROWS && !(*infeasible); ++
r )
1824 if( consdata->rows[0] ==
NULL )
1874 odd = consdata->rhs;
1876 for(
i = 0;
i < consdata->nvars; ++
i )
1880 odd = (
odd != (solval > 0.5));
1893 else if( consdata->intvar !=
NULL )
1903 if( *violated &&
sol ==
NULL )
1908 else if ( *violated &&
sol !=
NULL )
1959 SCIP_Bool separateparity,
1978 if( consdata->rows[0] ==
NULL )
2001 if ( separateparity && consdata->nvars > 3 )
2004 SCIP_Real maxval = -1.0;
2005 SCIP_Real minval = 2.0;
2006 SCIP_Real sum = 0.0;
2016 for (
j = 0;
j < consdata->nvars; ++
j)
2043 if ( (cnt - (
int) consdata->rhs) % 2 == 1 )
2049 SCIPdebugMsg(
scip,
"found violated parity cut (efficiacy: %f)\n", 1.0 - sum);
2056 for (
j = 0;
j < consdata->nvars; ++
j)
2084 SCIPdebugMsg(
scip,
"found violated parity cut (efficiacy: %f, minval: %f)\n", 1.0 - (sum - 1.0 + 2.0 * minval), minval);
2092 for (
j = 0;
j < consdata->nvars; ++
j)
2120 SCIPdebugMsg(
scip,
"found violated parity cut (efficiacy: %f, maxval: %f)\n", 1.0 - (sum + 1.0 - 2.0 * maxval), maxval);
2128 for (
j = 0;
j < consdata->nvars; ++
j)
2189 for (
i = 0;
i < m; ++
i)
2196 for (
i = 0;
i < m &&
i < n; ++
i)
2211 while (
k < m && A[
p[
k]][
j] == 0 )
2246 for (
k =
i+1;
k < m; ++
k)
2250 if ( A[
pk][s[
i]] != 0 )
2252 for (
j = s[
i];
j < n; ++
j)
2253 A[
pk][
j] = A[
pk][
j] ^ A[pi][
j];
2259 if (
i % 100 == 99 )
2299 for (
k = 0;
k < n; ++
k)
2303 for (
i =
r-1;
i >= 0; --
i)
2311 for (
k =
i+1;
k <
r; ++
k)
2314 if ( A[
p[
i]][s[
k]] != 0 )
2315 val = val ^
x[s[
k]];
2373 SCIPdebugMsg(
scip,
"Checking feasibility via the linear equation system over GF2 using Gauss.\n");
2385 for (
i = 0;
i < nconss; ++
i)
2396 for (
j = 0;
j < consdata->nvars; ++
j)
2400 var = consdata->vars[
j];
2433#ifdef SCIP_DISABLED_CODE
2440 for (
j = 0;
j < consdata->nvars; ++
j)
2448 if ( ( cnt - consdata->rhs ) % 2 != 0 )
2494 for (
i = 0;
i < nconss; ++
i)
2502 assert( consdata->nvars > 0 );
2509 for (
j = 0;
j < consdata->nvars; ++
j)
2514 var = consdata->vars[
j];
2640 SCIP_Bool tightened;
2641 SCIP_Bool infeasible;
2689 if ( heurtrysol !=
NULL )
2735 for (
i = 0;
i < nconss; ++
i)
2746 for (
j = 0;
j < consdata->nvars; ++
j)
2752 assert( !
noaggr || nones % 2 == (
int) consdata->rhs );
2753 if ( (
unsigned int) nones != consdata->rhs )
2755 val = (
SCIP_Real) (nones - (
int) consdata->rhs)/2;
2794 for (
i = nconss - 1;
i >= 0 ; --
i)
2799 if ( consdata->nvars == 0 )
2838 vars = consdata->vars;
2839 nvars = consdata->nvars;
2971 SCIP_Bool infeasible;
2972 SCIP_Bool tightened;
2996 vars = consdata->vars;
2997 nvars = consdata->nvars;
3000 if( consdata->propagated )
3013 watchedvar1 = consdata->watchedvar1;
3014 watchedvar2 = consdata->watchedvar2;
3017 if( watchedvar1 != -1 )
3022 if( watchedvar2 != -1 )
3029 if( watchedvar1 == -1 )
3031 watchedvar1 = watchedvar2;
3034 assert(watchedvar1 != -1 || watchedvar2 == -1);
3037 odd = consdata->rhs;
3041 if( watchedvar2 == -1 )
3057 if( watchedvar1 == -1 )
3059 assert(watchedvar2 == -1);
3062 else if( watchedvar2 == -1 && watchedvar1 !=
i )
3070 assert(watchedvar1 != -1 || watchedvar2 == -1);
3073 if( watchedvar1 == -1 )
3075 assert(watchedvar2 == -1);
3091 if ( consdata->intvar !=
NULL && !consdata->deleteintvar )
3096 assert( (nfixedones - (
int) consdata->rhs) % 2 == 0 );
3098 fixval = (nfixedones - (int) consdata->rhs)/2;
3106 SCIPdebugMsg(
scip,
"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n",
3117 SCIPdebugMsg(
scip,
"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n",
3155 if( watchedvar2 == -1 )
3157 assert(watchedvar1 != -1);
3160 SCIPdebugMsg(
scip,
"constraint <%s>: only one unfixed variable -> fix <%s> to %u\n",
3178 assert( (nfixedones - (
int) consdata->rhs) % 2 == 0 );
3180 fixval = (nfixedones - (int) consdata->rhs)/2;
3187 SCIPdebugMsg(
scip,
"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n",
3198 SCIPdebugMsg(
scip,
"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n",
3234 if ( consdata->intvar !=
NULL && !consdata->deleteintvar )
3243 assert(nfixedzeros == 0);
3372 consdata->propagated =
TRUE;
3392 SCIPdebugMsg(
scip,
"resolving fixations according to rule %d\n", (
int) proprule);
3437 vars = consdata->vars;
3438 nvars = consdata->nvars;
3444 if( !consdata->deleteintvar )
3448 if( !consdata->changed )
3584 SCIP_Bool infeasible;
3587 SCIPdebugMsg(
scip,
"all variables of xor constraints <%s> are in one clique, so fixed all variables to 0\n",
3591 for( v =
nvars - 1; v >= 0; --v )
3620 if( !consdata->rhs )
3628 for( v = 0; v <
nvars; ++v )
3664 if( consdata->intvar !=
NULL )
3666 SCIP_Bool infeasible;
3717 hashtablesize = nconss;
3724 for(
c = 0;
c < nconss; ++
c )
3771 SCIP_Bool infeasible;
3785 SCIP_Bool infeasible;
3835 SCIP_Bool redundant;
3837 SCIP_Bool infeasible;
3961 SCIP_Bool infeasible;
3963 SCIP_Bool redundant;
3991 SCIPdebugMsg(
scip,
"preprocess xor constraint pair <%s>[chg:%u] and <%s>[chg:%u]\n",
4231 SCIPdebugMsg(
scip,
"xor constraints <%s> and <%s> are redundant: delete <%s>\n",
4330 SCIPdebugMsg(
scip,
"xor constraint <%s> is superset of <%s> with parity %u\n",
4375 SCIPdebugMsg(
scip,
"xor constraint <%s> is subset of <%s> with parity %u\n",
4400 SCIPdebugMsg(
scip,
"xor constraints <%s> and <%s> yield sum %u == xor(<%s>,<%s>)\n",
4495 SCIP_Bool modifiable,
4501 SCIP_Bool removable,
4503 SCIP_Bool stickingatnode
4513 if( conshdlr ==
NULL )
4523 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
4524 local, modifiable, dynamic, removable, stickingatnode) );
4660 SCIP_Bool infeasible;
4661 SCIP_Bool redundant;
4774 SCIP_Real constant = 0.0;
4863 for(
c = 0;
c < nconss; ++
c )
4886 for( v = (*consdata)->nvars - 1; v >= 0; --v )
4933 *infeasible =
FALSE;
4935 for(
i = 0;
i < nconss && !(*infeasible);
i++ )
5020 for(
i = 0;
i < nconss;
i++ )
5057 for(
i = 0;
i < nconss;
i++ )
5089 for(
i = 0;
i < nconss;
i++ )
5132 for( v = 0; v < consdata->nvars; ++v )
5138 if( consdata->intvar !=
NULL )
5180 else if( nfixedvars > 0 || nchgbds > 0 )
5191 freq = conshdlrdata->gausspropfreq;
5192 if ( (
depth == 0 && freq == 0) || (freq > 0 &&
depth % freq == 0) )
5217 for(
c = nconss - 1;
c >= 0; --
c )
5222 for( v = consdata->nvars - 1; v >= 0; --v )
5246 for(
c = 0;
c < nconss; ++
c )
5253 for( v = 0; v < consdata->nvars; ++v )
5272 SCIP_Bool redundant;
5305 consdata->propagated =
FALSE;
5324 assert(consdata->nvars >= 2);
5327 if( consdata->nvars == 2 )
5329 SCIPdebugMsg(
scip,
"xor constraint <%s> has only two unfixed variables, rhs=%u\n",
5338 if( !consdata->rhs )
5409 nfixedvars, naggrvars, ndelconss, naddconss, &
cutoff) );
5411 if( conshdlrdata->presolpairwise )
5416 lastndelconss = *ndelconss;
5425 &
cutoff, nfixedvars, naggrvars, ndelconss, naddconss, nchgcoefs) );
5431 lastndelconss = *ndelconss;
5453 int naddedconss = 0;
5460 if ( consdata->extvars !=
NULL )
5463 if ( conshdlrdata->addflowextended )
5471 (*naddconss) += naddedconss;
5502 for(
i = 0;
i < consdata->nvars; ++
i )
5508 if( consdata->intvar !=
NULL )
5539 const char* consname;
5565 if( intvar !=
NULL )
5581 targetintvar, initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable,
5613 targetintvar, initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable,
5679 str += *(
str+1) ==
'=' ? 2 : 1;
5709 if( intvar ==
NULL )
5727 if( intvar !=
NULL )
5731 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
5737 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
5765 if ( consdata->intvar !=
NULL )
5774 if ( consdata->intvar !=
NULL )
5775 vars[consdata->nvars] = consdata->intvar;
5777 if ( consdata->nextvars > 0 )
5780 cnt = consdata->nvars +
nintvar;
5781 for (
j = 0;
j < consdata->extvarssize; ++
j)
5783 if ( consdata->extvars[
j] !=
NULL )
5784 vars[cnt++] = consdata->extvars[
j];
5786 assert( cnt == consdata->nvars +
nintvar + consdata->nextvars );
5806 if( consdata->intvar ==
NULL )
5807 (*nvars) = consdata->nvars + consdata->nextvars;
5809 (*
nvars) = consdata->nvars + 1 + consdata->nextvars;
5856 consdata->sorted =
FALSE;
5859 consdata->propagated =
FALSE;
5923 "constraints/xor/presolpairwise",
5924 "should pairwise constraint comparison be performed in presolving?",
5928 "constraints/xor/presolusehashing",
5929 "should hash table be used for detecting redundant constraints in advance?",
5933 "constraints/xor/addextendedform",
5934 "should the extended formulation be added in presolving?",
5938 "constraints/xor/addflowextended",
5939 "should the extended flow formulation be added (nonsymmetric formulation otherwise)?",
5943 "constraints/xor/separateparity",
5944 "should parity inequalities be separated?",
5948 "constraints/xor/gausspropfreq",
5949 "frequency for applying the Gauss propagator",
5978 SCIP_Bool modifiable,
5984 SCIP_Bool removable,
5986 SCIP_Bool stickingatnode
5996 if( conshdlr ==
NULL )
6006 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
6007 local, modifiable, dynamic, removable, stickingatnode) );
6052 return consdata->nvars;
6075 return consdata->vars;
6098 return consdata->intvar;
6120 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 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 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,)
SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)),)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_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_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_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
structs for symmetry computations
methods for dealing with symmetry detection graphs
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSINITPRE(x)
#define SCIP_DECL_CONSDELETE(x)
#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
enum SYM_Symtype SYM_SYMTYPE
#define SCIP_PRESOLTIMING_MEDIUM
#define SCIP_PRESOLTIMING_EXHAUSTIVE
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
enum SCIP_Vartype SCIP_VARTYPE