104struct SCIP_LexRedData
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 );
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);
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) )
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",
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",
960 &lb1, &ub1, &lb2, &ub2) );
990 SCIPdebugMessage(
"Detected infeasibility restricting variable LB %12s to %5.2f\n",
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) );
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) )
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 )
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 )
1557 assert( nvarstotal >= 0 );
1559 assert( nbranchvars >= 0 );
1569 varorder, &nvarorder,
nvars) );
1570 assert( nvarorder >= 0 );
1574 if ( nvarorder > 0 )
1602 if ( lexdata->
nvars == 0 )
1637 *infeasible =
FALSE;
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 );
1937 int nbranchvars = 0;
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 );
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)
struct SCIP_ShadowTree SCIP_SHADOWTREE
struct SCIP_ShadowNode SCIP_SHADOWNODE
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)
struct NodeDepthBranchIndex NODEDEPTHBRANCHINDEX
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)
struct LexRedPermData LEXDATA
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)
struct VarArrayNodeDepthBranchIndex VARARRAYNODEDEPTHBRANCHINDEX
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
struct SCIP_Eventhdlr SCIP_EVENTHDLR
struct SCIP_HashMap SCIP_HASHMAP
#define SCIP_DECL_SORTINDCOMP(x)
enum SCIP_Retcode SCIP_RETCODE
enum SYM_Symtype SYM_SYMTYPE
struct SCIP_Node SCIP_NODE
type definitions for problem variables
@ SCIP_VARTYPE_CONTINUOUS