73#include "scip/cons_eqknapsack.h"
77#define CONSHDLR_NAME "pseudoboolean"
78#define CONSHDLR_DESC "constraint handler dealing with pseudo Boolean constraints"
79#define CONSHDLR_ENFOPRIORITY -1000000
80#define CONSHDLR_CHECKPRIORITY -5000000
81#define CONSHDLR_EAGERFREQ 100
83#define CONSHDLR_MAXPREROUNDS -1
84#define CONSHDLR_NEEDSCONS TRUE
86#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_MEDIUM
88#define DEFAULT_DECOMPOSENORMALPBCONS FALSE
89#define DEFAULT_DECOMPOSEINDICATORPBCONS TRUE
91#define DEFAULT_SEPARATENONLINEAR TRUE
92#define DEFAULT_PROPAGATENONLINEAR TRUE
93#define DEFAULT_REMOVABLENONLINEAR TRUE
94#define NONLINCONSUPGD_PRIORITY 60000
97#undef NONLINCONSUPGD_PRIORITY
102#define HASHSIZE_PSEUDOBOOLEANNONLINEARTERMS 500
201 unsigned int issoftcons:1;
202 unsigned int changed:1;
203 unsigned int propagated:1;
204 unsigned int presolved:1;
205 unsigned int cliquesadded:1;
206 unsigned int upgradetried:1;
210struct SCIP_ConshdlrData
214 int nallconsanddatas;
216 int sallconsanddatas;
259 if( varind1 == -1 && varind2 == -1 )
265 if( varind1 < varind2 )
267 if( varind1 > varind2 )
270 if( varneg1 && !varneg2 )
272 if( !varneg1 && varneg2 )
301 consand1 = consanddata1->
cons;
302 consand2 = consanddata2->
cons;
360 for( v = cdata1->
nvars - 1; v > 0; --v )
363 for( v = cdata2->
nvars - 1; v > 0; --v )
376 for( v = cdata1->
nvars - 1; v >= 0; --v )
382 if( cdata1->
vars[v] != cdata2->
vars[v] )
412 for( v = cdata->
nvars - 1; v > 0; --v )
420 assert(minidx >= 0 && minidx <= maxidx);
434 if( ((*conshdlrdata)->inithashmapandtable) )
448 hashGetKeyAndConsDatas, hashKeyEqAndConsDatas, hashKeyValAndConsDatas, (
void*)
scip) );
454 (*conshdlrdata)->inithashmapandtable =
TRUE;
471 (*conshdlrdata)->allconsanddatas =
NULL;
472 (*conshdlrdata)->nallconsanddatas = 0;
473 (*conshdlrdata)->sallconsanddatas = 10;
478 (*conshdlrdata)->inithashmapandtable =
FALSE;
479 (*conshdlrdata)->hashtable =
NULL;
480 (*conshdlrdata)->hashtablesize = 0;
481 (*conshdlrdata)->hashmap =
NULL;
482 (*conshdlrdata)->hashmapsize = 0;
485 (*conshdlrdata)->nlinconss = 0;
488 (*conshdlrdata)->noriguses = 0;
504 assert((*conshdlrdata)->nallconsanddatas == 0);
507 if( (*conshdlrdata)->inithashmapandtable )
510 (*conshdlrdata)->hashmapsize = 0;
512 (*conshdlrdata)->hashtablesize = 0;
519 (*conshdlrdata)->inithashmapandtable =
FALSE;
524 (*conshdlrdata)->allconsanddatas =
NULL;
525 (*conshdlrdata)->nallconsanddatas = 0;
526 (*conshdlrdata)->sallconsanddatas = 0;
562 case SCIP_LINEARCONSTYPE_EQKNAPSACK:
563 *
nvars = SCIPgetNVarsEQKnapsack(
scip, cons);
625 case SCIP_LINEARCONSTYPE_EQKNAPSACK:
626 *lhs = SCIPgetCapacityEQKnapsack(
scip, cons);
672 for( v = 0; v < *
nvars; ++v )
674 vars[v] = linvars[v];
675 coefs[v] = lincoefs[v];
680 for( v = 0; v < *
nvars; ++v )
681 vars[v] = linvars[v];
693 for( v = 0; v < *
nvars; ++v )
695 vars[v] = linvars[v];
701 for( v = 0; v < *
nvars; ++v )
702 vars[v] = linvars[v];
718 for( v = 0; v < *
nvars; ++v )
720 vars[v] = linvars[v];
726 for( v = 0; v < *
nvars; ++v )
727 vars[v] = linvars[v];
739 for( v = 0; v < *
nvars; ++v )
741 vars[v] = linvars[v];
747 for( v = 0; v < *
nvars; ++v )
748 vars[v] = linvars[v];
753 case SCIP_LINEARCONSTYPE_EQKNAPSACK:
757 *
nvars = SCIPgetNVarsEQKnapsack(
scip, cons);
758 linvars = SCIPgetVarsEQKnapsack(
scip, cons);
763 weights = SCIPgetWeightsEQKnapsack(
scip, cons);
765 for( v = 0; v < *
nvars; ++v )
767 vars[v] = linvars[v];
773 for( v = 0; v < *
nvars; ++v )
774 vars[v] = linvars[v];
822 if( nlinvars !=
NULL )
824 if( nandress !=
NULL )
834 for( v = 0; v <
nvars; ++v )
846 hashmapentryexists =
SCIPhashmapExists(conshdlrdata->hashmap, (
void*)(hashmapvar));
849 hashmapvar =
vars[v];
854 if( hashmapentryexists )
863 if( hashmapentryexists )
871 if( !hashmapentryexists && linvars !=
NULL && nlinvars !=
NULL )
873 linvars[*nlinvars] =
vars[v];
874 if( lincoefs !=
NULL )
877 lincoefs[*nlinvars] = coefs[v];
881 else if( hashmapentryexists && nandress !=
NULL )
883 if( andress !=
NULL )
885 andress[*nandress] = hashmapvar;
887 if( andcoefs !=
NULL )
891 andcoefs[*nandress] = coefs[v];
892 andnegs[*nandress] = (
vars[v] != hashmapvar);
903#ifdef CHECK_CONSISTENCY
943 assert(consdata->nconsanddatas > 0);
944 assert(consdata->nconsanddatas <= consdata->sconsanddatas);
956 assert(
nvars == consdata->nlinvars + consdata->nconsanddatas);
974 andress, andcoefs, andnegs, &nandress) );
975 assert(nlinvars == consdata->nlinvars);
976 assert(nandress == consdata->nconsanddatas);
978 for( v = nandress - 1; v >= 0; --v )
980 SCIP_VAR* andresultant = andress[v];
983 for(
c = consdata->nconsanddatas - 1;
c >= 0; --
c )
986 if( consdata->consanddatas[
c]->cons !=
NULL )
991 if( res == andresultant && consdata->andnegs[
c] == andnegs[v] && consdata->andcoefs[
c] == andcoefs[v] )
998 alreadyfound[
c] =
TRUE;
1007 for(
c = consdata->nconsanddatas - 1;
c >= 0; --
c )
1023#define checkConsConsistency(scip, cons)
1048 tmpvars = consanddata->
vars;
1049 ntmpvars = consanddata->
nvars;
1052 for( v = ntmpvars - 1; v >= 0; --v )
1062 tmpvars = consanddata->
newvars;
1066 for( v = ntmpvars - 1; v >= 0; --v )
1077 if( !origdata || consanddata->
nvars == 0 )
1082 consanddata->
nuses = 0;
1083 consanddata->
nvars = 0;
1084 consanddata->
svars = 0;
1099 if( consanddata->
nvars > 0 )
1110 if( conshdlrdata->inithashmapandtable )
1142 if( conshdlrdata->inithashmapandtable )
1171 int const nandconss,
1191 assert(nandconss == 0 || (andconss !=
NULL && andcoefs !=
NULL));
1209 SCIPerrorMessage(
"left hand side of pseudo boolean constraint greater than right hand side\n");
1220 (*consdata)->issoftcons = issoftcons;
1223 (*consdata)->weight = weight;
1229 (*consdata)->indvar = indvar;
1232 (*consdata)->indvar =
NULL;
1235 if( intvar !=
NULL )
1242 (*consdata)->intvar = intvar;
1245 (*consdata)->intvar =
NULL;
1248 (*consdata)->lincons = lincons;
1249 (*consdata)->linconstype = linconstype;
1261 if( transforming || transformed )
1271 (*consdata)->nlinvars =
nvars - nandconss;
1282 if( andnegs !=
NULL )
1290 (*consdata)->nconsanddatas = nandconss;
1291 (*consdata)->sconsanddatas = nandconss;
1301 for(
c = nandconss - 1;
c >= 0; --
c )
1310 assert((*consdata)->consanddatas[
c]->origcons == andconss[
c] || (*consdata)->consanddatas[
c]->cons == andconss[
c]);
1315 if( (*consdata)->consanddatas[
c]->origcons !=
NULL && (*consdata)->consanddatas[
c]->cons ==
NULL )
1325 assert((*consdata)->consanddatas[
c]->cons !=
NULL);
1326 assert((*consdata)->consanddatas[
c]->newvars ==
NULL);
1327 assert((*consdata)->consanddatas[
c]->isoriginal);
1329 (*consdata)->consanddatas[
c]->istransformed =
TRUE;
1331 vars = (*consdata)->consanddatas[
c]->vars;
1332 ncvars = (*consdata)->consanddatas[
c]->nvars;
1342 for( v = ncvars - 1; v >= 0; --v )
1347 else if( (*consdata)->consanddatas[
c]->cons !=
NULL )
1348 assert((*consdata)->consanddatas[
c]->istransformed);
1350 ++((*consdata)->consanddatas[
c]->nuses);
1352 else if( transformed )
1354 assert((*consdata)->consanddatas[
c]->cons == andconss[
c]);
1356 assert((*consdata)->consanddatas[
c]->istransformed);
1361 SCIPsortPtrPtrRealBool((
void**)andress, (
void**)((*consdata)->consanddatas), (*consdata)->andcoefs, (*consdata)->andnegs, resvarComp, nandconss);
1368 (*consdata)->consanddatas =
NULL;
1369 (*consdata)->andcoefs =
NULL;
1370 (*consdata)->andnegs =
NULL;
1371 (*consdata)->nconsanddatas = 0;
1372 (*consdata)->sconsanddatas = 0;
1376 (*consdata)->lhs = lhs;
1377 (*consdata)->rhs = rhs;
1379 (*consdata)->changed =
TRUE;
1380 (*consdata)->propagated =
FALSE;
1381 (*consdata)->presolved =
FALSE;
1382 (*consdata)->cliquesadded =
FALSE;
1383 (*consdata)->upgradetried =
TRUE;
1392 conshdlrdata->noriguses += (*consdata)->nconsanddatas;
1414 assert((*consdata)->nconsanddatas == 0 || (*consdata)->consanddatas !=
NULL);
1418 if( (*consdata)->lincons !=
NULL )
1423 nconsanddatas = (*consdata)->nconsanddatas;
1424 consanddatas = (*consdata)->consanddatas;
1427 for(
c = nconsanddatas - 1;
c >= 0; --
c )
1429 assert((consanddatas[
c]->origcons ==
NULL) == (consanddatas[
c]->noriguses == 0));
1430 assert((consanddatas[
c]->cons ==
NULL) == (consanddatas[
c]->nuses == 0));
1431 assert(consanddatas[
c]->nuses >= 0);
1432 assert(consanddatas[
c]->noriguses >= 0);
1436 if( !isorig && consanddatas[
c]->cons !=
NULL )
1440 --(consanddatas[
c]->
nuses);
1443 if( consanddatas[
c]->nuses == 0 )
1445 if( conshdlrdata->inithashmapandtable )
1451 if( consanddatas[
c]->origcons ==
NULL )
1463 if( consanddatas[
c]->origcons ==
NULL )
1467 assert(conshdlrdata->nallconsanddatas > 0);
1469 for( d = conshdlrdata->nallconsanddatas - 1; d >= 0; --d )
1471 if( conshdlrdata->allconsanddatas[d] == consanddatas[
c] )
1473 --conshdlrdata->nallconsanddatas;
1477 conshdlrdata->allconsanddatas[d] = conshdlrdata->allconsanddatas[conshdlrdata->nallconsanddatas];
1487 else if( isorig && consanddatas[
c]->origcons !=
NULL )
1490 assert(consanddatas[
c]->nuses == 0);
1491 assert(consanddatas[
c]->nnewvars == 0);
1492 assert(consanddatas[
c]->snewvars == 0);
1498 if( consanddatas[
c]->noriguses == 0 )
1502 if( conshdlrdata->inithashmapandtable )
1517 assert(consanddatas[
c]->svars > 0);
1521 consanddatas[
c]->
nvars = 0;
1522 consanddatas[
c]->
svars = 0;
1527 assert(consanddatas[
c]->svars == 0);
1534 assert(conshdlrdata->nallconsanddatas > 0);
1535 for( d = conshdlrdata->nallconsanddatas - 1; d >= 0; --d )
1537 if( conshdlrdata->allconsanddatas[d] == consanddatas[
c] )
1539 --conshdlrdata->nallconsanddatas;
1543 conshdlrdata->allconsanddatas[d] = conshdlrdata->allconsanddatas[conshdlrdata->nallconsanddatas];
1554 assert(!consanddatas[
c]->istransformed);
1559 if( consanddatas[
c]->nuses == 0 && consanddatas[
c]->istransformed )
1564 else if( consanddatas[
c]->nuses == 0 )
1570 assert(consanddatas[
c]->nnewvars == 0);
1571 assert(consanddatas[
c]->snewvars == 0);
1574 tmpvars = consanddatas[
c]->
vars;
1575 ntmpvars = consanddatas[
c]->
nvars;
1578 for( v = ntmpvars - 1; v >= 0; --v )
1587 if( !consanddatas[
c]->istransformed && consanddatas[
c]->noriguses > 0 )
1590 assert(consanddatas[
c]->nuses == 0);
1591 assert(consanddatas[
c]->nnewvars == 0);
1592 assert(consanddatas[
c]->snewvars == 0);
1595 assert(consanddatas[
c]->svars > 0);
1598 assert(consanddatas[
c]->isoriginal);
1604 if( conshdlrdata->inithashmapandtable )
1698 for( v =
nvars - 1; v >= 0; --v )
1705 for( v =
nvars - 1; v >= 0; --v )
1761 for( v =
nvars - 1; v >= 0; --v )
1768 for( v =
nvars - 1; v >= 0; --v )
1822 assert(consdata->nlinvars + consdata->nconsanddatas >=
nvars);
1850 for( v = 0; v <
nvars; ++v )
1863 assert(!consdata->issoftcons ||
var != consdata->indvar);
1866 if( consanddata !=
NULL )
1880 if( consanddata ==
NULL )
1884 monomialvars[nmonomials] =
vars + v;
1885 monomialnvars[nmonomials] = 1;
1892 if( fixed != negated )
1908 monomialvars[nmonomials] = andvars;
1910 monomialnvars[nmonomials] = nandvars;
1914 monomialcoefs[nmonomials] = coefs[v];
1943 if( consdata->issoftcons )
2028 if( tmpdata !=
NULL )
2036 *andcons = tmpdata->
cons;
2080#ifdef SCIP_DISABLED_CODE
2081#ifdef WITH_DEBUG_SOLUTION
2082 if( SCIPdebugIsMainscip(
scip) )
2088 for( v =
nvars - 1; v >= 0; --v )
2096 val = ((val < 0.5) ? 0.0 : 1.0);
2101 SCIPerrorMessage(
"computed solution value %g for resultant <%s> violates debug solution value %g\n", val,
SCIPvarGetName(resultant), debugsolval);
2123 local, modifiable, dynamic, removable, stickingatnode) );
2135 if( conshdlrdata->nallconsanddatas == conshdlrdata->sallconsanddatas )
2141 conshdlrdata->allconsanddatas[conshdlrdata->nallconsanddatas] = newdata;
2142 ++(conshdlrdata->nallconsanddatas);
2148 newdata->
cons = newcons;
2155 for( v = newdata->
nvars - 1; v >= 0; --v )
2230 if( consdata->nconsanddatas == consdata->sconsanddatas )
2240 ++(consdata->nconsanddatas);
2243 switch( consdata->linconstype )
2266#ifdef WITHEQKNAPSACK
2267 case SCIP_LINEARCONSTYPE_EQKNAPSACK:
2284 consdata->changed =
TRUE;
2285 consdata->propagated =
FALSE;
2286 consdata->presolved =
FALSE;
2287 consdata->cliquesadded =
FALSE;
2288 consdata->upgradetried =
FALSE;
2310 SCIPerrorMessage(
"changing left hand side only allowed on standard lienar constraint \n");
2312#ifdef WITHEQKNAPSACK
2313 case SCIP_LINEARCONSTYPE_EQKNAPSACK:
2341 SCIPerrorMessage(
"changing left hand side only allowed on standard lienar constraint \n");
2343#ifdef WITHEQKNAPSACK
2344 case SCIP_LINEARCONSTYPE_EQKNAPSACK:
2416 SCIP_CALL(
getLinVarsAndAndRess(
scip, cons,
vars, coefs,
nvars, linvars, lincoefs, &nlinvars, andress, andcoefs, andnegs, &nandress) );
2417 assert(consdata->nconsanddatas == nandress);
2433 for(
c = consdata->nconsanddatas - 1;
c >= 0; --
c )
2438 consanddata = consdata->consanddatas[
c];
2441 andcons = consanddata->
cons;
2446 val = andnegs[
c] ? -andcoefs[
c] : andcoefs[
c];
2451 for( v = nandvars - 1; v >= 0; --v )
2458 for( v = nandvars - 1; v >= 0; --v )
2468 for(
c = consdata->nconsanddatas - 1;
c >= 0; --
c )
2473 consanddata = consdata->consanddatas[
c];
2476 andcons = consanddata->
cons;
2481 val = andnegs[
c] ? -andcoefs[
c] : andcoefs[
c];
2486 for( v = nandvars - 1; v >= 0; --v )
2493 for( v = nandvars - 1; v >= 0; --v )
2505 consdata->propagated =
FALSE;
2510 consdata->lhs = lhs;
2511 consdata->presolved =
FALSE;
2512 consdata->changed =
TRUE;
2587 SCIP_CALL(
getLinVarsAndAndRess(
scip, cons,
vars, coefs,
nvars, linvars, lincoefs, &nlinvars, andress, andcoefs, andnegs, &nandress) );
2588 assert(consdata->nconsanddatas == nandress);
2604 for(
c = consdata->nconsanddatas - 1;
c >= 0; --
c )
2609 consanddata = consdata->consanddatas[
c];
2612 andcons = consanddata->
cons;
2617 val = andnegs[
c] ? -andcoefs[
c] : andcoefs[
c];
2622 for( v = nandvars - 1; v >= 0; --v )
2629 for( v = nandvars - 1; v >= 0; --v )
2639 for(
c = consdata->nconsanddatas - 1;
c >= 0; --
c )
2644 consanddata = consdata->consanddatas[
c];
2647 andcons = consanddata->
cons;
2652 val = andnegs[
c] ? -andcoefs[
c] : andcoefs[
c];
2657 for( v = nandvars - 1; v >= 0; --v )
2664 for( v = nandvars - 1; v >= 0; --v )
2676 consdata->propagated =
FALSE;
2681 consdata->rhs = rhs;
2682 consdata->presolved =
FALSE;
2683 consdata->changed =
TRUE;
2705 int const*
const ntermvars,
2748 for( t = 0; t <
nterms; ++t )
2753 initial, enforce, check, local, modifiable, dynamic, stickingatnode,
2754 &(andconss[*nandconss])) );
2756 andvals[*nandconss] = termcoefs[t];
2757 andnegs[*nandconss] =
FALSE;
2833 assert(nlinvars > 0 || nandress > 0);
2843 ++(conshdlrdata->nlinconss);
2859 nvars = nlinvars + nandress;
2862 for( v = nlinvars - 1; v >= 0; --v )
2892 for( v = nandress - 1; v >= 0; --v )
2920 SCIPdebugMsg(
scip,
"While creating the linear constraint of the pseudoboolean constraint we found %d zero coefficients that were removed\n", nzero);
2938 if( upgrconshdlr !=
NULL &&
nvars > 2 && ncoeffspone + ncoeffsnone ==
nvars
2954 for( v = 0; v < nlinvars; ++v )
2956 if( mult * linvals[v] > 0.0 )
2957 transvars[v] = linvars[v];
2966 for( v = 0; v < nandress; ++v )
2968 if( mult * andvals[v] > 0.0 )
2969 transvars[nlinvars + v] = andress[v];
2981 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3010 if( upgrconshdlr !=
NULL && !created && ncoeffspone + ncoeffsnone ==
nvars )
3017 SCIPdebugMsg(
scip,
"linear pseudoboolean constraint will be a set partitioning constraint\n");
3020 mult =
SCIPisEQ(
scip, *lhs, 1.0 - ncoeffsnone) ? +1 : -1;
3026 for( v = 0; v < nlinvars; ++v )
3028 if( mult * linvals[v] > 0.0 )
3029 transvars[v] = linvars[v];
3038 for( v = 0; v < nandress; ++v )
3040 if( mult * andvals[v] > 0.0 )
3041 transvars[nlinvars + v] = andress[v];
3053 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3067 SCIPdebugMsg(
scip,
"linear pseudoboolean constraint will be a set packing constraint\n");
3076 for( v = 0; v < nlinvars; ++v )
3078 if( mult * linvals[v] > 0.0 )
3079 transvars[v] = linvars[v];
3088 for( v = 0; v < nandress; ++v )
3090 if( mult * andvals[v] > 0.0 )
3091 transvars[nlinvars + v] = andress[v];
3103 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3121 SCIPwarningMessage(
scip,
"Does not expect this, because this constraint should be a set packing constraint.\n");
3125 SCIPwarningMessage(
scip,
"Does not expect this, because this constraint should be a logicor constraint.\n");
3128 SCIPdebugMsg(
scip,
"linear pseudoboolean constraint will be a set covering constraint\n");
3137 for( v = 0; v < nlinvars; ++v )
3139 if( mult * linvals[v] > 0.0 )
3140 transvars[v] = linvars[v];
3149 for( v = 0; v < nandress; ++v )
3151 if( mult * andvals[v] > 0.0 )
3152 transvars[nlinvars + v] = andress[v];
3164 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3192 SCIPdebugMsg(
scip,
"linear pseudoboolean constraint will be a knapsack constraint\n");
3213 for( v = 0; v < nlinvars; ++v )
3219 transvars[v] = linvars[v];
3220 weights[v] = weight;
3225 weights[v] = -weight;
3231 for( v = 0; v < nandress; ++v )
3237 transvars[nlinvars + v] = andress[v];
3238 weights[nlinvars + v] = weight;
3244 weights[nlinvars + v] = -weight;
3252 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3264#ifdef WITHEQKNAPSACK
3273 if( upgrconshdlr !=
NULL && !created && (ncoeffspone + ncoeffsnone + ncoeffspint + ncoeffsnint ==
nvars) &&
SCIPisEQ(
scip, *lhs, *rhs) )
3283 SCIPdebugMsg(
scip,
"linear pseudoboolean constraint will be a equality-knapsack constraint\n");
3301 for( v = 0; v < nlinvars; ++v )
3307 transvars[v] = linvars[v];
3308 weights[v] = weight;
3313 weights[v] = -weight;
3319 for( v = 0; v < nandress; ++v )
3325 transvars[nlinvars + v] = andress[v];
3326 weights[nlinvars + v] = weight;
3332 weights[nlinvars + v] = -weight;
3339 SCIP_CALL( SCIPcreateConsEqKnapsack(
scip, &cons, name,
nvars, transvars, weights, capacity,
3340 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3343 (*linconstype) = SCIP_LINEARCONSTYPE_EQKNAPSACK;
3362 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3367 for( v = 0; v < nandress; ++v )
3459 assert(consdata->nlinvars + consdata->nconsanddatas >=
nvars);
3471 for( v = 0; v <
nvars; ++v )
3482 if( consanddata !=
NULL )
3490 if( consanddata ==
NULL )
3501 if( andcons ==
NULL )
3502 andcons = consanddata->
cons;
3512 for(
i = 0;
i < nandvars; ++
i )
3516 solval = 1.0 - solval;
3520 activity += coefs[v] * solval;
3523 SCIPdebugMsg(
scip,
"lhs = %g, activity = %g, rhs = %g\n", lhs, activity, rhs);
3526 lhsviol = lhs - activity;
3527 rhsviol = activity - rhs;
3529 if(lhsviol > rhsviol)
3608 for(
c = conshdlrdata->nallconsanddatas - 1;
c >= 0; --
c )
3615 if( !conshdlrdata->allconsanddatas[
c]->istransformed )
3618 andcons = conshdlrdata->allconsanddatas[
c]->cons;
3621 if( andcons ==
NULL )
3632 for( v =
nvars - 1; v >= 0; --v )
3636 if( solval < minsolval )
3639 sumsolval += solval;
3646 viol =
MAX3(0.0, solval - minsolval, sumsolval - (
nvars - 1.0 + solval));
3671 SCIP*
const targetscip,
3673 SCIP*
const sourcescip,
3711 sourcelincons = sourceconsdata->lincons;
3721 int ntargetandconss;
3724 targetlinconstype = sourceconsdata->linconstype;
3726 switch( targetlinconstype )
3744#ifdef WITHEQKNAPSACK
3745 case SCIP_LINEARCONSTYPE_EQKNAPSACK:
3756 if( conshdlrlinear ==
NULL )
3762 targetlincons =
NULL;
3782 targetandconss =
NULL;
3783 targetandcoefs =
NULL;
3784 ntargetandconss = 0;
3790 int nsourceandconss;
3799 nsourceandconss = sourceconsdata->nconsanddatas;
3814 targetlinvars, targetlincoefs, &ntargetlinvars) );
3821 SCIPvarIsHashkeyEq, SCIPvarGetHashkeyVal,
NULL) );
3823 for(
c = 0 ;
c < ntargetlinvars; ++
c )
3832 for(
c = 0 ;
c < nsourceandconss; ++
c )
3839 consanddata = sourceconsdata->consanddatas[
c];
3852 targetandconss[ntargetandconss] =
NULL;
3864 targetandcoefs[ntargetandconss] = sourceconsdata->andcoefs[
c];
3870 assert(ntargetandconss <= ntargetlinvars);
3880 const char* consname;
3883 assert(sourceconsdata->issoftcons == (sourceconsdata->indvar !=
NULL));
3884 indvar = sourceconsdata->indvar;
3885 intvar = sourceconsdata->intvar;
3888 if( indvar !=
NULL )
3918 targetlincons, targetlinconstype, targetandconss, targetandcoefs, ntargetandconss,
3919 indvar, sourceconsdata->weight, sourceconsdata->issoftcons, intvar, targetlhs, targetrhs,
3920 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3930 if( targetlincons !=
NULL )
3936 if( targetandconss !=
NULL )
3940 assert(ntargetandconss <= sourceconsdata->nconsanddatas);
3942 for(
c = 0 ;
c < ntargetandconss; ++
c )
3944 if( targetandconss[
c] !=
NULL )
3975 allconsanddatas = conshdlrdata->allconsanddatas;
3977 assert(conshdlrdata->nallconsanddatas >= 0);
3978 assert(conshdlrdata->nallconsanddatas <= conshdlrdata->sallconsanddatas);
3980 for(
c = conshdlrdata->nallconsanddatas - 1;
c >= 0; --
c )
3989 consanddata = allconsanddatas[
c];
3994 if( consanddata->
nuses == 0 )
4012 cons = consanddata->
cons;
4035 for( v =
nvars - 1; v > 0; --v )
4038 for( v = nnewvars - 1; v > 0; --v )
4043 if(
nvars == nnewvars )
4050 for( v =
nvars - 1; v >= 0; --v )
4052 if(
vars[v] != newvars[v] )
4064 if( nnewvars > consanddata->
snewvars )
4074 for( v = consanddata->
nnewvars - 1; v >= 0; --v )
4156 int nnewconsanddatas;
4157 int snewconsanddatas;
4182 SCIPsortPtrRealBool((
void**)(consdata->consanddatas), consdata->andcoefs, consdata->andnegs, resvarCompWithInactive, consdata->nconsanddatas);
4187 consanddatas = consdata->consanddatas;
4188 oldandcoefs = consdata->andcoefs;
4189 oldandnegs = consdata->andnegs;
4190 nconsanddatas = consdata->nconsanddatas;
4191 assert(nconsanddatas == 0 || (consanddatas !=
NULL && oldandcoefs !=
NULL));
4193 snewconsanddatas = nconsanddatas + nandress;
4200 nnewconsanddatas = 0;
4203 for(
c = 0, c1 = 0;
c < nconsanddatas && c1 < nandress; )
4213 if( !consanddatas[
c]->istransformed )
4216 consdata->changed =
TRUE;
4217 consdata->upgradetried =
FALSE;
4221 andcons = consanddatas[
c]->
cons;
4224 if( andcons ==
NULL )
4227 consdata->changed =
TRUE;
4228 consdata->upgradetried =
FALSE;
4235 oldandnegs[
c] ? -oldandcoefs[
c] : oldandcoefs[
c], consdata->lhs, consdata->rhs) );
4237 consdata->changed =
TRUE;
4238 consdata->upgradetried =
FALSE;
4254 compval = resvarComp((
void*)res1, (
void*)res2);
4260 assert(consanddatas[
c]->nuses > 0);
4261 --(consanddatas[
c]->
nuses);
4265 consdata->lhs, consdata->rhs) );
4267 consdata->changed =
TRUE;
4268 consdata->upgradetried =
FALSE;
4269 consdata->propagated =
FALSE;
4270 consdata->presolved =
FALSE;
4272 else if( compval == +1 )
4277 newandcoefs[nnewconsanddatas] = andcoefs[c1];
4278 newandnegs[nnewconsanddatas] = andnegs[c1];
4279 ++(newconsanddatas[nnewconsanddatas]->
nuses);
4283 -newandcoefs[nnewconsanddatas] : newandcoefs[nnewconsanddatas], newlhs, newrhs) );
4285 consdata->changed =
TRUE;
4286 consdata->upgradetried =
FALSE;
4287 consdata->cliquesadded =
FALSE;
4288 consdata->propagated =
FALSE;
4289 consdata->presolved =
FALSE;
4304 newconsanddatas[nnewconsanddatas] = consanddatas[
c];
4306 newandcoefs[nnewconsanddatas] = andcoefs[c1];
4307 newandnegs[nnewconsanddatas] = andnegs[c1];
4309 if( ((oldandnegs[
c] == andnegs[c1]) && !
SCIPisEQ(
scip, oldandcoefs[
c], newandcoefs[c1]))
4310 || ((oldandnegs[
c] != newandnegs[c1]) && !
SCIPisEQ(
scip, oldandcoefs[
c], -newandcoefs[c1])) )
4311 consdata->upgradetried =
FALSE;
4313 coefsignchanged = (oldandnegs[
c] == andnegs[c1]) &&
4314 ((oldandcoefs[
c] < 0 && andcoefs[c1] > 0) || (oldandcoefs[
c] > 0 && andcoefs[c1] < 0));
4315 coefsignchanged = coefsignchanged || ((oldandnegs[
c] != andnegs[c1]) &&
4316 ((oldandcoefs[
c] < 0 && andcoefs[c1] < 0) || (oldandcoefs[
c] > 0 && andcoefs[c1] > 0)));
4318 || (consdata->lhs < 0 && newlhs > 0) || (consdata->lhs > 0 && newlhs < 0);
4320 || (consdata->rhs < 0 && newrhs > 0) || (consdata->rhs > 0 && newrhs < 0);
4323 if( coefsignchanged || lhschanged || rhschanged || newconsanddatas[nnewconsanddatas]->nnewvars > 0)
4327 -oldandcoefs[
c] : oldandcoefs[
c], consdata->lhs, consdata->rhs) );
4329 -newandcoefs[nnewconsanddatas] : newandcoefs[nnewconsanddatas], newlhs, newrhs) );
4331 consdata->changed =
TRUE;
4332 consdata->upgradetried =
FALSE;
4333 consdata->cliquesadded =
FALSE;
4334 consdata->propagated =
FALSE;
4335 consdata->presolved =
FALSE;
4345 if(
c < nconsanddatas )
4349 for( ;
c < nconsanddatas; ++
c )
4357 andcons = consanddatas[
c]->
cons;
4359 if( andcons !=
NULL )
4366 if( andcons ==
NULL )
4368 consdata->changed =
TRUE;
4369 consdata->upgradetried =
FALSE;
4373 assert(consanddatas[
c]->nuses > 0);
4374 --(consanddatas[
c]->
nuses);
4378 consdata->lhs, consdata->rhs) );
4379 consdata->changed =
TRUE;
4380 consdata->upgradetried =
FALSE;
4381 consdata->propagated =
FALSE;
4382 consdata->presolved =
FALSE;
4385 else if( c1 < nandress )
4387 for( ; c1 < nandress; ++c1 )
4395 newandcoefs[nnewconsanddatas] = andcoefs[c1];
4396 newandnegs[nnewconsanddatas] = andnegs[c1];
4397 ++(newconsanddatas[nnewconsanddatas]->
nuses);
4401 -newandcoefs[nnewconsanddatas] : newandcoefs[nnewconsanddatas], newlhs, newrhs) );
4404 consdata->changed =
TRUE;
4405 consdata->upgradetried =
FALSE;
4406 consdata->cliquesadded =
FALSE;
4407 consdata->propagated =
FALSE;
4408 consdata->presolved =
FALSE;
4411 assert(
c == nconsanddatas && c1 == nandress);
4420 consdata->upgradetried =
FALSE;
4421 consdata->lhs = newlhs;
4422 consdata->rhs = newrhs;
4425 consdata->consanddatas = newconsanddatas;
4426 consdata->andcoefs = newandcoefs;
4427 consdata->andnegs = newandnegs;
4428 consdata->nconsanddatas = nnewconsanddatas;
4429 consdata->sconsanddatas = snewconsanddatas;
4431 oldnvars = consdata->nlinvars;
4434 consdata->nlinvars -= nnewconsanddatas;
4436 if( oldnvars != consdata->nlinvars )
4438 consdata->changed =
TRUE;
4439 consdata->upgradetried =
FALSE;
4440 consdata->cliquesadded =
FALSE;
4441 consdata->propagated =
FALSE;
4442 consdata->presolved =
FALSE;
4446 consanddatas = consdata->consanddatas;
4447 nconsanddatas = consdata->nconsanddatas;
4448 assert(nconsanddatas == 0 || consanddatas !=
NULL);
4451 for(
c = nconsanddatas - 1;
c > 0; --
c )
4482 if( resind1 == -1 && resind2 == -1 )
4488 if( resind1 <= resind2 )
4490 assert(resind1 == resind2);
4506 int*
const naggrvars,
4535 assert(consdata->nconsanddatas > 0);
4538 if( consdata->cliquesadded )
4541 consdata->cliquesadded =
TRUE;
4550 assert(consdata->nconsanddatas > 0);
4551 assert(consdata->nconsanddatas <= consdata->sconsanddatas);
4555 assert(
nvars == consdata->nlinvars + consdata->nconsanddatas);
4570 assert(nandress == consdata->nconsanddatas);
4574 for(
c = nandress - 1;
c >= 0; --
c )
4580 consanddata = consdata->consanddatas[
c];
4588 andvars = consanddata->
newvars;
4593 andvars = consanddata->
vars;
4594 nandvars = consanddata->
nvars;
4597 for( v1 = nandvars - 1; v1 >= 0; --v1 )
4615 for( v2 = nlinvars - 1; v2 >= 0; --v2 )
4645 if( values[0] != values[1] && var1 == var2 )
4651 clqvars[0] = andres;
4662 *nchgbds += nchgbdslocal;
4694 clqvars[0] = andres;
4705 *nchgbds += nchgbdslocal;
4725 for(
c = nandress - 1;
c > 0; --
c )
4734 consanddata1 = consdata->consanddatas[
c];
4736 consanddata2 = consdata->consanddatas[
c - 1];
4745 andvars1 = consanddata1->
newvars;
4746 nandvars1 = consanddata1->
nnewvars;
4750 andvars1 = consanddata1->
vars;
4751 nandvars1 = consanddata1->
nvars;
4757 andvars2 = consanddata2->
newvars;
4758 nandvars2 = consanddata2->
nnewvars;
4762 andvars2 = consanddata2->
vars;
4763 nandvars2 = consanddata2->
nvars;
4767 for( v1 = nandvars1 - 1; v1 >= 0; --v1 )
4772 var1 = andvars1[v1];
4785 for( v2 = nandvars2 - 1; v2 >= 0; --v2 )
4789 var2 = andvars2[v2];
4815 if( values[0] != values[1] && var1 == var2 )
4821 clqvars[0] = andres;
4822 clqvars[1] = andres2;
4831 *nchgbds += nchgbdslocal;
4864 clqvars[0] = andres;
4875 *nchgbds += nchgbdslocal;
4932 if( consdata->propagated )
4936 consdata->propagated =
TRUE;
4959 consanddatas = consdata->consanddatas;
4960 nconsanddatas = consdata->nconsanddatas;
4961 assert(nconsanddatas == 0 || consanddatas !=
NULL);
4967 for(
c = nconsanddatas - 1;
c >= 0; --
c )
4973 if( !consanddatas[
c]->istransformed )
4976 andcons = consanddatas[
c]->
cons;
5007 if( conshdlrdata->nallconsanddatas == 0 )
5010 allconsanddatas = conshdlrdata->allconsanddatas;
5012 assert(conshdlrdata->nallconsanddatas >= 1);
5013 assert(conshdlrdata->nallconsanddatas <= conshdlrdata->sallconsanddatas);
5015 if( nfixedvars >= 1 &&
nvars >= 1 )
5023 activescalars =
NULL;
5026 for(
c = conshdlrdata->nallconsanddatas - 1;
c >= 0; --
c )
5033 consanddata = allconsanddatas[
c];
5051 if( consanddata->
nvars == 0 )
5068 consanddata->
nuses = 0;
5083 if( consanddata->
nuses == 0 )
5120 for(
w = 0;
w < nfixedvars && del; ++
w )
5129 activevars[0] = fixedvars[
w];
5130 activescalars[0] = 1.0;
5131 activeconstant = 0.0;
5134 &activeconstant, &requiredsize,
TRUE) );
5137 for(
i = 0;
i < nactivevars && del; ++
i )
5141 if( activevars[
i] == resvar )
5155 if( !looseorcolumn )
5177 cons = consanddata->
cons;
5192 consanddata->
nuses = 0;
5210 tmpvars = consanddata->
vars;
5212 for( v = consanddata->
nvars - 1; v >= 0; --v )
5220 tmpvars = consanddata->
vars;
5221 stmpvars = consanddata->
svars;
5225 consanddata->
newvars = tmpvars;
5231 if( activevars !=
NULL )
5267 consanddatas = consdata->consanddatas;
5268 nconsanddatas = consdata->nconsanddatas;
5269 assert(nconsanddatas > 0 && consanddatas !=
NULL);
5273 for(
c = nconsanddatas - 1;
c >= 0; --
c )
5277 consanddata = consanddatas[
c];
5287 for(
c = nconsanddatas - 1;
c >= 0; --
c )
5291 consanddata = consanddatas[
c];
5293 assert(consanddatas[
c]->istransformed);
5297 if( consanddata->
nuses > 0 )
5298 --(consanddata->
nuses);
5301 if( consanddata->
nuses == 0 )
5336 if( !looseorcolumn )
5357 consdata->nconsanddatas = 0;
5387 int const nconsanddatas,
5414 assert(nconsanddatas > 0);
5415 assert(*xortype >= -1 && *xortype <= 1);
5418 SCIPsortPtr((
void**)linvars, SCIPvarCompActiveAndNegated, nlinvars);
5422 for( v = nlinvars - 1; v >= 0; --v )
5427 value += lincoefs[v];
5442 for(
c = nconsanddatas - 1;
c >= 0; --
c )
5446 consanddata = consanddatas[
c];
5453 termvars = consanddata->
newvars;
5458 termvars = consanddata->
vars;
5459 ntermvars = consanddata->
nvars;
5467 SCIPsortPtrBool((
void**)repvars, negated, SCIPvarCompActiveAndNegated, ntermvars);
5469 for( v = ntermvars - 1; v >= 0; --v )
5478 if( (negated[v] && values[pos]) || (!negated[v] && !values[pos]) )
5494 if( val != consanddatanegs[
c] )
5495 value += consanddatacoefs[
c];
5501 if( *xortype == -1 )
5509 else if( *xortype == 1 && cnt % 2 == 0 )
5511 else if( *xortype == 0 && cnt % 2 == 1 )
5517 if( *xortype == -1 )
5525 else if( *xortype == 1 && cnt % 2 == 1 )
5527 else if( *xortype == 0 && cnt % 2 == 0 )
5548 int*
const ndelconss,
5549 int*
const naddconss,
5550 int*
const nfixedvars,
5551 int*
const nchgcoefs,
5552 int*
const nchgsides,
5600 consanddatas = consdata->consanddatas;
5601 andcoefs = consdata->andcoefs;
5602 andnegs = consdata->andnegs;
5603 nconsanddatas = consdata->nconsanddatas;
5604 assert(nconsanddatas > 0 && consanddatas !=
NULL);
5616 lincons = consdata->lincons;
5620 assert(nallvars - nconsanddatas == consdata->nlinvars);
5621 nlinvars = consdata->nlinvars;
5643 assert(nlinvars == consdata->nlinvars);
5644 assert(nandress == nallvars-nlinvars);
5655 firstnlinvars = nlinvars;
5658 SCIPsortPtr((
void**)linvars, SCIPvarCompActiveAndNegated, nlinvars);
5660 for(
c = nconsanddatas - 1;
c >= 0; --
c )
5662 consanddata = consanddatas[
c];
5688 oldnlinvars = nlinvars;
5691 for( v =
nvars - 1, v1 = nlinvars - 1; v >= 0 && v1 >= 0; )
5711 linvars[nlinvars] =
var;
5733 for( ; v >= 0; --v )
5748 linvars[nlinvars] =
var;
5757 if( nlinvars > oldnlinvars )
5760 SCIPsortPtr((
void**)linvars, SCIPvarCompActiveAndNegated, nlinvars);
5768 for( v = (1 << nlinvars) - 1; v >= 0; --v )
5771 for( v1 = nlinvars - 1; v1 >= 0; --v1 )
5784 consdata->lhs, consanddatas, andcoefs, andnegs, nconsanddatas, cnt, &xortype) );
5791 assert(xortype >= -1 && xortype <= 1);
5839 int*
const ndelconss,
5840 int*
const naddconss,
5841 int*
const nfixedvars,
5842 int*
const nchgcoefs,
5843 int*
const nchgsides,
5871 consanddatas = consdata->consanddatas;
5872 nconsanddatas = consdata->nconsanddatas;
5873 assert(nconsanddatas > 0 && consanddatas !=
NULL);
5881 if( nconsanddatas == 1 )
5901 if( consdata->nlinvars == 0 )
5913 lincons = consdata->lincons;
5915 consanddata = consanddatas[0];
5944 assert(nallvars == consdata->nlinvars + 1);
5946 nlinvars = consdata->nlinvars;
5961 assert(nlinvars == consdata->nlinvars);
5964 for( v = 0; v < nlinvars; ++v )
5970 for( v = 0; v <
nvars; ++v )
6002 c = nconsanddatas - 1;
6003 assert(consanddatas[
c]->istransformed);
6006 if( consanddatas[
c]->nnewvars > 0 )
6014 neqvars = consanddatas[
c]->
nvars;
6024 for( v = neqvars - 1; v > 0; --v )
6028 for( --
c ;
c >= 0; --
c )
6035 consanddata = consanddatas[
c];
6037 assert(consanddatas[
c]->istransformed);
6054 for( v =
nvars - 1; v > 0; --v )
6059 if(
nvars < nminvars )
6062 else if(
nvars > nmaxvars )
6065 assert(nminvars <= nmaxvars);
6068 for( v = 0, v2 = 0; v < neqvars && v2 <
nvars; )
6079 if( index1 < index2 )
6081 else if( index1 > index2 )
6085 assert(index1 == index2);
6088 if( nneweqvars < v )
6089 eqvars[nneweqvars] = eqvars[v];
6095 neqvars = nneweqvars;
6100 if( nminvars > neqvars + 1 )
6142 if( neqvars > 0 && consdata->nlinvars == 0 )
6148 for( v = 0; v < neqvars; ++v )
6165 if( nminvars == neqvars )
6177 if( neqvars > 0 && nminvars == nmaxvars && nminvars == neqvars + 1 )
6188 lincons = consdata->lincons;
6200 for(
c = nconsanddatas - 1;
c >= 0; --
c )
6206 consanddata = consanddatas[
c];
6208 assert(consanddatas[
c]->istransformed);
6223 for( v = 0, v2 = 0; v < neqvars && v2 <
nvars; )
6234 assert(index1 >= index2);
6236 if( index1 > index2 )
6243 assert(index1 == index2);
6253 for( ; v2 <
nvars; ++v2)
6265 if( consdata->nlinvars > 0 )
6275 for( v = 0; v < neqvars; ++v )
6282 assert(
nvars == consdata->nlinvars + consdata->nconsanddatas);
6296 for( v = 0; v <
nvars; ++v )
6302 assert(nlinvars == consdata->nlinvars);
6305 for( v = 0; v < nlinvars; ++v )
6351 int*
const ndelconss,
6352 int*
const naddconss,
6353 int*
const nfixedvars,
6354 int*
const nchgcoefs,
6355 int*
const nchgsides,
6384 consanddatas = consdata->consanddatas;
6385 nconsanddatas = consdata->nconsanddatas;
6386 assert(nconsanddatas > 0 && consanddatas !=
NULL);
6408 if( nconsanddatas == 1 )
6411 if( consdata->nlinvars == 0 )
6440 if( consdata->nlinvars > 0 )
6445 assert(consdata->nlinvars == 0 && nconsanddatas > 1);
6447 c = nconsanddatas - 1;
6448 assert(consanddatas[
c]->istransformed);
6451 if( consanddatas[
c]->nnewvars > 0 )
6459 neqvars = consanddatas[
c]->
nvars;
6469 for( v = neqvars - 1; v > 0; --v )
6473 for( --
c ;
c >= 0; --
c )
6480 consanddata = consanddatas[
c];
6482 assert(consanddatas[
c]->istransformed);
6499 for( v =
nvars - 1; v > 0; --v )
6504 if(
nvars < nminvars )
6507 else if(
nvars > nmaxvars )
6510 assert(nminvars <= nmaxvars);
6513 for( v = 0, v2 = 0; v < neqvars && v2 <
nvars; )
6524 if( index1 < index2 )
6526 else if( index1 > index2 )
6530 assert(index1 == index2);
6533 if( nneweqvars < v )
6534 eqvars[nneweqvars] = eqvars[v];
6540 neqvars = nneweqvars;
6582 if( neqvars > 0 && ((nminvars == nmaxvars && nminvars == neqvars + 1) || (nminvars == neqvars) || (type ==
SCIP_SETPPCTYPE_PARTITIONING)) )
6612 if( neqvars == nminvars )
6615 createcons = (
SCIPisLE(
scip, lhs, rhs) && ((nminvars == nmaxvars && nminvars == neqvars + 1) || (nminvars == neqvars)));
6620 lincons = consdata->lincons;
6638 for(
c = nconsanddatas - 1;
c >= 0; --
c )
6644 consanddata = consanddatas[
c];
6646 assert(consanddatas[
c]->istransformed);
6662 if( deletecons && neqvars + 1 <
nvars )
6681 for( v = 0, v2 = 0; v < neqvars && v2 <
nvars; )
6692 assert(index1 >= index2);
6694 if( index1 > index2 )
6701 else if( deletecons )
6718 assert(index1 == index2);
6729 for( ; v2 <
nvars; ++v2)
6735 else if( deletecons )
6756 for( v = 0; v < neqvars; ++v )
6827 int*
const ndelconss,
6828 int*
const naddconss,
6829 int*
const nfixedvars,
6830 int*
const nchgcoefs,
6831 int*
const nchgsides,
6856 consanddatas = consdata->consanddatas;
6857 assert(consdata->nconsanddatas == 0 || consanddatas !=
NULL);
6861 if( consdata->nconsanddatas == 0 )
6877 assert(consdata->nlinvars + consdata->nconsanddatas ==
nvars);
6879 switch( consdata->linconstype )
6896#ifdef WITHEQKNAPSACK
6897 case SCIP_LINEARCONSTYPE_EQKNAPSACK:
6914 consdata->upgradetried =
TRUE;
6925 int*
const ndelconss,
6926 int*
const naggrvars,
6962 consanddatas = consdata->consanddatas;
6963 nconsanddatas = consdata->nconsanddatas;
6964 assert(nconsanddatas == 0 || consanddatas !=
NULL);
6973 if( nconsanddatas < 2 || nconsanddatas > 3 )
6979 assert(consdata->nlinvars + nconsanddatas ==
nvars);
6982 if( consdata->nlinvars != 1 )
6986 if( consanddatas[0]->nnewvars > 0 )
6991 if( consanddatas[1]->nnewvars > 0 )
6993 if(
nvars != consanddatas[1]->nnewvars )
7011 if( consanddatas[nconsanddatas - 1]->nnewvars > 0 )
7014 vars = consanddatas[nconsanddatas - 1]->
vars;
7022 for( v = 1; v <
nvars; ++v )
7047 for( v =
nvars - 1; v >= 0; --v )
7058 ++(varcount[negated[v]][v]);
7061 for(
c = nconsanddatas - 2;
c >= 0; --
c )
7066 if( consanddatas[nconsanddatas - 1]->nnewvars > 0 )
7080 for( v = 1; v <
nvars; ++v )
7105 for( v =
nvars - 1; v >= 0; --v )
7119 ++(varcount[negated[v]][pos]);
7132 for(
i = 1;
i >= 0; --
i )
7134 for( v =
nvars - 1; v >= 0; --v )
7138 if( varcount[
i][v] == 0 )
7140 else if( varcount[
i][v] == 1 )
7142 else if( varcount[
i][v] == 2 )
7150 if( othercount == 0 )
7155 if( nconsanddatas == 2 && twocount ==
nvars - 1 && onecount == 2 && zerocount == 1 )
7170 assert(nconsvars == consdata->nlinvars + nconsanddatas);
7175 for( v = 0; v < nconsvars; ++v )
7202 for(
i = 1;
i >= 0; --
i )
7204 for( v =
nvars - 1; v >= 0; --v )
7207 if( varcount[
i][v] == 2 )
7256 else if(
nvars == 2 && nconsanddatas == 3 && twocount == 2 && onecount == 2 && zerocount == 0)
7275 assert(nconsvars == consdata->nlinvars + nconsanddatas);
7280 for( v = 0; v < nconsvars; ++v )
7294 newandvars[0] =
NULL;
7295 newandvars[1] =
NULL;
7299 for(
i = 1;
i >= 0; --
i )
7301 for( v =
nvars - 1; v >= 0; --v )
7304 if( varcount[
i][v] == 1 )
7306 if( newandvars[0] ==
NULL )
7417 if( consdata->intvar !=
NULL )
7419 vars[0] = consdata->intvar;
7443 for(
i = 0;
i < tmpnvars; ++
i )
7444 vals[
i] = tmpvals[
i];
7449 for(
i = 0;
i < tmpnvars; ++
i )
7455 for(
i = 0;
i < tmpnvars; ++
i )
7461 for(
i = 0;
i < tmpnvars; ++
i )
7472 for(
i = 0;
i < tmpnvars; ++
i )
7485 for(
c = 0;
c < consdata->nconsanddatas; ++
c )
7492 tmpnvars = consdata->consanddatas[
c]->nvars;
7493 for(
i = 0;
i < tmpnvars; ++
i )
7494 vars[
i] = consdata->consanddatas[
c]->vars[
i];
7495 for(
i = 0;
i < tmpnvars; ++
i )
7517#ifdef NONLINCONSUPGD_PRIORITY
7523 SCIP_EXPRGRAPH* exprgraph;
7524 SCIP_EXPRGRAPHNODE* node;
7543 node = SCIPgetExprgraphNodeNonlinear(
scip, cons);
7549 switch( SCIPexprgraphGetNodeOperator(node) )
7551 case SCIP_EXPR_VARIDX:
7552 case SCIP_EXPR_CONST:
7553 case SCIP_EXPR_PLUS:
7554 case SCIP_EXPR_MINUS:
7556 case SCIP_EXPR_LINEAR:
7562 case SCIP_EXPR_SQUARE:
7563 case SCIP_EXPR_SQRT:
7564 case SCIP_EXPR_REALPOWER:
7565 case SCIP_EXPR_INTPOWER:
7566 case SCIP_EXPR_SIGNPOWER:
7577 case SCIP_EXPR_SIGN:
7578 case SCIP_EXPR_PRODUCT:
7579 case SCIP_EXPR_USER:
7583 case SCIP_EXPR_QUADRATIC:
7586 case SCIP_EXPR_POLYNOMIAL:
7590 case SCIP_EXPR_PARAM:
7591 case SCIP_EXPR_LAST:
7601 for(
i = 0;
i < SCIPgetNLinearVarsNonlinear(
scip, cons); ++
i )
7603 var = SCIPgetLinearVarsNonlinear(
scip, cons)[
i];
7615 for(
i = 0;
i < SCIPexprgraphGetNodeNChildren(node); ++
i )
7617 SCIP_EXPRGRAPHNODE* child;
7619 child = SCIPexprgraphGetNodeChildren(node)[
i];
7621 if( SCIPexprgraphGetNodeOperator(child) != SCIP_EXPR_VARIDX )
7623 SCIPdebugMsg(
scip,
"not pseudoboolean because child %d is not a variable\n",
i);
7627 var = (
SCIP_VAR*)SCIPexprgraphGetNodeVar(exprgraph, child);
7638 if( upgdconsssize < 1 )
7648 lhs -= SCIPexprgraphGetNodePolynomialConstant(node);
7650 rhs -= SCIPexprgraphGetNodePolynomialConstant(node);
7653 if( objvar !=
NULL )
7657 for(
i = 0;
i < SCIPgetNLinearVarsNonlinear(
scip, cons); ++
i )
7659 var = SCIPgetLinearVarsNonlinear(
scip, cons)[
i];
7661 linvars[nlinvars++] =
var;
7665 nlinvars = SCIPgetNLinearVarsNonlinear(
scip, cons);
7668 nterms = SCIPexprgraphGetNodePolynomialNMonomials(node);
7675 SCIP_EXPRDATA_MONOMIAL* monomial;
7677 monomial = SCIPexprgraphGetNodePolynomialMonomials(node)[
i];
7680 ntermvars[
i] = SCIPexprGetMonomialNFactors(monomial);
7683 for( j = 0; j < SCIPexprGetMonomialNFactors(monomial); ++j )
7685 terms[
i][j] = (
SCIP_VAR*)SCIPexprgraphGetNodeVar(exprgraph, SCIPexprgraphGetNodeChildren(node)[SCIPexprGetMonomialChildIndices(monomial)[j]]);
7686 assert(SCIPexprGetMonomialExponents(monomial)[j] > 0.0);
7689 termvals[
i] = SCIPexprGetMonomialCoef(monomial);
7694 objvar !=
NULL ? linvars : SCIPgetLinearVarsNonlinear(
scip, cons), nlinvars, SCIPgetLinearCoefsNonlinear(
scip, cons),
7766 for(
c = conshdlrdata->nallconsanddatas - 1;
c >= 0; --
c )
7776 assert(conshdlrdata->allconsanddatas[
c]->newvars ==
NULL);
7778 vars = conshdlrdata->allconsanddatas[
c]->vars;
7779 nvars = conshdlrdata->allconsanddatas[
c]->nvars;
7783 for( v =
nvars - 1; v > 0; --v )
7791 andcons = conshdlrdata->allconsanddatas[
c]->cons;
7802 SCIPconsGetName(conshdlrdata->allconsanddatas[
c]->cons), (
void*)(conshdlrdata->allconsanddatas[
c]),
7803 (
void*)(conshdlrdata->allconsanddatas[
c]->cons));
7824 for(
c = 0;
c < nconss; ++
c )
7844 if( !conshdlrdata->decomposenormalpbcons && !consdata->issoftcons )
7859 if( !consdata->issoftcons )
7880 assert(consdata->weight != 0);
7896 updateandconss =
FALSE;
7899 if( conshdlrdata->decomposeindicatorpbcons )
7921 updateandconss =
TRUE;
7934 for( v =
nvars - 1; v >= 0; --v )
7944 if( !updateandconss )
7968 for( v =
nvars - 1; v >= 0; --v )
8002 updateandconss =
TRUE;
8014 ub = lhs - maxact - 1;
8045 if( !updateandconss )
8061 lb = rhs - minact + 1;
8122 for(
c = (*consdata)->nconsanddatas - 1;
c >= 0; --
c )
8124 assert((*consdata)->consanddatas[
c]->nuses == 0);
8125 assert((*consdata)->consanddatas[
c]->cons ==
NULL);
8126 assert((*consdata)->consanddatas[
c]->noriguses == 0 || ((*consdata)->consanddatas[
c]->origcons !=
NULL &&
SCIPconsIsOriginal((*consdata)->consanddatas[
c]->origcons)));
8129 conshdlrdata->noriguses -= (*consdata)->nconsanddatas;
8131 assert(conshdlrdata->noriguses >= 0);
8158 assert(sourcedata->nconsanddatas == 0 || sourcedata->consanddatas !=
NULL);
8164 for(
c = sourcedata->nconsanddatas - 1;
c >= 0; --
c )
8167 andconss[
c] = sourcedata->consanddatas[
c]->origcons;
8174 andconss, sourcedata->andcoefs, sourcedata->andnegs, sourcedata->nconsanddatas, sourcedata->indvar, sourcedata->weight,
8175 sourcedata->issoftcons, sourcedata->intvar, sourcedata->lhs, sourcedata->rhs,
SCIPconsIsChecked(sourcecons),
8292 if( consdata->issoftcons )
8325 int firstupgradetry;
8341 oldnfixedvars = *nfixedvars;
8342 oldnaggrvars = *naggrvars;
8343 oldnchgbds = *nchgbds;
8344 oldndelconss = *ndelconss;
8345 oldnupgdconss = *nupgdconss;
8346 oldnchgcoefs = *nchgcoefs;
8347 oldnchgsides = *nchgsides;
8355 firstchange = INT_MAX;
8356 firstupgradetry = INT_MAX;
8408 andress, andcoefs, andnegs, &nandress) );
8433 if( firstchange == INT_MAX && consdata->changed )
8446 if( consdata->changed )
8459 if( firstupgradetry == INT_MAX && !consdata->upgradetried )
8460 firstupgradetry =
c;
8465 consdata->presolved =
TRUE;
8483 consdata->changed =
FALSE;
8502 else if( *nfixedvars > oldnfixedvars || *naggrvars > oldnaggrvars || *nchgbds > oldnchgbds || *ndelconss > oldndelconss
8503 || *nupgdconss > oldnupgdconss || *nchgcoefs > oldnchgcoefs || *nchgsides > oldnchgsides )
8532 lhs = consdata->lhs;
8533 rhs = consdata->rhs;
8541 SCIPdebugMsg(
scip,
"%socking constraint <%s> by [%d;%d].\n", (nlocksneg < 0) || (nlockspos < 0) ?
"Unl" :
"L",
SCIPconsGetName(cons), nlocksneg, nlockspos);
8544 for(
c = consdata->nconsanddatas - 1;
c >= 0; --
c )
8553 consanddata = consdata->consanddatas[
c];
8559 andcons = consanddata->
cons;
8561 if( andcons ==
NULL )
8570 consanddata->
nvars = 0;
8571 consanddata->
svars = 0;
8581 andvars = consanddata->
newvars;
8586 andvars = consanddata->
vars;
8587 nandvars = consanddata->
nvars;
8594 val = consdata->andnegs[
c] ? -consdata->andcoefs[
c] : consdata->andcoefs[
c];
8601 for( v = nandvars - 1; v >= 0; --v )
8611 for( v = nandvars - 1; v >= 0; --v )
8628 for( v = nandvars - 1; v >= 0; --v )
8638 for( v = nandvars - 1; v >= 0; --v )
8677 const char* consname;
8689 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
8716 const char* firstcomp;
8717 const char* secondcomp;
8718 const char* lhsstrptr;
8719 const char* rhsstrptr;
8720 const char* varstrptr;
8721 char* polynomialstr;
8766 if( endptr[1] ==
'=' )
8775 if( strncmp(endptr,
"[free]", 6) == 0 )
8790 if( firstcomp ==
NULL )
8796 if( secondcomp !=
NULL )
8801 else if( strncmp(firstcomp,
"<=", 2) != 0 )
8806 else if( strncmp(endptr,
"<=", 2) != 0 )
8808 SCIPerrorMessage(
"Bad second comparator, expected ranged specification: %s", str);
8812 secondcomp = endptr;
8816 endptr += increment;
8820 if( firstcomp ==
NULL )
8832 switch( *firstcomp )
8835 assert(firstcomp[1] ==
'=');
8837 if( secondcomp !=
NULL )
8839 assert(secondcomp[0] ==
'<' && secondcomp[1] ==
'=');
8841 rhsstrptr = secondcomp + 2;
8842 varstrptr = firstcomp + 2;
8846 rhsstrptr = firstcomp + 2;
8849 assert(firstcomp[1] ==
'=');
8852 lhsstrptr = firstcomp + 2;
8855 assert(firstcomp[1] ==
'=');
8858 rhsstrptr = firstcomp + 2;
8859 lhsstrptr = firstcomp + 2;
8862 assert(strncmp(firstcomp,
"[free]", 6) == 0);
8865 endptr = firstcomp + 6;
8869 SCIPerrorMessage(
"Parsing has wrong comparator character '%c', should be one of <=>[", *firstcomp);
8878 if( lhsstrptr !=
NULL )
8882 SCIPerrorMessage(
"error parsing left hand side number from <%s>\n", lhsstrptr);
8887 if( rhsstrptr == lhsstrptr )
8892 if( rhsstrptr !=
NULL && rhsstrptr != lhsstrptr )
8896 SCIPerrorMessage(
"error parsing right hand side number from <%s>\n", lhsstrptr);
8911 if( *endptr ==
'(' )
8913 endptr = strchr(endptr + 1,
'=');
8915 if( endptr ==
NULL )
8924 if( indvar ==
NULL )
8931 endptr = strchr(endptr,
')');
8933 if( endptr ==
NULL )
8944 polynomialsize = (int)(
MAX(firstcomp, secondcomp) + 1 - varstrptr);
8946 (void)
SCIPstrncpy(polynomialstr, varstrptr, polynomialsize);
8952 polynomialsize -= (int)(endptr + 1 - polynomialstr);
8958 SCIPerrorMessage(
"no luck in parsing pseudoboolean polynomial '%s'\n", varstrptr);
8961 else if( polynomialsize >= 1 )
8963 SCIPerrorMessage(
"no completion of parsing pseudoboolean polynomial '%s'\n", varstrptr);
8980 for(
i = 0;
i < nmonomials; ++
i )
8988 for( j = 0; j < monomialnvars[
i]; ++j )
8990 if( monomialexps[
i][j] < 0.0 )
8992 SCIPerrorMessage(
"invalid exponent '%f' on variable <%s> in pseudoboolean polynomial '%s'\n", monomialexps[
i][j],
SCIPvarGetName(monomialvars[
i][j]), varstrptr);
8996 if( monomialexps[
i][j] == 0.0 )
8999 monomialvars[
i][ntermvars[
nterms]++] = monomialvars[
i][j];
9002 if( ntermvars[
nterms] > 1 )
9004 terms[
nterms] = monomialvars[
i];
9005 termvals[
nterms] = monomialcoefs[
i];
9008 else if( ntermvars[
nterms] == 1 )
9010 if( issoftcons && ( monomialvars[
i][0] == indvar ||
SCIPvarGetNegatedVar(monomialvars[
i][0]) == indvar ) )
9016 linvars[nlinvars] = monomialvars[
i][0];
9017 linvals[nlinvars] = monomialcoefs[
i];
9025 lhs -= monomialcoefs[
i];
9028 rhs -= monomialcoefs[
i];
9033 SCIP_CALL(
SCIPcreateConsPseudoboolean(
scip, cons, name, linvars, nlinvars, linvals, terms,
nterms, ntermvars, termvals, indvar, weight, issoftcons,
NULL, lhs, rhs, initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
9100 assert(nlinconsvars >= 0);
9103 if( nlinconsvars == 0 )
9110 else if( varssize < nlinconsvars )
9128 assert(nlinconsvars == nlinvars + nandress);
9150 for(
r = nandress - 1;
r >= 0; --
r )
9162 andcons = consanddata->
cons;
9169 if( varssize <=
nvars )
9188 if( varssize <
nvars + noperands )
9261 assert(nlinconsvars >= 0);
9264 if( nlinconsvars == 0 )
9282 assert(nlinconsvars == nlinvars + nandress);
9298 for(
r = nandress - 1;
r >= 0; --
r )
9310 andcons = consanddata->
cons;
9373 consEnfolpPseudoboolean, consEnfopsPseudoboolean, consCheckPseudoboolean, consLockPseudoboolean,
9397 "decompose every normal pseudo boolean constraint into a \"linear\" constraint and \"and\" constraints",
9401 "decompose every soft pseudo boolean constraint into \"indicator\" constraints and \"and\" constraints",
9404 "constraints/" CONSHDLR_NAME "/nlcseparate",
"should the nonlinear constraints be separated during LP processing?",
9407 "constraints/" CONSHDLR_NAME "/nlcpropagate",
"should the nonlinear constraints be propagated during node processing?",
9410 "constraints/" CONSHDLR_NAME "/nlcremovable",
"should the nonlinear constraints be removable?",
9413#ifdef NONLINCONSUPGD_PRIORITY
9483 assert(nandconss == 0 || (andconss !=
NULL && andcoefs !=
NULL));
9486 if( intvar !=
NULL )
9489 SCIPerrorMessage(
"intvar currently not supported by pseudo boolean constraint handler\n");
9495 if( conshdlr ==
NULL )
9510 assert(conshdlrdata->allconsanddatas !=
NULL);
9511 assert(conshdlrdata->nallconsanddatas <= conshdlrdata->sallconsanddatas);
9513 memisinvalid =
TRUE;
9519 for(
c = nandconss - 1;
c >= 0; --
c )
9574 newdata->
cons = andconss[
c];
9577 for( v = newdata->
nvars - 1; v >= 0; --v )
9593 if( tmpdata ==
NULL || (tmpdata->
cons != andconss[
c] && tmpdata->
origcons != andconss[
c]))
9597 SCIPwarningMessage(
scip,
"Another and-constraint with the same variables but different and-resultant is added to the global and-constraint hashtable of pseudoboolean constraint handler.\n");
9601 if( conshdlrdata->nallconsanddatas == conshdlrdata->sallconsanddatas )
9606 conshdlrdata->allconsanddatas[conshdlrdata->nallconsanddatas] = newdata;
9607 ++(conshdlrdata->nallconsanddatas);
9613 memisinvalid =
TRUE;
9629 newdata->noriguses = 1;
9639 memisinvalid =
FALSE;
9683 indvar, weight, issoftcons, intvar, lhs, rhs, check,
FALSE) );
9687 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
9688 local, modifiable, dynamic, removable, stickingatnode) );
9764 if( intvar !=
NULL )
9767 SCIPerrorMessage(
"intvar currently not supported by pseudo boolean constraint handler\n");
9773 if( conshdlr ==
NULL )
9779 if( modifiable && issoftcons )
9801 initial, enforce, check, local, modifiable, dynamic, stickingatnode,
9802 andconss, andcoefs, andnegs, &nandconss) );
9806 for(
c = nandconss - 1;
c >= 0; --
c )
9825 &lhs, &rhs, issoftcons, initial, separate, enforce,
FALSE,
propagate, local, modifiable, dynamic,
9826 removable, stickingatnode, &lincons, &linconstype) );
9833 indvar, weight, issoftcons, intvar, lhs, rhs, check,
FALSE) );
9843 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
9844 local, modifiable, dynamic, removable, stickingatnode) );
9881 terms,
nterms, ntermvars, termvals, indvar, weight, issoftcons, intvar, lhs, rhs,
9920 switch( consdata->linconstype )
9943#ifdef WITHEQKNAPSACK
9944 case SCIP_LINEARCONSTYPE_EQKNAPSACK:
9957 consdata->propagated =
FALSE;
9958 consdata->presolved =
FALSE;
9959 consdata->cliquesadded =
FALSE;
10016 return consdata->indvar;
10040 return consdata->lincons;
10064 return consdata->linconstype;
10090 return consdata->nlinvars;
10126 if( *nlinvars < consdata->nlinvars )
10128 *nlinvars = consdata->nlinvars;
10143 SCIP_CALL(
getLinVarsAndAndRess(
scip, cons,
vars, coefs,
nvars, linvars, lincoefs, nlinvars,
NULL,
NULL,
NULL,
NULL) );
10159 int*
const nandconss
10170 assert(*nandconss == 0 || andconss !=
NULL);
10171 assert(*nandconss == 0 || andcoefs !=
NULL);
10185 if( *nandconss < consdata->nconsanddatas )
10187 *nandconss = consdata->nconsanddatas;
10191 *nandconss = consdata->nconsanddatas;
10192 assert(*nandconss == 0 || consdata->consanddatas !=
NULL);
10196 for(
c = *nandconss - 1;
c >= 0; --
c )
10199 assert(consdata->consanddatas[
c]->istransformed ? (consdata->consanddatas[
c]->cons !=
NULL) :
TRUE);
10200 assert(consdata->consanddatas[
c]->isoriginal ? (consdata->consanddatas[
c]->origcons !=
NULL) :
TRUE);
10201 assert(consdata->consanddatas[
c]->cons !=
NULL || consdata->consanddatas[
c]->origcons !=
NULL);
10202 assert(isorig ? consdata->consanddatas[
c]->origcons !=
NULL : consdata->consanddatas[
c]->cons !=
NULL);
10204 andconss[
c] = (isorig ? consdata->consanddatas[
c]->origcons : consdata->consanddatas[
c]->cons);
10207 andcoefs[
c] = consdata->andcoefs[
c];
10236 return consdata->nconsanddatas;
10268 switch( consdata->linconstype )
10276#ifdef WITHEQKNAPSACK
10277 case SCIP_LINEARCONSTYPE_EQKNAPSACK:
10279 SCIPerrorMessage(
"changing left hand side only allowed on standard linear constraint \n");
10316 switch( consdata->linconstype )
10324#ifdef WITHEQKNAPSACK
10325 case SCIP_LINEARCONSTYPE_EQKNAPSACK:
10327 SCIPerrorMessage(
"changing right hand side only allowed on standard linear constraint \n");
10360 return consdata->lhs;
10385 return consdata->rhs;
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_CHECKPRIORITY
#define CONSHDLR_MAXPREROUNDS
#define CONSHDLR_PRESOLTIMING
#define CONSHDLR_EAGERFREQ
#define CONSHDLR_ENFOPRIORITY
Constraint handler for AND constraints, .
constraint handler for indicator constraints
Constraint handler for knapsack constraints of the form , x binary and .
#define NONLINCONSUPGD_PRIORITY
Constraint handler for linear constraints in their most general form, .
Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...
constraint handler for nonlinear constraints specified by algebraic expressions
static SCIP_RETCODE checkAndConss(SCIP *const scip, SCIP_CONSHDLR *const conshdlr, SCIP_SOL *const sol, SCIP_Bool *const violated)
static SCIP_RETCODE getLinVarsAndAndRess(SCIP *const scip, SCIP_CONS *const cons, SCIP_VAR **const vars, SCIP_Real *const coefs, int const nvars, SCIP_VAR **const linvars, SCIP_Real *const lincoefs, int *const nlinvars, SCIP_VAR **const andress, SCIP_Real *const andcoefs, SCIP_Bool *const andnegs, int *const nandress)
#define HASHSIZE_PSEUDOBOOLEANNONLINEARTERMS
static SCIP_RETCODE conshdlrdataCreate(SCIP *const scip, SCIP_CONSHDLRDATA **conshdlrdata)
static SCIP_RETCODE lockRoundingAndCons(SCIP *const scip, SCIP_CONS *const cons, CONSANDDATA *const consanddata, SCIP_Real const coef, SCIP_Real const lhs, SCIP_Real const rhs)
static SCIP_RETCODE copyConsPseudoboolean(SCIP *const targetscip, SCIP_CONS **targetcons, SCIP *const sourcescip, SCIP_CONS *const sourcecons, const char *name, SCIP_HASHMAP *const varmap, SCIP_HASHMAP *const consmap, SCIP_Bool const initial, SCIP_Bool const separate, SCIP_Bool const enforce, SCIP_Bool const check, SCIP_Bool const propagate, SCIP_Bool const local, SCIP_Bool const modifiable, SCIP_Bool const dynamic, SCIP_Bool const removable, SCIP_Bool const stickingatnode, SCIP_Bool const global, SCIP_Bool *const valid)
static SCIP_RETCODE getLinearConsNVars(SCIP *const scip, SCIP_CONS *const cons, SCIP_LINEARCONSTYPE const constype, int *const nvars)
static SCIP_RETCODE checkLocksAndRes(SCIP *const scip, SCIP_VAR *res)
static SCIP_RETCODE propagateCons(SCIP *const scip, SCIP_CONS *const cons, SCIP_Bool *const cutoff, int *const ndelconss)
static SCIP_RETCODE getLinearConsSides(SCIP *const scip, SCIP_CONS *const cons, SCIP_LINEARCONSTYPE const constype, SCIP_Real *const lhs, SCIP_Real *const rhs)
#define DEFAULT_DECOMPOSEINDICATORPBCONS
static SCIP_RETCODE conshdlrdataFree(SCIP *const scip, SCIP_CONSHDLRDATA **conshdlrdata)
struct ConsAndData CONSANDDATA
static SCIP_RETCODE chgRhsLinearCons(SCIP *const scip, SCIP_CONS *const cons, SCIP_LINEARCONSTYPE const constype, SCIP_Real const rhs)
static SCIP_RETCODE computeConsAndDataChanges(SCIP *const scip, SCIP_CONSHDLRDATA *const conshdlrdata)
static SCIP_RETCODE getLinearConsVarsData(SCIP *const scip, SCIP_CONS *const cons, SCIP_LINEARCONSTYPE const constype, SCIP_VAR **const vars, SCIP_Real *const coefs, int *const nvars)
#define checkConsConsistency(scip, cons)
static SCIP_RETCODE tryUpgradingLogicor(SCIP *const scip, SCIP_CONS *const cons, SCIP_CONSHDLRDATA *const conshdlrdata, int *const ndelconss, int *const naddconss, int *const nfixedvars, int *const nchgcoefs, int *const nchgsides, SCIP_Bool *const cutoff)
static SCIP_RETCODE unlockRoundingAndCons(SCIP *const scip, SCIP_CONS *const cons, CONSANDDATA *const consanddata, SCIP_Real const coef, SCIP_Real const lhs, SCIP_Real const rhs)
static SCIP_RETCODE addCoefTerm(SCIP *const scip, SCIP_CONS *const cons, SCIP_VAR **const vars, int const nvars, SCIP_Real const val)
static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
#define DEFAULT_PROPAGATENONLINEAR
static SCIP_RETCODE inithashmapandtable(SCIP *const scip, SCIP_CONSHDLRDATA **conshdlrdata)
static SCIP_RETCODE createAndAddAndCons(SCIP *const scip, SCIP_CONSHDLR *const conshdlr, SCIP_VAR **const vars, int const nvars, SCIP_Bool const initial, SCIP_Bool const enforce, SCIP_Bool const check, SCIP_Bool const local, SCIP_Bool const modifiable, SCIP_Bool const dynamic, SCIP_Bool const stickingatnode, SCIP_CONS **const andcons)
static SCIP_RETCODE consdataPrint(SCIP *const scip, SCIP_CONS *const cons, FILE *const file)
static SCIP_RETCODE addNewLocks(SCIP *const scip, SCIP_CONS *const cons, CONSANDDATA *const consanddata, SCIP_Real const coef, SCIP_Real const lhs, SCIP_Real const rhs)
static SCIP_RETCODE consdataCreate(SCIP *const scip, SCIP_CONSHDLR *const conshdlr, SCIP_CONSDATA **consdata, SCIP_CONS *const lincons, SCIP_LINEARCONSTYPE const linconstype, SCIP_CONS **const andconss, SCIP_Real *const andcoefs, SCIP_Bool *const andnegs, int const nandconss, SCIP_VAR *const indvar, SCIP_Real const weight, SCIP_Bool const issoftcons, SCIP_VAR *const intvar, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool check, SCIP_Bool transforming)
static SCIP_RETCODE transformToOrig(SCIP *const scip, CONSANDDATA *consanddata, SCIP_CONSHDLRDATA *conshdlrdata)
static SCIP_RETCODE addCliques(SCIP *const scip, SCIP_CONS *const cons, SCIP_Bool *const cutoff, int *const naggrvars, int *const nchgbds)
static SCIP_RETCODE chgLhs(SCIP *const scip, SCIP_CONS *const cons, SCIP_Real lhs)
#define DEFAULT_REMOVABLENONLINEAR
static SCIP_RETCODE updateConsanddataUses(SCIP *const scip, SCIP_CONS *const cons, SCIP_CONSHDLRDATA *const conshdlrdata, int *const ndelconss)
#define DEFAULT_SEPARATENONLINEAR
static SCIP_RETCODE createAndAddLinearCons(SCIP *const scip, SCIP_CONSHDLR *const conshdlr, SCIP_VAR **const linvars, int const nlinvars, SCIP_Real *const linvals, SCIP_VAR **const andress, int const nandress, SCIP_Real const *const andvals, SCIP_Bool *const andnegs, SCIP_Real *const lhs, SCIP_Real *const rhs, SCIP_Bool const issoftcons, SCIP_Bool const initial, SCIP_Bool const separate, SCIP_Bool const enforce, SCIP_Bool const check, SCIP_Bool const propagate, SCIP_Bool const local, SCIP_Bool const modifiable, SCIP_Bool const dynamic, SCIP_Bool const removable, SCIP_Bool const stickingatnode, SCIP_CONS **const lincons, SCIP_LINEARCONSTYPE *const linconstype)
static SCIP_RETCODE findAggregation(SCIP *const scip, SCIP_CONS *const cons, SCIP_CONSHDLRDATA *const conshdlrdata, int *const ndelconss, int *const naggrvars, SCIP_Bool *const cutoff)
static SCIP_RETCODE createAndAddAnds(SCIP *const scip, SCIP_CONSHDLR *const conshdlr, SCIP_VAR **const *const terms, SCIP_Real *const termcoefs, int const nterms, int const *const ntermvars, SCIP_Bool const initial, SCIP_Bool const enforce, SCIP_Bool const check, SCIP_Bool const local, SCIP_Bool const modifiable, SCIP_Bool const dynamic, SCIP_Bool const stickingatnode, SCIP_CONS **const andconss, SCIP_Real *const andvals, SCIP_Bool *const andnegs, int *const nandconss)
static SCIP_RETCODE tryUpgrading(SCIP *const scip, SCIP_CONS *const cons, SCIP_CONSHDLRDATA *const conshdlrdata, int *const ndelconss, int *const naddconss, int *const nfixedvars, int *const nchgcoefs, int *const nchgsides, SCIP_Bool *const cutoff)
static SCIP_RETCODE chgLhsLinearCons(SCIP *const scip, SCIP_CONS *const cons, SCIP_LINEARCONSTYPE const constype, SCIP_Real const lhs)
#define DEFAULT_DECOMPOSENORMALPBCONS
static SCIP_RETCODE correctConshdlrdata(SCIP *const scip, SCIP_CONSHDLRDATA *const conshdlrdata, int *const ndelconss)
static SCIP_RETCODE tryUpgradingSetppc(SCIP *const scip, SCIP_CONS *const cons, SCIP_CONSHDLRDATA *const conshdlrdata, int *const ndelconss, int *const naddconss, int *const nfixedvars, int *const nchgcoefs, int *const nchgsides, SCIP_Bool *const cutoff)
static SCIP_RETCODE checkSolution(SCIP *const scip, SCIP_VAR **const vars, int const nvars, SCIP_Bool *const values, SCIP_VAR **const linvars, SCIP_Real *const lincoefs, int const nlinvars, SCIP_Real const constant, SCIP_Real const side, CONSANDDATA **const consanddatas, SCIP_Real *const consanddatacoefs, SCIP_Bool *const consanddatanegs, int const nconsanddatas, int const cnt, int *const xortype)
static SCIP_RETCODE checkOrigPbCons(SCIP *const scip, SCIP_CONS *const cons, SCIP_SOL *const sol, SCIP_Bool *const violated, SCIP_Bool const printreason)
static SCIP_RETCODE tryUpgradingXor(SCIP *const scip, SCIP_CONS *const cons, SCIP_CONSHDLRDATA *const conshdlrdata, int *const ndelconss, int *const naddconss, int *const nfixedvars, int *const nchgcoefs, int *const nchgsides, SCIP_Bool *const cutoff)
static SCIP_RETCODE chgRhs(SCIP *const scip, SCIP_CONS *const cons, SCIP_Real rhs)
static SCIP_RETCODE updateAndConss(SCIP *const scip, SCIP_CONS *const cons)
static SCIP_RETCODE consdataFree(SCIP *const scip, SCIP_CONSDATA **consdata, SCIP_Bool isorig, SCIP_CONSHDLRDATA *conshdlrdata)
static SCIP_RETCODE removeOldLocks(SCIP *const scip, SCIP_CONS *const cons, CONSANDDATA *const consanddata, SCIP_Real const coef, SCIP_Real const lhs, SCIP_Real const rhs)
static SCIP_RETCODE correctLocksAndCaptures(SCIP *const scip, SCIP_CONS *const cons, SCIP_CONSHDLRDATA *const conshdlrdata, SCIP_Real const newlhs, SCIP_Real const newrhs, SCIP_VAR **const andress, SCIP_Real *const andcoefs, SCIP_Bool *const andnegs, int const nandress)
constraint handler for pseudoboolean constraints
#define ARTIFICIALVARNAMEPREFIX
Constraint handler for the set partitioning / packing / covering constraints .
Constraint handler for XOR constraints, .
#define SCIPdebugGetSolVal(scip, var, val)
#define SCIPdebugAddSolVal(scip, var, val)
#define SCIP_CALL_ABORT(x)
SCIP_RETCODE SCIPchgLhsPseudoboolean(SCIP *const scip, SCIP_CONS *const cons, SCIP_Real const lhs)
int SCIPgetNVarsKnapsack(SCIP *scip, SCIP_CONS *cons)
#define SCIP_DECL_NONLINCONSUPGD(x)
int SCIPgetNVarsLogicor(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPchgRhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
SCIP_LINEARCONSTYPE SCIPgetLinearConsTypePseudoboolean(SCIP *const scip, SCIP_CONS *const cons)
SCIP_RETCODE SCIPaddCoefPseudoboolean(SCIP *const scip, SCIP_CONS *const cons, SCIP_VAR *const var, SCIP_Real const val)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPcreateConsAnd(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, 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 SCIPaddCoefKnapsack(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Longint weight)
SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPchgAndConsCheckFlagWhenUpgr(SCIP *scip, SCIP_CONS *cons, SCIP_Bool flag)
int SCIPgetNVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR * SCIPgetResultantAnd(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsIndicator(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
int SCIPgetNAndsPseudoboolean(SCIP *const scip, SCIP_CONS *const cons)
int SCIPgetNLinVarsWithoutAndPseudoboolean(SCIP *const scip, SCIP_CONS *const cons)
int SCIPgetNVarsAnd(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPgetLinDatasWithoutAndPseudoboolean(SCIP *const scip, SCIP_CONS *const cons, SCIP_VAR **const linvars, SCIP_Real *const lincoefs, int *const nlinvars)
SCIP_Real * SCIPgetValsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPchgAndConsRemovableFlagWhenUpgr(SCIP *scip, SCIP_CONS *cons, SCIP_Bool flag)
SCIP_Real SCIPgetLhsPseudoboolean(SCIP *const scip, SCIP_CONS *const 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_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_VAR * SCIPgetIndVarPseudoboolean(SCIP *const scip, SCIP_CONS *const cons)
SCIP_VAR ** SCIPgetVarsSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPsortAndCons(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPisAndConsSorted(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetRhsNonlinear(SCIP_CONS *cons)
SCIP_RETCODE SCIPaddTermPseudoboolean(SCIP *const scip, SCIP_CONS *const cons, SCIP_VAR **const vars, int const nvars, SCIP_Real const val)
SCIP_RETCODE SCIPchgRhsPseudoboolean(SCIP *const scip, SCIP_CONS *const cons, SCIP_Real const rhs)
SCIP_RETCODE SCIPaddCoefSetppc(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
enum SCIP_SetppcType SCIP_SETPPCTYPE
SCIP_RETCODE SCIPcreateConsKnapsack(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Longint *weights, SCIP_Longint capacity, 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_Longint * SCIPgetWeightsKnapsack(SCIP *scip, SCIP_CONS *cons)
SCIP_Longint SCIPgetCapacityKnapsack(SCIP *scip, SCIP_CONS *cons)
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_VAR ** SCIPgetVarsLogicor(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsAnd(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsKnapsack(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsLogicor(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_RETCODE SCIPcreateConsBasicPseudoboolean(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR **linvars, int nlinvars, SCIP_Real *linvals, SCIP_VAR ***terms, int nterms, int *ntermvars, SCIP_Real *termvals, SCIP_VAR *indvar, SCIP_Real weight, SCIP_Bool issoftcons, SCIP_VAR *intvar, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE SCIPgetAndDatasPseudoboolean(SCIP *const scip, SCIP_CONS *const cons, SCIP_CONS **const andconss, SCIP_Real *const andcoefs, int *const nandconss)
SCIP_CONS * SCIPgetLinearConsPseudoboolean(SCIP *const scip, SCIP_CONS *const cons)
enum SCIP_LinearConsType SCIP_LINEARCONSTYPE
SCIP_RETCODE SCIPcreateConsPseudobooleanWithConss(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONS *lincons, SCIP_LINEARCONSTYPE linconstype, SCIP_CONS **andconss, SCIP_Real *andcoefs, int nandconss, SCIP_VAR *indvar, SCIP_Real weight, SCIP_Bool issoftcons, SCIP_VAR *intvar, 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 SCIPchgLhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
SCIP_RETCODE SCIPcreateConsPseudoboolean(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR **linvars, int nlinvars, SCIP_Real *linvals, SCIP_VAR ***terms, int nterms, int *ntermvars, SCIP_Real *termvals, SCIP_VAR *indvar, SCIP_Real weight, SCIP_Bool issoftcons, SCIP_VAR *intvar, 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_Real SCIPgetLhsNonlinear(SCIP_CONS *cons)
SCIP_Real SCIPgetRhsPseudoboolean(SCIP *const scip, SCIP_CONS *const cons)
SCIP_RETCODE SCIPaddCoefLogicor(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
@ SCIP_LINEARCONSTYPE_LINEAR
@ SCIP_LINEARCONSTYPE_INVALIDCONS
@ SCIP_LINEARCONSTYPE_LOGICOR
@ SCIP_LINEARCONSTYPE_KNAPSACK
@ SCIP_LINEARCONSTYPE_SETPPC
@ SCIP_SETPPCTYPE_PARTITIONING
@ SCIP_SETPPCTYPE_COVERING
@ SCIP_SETPPCTYPE_PACKING
SCIP_RETCODE SCIPincludeConshdlrPseudoboolean(SCIP *scip)
SCIP_RETCODE SCIPgetConsCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_CONS *sourcecons, SCIP_CONS **targetcons, SCIP_CONSHDLR *sourceconshdlr, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name, 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_Bool SCIPisConsCompressionEnabled(SCIP *scip)
SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNFixedVars(SCIP *scip)
SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapRemove(SCIP_HASHMAP *hashmap, void *origin)
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)
#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 SCIPhashtableRemove(SCIP_HASHTABLE *hashtable, void *element)
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,...)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
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 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 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_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
void SCIPconsAddUpgradeLocks(SCIP_CONS *cons, int nlocks)
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)
int SCIPconsGetNUpgradeLocks(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsOriginal(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
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_Bool SCIPconsIsLocked(SCIP_CONS *cons)
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsAdded(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_RETCODE SCIPtransformCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
SCIP_RETCODE SCIPsetConsChecked(SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPensureBlockMemoryArray(scip, ptr, arraysizeptr, minsize)
#define SCIPallocClearBlockMemoryArray(scip, ptr, num)
#define SCIPallocClearBufferArray(scip, ptr, num)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
void SCIPupdateSolConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLT(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 SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_RETCODE SCIPremoveVarFromGlobalStructures(SCIP *scip, SCIP_VAR *var)
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 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_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
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_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
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 SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
void SCIPfreeParseVarsPolynomialData(SCIP *scip, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int nmonomials)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_RETCODE SCIPwriteVarsPolynomial(SCIP *scip, FILE *file, SCIP_VAR ***monomialvars, SCIP_Real **monomialexps, SCIP_Real *monomialcoefs, int *monomialnvars, int nmonomials, SCIP_Bool type)
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_Bool SCIPvarIsOriginal(SCIP_VAR *var)
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 SCIPparseVarsPolynomial(SCIP *scip, const char *str, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int *nmonomials, char **endptr, SCIP_Bool *success)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
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_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortPtrBool(void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortPtrRealBool(void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortPtrPtrRealBool(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPskipSpace(char **s)
int SCIPstrncpy(char *t, const char *s, int size)
SCIP_RETCODE SCIPaddSymgraphEdge(SCIP *scip, SYM_GRAPH *graph, int first, int second, SCIP_Bool hasval, SCIP_Real val)
SCIP_RETCODE SCIPaddSymgraphOpnode(SCIP *scip, SYM_GRAPH *graph, int op, int *nodeidx)
SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
SCIP_RETCODE SCIPaddSymgraphConsnode(SCIP *scip, SYM_GRAPH *graph, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, int *nodeidx)
SCIP_RETCODE SCIPaddSymgraphVarAggregation(SCIP *scip, SYM_GRAPH *graph, int rootidx, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real constant)
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
static volatile int nterms
memory allocation routines
#define BMScopyMemoryArray(ptr, source, num)
#define BMSclearMemoryArray(ptr, num)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for managing constraints
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 constraint handler plugins and constraints
public methods for problem copies
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 solutions
public methods for SCIP variables
unsigned int istransformed
methods for dealing with symmetry detection graphs
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSINITPRE(x)
#define SCIP_DECL_CONSDELETE(x)
struct SCIP_Cons SCIP_CONS
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
struct SYM_Graph SYM_GRAPH
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSENFOPS(x)
#define SCIP_DECL_CONSPARSE(x)
#define SCIP_DECL_CONSTRANS(x)
#define SCIP_DECL_CONSPRESOL(x)
#define SCIP_DECL_CONSLOCK(x)
struct SCIP_Conshdlr SCIP_CONSHDLR
#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_CONSFREE(x)
struct SCIP_HashMap SCIP_HASHMAP
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
struct SCIP_HashTable SCIP_HASHTABLE
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_TRANSFORMING
enum SYM_Symtype SYM_SYMTYPE
@ SYM_CONSOPTYPE_PB_LINEAR
enum SCIP_Varstatus SCIP_VARSTATUS