104struct SCIP_LexRedData
114 SCIP_Bool hasdynamicperm;
115 SCIP_Bool treewarninggiven;
160 permlen = 2 * (*lexdata)->nvars;
165 permlen = (*lexdata)->nvars;
168 if ( (*lexdata)->nvars > 0 )
175 if ( (*lexdata)->isdynamic )
182 for (
i = 0;
i < (*lexdata)->nvars; ++
i)
197 assert( (*lexdata)->vardomaincenter ==
NULL );
203 assert( (*lexdata)->nvars == 0 );
205 assert( (*lexdata)->vardomaincenter ==
NULL );
230 SCIP_Real* permvardomaincenter,
231 SCIP_Bool usedynamicorder,
236 SCIP_Bool issignedperm;
237 int* indexcorrection;
238 int naffectedvariables;
259 (*lexdata)->symtype = symtype;
261 (*lexdata)->isdynamic = usedynamicorder;
264 naffectedvariables = 0;
269 indexcorrection[
i] = -1;
271 indexcorrection[
i] = naffectedvariables++;
275 if ( naffectedvariables <= 0 )
277 assert( naffectedvariables == 0 );
286 if ( usedynamicorder )
294 (*lexdata)->nvars = naffectedvariables;
295 permlen = issignedperm ? 2 * (*lexdata)->nvars : (*lexdata)->nvars;
305 (*lexdata)->vardomaincenter =
NULL;
308 for (j = 0; j <
nvars; ++j)
310 i = indexcorrection[j];
315 (*lexdata)->vars[
i] =
vars[j];
319 if ( perm[j] >=
nvars )
321 (*lexdata)->perm[
i] = indexcorrection[perm[j] -
nvars] + (*lexdata)->nvars;
322 (*lexdata)->perm[
i + (*lexdata)->nvars] = indexcorrection[perm[j] -
nvars];
323 assert( (*lexdata)->nvars <= (*lexdata)->perm[
i] && (*lexdata)->perm[
i] < 2 * (*lexdata)->nvars );
327 (*lexdata)->perm[
i] = indexcorrection[perm[j]];
328 (*lexdata)->perm[
i + (*lexdata)->nvars] = indexcorrection[perm[j]] + (*lexdata)->nvars;
332 (*lexdata)->perm[
i] = indexcorrection[perm[j]];
335 (*lexdata)->vardomaincenter[
i] = permvardomaincenter[j];
339 assert( (*lexdata)->perm[
i] >= 0 );
340 assert( (*lexdata)->perm[
i] < permlen );
344 for (
i = 0;
i < (*lexdata)->nvars; ++
i)
346 if ( (*lexdata)->perm[
i] >= (*lexdata)->nvars )
350 (*lexdata)->invperm[(*lexdata)->perm[
i]] =
i;
351 (*lexdata)->invperm[(*lexdata)->perm[
i] - (*lexdata)->nvars] =
i + (*lexdata)->nvars;
355 (*lexdata)->invperm[(*lexdata)->perm[
i]] =
i;
358 (*lexdata)->invperm[(*lexdata)->perm[
i] + (*lexdata)->nvars] =
i + (*lexdata)->nvars;
364 for (
i = 0;
i < (*lexdata)->nvars; ++
i)
373 if ( usedynamicorder )
384 for (
i = 0;
i < (*lexdata)->nvars; ++
i)
386 var = (*lexdata)->vars[
i];
402 (*lexdata)->varmap =
NULL;
435 vars = vararraynodedepthbranchindices->
vars;
473 if ( varorder ==
NULL )
475 return varorder[pos];
504 assert( nvarstotal >= 0 );
506 assert( nbranchvars >= 0 );
518 if (
nvars < nbranchvars )
529 assert( varindex < masterdata->nsymvars );
540 assert( (*nselvars) < maxnselvars );
541 varorder[(*nselvars)++] =
i;
547 for (
i = 0;
i < nbranchvars; ++
i)
556 assert( varindex < masterdata->nsymvars );
562 assert( varindex == INT_MAX || (varindex >= 0 && varindex < lexdata->
nvars) );
565 if ( varindex == INT_MAX )
570 varorder[(*nselvars)++] = varindex;
580 vararraynodedepthbranchindices.
vars =
vars;
581 SCIPsortInd(varorder, sortbynodedepthbranchindices, (
void*) &vararraynodedepthbranchindices, *nselvars);
598 SCIP_Bool* peekbdset,
615 if ( peekmode && peekbdset[varidx1] )
617 *ub1 = peekubs[varidx1];
618 *lb1 = peeklbs[varidx1];
625 if ( peekmode && peekbdset[varidx2] )
627 *ub2 = peekubs[varidx2];
628 *lb2 = peeklbs[varidx2];
672 &lb1, &ub1, &lb2, &ub2) );
675 if ( isnegated &&
SCIPisLT(
scip, ub1, shift1 + shift2 - ub2) )
679 if ( (!isnegated) &&
SCIPisLT(
scip, ub1, shift1 - shift2 + lb2) )
719 &lb1, &ub1, &lb2, &ub2) );
722 if ( isnegated &&
SCIPisGT(
scip, ub1, shift1 + shift2 - ub2) )
726 if ( (!isnegated) &&
SCIPisGT(
scip, ub1, shift1 - shift2 + lb2) )
742 SCIP_Bool* infeasible,
757 SCIP_Bool tighten =
FALSE;
765 &lb1, &ub1, &lb2, &ub2) );
773 newbd = center1 + center2 - ub2;
781 newbd = center1 + lb2 - center2;
790 peeklbs[varidx1] = newbd;
791 peekubs[varidx1] = ub1;
792 peekbdset[varidx1] =
TRUE;
809 SCIPdebugMessage(
"Detected infeasibility restricting variable LB %12s to %5.2f\n",
829 SCIP_Bool* infeasible,
844 SCIP_Bool tighten =
FALSE;
857 &lb1, &ub1, &lb2, &ub2) );
865 newbd = center1 + center2 - ub1;
873 newbd = center2 - center1 + ub1;
884 peeklbs[varidx2] = newbd;
885 peekubs[varidx2] = ub2;
886 peekbdset[varidx2] =
TRUE;
890 peeklbs[varidx2] = lb2;
891 peekubs[varidx2] = newbd;
892 peekbdset[varidx2] =
TRUE;
919 SCIPdebugMessage(
"Detected infeasibility restricting variable %sB %12s to %5.2f\n",
936 SCIP_Bool* infeasible,
949 SCIP_Bool tighten =
FALSE;
960 &lb1, &ub1, &lb2, &ub2) );
990 SCIPdebugMessage(
"Detected infeasibility restricting variable LB %12s to %5.2f\n",
1009 SCIP_Bool isnegated,
1010 SCIP_Bool* infeasible,
1017 SCIP_Bool* peekbdset
1028 varidx1, varidx2, peeklbs, peekubs, peekbdset) )
1043 "x: lb=%5.2f, ub=%5.2f, shift=%5.2f "
1044 "y: lb=%5.2f, ub=%5.2f, shift=%5.2f negated=%u\n",
1045 lb1, ub1, center1, lb2, ub2, center2, isnegated);
1056 peeklbs, peekubs, peekbdset) );
1061 varidx1, varidx2, peeklbs, peekubs, peekbdset) );
1066 varidx1, varidx2, peeklbs, peekubs, peekbdset) );
1084 SCIP_Real fixvaluei,
1085 SCIP_Real fixvaluej,
1086 SCIP_Bool* peekfeasible,
1089 SCIP_Bool* peekbdset
1100 SCIP_Bool isnegated;
1101 SCIP_Bool infeasible =
FALSE;
1114 assert( fixi != fixj || fixvaluei == fixvaluej );
1116 assert( fixrow < nselvars );
1122 *peekfeasible =
TRUE;
1127 for (
i = 0;
i < lexdata->
nvars; ++
i)
1130 peeklbs[fixi] = fixvaluei;
1131 peeklbs[fixj] = fixvaluej;
1132 peekubs[fixi] = fixvaluei;
1133 peekubs[fixj] = fixvaluej;
1134 peekbdset[fixi] =
TRUE;
1135 peekbdset[fixj] =
TRUE;
1137 for (row = fixrow + 1; row < nselvars; ++row)
1151 vari = lexdata->
vars[
i];
1152 if ( j >= lexdata->
nvars )
1155 j = j - lexdata->
nvars;
1156 varj = lexdata->
vars[j];
1161 varj = lexdata->
vars[j];
1180 if (
alwaysLTshiftedVars(
scip, vari, varj, centeri, centerj, isnegated,
TRUE,
i, j, peeklbs, peekubs, peekbdset) )
1182 *peekfeasible =
FALSE;
1188 i, j, peeklbs, peekubs, peekbdset) );
1191 i, j, peeklbs, peekubs, peekbdset) );
1195 i, j, peeklbs, peekubs, peekbdset) )
1209 SCIP_Bool* infeasible,
1222 SCIP_Bool isnegated;
1230 assert( *nreductions >= 0 );
1233 if ( nselvars <= 0 )
1244 for (row = 0; row < nselvars; ++row)
1258 vari = lexdata->
vars[
i];
1259 if ( j >= lexdata->
nvars )
1262 j = j - lexdata->
nvars;
1263 varj = lexdata->
vars[j];
1268 varj = lexdata->
vars[j];
1301 if ( row < nselvars )
1305 SCIP_Bool* peekbdset;
1314 SCIP_Bool peekfeasible;
1316 SCIP_CALL(
getVarBounds(vari, varj,
FALSE, 0, 0,
NULL,
NULL,
NULL, &lb1, &ub1, &lb2, &ub2) );
1334 &peekfeasible, peeklbs, peekubs, peekbdset) );
1335 if ( !peekfeasible )
1363 SCIPerrorMessage(
"unsupported variable type encountered at the lexicographic reduction propagator\n");
1394 lbi = lb1 - centeri;
1395 ubi = ub1 - centeri;
1398 lbj = centerj - ub2;
1399 ubj = centerj - lb2;
1403 lbj = lb2 - centerj;
1404 ubj = ub2 - centerj;
1421 fixvalj = centerj - lbj;
1423 fixvalj = lbj + centerj;
1427 row, lbi + centeri, fixvalj, &peekfeasible, peeklbs, peekubs, peekbdset) );
1428 if ( !peekfeasible )
1457 SCIPerrorMessage(
"unsupported variable type encountered at the lexicographic reduction propagator\n");
1476 fixvalj = centerj - ubj;
1478 fixvalj = ubj + centerj;
1482 row, ubi + centeri, fixvalj, &peekfeasible, peeklbs, peekubs, peekbdset) );
1483 if ( !peekfeasible )
1544 SCIP_Bool* infeasible,
1557 assert( nvarstotal >= 0 );
1559 assert( nbranchvars >= 0 );
1569 varorder, &nvarorder,
nvars) );
1570 assert( nvarorder >= 0 );
1574 if ( nvarorder > 0 )
1590 SCIP_Bool* infeasible,
1602 if ( lexdata->
nvars == 0 )
1622 SCIP_Bool* infeasible,
1637 *infeasible =
FALSE;
1665 SCIP_Bool* inforesolved
1690 if ( shadownode ==
NULL )
1693 *inforesolved =
FALSE;
1696 SCIPwarningMessage(
scip,
"Attempting lexicographic reduction on nodes not existing in the symmetry shadowtree"
1697 " (and suppressing future warnings)\n");
1708 shadownode = shadownode->
parent;
1715 while (shadownode !=
NULL)
1717 assert( shadowdepth > 0 );
1732 if ( varindex == INT_MAX )
1736 assert( varindex < masterdata->nsymvars );
1749 assert( *nbranchvars < masterdata->nsymvars );
1750 branchvars[(*nbranchvars)++] =
var;
1760 shadownode = shadownode->
parent;
1764 assert( shadowdepth == 0 );
1766 *inforesolved =
TRUE;
1801 assert( *nbranchvars >= 0 );
1802 assert( *nbranchvars <= masterdata->nsymvars );
1812 while ( *nbranchvars > 0 )
1813 branchvars[--(*nbranchvars)] =
NULL;
1814 assert( *nbranchvars == 0 );
1818 shadownode = shadownode->
parent;
1825 while (shadownode !=
NULL)
1828 assert( shadowdepth > 0 );
1844 assert( varindex < masterdata->nsymvars );
1853 shadownode = shadownode->
parent;
1859 assert( shadowdepth == 0 );
1925 SCIP_Bool* infeasible,
1937 int nbranchvars = 0;
1938 SCIP_Bool inforesolved;
1949 *infeasible =
FALSE;
1976 branchvars, &nbranchvars, shadowtree, focusnode, &inforesolved) );
1979 if ( !inforesolved )
1989 if ( nbranchvars > 0 || !
masterdata->hasdynamicperm )
2022 branchvars, &nbranchvars, shadowtree, focusnode) );
2023 assert( nbranchvars == 0 );
2040 SCIP_Real* permvardomaincenter,
2041 SCIP_Bool usedynamicorder,
2086 permvars, npermvars, perm, symtype, permvardomaincenter, usedynamicorder, success) );
2173 (*masterdata)->shadowtreeeventhdlr = shadowtreeeventhdlr;
2174 (*masterdata)->symvarmap =
NULL;
2175 (*masterdata)->nsymvars = 0;
2176 (*masterdata)->lexdatas =
NULL;
2177 (*masterdata)->nlexdatas = 0;
2178 (*masterdata)->maxnlexdatas = 0;
2179 (*masterdata)->nred = 0;
2180 (*masterdata)->ncutoff = 0;
2181 (*masterdata)->hasdynamicperm =
FALSE;
2182 (*masterdata)->treewarninggiven =
FALSE;
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)
#define SCIP_CALL_ABORT(x)
SCIP_RETCODE SCIPactivateShadowTree(SCIP *scip, SCIP_EVENTHDLR *eventhdlr)
SCIP_SHADOWTREE * SCIPgetShadowTree(SCIP_EVENTHDLR *eventhdlr)
SCIP_SHADOWNODE * SCIPshadowTreeGetShadowNode(SCIP_SHADOWTREE *shadowtree, SCIP_NODE *node)
SCIP_Bool SCIPisTransformed(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 SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
#define SCIPfreeCleanBufferArray(scip, ptr)
#define SCIPallocCleanBufferArray(scip, ptr, num)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(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 SCIPallocBlockMemory(scip, ptr)
int SCIPnodeGetDepth(SCIP_NODE *node)
SCIP_Bool SCIPsymGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsymEQ(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_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_NODE * SCIPgetFocusNode(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
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)
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)
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_Real * vardomaincenter
struct SCIP_ShadowNode ** children
SCIP_SHADOWBOUNDUPDATE * branchingdecisions
struct SCIP_ShadowNode * parent
NODEDEPTHBRANCHINDEX * nodedepthbranchindices
SCIP_LEXREDDATA * masterdata
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_Bool canGTshiftedVars(SCIP *scip, SCIP_VAR *var1, SCIP_VAR *var2, SCIP_Real shift1, SCIP_Real shift2, SCIP_Bool isnegated, SCIP_Bool peekmode, int varidx1, int varidx2, SCIP_Real *peeklbs, SCIP_Real *peekubs, SCIP_Bool *peekbdset)
static SCIP_RETCODE propagateLowerBoundVar(SCIP *scip, SCIP_VAR *var1, SCIP_VAR *var2, SCIP_Real center1, SCIP_Real center2, SCIP_Bool isnegated, SCIP_Bool *infeasible, int *nreductions, SCIP_Bool peekmode, int varidx1, int varidx2, SCIP_Real *peeklbs, SCIP_Real *peekubs, SCIP_Bool *peekbdset)
static SCIP_RETCODE propagateVariablePair(SCIP *scip, SCIP_VAR *var1, SCIP_VAR *var2, SCIP_Real center1, SCIP_Real center2, SCIP_Bool isnegated, SCIP_Bool *infeasible, int *nreductions, SCIP_Bool peekmode, int varidx1, int varidx2, SCIP_Real *peeklbs, SCIP_Real *peekubs, SCIP_Bool *peekbdset)
static SCIP_RETCODE propagateLexredDynamic(SCIP *scip, SCIP_LEXREDDATA *masterdata, LEXDATA *lexdata, NODEDEPTHBRANCHINDEX *nodedepthbranchindices, int nvarstotal, SCIP_VAR **branchvars, int nbranchvars, SCIP_Bool *infeasible, int *nreductions)
SCIP_RETCODE SCIPlexicographicReductionPropagate(SCIP *scip, SCIP_LEXREDDATA *masterdata, SCIP_Bool *infeasible, int *nred, SCIP_Bool *didrun)
static SCIP_Bool alwaysLTshiftedVars(SCIP *scip, SCIP_VAR *var1, SCIP_VAR *var2, SCIP_Real shift1, SCIP_Real shift2, SCIP_Bool isnegated, SCIP_Bool peekmode, int varidx1, int varidx2, SCIP_Real *peeklbs, SCIP_Real *peekubs, SCIP_Bool *peekbdset)
SCIP_RETCODE SCIPlexicographicReductionGetStatistics(SCIP *scip, SCIP_LEXREDDATA *masterdata, int *nred, int *ncutoff)
static SCIP_RETCODE peekStaticLexredIsFeasible(SCIP *scip, LEXDATA *lexdata, int *varorder, int nselvars, int fixi, int fixj, int fixrow, SCIP_Real fixvaluei, SCIP_Real fixvaluej, SCIP_Bool *peekfeasible, SCIP_Real *peeklbs, SCIP_Real *peekubs, SCIP_Bool *peekbdset)
SCIP_RETCODE SCIPlexicographicReductionReset(SCIP *scip, SCIP_LEXREDDATA *masterdata)
static SCIP_RETCODE propagateUpperBoundSymVar(SCIP *scip, SCIP_VAR *var1, SCIP_VAR *var2, SCIP_Real center1, SCIP_Real center2, SCIP_Bool isnegated, SCIP_Bool *infeasible, int *nreductions, SCIP_Bool peekmode, int varidx1, int varidx2, SCIP_Real *peeklbs, SCIP_Real *peekubs, SCIP_Bool *peekbdset)
static SCIP_RETCODE getVarBounds(SCIP_VAR *var1, SCIP_VAR *var2, SCIP_Bool peekmode, int varidx1, int varidx2, SCIP_Real *peeklbs, SCIP_Real *peekubs, SCIP_Bool *peekbdset, SCIP_Real *lb1, SCIP_Real *ub1, SCIP_Real *lb2, SCIP_Real *ub2)
SCIP_RETCODE SCIPlexicographicReductionPrintStatistics(SCIP *scip, SCIP_LEXREDDATA *masterdata)
static SCIP_RETCODE propagateLexredStatic(SCIP *scip, SCIP_LEXREDDATA *masterdata, LEXDATA *lexdata, SCIP_Bool *infeasible, int *nreductions)
static SCIP_RETCODE lexdataFree(SCIP *scip, LEXDATA **lexdata)
static SCIP_RETCODE getVarOrder(SCIP *scip, SCIP_LEXREDDATA *masterdata, LEXDATA *lexdata, NODEDEPTHBRANCHINDEX *nodedepthbranchindices, int nvarstotal, SCIP_VAR **branchvars, int nbranchvars, int *varorder, int *nselvars, int maxnselvars)
static SCIP_RETCODE shadowtreeUndoNodeDepthBranchIndices(SCIP *scip, SCIP_LEXREDDATA *masterdata, NODEDEPTHBRANCHINDEX *nodedepthbranchindices, SCIP_VAR **branchvars, int *nbranchvars, SCIP_SHADOWTREE *shadowtree, SCIP_NODE *focusnode)
SCIP_RETCODE SCIPlexicographicReductionFree(SCIP *scip, SCIP_LEXREDDATA **masterdata)
static SCIP_RETCODE propagateLexicographicReductionPerm(SCIP *scip, SCIP_LEXREDDATA *masterdata, LEXDATA *lexdata, NODEDEPTHBRANCHINDEX *nodedepthbranchindices, int nvarstotal, SCIP_VAR **branchvars, int nbranchvars, SCIP_Bool *infeasible, int *nreductions)
SCIP_RETCODE SCIPlexicographicReductionAddPermutation(SCIP *scip, SCIP_LEXREDDATA *masterdata, SCIP_VAR **permvars, int npermvars, int *perm, SYM_SYMTYPE symtype, SCIP_Real *permvardomaincenter, SCIP_Bool usedynamicorder, SCIP_Bool *success)
static SCIP_RETCODE propagateSelfReflectionVar(SCIP *scip, SCIP_VAR *var, SCIP_Real center, SCIP_Bool *infeasible, int *nreductions, SCIP_Bool peekmode, int varidx, SCIP_Real *peeklbs, SCIP_Real *peekubs, SCIP_Bool *peekbdset)
static SCIP_RETCODE propagateStaticLexred(SCIP *scip, LEXDATA *lexdata, int *varorder, int nselvars, SCIP_Bool *infeasible, int *nreductions)
static SCIP_RETCODE shadowtreeFillNodeDepthBranchIndices(SCIP *scip, SCIP_LEXREDDATA *masterdata, NODEDEPTHBRANCHINDEX *nodedepthbranchindices, SCIP_VAR **branchvars, int *nbranchvars, SCIP_SHADOWTREE *shadowtree, SCIP_NODE *focusnode, SCIP_Bool *inforesolved)
SCIP_RETCODE SCIPincludeLexicographicReduction(SCIP *scip, SCIP_LEXREDDATA **masterdata, SCIP_EVENTHDLR *shadowtreeeventhdlr)
static SCIP_RETCODE lexdataCreate(SCIP *scip, SCIP_LEXREDDATA *masterdata, LEXDATA **lexdata, SCIP_VAR *const *vars, int nvars, int *perm, SYM_SYMTYPE symtype, SCIP_Real *permvardomaincenter, SCIP_Bool usedynamicorder, SCIP_Bool *success)
static int varOrderGetIndex(int *varorder, int pos)
methods for handling symmetries by dynamic lexicographic ordering reduction
struct SCIP_LexRedData SCIP_LEXREDDATA
#define SCIP_DECL_SORTINDCOMP(x)
enum SCIP_Retcode SCIP_RETCODE
enum SYM_Symtype SYM_SYMTYPE
type definitions for problem variables
@ SCIP_VARTYPE_CONTINUOUS