114#define SYMHDLR_NAME "orbitopalreduction"
117#define EVENTHDLR_NAME "symmetry_orbitopal_eventhdlr"
118#define EVENTHDLR_DESC "event handler for maintaining the branch-and-bound tree"
119#define DEFAULT_COLUMNORDERING SCIP_COLUMNORDERING_MEDIAN
145struct SCIP_OrbitopalReductionData
173 assert( orbireddata->conshdlr_nonlinear_checked );
183 assert( orbireddata->conshdlr_nonlinear_checked );
184 return orbireddata->conshdlr_nonlinear ==
NULL ?
FALSE :
261 assert( col1 < orbidata->ncols );
263 assert( col2 < orbidata->ncols );
266 for (
i = 0;
i < orbidata->
nrows; ++
i)
268 var1 = orbidata->
vars[
i * orbidata->
ncols + col1];
269 var2 = orbidata->
vars[
i * orbidata->
ncols + col2];
310 int* origequalcolids;
311 int norigequalcolids;
312 int middlecolumn = 0;
313 int positionorigcolidincolorder;
314 int positionswaporigcolidincolorder;
332 ncols = orbidata->
ncols;
342 thiscolswap->
from = 0;
349 if ( origcolid == INT_MAX )
351 thiscolswap->
from = 0;
356 assert( origcolid < ncols );
360 swaporigcolid = origcolid;
366 middlecolumn = ncols / 2;
371 for (
c = 0;
c < ncols; ++
c)
374 if (
c == origcolid )
384 if ( colorderinv[
c] >= colorderinv[swaporigcolid] )
389 if ( colorderinv[
c] <= colorderinv[swaporigcolid] )
394 if (
ABS(colorderinv[
c] - middlecolumn) >=
395 ABS(colorderinv[swaporigcolid] - middlecolumn) )
415 norigequalcolids = 0;
419#ifdef SCIP_MORE_DEBUG
420 SCIPdebugMessage(
"Detect columns identical to original column %d: ", origcolid);
422 for (
c = 0;
c < ncols; ++
c)
425 if (
c == origcolid )
427 origequalcolids[norigequalcolids++] =
c;
428#ifdef SCIP_MORE_DEBUG
431 assert( norigequalcolids <= ncols );
440 origequalcolids[norigequalcolids++] =
c;
441#ifdef SCIP_MORE_DEBUG
444 assert( norigequalcolids <= ncols );
446#ifdef SCIP_MORE_DEBUG
451 assert( norigequalcolids >= 1 );
458 SCIPsortInd(origequalcolids, SCIPsortArgsortInt, colorderinv, norigequalcolids);
460 swaporigcolid = origequalcolids[norigequalcolids / 2];
474 thiscolswap->
from = swaporigcolid;
475 thiscolswap->
to = origcolid;
478 if ( swaporigcolid == origcolid )
485 var1 = orbidata->
vars[
i * ncols + swaporigcolid];
486 var2 = orbidata->
vars[
i * ncols + origcolid];
495 positionorigcolidincolorder = colorderinv[origcolid];
496 assert( positionorigcolidincolorder >= 0 );
497 assert( positionorigcolidincolorder < ncols );
498 assert( colorder[positionorigcolidincolorder] == origcolid );
501 positionswaporigcolidincolorder = colorderinv[swaporigcolid];
502 assert( positionswaporigcolidincolorder >= 0 );
503 assert( positionswaporigcolidincolorder < ncols );
504 assert( colorder[positionswaporigcolidincolorder] == swaporigcolid );
506 SCIPdebugMessage(
"Orbitope %p: Swapping column %d (at position %d) with column %d (at position %d)\n",
507 (
void*) orbidata, origcolid, positionorigcolidincolorder, swaporigcolid, positionswaporigcolidincolorder);
510 colorder[positionswaporigcolidincolorder] = origcolid;
511 colorder[positionorigcolidincolorder] = swaporigcolid;
512 colorderinv[origcolid] = positionswaporigcolidincolorder;
513 colorderinv[swaporigcolid] = positionorigcolidincolorder;
590 *nselrows = orbidata->
nrows;
608 if ( ancestornodeinfo !=
NULL )
611 for (
i = ancestornodeinfo->
nrows - 1;
i >= 0; --
i)
613 (*roworder)[(*nselrows)++] = ancestornodeinfo->
rows[
i];
617 for (j = 0; j < (*nselrows) - 1; ++j)
619 assert( ancestornodeinfo->
rows[
i] != (*roworder)[j] );
630 for (
i = 0;
i < (*nselrows) / 2; ++
i)
634 (*roworder)[
i] = (*roworder)[(*nselrows) - 1 -
i];
635 (*roworder)[(*nselrows) - 1 -
i] = j;
667 while ( node !=
NULL )
670 rootedpath[
i--] = node;
677 node = rootedpath[
i];
686 if ( ancestornodeinfo ==
NULL )
692 for (j = 0; j < ancestornodeinfo->
ncolswaps; ++j)
694 int positionfromincolorder;
695 int positiontoincolorder;
697 thiscolswap = &ancestornodeinfo->
colswaps[j];
703 positionfromincolorder = colorderinv[thiscolswap->
from];
704 assert( positionfromincolorder >= 0 );
705 assert( positionfromincolorder < orbidata->ncols );
706 assert( colorder[positionfromincolorder] == thiscolswap->
from );
709 positiontoincolorder = colorderinv[thiscolswap->
to];
710 assert( positiontoincolorder >= 0 );
711 assert( positiontoincolorder < orbidata->ncols );
712 assert( colorder[positiontoincolorder] == thiscolswap->
to );
715 colorder[positiontoincolorder] = thiscolswap->
from;
716 colorder[positionfromincolorder] = thiscolswap->
to;
717 colorderinv[thiscolswap->
from] = positiontoincolorder;
718 colorderinv[thiscolswap->
to] = positionfromincolorder;
772 for (
c = 0;
c < nchildren; ++
c)
774 childnode = children[
c];
779 for (
i = 0;
i < nboundchgs; ++
i)
797 if ( nbranchvars > 0 )
799 for (j = 0; j < nbranchvars; ++j)
801 if ( branchvars[j] ==
var )
807 if ( j < nbranchvars )
812 if ( nbranchvars >= maxnbranchvars )
814 assert( nbranchvars == maxnbranchvars );
815 assert( maxnbranchvars > 0 );
819 assert( nbranchvars < maxnbranchvars );
820 branchvars[nbranchvars++] =
var;
825 if ( nbranchvars <= 0 )
833 newnodeinfo->
nrows = 0;
849 for (
i = 0;
i < nbranchvars; ++
i)
861 for (j = 0; j < nselrows; ++j)
863 if ( rowid == roworder[j] )
873 roworder[nselrows++] = rowid;
885 newnodeinfo->
nrows, newnodeinfo->
nrows + 1) );
887 newnodeinfo->
rows[newnodeinfo->
nrows++] = rowid;
906 for (
i = 0;
i < orbidata->
ncols; ++
i)
910 for (
i = 0;
i < orbidata->
ncols; ++
i)
924 for (
i = 0;
i < nbranchvars; ++
i)
927 colorderinv, branchvars[
i], &tmpcolswap) );
930 if ( tmpcolswap.
from == tmpcolswap.
to )
946 thiscolswap->
from = tmpcolswap.
from;
947 thiscolswap->
to = tmpcolswap.
to;
979 return eventExecNodeBranched(
scip, eventhdlr, event, eventdata);
1016 for (
c = 1;
c < orbidata->
ncols; ++
c)
1048 assert( (*orbidata)->nrows > 0 );
1049 assert( (*orbidata)->ncols > 0 );
1050 assert( (*orbidata)->nrows * (*orbidata)->ncols > 0 );
1062 for (
i = 0;
i < nentries; ++
i)
1068 if ( nodeinfo ==
NULL )
1090 nelem = (*orbidata)->nrows * (*orbidata)->ncols;
1092 for (
i = 0;
i < nelem; ++
i)
1131 nelem =
nrows * ncols;
1146 orbidata->
ncols = ncols;
1162 SCIPdebugMessage(
"Orbitope variables for (%dx%d) orbitope with orbidata %p\n",
nrows, ncols, (
void*) orbidata);
1165 for (
i = 0, rowid = 0, colid = 0;
i < nelem; ++
i, ++colid)
1167 if ( colid == ncols )
1221 hashGetKeyBnbnodeinfo, hashKeyEqBnbnodeinfo, hashKeyValBnbnodeinfo,
NULL) );
1225 assert( orbireddata->norbitopes >= 0 );
1226 assert( (orbireddata->norbitopes == 0) == (orbireddata->orbitopes ==
NULL) );
1227 assert( orbireddata->norbitopes <= orbireddata->maxnorbitopes );
1228 if ( orbireddata->norbitopes == orbireddata->maxnorbitopes )
1235 if ( orbireddata->norbitopes == 0 )
1244 orbireddata->maxnorbitopes = newsize;
1247 assert( orbireddata->norbitopes < orbireddata->maxnorbitopes );
1250 assert( orbireddata->norbitopes < orbireddata->maxnorbitopes );
1251 orbireddata->orbitopes[orbireddata->norbitopes++] = orbidata;
1316 *colorderinv =
NULL;
1319 ncols = orbidata->
ncols;
1326 for (
i = 0;
i < ncols; ++
i)
1330 for (
i = 0;
i < ncols; ++
i)
1331 (*colorderinv)[
i] =
i;
1380 assert( ncols <= orbidata->ncols );
1384 for (rowid = 0; rowid <
nrows; ++rowid)
1387 for (colid = 0; colid < ncols; ++colid)
1390 idx = rowid * ncols + colid;
1391 origidx = origrowid * ncols + origcolid;
1392 var = orbidata->
vars[origidx];
1399 for (colid = 0; colid < ncols - 1; ++colid)
1402 for (rowid = 0; rowid <
nrows; ++rowid)
1405 assert(
SCIPsymGE(
scip, matrix[rowid * ncols + colid], matrix[rowid * ncols + colid + 1]) );
1407 if (
SCIPsymGT(
scip, matrix[rowid * ncols + colid], matrix[rowid * ncols + colid + 1]) )
1420 assert(
SCIPsymEQ(
scip, matrix[rowid * ncols + colid], matrix[rowid * ncols + colid + 1]) );
1421 if ( addinfinitesimals
1422 ? (infinitesimal[colid] == rowid)
1423 : (infinitesimal[colid + 1] == rowid)
1444 unsigned int hash = 0;
1449 for (
i = 0;
i < len;
i++)
1451 hash ^= (
unsigned int) (array[
i]);
1452 hash = (hash << 1) ^ (hash >> 1);
1459#ifdef SCIP_MORE_DEBUG
1462void debugPrintMatrix(
1475 for (row = 0; row <
nrows; ++row)
1478 for (col = 0; col < ncols; ++col)
1502 int* lexminepsrow =
NULL;
1504 int* lexmaxepsrow =
NULL;
1528 *infeasible =
FALSE;
1532 ncols = orbidata->
ncols;
1536 if ( nselrows <= 0 )
1539#ifdef SCIP_MORE_DEBUG
1547 for (k = 0; k < ncols; ++k)
1553 for (
r = 0;
r < nselrows; ++
r)
1556 for (k = 0; k < ncols; ++k)
1558 thisvar = orbidata->
vars[roworder[
r] * ncols + colorder[k]];
1567 nelem = nselrows * ncols;
1574 for (colid = 0; colid < ncols; ++colid)
1575 lexminepsrow[colid] = -1;
1580 for (rowid = 0,
i = colid; rowid < nselrows; ++rowid,
i += ncols)
1583 origidx = origrowid * ncols + origcolid;
1584 var = orbidata->
vars[origidx];
1586 assert(
i == rowid * ncols + colid );
1592 for (colid = ncols - 2; colid >= 0; --colid)
1601 for (rowid = 0,
i = colid; rowid < nselrows; ++rowid,
i += ncols)
1604 origidx = origrowid * ncols + origcolid;
1605 assert(
i == rowid * ncols + colid );
1608 assert( (
i + 1) % ncols > 0 );
1610 var = orbidata->
vars[origidx];
1626 ( lexminepsrow[colid + 1] == rowid &&
SCIPsymEQ(
scip, ub, lexminface[
i + 1]) ) )
1632 if ( lastunfixed >= 0 )
1636 lexminface[lastunfixed * ncols + colid + 1]) );
1646 lexminface[lastunfixed * ncols + colid] += 1.0;
1653 assert( lexminepsrow[colid] == -1 );
1654 lexminepsrow[colid] = lastunfixed;
1661 rowid = lastunfixed;
1662 i = rowid * ncols + colid;
1669 SCIPdebugMessage(
"Cannot repair infeasibility for column %d (original: %d), min\n", colid, origcolid);
1678 lexminface[
i] =
MAX(lexminface[
i + 1], lb);
1684 else if ( lexminepsrow[colid + 1] == rowid )
1695 assert( lexminepsrow[colid] == -1 );
1696 lexminepsrow[colid] = rowid;
1710 lastunfixed = rowid;
1717 lastunfixed = rowid;
1742 for (colid = 0; colid < ncols; ++colid)
1743 lexmaxepsrow[colid] = -1;
1748 for (rowid = 0,
i = colid; rowid < nselrows; ++rowid,
i += ncols)
1751 origidx = origrowid * ncols + origcolid;
1752 var = orbidata->
vars[origidx];
1754 assert(
i == rowid * ncols + colid );
1760 for (colid = 1; colid < ncols; ++colid)
1769 for (rowid = 0,
i = colid; rowid < nselrows; ++rowid,
i += ncols)
1772 origidx = origrowid * ncols + origcolid;
1773 assert(
i == rowid * ncols + colid );
1778 var = orbidata->
vars[origidx];
1794 ( lexmaxepsrow[colid - 1] == rowid &&
SCIPsymEQ(
scip, lb, lexmaxface[
i - 1]) ) )
1800 if ( lastunfixed >= 0 )
1804 lexmaxface[lastunfixed * ncols + colid - 1]) );
1814 lexmaxface[lastunfixed * ncols + colid] -= 1.0;
1823 assert( lexmaxepsrow[colid] == -1 );
1824 lexmaxepsrow[colid] = lastunfixed;
1831 rowid = lastunfixed;
1832 i = rowid * ncols + colid;
1839 SCIPdebugMessage(
"Cannot repair infeasibility for column %d (original: %d), max\n", colid, origcolid);
1848 lexmaxface[
i] =
MIN(lexmaxface[
i - 1], ub);
1854 else if ( lexmaxepsrow[colid - 1] == rowid )
1865 assert( lexmaxepsrow[colid] == -1 );
1866 lexmaxepsrow[colid] = rowid;
1880 lastunfixed = rowid;
1887 lastunfixed = rowid;
1907#ifdef SCIP_MORE_DEBUG
1910 debugPrintMatrix(lexminface, nselrows, ncols);
1912 debugPrintMatrix(lexmaxface, nselrows, ncols);
1916 for (colid = 0; colid < ncols; ++colid)
1918 for (rowid = 0,
i = colid; rowid < nselrows; ++rowid,
i += ncols)
1920 assert(
i == rowid * ncols + colid );
1925 origidx = origrowid * ncols + origcolid;
1926 var = orbidata->
vars[origidx];
1934 SCIPdebugMessage(
"Fixing variable LB %12s (%3d,%3d) to %5.2f\n",
var->name, rowid, colid, lexminface[
i]);
1939 SCIPdebugMessage(
"Fixing variable LB %12s (%3d,%3d) to %5.2f (no success)\n",
var->name, rowid, colid,
1944 SCIPdebugMessage(
"Detected infeasibility fixing variable %12s (%3d,%3d) to %5.2f\n",
1945 var->name, rowid, colid, lexminface[
i]);
1952 SCIPdebugMessage(
"Fixing variable UB %12s (%3d,%3d) to %5.2f\n",
var->name, rowid, colid, lexminface[
i]);
1957 SCIPdebugMessage(
"Fixing variable UB %12s (%3d,%3d) to %5.2f (no success)\n",
var->name, rowid, colid,
1962 SCIPdebugMessage(
"Detected infeasibility fixing variable %12s (%3d,%3d) to %5.2f\n",
1963 var->name, rowid, colid, lexminface[
i]);
1976 SCIPdebugMessage(
"Restricting variable LB %12s (%3d,%3d) to %5.2f\n",
var->name, rowid, colid,
1982 SCIPdebugMessage(
"Restricting variable LB %12s (%3d,%3d) to %5.2f (no success)\n",
var->name,
1983 rowid, colid, lexminface[
i]);
1987 SCIPdebugMessage(
"Detected infeasibility restricting variable LB %12s (%3d,%3d) to %5.2f\n",
1988 var->name, rowid, colid, lexminface[
i]);
1996 SCIPdebugMessage(
"Restricting variable UB %12s (%3d,%3d) to %5.2f\n",
var->name, rowid, colid,
2002 SCIPdebugMessage(
"Restricting variable UB %12s (%3d,%3d) to %5.2f (no success)\n",
var->name,
2003 rowid, colid, lexmaxface[
i]);
2007 SCIPdebugMessage(
"Detected infeasibility restricting variable UB %12s (%3d,%3d) to %5.2f\n",
2008 var->name, rowid, colid, lexmaxface[
i]);
2047 *infeasible =
FALSE;
2059 if ( nselrows == 0 )
2071 int hash = colhash ^ rowhash;
2074 SCIPdebugPrintf(
"Col hash %32d; Row hash %32d; Hash %32d\n", colhash, rowhash, hash);
2078 while ( tmpnode !=
NULL )
2080 int nbranchings, nconsprop, nprop;
2105#ifdef SCIP_MORE_DEBUG
2130 *nred = orbireddata->nred;
2131 *ncutoff = orbireddata->ncutoff;
2148 if ( orbireddata->norbitopes == 0 )
2155 " orbitopal reduction: %4d components: ", orbireddata->norbitopes);
2156 for (
i = 0;
i < orbireddata->norbitopes; ++
i)
2161 "%dx%d", orbireddata->orbitopes[
i]->nrows, orbireddata->orbitopes[
i]->ncols);
2185 assert( (orbireddata->norbitopes == 0) == (orbireddata->orbitopes ==
NULL) );
2189 *infeasible =
FALSE;
2204 for (
c = 0;
c < orbireddata->norbitopes; ++
c)
2206 orbidata = orbireddata->orbitopes[
c];
2210 SCIPdebugMessage(
"Found %d reductions during orbitopal reduction for orbitope %d\n", thisfixedvars,
c);
2211 *nred += thisfixedvars;
2219 SCIPdebugMessage(
"Detected infeasibility during orbitopal reduction for orbitope %d\n",
c);
2224 orbireddata->nred += *nred;
2226 ++orbireddata->ncutoff;
2253 if ( !orbireddata->conshdlr_nonlinear_checked )
2256 orbireddata->conshdlr_nonlinear_checked =
TRUE;
2274 assert( orbireddata->norbitopes >= 0 );
2275 assert( (orbireddata->norbitopes == 0) == (orbireddata->orbitopes ==
NULL) );
2276 assert( orbireddata->norbitopes <= orbireddata->maxnorbitopes );
2280 while (orbireddata->norbitopes > 0)
2284 assert( orbireddata->norbitopes == 0 );
2286 orbireddata->orbitopes =
NULL;
2287 orbireddata->maxnorbitopes = 0;
2332 "The column ordering variant, respects enum SCIP_ColumnOrdering.",
2340 (*orbireddata)->eventhdlr = eventhdlr;
2343 (*orbireddata)->orbitopes =
NULL;
2344 (*orbireddata)->norbitopes = 0;
2345 (*orbireddata)->maxnorbitopes = 0;
2348 (*orbireddata)->conshdlr_nonlinear =
NULL;
2349 (*orbireddata)->conshdlr_nonlinear_checked =
FALSE;
2352 (*orbireddata)->nred = 0;
2353 (*orbireddata)->ncutoff = 0;
2366 return orbireddata->defaultcolumnordering;
SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_STAGE SCIPgetStage(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)
int SCIPhashtableGetNEntries(SCIP_HASHTABLE *hashtable)
SCIP_RETCODE SCIPhashtableSafeInsert(SCIP_HASHTABLE *hashtable, void *element)
void * SCIPhashtableGetEntry(SCIP_HASHTABLE *hashtable, int entryidx)
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)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
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_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_NODE * SCIPeventGetNode(SCIP_EVENT *event)
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
#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 SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
void SCIPnodeGetNDomchg(SCIP_NODE *node, int *nbranchings, int *nconsprop, int *nprop)
SCIP_DOMCHG * SCIPnodeGetDomchg(SCIP_NODE *node)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
SCIP_NODE * SCIPnodeGetParent(SCIP_NODE *node)
int SCIPnodeGetDepth(SCIP_NODE *node)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_Bool SCIPsymGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsymEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsymLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsymGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsymLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPgetChildren(SCIP *scip, SCIP_NODE ***children, int *nchildren)
SCIP_NODE * SCIPgetFocusNode(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)
SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)
SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG *boundchg)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)
void SCIPsortInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
assert(minobj< SCIPgetCutoffbound(scip))
memory allocation routines
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for managing constraints
public methods for message output
public methods for problem variables
public methods for branching rule plugins and branching
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 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 SCIP variables
SCIP_HASHMAP * rowindexmap
SCIP_Longint lastnodenumber
SCIP_HASHTABLE * nodeinfos
SCIP_ROWORDERING rowordering
SCIP_HASHMAP * colindexmap
SCIP_COLUMNORDERING columnordering
datastructures for block memory pools and memory buffers
SCIP main data structure.
data structures for branch and bound tree
datastructures for problem variables
methods for handling symmetries
static SCIP_RETCODE propagateStaticOrbitope(SCIP *scip, ORBITOPEDATA *orbidata, int *roworder, int nselrows, int *colorder, SCIP_Bool *infeasible, int *nfixedvars)
static SCIP_RETCODE getRowOrder(SCIP *scip, ORBITOPEDATA *orbidata, SCIP_NODE *node, int **roworder, int *nselrows)
static SCIP_RETCODE populateRootedPathColumnOrder(ORBITOPEDATA *orbidata, SCIP_NODE *node, SCIP_NODE **rootedpath, int *colorder, int *colorderinv)
static SCIP_RETCODE freeOrbitope(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, ORBITOPEDATA **orbidata)
static int debugGetArrayHash(int *array, int len)
static void freeColumnOrder(SCIP *scip, ORBITOPEDATA *orbidata, int **colorder, int **colorderinv)
SCIP_RETCODE SCIPincludeOrbitopalReduction(SCIP *scip, SCIP_ORBITOPALREDDATA **orbireddata)
struct OrbitopeData ORBITOPEDATA
SCIP_RETCODE SCIPorbitopalReductionFree(SCIP *scip, SCIP_ORBITOPALREDDATA **orbireddata)
SCIP_RETCODE SCIPorbitopalReductionReset(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata)
static SCIP_RETCODE propagateOrbitope(SCIP *scip, ORBITOPEDATA *orbidata, SCIP_Bool *infeasible, int *nfixedvars)
SCIP_RETCODE SCIPorbitopalReductionAddOrbitope(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, SCIP_ROWORDERING rowordering, SCIP_COLUMNORDERING colordering, SCIP_VAR **vars, int nrows, int ncols, SCIP_Bool *success)
static SCIP_Bool rowIsBranchRow(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, ORBITOPEDATA *orbidata, int rowid)
SCIP_RETCODE SCIPorbitopalReductionPropagate(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, SCIP_Bool *infeasible, int *nred, SCIP_Bool *didrun)
static void freeRowOrder(SCIP *scip, ORBITOPEDATA *orbidata, int **roworder)
SCIP_RETCODE SCIPorbitopalReductionGetStatistics(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, int *nred, int *ncutoff)
struct BnbNodeInfo BNBNODEINFO
static SCIP_RETCODE updateColumnOrderWhenBranchingOnColumn(SCIP *scip, ORBITOPEDATA *orbidata, int *colorder, int *colorderinv, SCIP_VAR *var, COLSWAP *thiscolswap)
static SCIP_RETCODE addOrbitope(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, SCIP_ROWORDERING rowordering, SCIP_COLUMNORDERING colordering, SCIP_VAR **vars, int nrows, int ncols, SCIP_Bool *success)
SCIP_RETCODE SCIPorbitopalReductionPrintStatistics(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata)
static SCIP_Bool testColumnsAreSymmetricallyEquivalent(SCIP *scip, ORBITOPEDATA *orbidata, int col1, int col2)
static SCIP_RETCODE getColumnOrder(SCIP *scip, ORBITOPEDATA *orbidata, SCIP_NODE *eventnode, int **colorder, int **colorderinv)
static SCIP_Bool vartypeIsBranchRowType(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, SCIP_VARTYPE vartype)
SCIP_COLUMNORDERING SCIPorbitopalReductionGetDefaultColumnOrdering(SCIP_ORBITOPALREDDATA *orbireddata)
static int getArrayEntryOrIndex(int *arr, int idx)
#define DEFAULT_COLUMNORDERING
static void assertIsOrbitopeMatrix(SCIP *scip, ORBITOPEDATA *orbidata, int *roworder, int *colorder, SCIP_Real *matrix, int nrows, int ncols, int *infinitesimal, SCIP_Bool addinfinitesimals)
@ SCIP_COLUMNORDERING_CENTRE
@ SCIP_COLUMNORDERING_FIRST
@ SCIP_COLUMNORDERING_NONE
@ SCIP_COLUMNORDERING_LAST
@ SCIP_COLUMNORDERING_MEDIAN
enum SCIP_ColumnOrdering SCIP_COLUMNORDERING
@ SCIP_ROWORDERING_BRANCHING
struct SCIP_OrbitopalReductionData SCIP_ORBITOPALREDDATA
enum SCIP_RowOrdering SCIP_ROWORDERING
struct SCIP_Conshdlr SCIP_CONSHDLR
struct SCIP_Eventhdlr SCIP_EVENTHDLR
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_NODEBRANCHED
struct SCIP_HashMap SCIP_HASHMAP
#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
type definitions for symmetry computations
struct SCIP_Node SCIP_NODE
type definitions for problem variables
union SCIP_DomChg SCIP_DOMCHG
struct SCIP_BoundChg SCIP_BOUNDCHG
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_BOUNDCHGTYPE_BRANCHING
enum SCIP_Vartype SCIP_VARTYPE