62#define HEUR_NAME "dps"
63#define HEUR_DESC "primal heuristic for decomposable MIPs"
64#define HEUR_DISPCHAR SCIP_HEURDISPCHAR_LNS
65#define HEUR_PRIORITY 75000
68#define HEUR_MAXDEPTH -1
69#define HEUR_TIMING SCIP_HEURTIMING_BEFORENODE | SCIP_HEURTIMING_AFTERNODE
70#define HEUR_USESSUBSCIP TRUE
72#define DEFAULT_MAXIT 50
73#define DEFAULT_PENALTY 100.0
76#define EVENTHDLR_NAME "Dps"
77#define EVENTHDLR_DESC "event handler for " HEUR_NAME " heuristic"
170 newlabel = varlabels[
nvars - 1];
172 for( v = 0; v < nlinkvars; v++ )
198 for( v = 0; v < nlinkvars; v++ )
316 for(
i = 0;
i < nconss; ++
i )
395 nvars, nconss, success) );
410 for( v = 0; v <
nvars; v++ )
424 for(
c = 0;
c < nlinking;
c++ )
426 const char* conshdlrname;
440#ifdef SCIP_MORE_DEBUG
449 if( !( (strcmp(conshdlrname,
"linear") == 0) || (strcmp(conshdlrname,
"setppc") == 0)
450 || (strcmp(conshdlrname,
"logicor") == 0) || (strcmp(conshdlrname,
"knapsack") == 0)
451 || (strcmp(conshdlrname,
"varbound") == 0) ) )
463 if( nconsvars > maxnconsvars )
472 maxnconsvars = newsize;
485 for( v = 0; v < nconsvars; v++ )
490 blockvals[nblockvars] = consvals[v];
502 blockvars[nblockvars] = negblockvar;
503 blockvals[nblockvars] = consvals[v];
510 if( nblockvars == 0 )
546 blockvals[nblockvars] = -1.0;
548#ifdef SCIP_MORE_DEBUG
566 blockvals[nblockvars] = 1.0;
568#ifdef SCIP_MORE_DEBUG
582#ifdef SCIP_MORE_DEBUG
597 for( v = 0; v < nblockvars - linkings[
c]->
nslacksperblock && (!mininfinite || !maxinfinite); v++ )
604 if( blockvals[v] >= 0.0 )
609 minact += blockvals[v] * lb;
611 maxact += blockvals[v] * ub;
618 minact += blockvals[v] * ub;
620 maxact += blockvals[v] * lb;
686 assert(0 == nvarsblock[0]);
693 conssoffset += nconssblock[
i];
694 varsoffset += nvarsblock[
i];
773 for(
i = 0;
i < length;
i++ )
808 for(
i = 0;
i < linking->
nblocks - nnonintblocks;
i++ )
809 sumafter += 1 - fracPart[nnonintblocks +
i];
811 for(
i = 0;
i < linking->
nblocks - nnonintblocks;
i++ )
813 sumbefor += fracPart[nnonintblocks +
i];
814 sumafter -= 1 - fracPart[nnonintblocks +
i];
816 if( sumbefor >= sumafter )
818 for( k = 0; k <=
i; k++ )
819 fracPart[nnonintblocks + k] = -fracPart[nnonintblocks + k];
821 for( k =
i + 1; k < linking->
nblocks - nnonintblocks; k++ )
822 fracPart[nnonintblocks + k] = 1 - fracPart[nnonintblocks + k];
828 diff = sumbefor - sumafter;
832 for(
i = nnonintblocks - 1;
i >= 0;
i-- )
846 assert(nnonintblocks == 0);
847 fracPart[idx] += diff;
900 for(
c = 0;
c < nlinking;
c++ )
902 linking = linkings[
c];
941 if( origvar ==
NULL )
947 lpvalue += varlpvalue * consvals[
i];
977 residual = goalvalue - part;
995 residual = goalvalue - part;
1009 goalvalue = residualrhs / (linking->
nblocks -
b);
1020 goalvalue = residuallhs / (linking->
nblocks -
b);
1042#ifdef SCIP_MORE_DEBUG
1051#ifdef SCIP_MORE_DEBUG
1069 int* nviolatedblocksrhs,
1070 int* nviolatedblockslhs,
1074 int* nonviolatedblocksrhs;
1075 int* nonviolatedblockslhs;
1089 for( v = 0; v < linking->
nblocks; v++ )
1108 (*nviolatedblocksrhs)++;
1110 (*shift)[v] += slackval;
1111 sumviols += slackval;
1115 nonviolatedblocksrhs[v - *nviolatedblocksrhs] = v;
1125 (*nviolatedblockslhs)++;
1127 (*shift)[v] -= slackval;
1128 sumviols -= slackval;
1132 nonviolatedblockslhs[v - *nviolatedblockslhs] = v;
1138 if( *nviolatedblocksrhs + *nviolatedblockslhs == 0 ||
1139 linking->
nblocks == *nviolatedblocksrhs || linking->
nblocks == *nviolatedblockslhs )
1159 assert(*nviolatedblocksrhs != 0);
1164 for( v = 0; v < linking->
nblocks - *nviolatedblocksrhs; v++ )
1167 part = linking->
currentrhs[nonviolatedblocksrhs[v]] - residual/(linking->
nblocks - *nviolatedblocksrhs - v);
1169 shift_tmp = part - linking->
currentrhs[nonviolatedblocksrhs[v]];
1170 residual += shift_tmp;
1171 (*shift)[nonviolatedblocksrhs[v]] += shift_tmp;
1176 if( linking->
nblocks - *nviolatedblocksrhs == 1 )
1177 (*shift)[nonviolatedblocksrhs[0] == 0 ? 1 : 0] -= residual;
1179 (*shift)[nonviolatedblocksrhs[0]] -= residual;
1190 assert(*nviolatedblockslhs != 0);
1195 for( v = 0; v < linking->
nblocks - *nviolatedblockslhs; v++ )
1198 part = linking->
currentlhs[nonviolatedblockslhs[v]] - residual/(linking->
nblocks - *nviolatedblockslhs - v);
1200 shift_tmp = part - linking->
currentlhs[nonviolatedblockslhs[v]];
1201 residual += shift_tmp;
1202 (*shift)[nonviolatedblockslhs[v]] += shift_tmp;
1207 if( linking->
nblocks - *nviolatedblockslhs == 1 )
1208 (*shift)[nonviolatedblockslhs[0] == 0 ? 1 : 0] -= residual;
1210 (*shift)[nonviolatedblockslhs[0]] -= residual;
1231 int** nviolatedblocksrhs,
1232 int** nviolatedblockslhs,
1252 for(
c = 0;
c < nlinking;
c++ )
1256 linking = linkings[
c];
1257 (*nviolatedblocksrhs)[
c] = 0;
1258 (*nviolatedblockslhs)[
c] = 0;
1273 for( v = 0; v < linking->
nblocks; v++ )
1279 for( v = 0; v < linking->
nblocks; v++)
1291 for( v = 0; v < linking->
nblocks; v++ )
1323 int* nviolatedblocksrhs,
1324 int* nviolatedblockslhs,
1338 for(
c = 0;
c < nlinking;
c++ )
1340 assert(nviolatedblocksrhs[
c] >= 0);
1341 assert(nviolatedblockslhs[
c] >= 0);
1344 if( nviolatedblocksrhs[
c] + nviolatedblockslhs[
c] == 0 )
1361 new_obj = old_obj +
heurdata->penalty * nviolatedblocksrhs[
c];
1369 new_obj = old_obj +
heurdata->penalty * nviolatedblockslhs[
c];
1418 sol = sols[nsols - 1];
1460 rvar = linking->
slacks[2 *
i];
1461 lvar = linking->
slacks[2 *
i + 1];
1464 activity = activitycons + rval - lval;
1468 else if( linking->
hasrhs )
1472 activity = activitycons + rval;
1480 activity = activitycons - lval;
1494 SCIPdebugMsg(subscip,
"Correcting solution successful\n");
1554 for( v = 0; v < blockproblem[
b]->
nblockvars; v++ )
1560 for( v = blockproblem[
b]->nblockvars; v <
nvars; v++ )
1604 if( timesubscip < time - 1.0 )
1664 for( v = 0; v < nblockvars; v++ )
1759 int* sortedvarlabels;
1760 int* sortedconslabels;
1786 assigneddecomp =
NULL;
1787 blockproblem =
NULL;
1811 decomp = alldecomps[0];
1822 SCIPdebugMsg(
scip,
"problem has no constraints, no variables or less than two blocks\n");
1867 decomp = assigneddecomp;
1892 if(
heurdata->maxlinkscore != 1.0 )
1901 if( linkscore >
heurdata->maxlinkscore )
1912 SCIPdebugMsg(
scip,
"Problem has linking variables or no linking constraints or less than two blocks\n");
1917 heurdata->linkingconss = sortedconss;
1992 for( k = 0; k <
heurdata->maxit; k++ )
2013 if( eventhdlr ==
NULL )
2048 SCIPdebugMsg(
scip,
"Subproblem reached timelimit without optimal solution\n");
2052 allslacksval += blocksolval;
2085 for(
c = 0;
c < nblockvars;
c++ )
2139 int* nviolatedblocksrhs;
2140 int* nviolatedblockslhs;
2184 if( linkings !=
NULL )
2208 if( blockproblem !=
NULL )
2222 if( assigneddecomp !=
NULL )
2225 if( sortedconslabels !=
NULL )
2228 if( sortedvarlabels !=
NULL )
2231 if( sortedconss !=
NULL )
2234 if( sortedvars !=
NULL )
2276 "maximal linking score of used decomposition (equivalent to percentage of linking constraints)",
2280 "multiplier for absolute increase of penalty parameters (0: no increase)",
2284 "should the problem get reoptimized with the original objective function?", &
heurdata->reoptimize,
FALSE,
FALSE,
NULL,
NULL) );
2293 "should the heuristic run before or after the processing of the node? (0: before, 1: after, 2: both)",
#define SCIP_CALL_ABORT(x)
SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPchgRhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBasicLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs)
SCIP_Real SCIPgetActivityLinear(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
SCIP_RETCODE SCIPchgLhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
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_RETCODE SCIPcopyLimits(SCIP *sourcescip, SCIP *targetscip)
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_RETCODE SCIPcomputeDecompConsLabels(SCIP *scip, SCIP_DECOMP *decomp, SCIP_CONS **conss, int nconss)
void SCIPgetDecomps(SCIP *scip, SCIP_DECOMP ***decomps, int *ndecomps, SCIP_Bool original)
SCIP_RETCODE SCIPdecompSetVarsLabels(SCIP_DECOMP *decomp, SCIP_VAR **vars, int *labels, int nvars)
int SCIPdecompGetNBlocks(SCIP_DECOMP *decomp)
SCIP_RETCODE SCIPdecompSetConsLabels(SCIP_DECOMP *decomp, SCIP_CONS **conss, int *labels, int nconss)
SCIP_RETCODE SCIPdecompCreate(SCIP_DECOMP **decomp, BMS_BLKMEM *blkmem, int nblocks, SCIP_Bool original, SCIP_Bool benderslabels)
SCIP_RETCODE SCIPdecompGetVarsSize(SCIP_DECOMP *decomp, int *varssize, int nlabels)
SCIP_RETCODE SCIPcomputeDecompStats(SCIP *scip, SCIP_DECOMP *decomp, SCIP_Bool uselimits)
char * SCIPdecompPrintStats(SCIP_DECOMP *decomp, char *strbuf)
SCIP_RETCODE SCIPdecompGetConssSize(SCIP_DECOMP *decomp, int *consssize, int nlabels)
void SCIPdecompGetConsLabels(SCIP_DECOMP *decomp, SCIP_CONS **conss, int *labels, int nconss)
void SCIPdecompFree(SCIP_DECOMP **decomp, BMS_BLKMEM *blkmem)
int SCIPdecompGetNBorderVars(SCIP_DECOMP *decomp)
void SCIPdecompGetVarsLabels(SCIP_DECOMP *decomp, SCIP_VAR **vars, int *labels, int nvars)
SCIP_Bool SCIPdecompUseBendersLabels(SCIP_DECOMP *decomp)
int SCIPdecompGetNBorderConss(SCIP_DECOMP *decomp)
SCIP_Bool SCIPdecompIsOriginal(SCIP_DECOMP *decomp)
SCIP_RETCODE SCIPfree(SCIP **scip)
SCIP_RETCODE SCIPcreate(SCIP **scip)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
const char * SCIPgetProbName(SCIP *scip)
SCIP_VAR ** SCIPgetOrigVars(SCIP *scip)
SCIP_CONS ** SCIPgetConss(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNConss(SCIP *scip)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
int SCIPgetNOrigVars(SCIP *scip)
SCIP_RETCODE SCIPcreateProb(SCIP *scip, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata)
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
SCIP_RETCODE SCIPsetSubscipsOff(SCIP *scip, SCIP_Bool quiet)
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
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)
SCIP_RETCODE SCIPgetIntParam(SCIP *scip, const char *name, int *value)
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPincludeHeurDps(SCIP *scip)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur,)
SCIP_HEURDATA * SCIPheurGetData(SCIP_HEUR *heur)
SCIP_RETCODE SCIPincludeHeurBasic(SCIP *scip, SCIP_HEUR **heur, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, SCIP_HEURTIMING timingmask, SCIP_Bool usessubscip, SCIP_DECL_HEUREXEC((*heurexec)), SCIP_HEURDATA *heurdata)
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur,)
SCIP_Longint SCIPheurGetNCalls(SCIP_HEUR *heur)
const char * SCIPheurGetName(SCIP_HEUR *heur)
void SCIPheurSetData(SCIP_HEUR *heur, SCIP_HEURDATA *heurdata)
SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
SCIP_RETCODE SCIPaddSolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool *stored)
int SCIPgetNSols(SCIP *scip)
SCIP_RETCODE SCIPcreateOrigSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_RETCODE SCIPsetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_SOL ** SCIPgetSols(SCIP *scip)
SCIP_RETCODE SCIPtrySolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_RETCODE SCIPtransformProb(SCIP *scip)
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
SCIP_RETCODE SCIPinterruptSolve(SCIP *scip)
SCIP_RETCODE SCIPsolve(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
SCIP_Real SCIPgetDualbound(SCIP *scip)
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
SCIP_Real SCIPgetTotalTime(SCIP *scip)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool 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_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
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_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
void SCIPsortIntPtr(int *intarray, void **ptrarray, int len)
void SCIPsortIntReal(int *intarray, SCIP_Real *realarray, int len)
void SCIPsortRealInt(SCIP_Real *realarray, int *intarray, int len)
void SCIPsortIntIntReal(int *intarray1, int *intarray2, SCIP_Real *realarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIPfreeSol(scip, &heurdata->sol))
SCIPcreateSol(scip, &heurdata->sol, heur))
static SCIP_RETCODE updateLambda(SCIP *scip, SCIP_HEURDATA *heurdata, LINKING **linkings, BLOCKPROBLEM **blockproblem, int *nviolatedblocksrhs, int *nviolatedblockslhs, int nlinking)
static SCIP_RETCODE assignLinking(SCIP *scip, SCIP_DECOMP *newdecomp, SCIP_VAR **vars, SCIP_CONS **conss, int *varlabels, int *conslabels, int nvars, int nconss, int nlinkvars)
static SCIP_RETCODE roundPartition(SCIP *scip, LINKING *linking, BLOCKPROBLEM **blockproblem, SCIP_Bool roundbyrhs)
struct Blockproblem BLOCKPROBLEM
static SCIP_RETCODE updatePartition(SCIP *scip, LINKING **linkings, BLOCKPROBLEM **blockproblem, int **nviolatedblocksrhs, int **nviolatedblockslhs, int nlinking, int nblocks, int iteration, SCIP_Bool *oneupdate)
static SCIP_RETCODE createSubscip(SCIP *scip, SCIP **subscip)
static SCIP_RETCODE initCurrent(SCIP *scip, LINKING **linkings, BLOCKPROBLEM **blockproblem, SCIP_HEURTIMING heurtiming, int nlinking, SCIP_Bool *success)
static SCIP_RETCODE reuseSolution(LINKING **linkings, BLOCKPROBLEM **blockproblem, int nblocks)
static SCIP_RETCODE createBlockproblem(SCIP *scip, BLOCKPROBLEM *blockproblem, LINKING **linkings, SCIP_CONS **conss, SCIP_VAR **vars, int nconss, int nvars, SCIP_CONS **linkingconss, int nlinking, int blocknumber, SCIP_Bool *success)
static SCIP_RETCODE reoptimize(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL *sol, BLOCKPROBLEM **blockproblem, int nblocks, SCIP_Bool limits, SCIP_SOL **newsol, SCIP_Bool *success)
static SCIP_RETCODE createAndSplitProblem(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_DECOMP *decomp, BLOCKPROBLEM **blockproblem, LINKING **linkings, SCIP_VAR **vars, SCIP_CONS **conss, SCIP_Bool *success)
static SCIP_RETCODE calculateShift(SCIP *scip, BLOCKPROBLEM **blockproblem, LINKING *linking, SCIP_Real **shift, int *nviolatedblocksrhs, int *nviolatedblockslhs, SCIP_Bool *update)
static SCIP_RETCODE copyToSubscip(SCIP *scip, SCIP *subscip, const char *name, SCIP_VAR **vars, SCIP_CONS **conss, SCIP_HASHMAP *varsmap, SCIP_HASHMAP *conssmap, int nvars, int nconss, SCIP_Bool *success)
assert(minobj< SCIPgetCutoffbound(scip))
#define BMSclearMemoryArray(ptr, num)
SCIP_Real SCIPconsGetLhs(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
SCIP_RETCODE SCIPgetConsVals(SCIP *scip, SCIP_CONS *cons, SCIP_Real *vals, int varssize, SCIP_Bool *success)
SCIP_Real SCIPconsGetRhs(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for decompositions
public methods for primal heuristics
#define SCIPdebugPrintCons(x, y, z)
public data structures and miscellaneous methods
public methods for constraint handler plugins and constraints
public methods for decompositions
public methods for primal heuristic plugins and divesets
public methods for memory management
public methods for message handling
public methods for SCIP parameter handling
public methods for global and local (sub)problems
SCIP_RETCODE SCIPincludeDefaultPlugins(SCIP *scip)
SCIP_CONS ** linkingconss
struct SCIP_Cons SCIP_CONS
#define SCIP_DECOMP_LINKVAR
struct SCIP_Decomp SCIP_DECOMP
#define SCIP_DECOMP_LINKCONS
struct SCIP_Eventhdlr SCIP_EVENTHDLR
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_LPSOLVED
#define SCIP_DECL_HEURCOPY(x)
struct SCIP_HeurData SCIP_HEURDATA
struct SCIP_Heur SCIP_HEUR
#define SCIP_DECL_HEURFREE(x)
#define SCIP_DECL_HEUREXEC(x)
struct SCIP_HashMap SCIP_HASHMAP
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STATUS_BESTSOLLIMIT
enum SCIP_Status SCIP_STATUS
unsigned int SCIP_HEURTIMING
#define SCIP_HEURTIMING_AFTERNODE
#define SCIP_HEURTIMING_BEFORENODE
@ SCIP_VARTYPE_CONTINUOUS