SCIP_BranchruleData
106 intfirstmultaggrdepth;
113 intnmultaggrconsadd;
124 inttotalmultaggrcands;
143assert(branchruledata !=
NULL);
144assert(branchruledata->ratioggain !=
NULL);
145assert(branchruledata->nmultaggrbranch >= 0);
146assert(branchruledata->size >= 0);
149 if( branchruledata->nmultaggrbranch + 1 > branchruledata->size )
152assert(newsize >= branchruledata->nmultaggrbranch + 1);
154branchruledata->size = newsize;
176#ifdef SCIP_STATISTIC
205assert(branchrule !=
NULL);
208assert(branchruledata !=
NULL);
212assert(bestcand !=
NULL);
213assert(bestscore !=
NULL);
231 SCIPdebugMsg(
scip,
"cannot perform probing in selectVarMultAggrBranching, depth limit reached.\n");
238assert(fixvars !=
NULL);
244 for( i = 0; i < nfixvars; i++ )
246assert(fixvars[i] !=
NULL);
250 for( i = 0; i < nfixvars; i++ )
252assert(fixvars[i] !=
NULL);
258fixvarssol = fixvarssols[i];
283startprobing =
FALSE;
298assert(probingconsdown !=
NULL);
303assert(node !=
NULL);
324 SCIPdebugMsg(
scip,
"error solving down node probing LP: status=%d\n", solstatdown);
340 for( j = 0 ; j < ndownvars; j++ )
346assert(downvars !=
NULL);
347assert(downvars[j] !=
NULL);
351estimateincr =
MIN(pscdown, pscup);
353estimateprobdown += estimateincr;
362assert(probingconsup !=
NULL);
386 SCIPdebugMsg(
scip,
"error solving up node probing LP: status=%d\n", solstatup);
395 SCIPdebugMsg(
scip,
" down node objval: %g up node objval: %g\n", downobjval, upobjval);
404 for( k = 0 ; k < nupvars; k++ )
410assert(upvars !=
NULL);
411assert(upvars[k] !=
NULL);
415estimateincr =
MIN(pscdown, pscup);
416estimateprobup += estimateincr;
422 if( downinf || upinf )
431 if( downinf && upinf )
433 SCIPdebugMsg(
scip,
"node can be cut off due to strong branching on multi-aggregated variable <%s>\n",
447 SCIPdebugMsg(
scip,
"%s child of multi-aggregated variable <%s> is infeasible\n",
474down =
MAX(downobjval, lpobjval);
475up =
MAX(upobjval, lpobjval);
476downgain = down - lpobjval;
477upgain = up - lpobjval;
480 if( allcolsinlp && !exactsolve )
483minbound =
MIN(downobjval, upobjval);
484*provedbound =
MAX(*provedbound, minbound);
488 if( score > *bestmultaggrscore )
489*bestmultaggrscore = score;
493 if( score > *bestscore )
496 if( branchruledata->nmultaggrbranch == 0 )
498branchruledata->rundepth = SCIPgetNRuns(scip);
499branchruledata->firstmultaggrdepth = SCIPgetFocusDepth(scip);
505*bestscore =
MAX(score, *bestscore);
506*bestcand = fixvars[i];
507*bestsol = fixvarssol;
508*bestdown = downobjval;
510*bestdownvalid =
TRUE;
511*bestupvalid =
TRUE;
512*estimatedown = estimateprobdown;
513*estimateup = estimateprobup;
515assert(bestscore !=
NULL);
516assert(bestcand !=
NULL);
517assert(bestup !=
NULL);
518assert(bestdown !=
NULL);
542assert(probingconsup !=
NULL);
553assert(probingconsdown !=
NULL);
574assert(branchrule !=
NULL);
591assert(branchruledata !=
NULL);
610assert(branchruledata !=
NULL);
612branchruledata->lastcand = 0;
614branchruledata->firstmultaggrdepth = 0;
615branchruledata->nmultaggrbranch = 0;
616branchruledata->nfracbranch = 0;
617branchruledata->nEscore = 0;
618branchruledata->nmultaggrcutoff = 0;
619branchruledata->nmultaggrconsadd = 0;
620branchruledata->nfractcutoff = 0;
621branchruledata->nfractconsadd = 0;
622branchruledata->nrun = 0;
623branchruledata->size = 100;
624branchruledata->ameanratio = 0.0;
625branchruledata->noupdate =
FALSE;
626branchruledata->clckstrongbr =
NULL;
627branchruledata->clckmultaggrbr =
NULL;
628branchruledata->nstrongbrcall = 0;
629branchruledata->nmultaggrbrcall = 0;
630branchruledata->totalmultaggrcands = 0;
631branchruledata->totallpcands = 0;
649assert(branchruledata !=
NULL);
650assert((branchruledata->skipdown !=
NULL) == (branchruledata->skipup !=
NULL));
657branchruledata->nmultaggrvars);
659branchruledata->firstmultaggrdepth,
660branchruledata->rundepth);
662branchruledata->nmultaggrbranch, branchruledata->nmultaggrbranch + branchruledata->nfracbranch);
675 if( branchruledata->totallpcands != 0 )
690 if( branchruledata->totalmultaggrcands != 0 )
693 SCIPgetClockTime(
scip, branchruledata->clckmultaggrbr) / branchruledata->totalmultaggrcands);
701 if( branchruledata->nmultaggrbranch != 0 )
703 for( j = 0; j < branchruledata->nmultaggrbranch; j++ )
705branchruledata->ameanratio += branchruledata->ratioggain[j];
710branchruledata->ameanratio = branchruledata->ameanratio / branchruledata->nmultaggrbranch;
726 if( branchruledata->skipdown !=
NULL)
730branchruledata->skipdown =
NULL;
731branchruledata->skipup =
NULL;
732branchruledata->skipsize = 0;
767assert(branchrule !=
NULL);
770assert(result !=
NULL);
777assert(branchruledata !=
NULL);
793branchruledata->nmultaggrvars = 0;
799 for( i = 0; i < nfixvars; i++ )
804branchruledata->nmultaggrvars += 1;
814assert(nlpcands > 0);
815assert(npriolpcands > 0);
824 if( branchruledata->skipdown ==
NULL)
826assert(branchruledata->skipup ==
NULL);
842branchruledata->skipup, nlpcands, npriolpcands, nlpcands, &branchruledata->lastcand,
843branchruledata->maxproprounds, branchruledata->probingbounds,
TRUE,
844&bestcandpos, &bestdown, &bestup, &bestscore, &bestdownvalid, &bestupvalid, &provedbound, result) );
849branchruledata->nstrongbrcall += 1;
854 SCIP_VAR* bestcand = lpcands[bestcandpos];
855 SCIP_Realbestsol = lpcandssol[bestcandpos];
866|| branchruledata->maxproprounds != 0 )
875fdown = MAX(bestdown, lpobjval);
876fup = MAX(bestup, lpobjval);
877fdowngain = fdown - lpobjval;
878fupgain = fup - lpobjval;
888&estimatedown, &estimateup, &bestmultaggrscore, result) );
891&estimatedown, &estimateup, result) );
895branchruledata->nmultaggrbrcall += 1;
901 if( !(branchruledata->noupdate) )
903if( SCIPisEQ(scip, bestmultaggrscore, bestscore) )
904branchruledata->nEscore += 1;
908assert(bestcand !=
NULL);
918 if( !(branchruledata->noupdate) )
920branchruledata->nmultaggrbranch += 1;
924SCIP_Real gfractbranch;
925SCIP_Real gmultaggrbranch;
932down = MAX(bestdown, lpobjval);
933up = MAX(bestup, lpobjval);
934downgain = down - lpobjval;
935upgain = up - lpobjval;
937SCIP_CALL( ensureArraySize(scip, branchruledata) );
939gfractbranch= sqrt(MAX(fdowngain,1e-06) * MAX(fupgain,1e-06));
940gmultaggrbranch = sqrt(MAX(downgain,1e-06) * MAX(upgain,1e-06));
942nmultaggrbranch = branchruledata->nmultaggrbranch;
944if( gmultaggrbranch == 0.0 )
946branchruledata->ratioggain[nmultaggrbranch - 1] = 1;
950branchruledata->ratioggain[nmultaggrbranch - 1] = gfractbranch / gmultaggrbranch;
974assert(downchild !=
NULL);
975assert(upchild !=
NULL);
1003 if( !(branchruledata->noupdate) )
1004branchruledata->nfracbranch += 1
1012assert(downchild !=
NULL);
1013assert(upchild !=
NULL);
1039branchruledata->nfractcutoff += 1;
1043branchruledata->nfractconsadd += 1;
1071branchruledata->lastcand = 0;
1072branchruledata->skipsize = 0;
1073branchruledata->skipup =
NULL;
1074branchruledata->skipdown =
NULL;
1081assert(branchrule !=
NULL);
1092 "branching/multaggr/reevalage",
1093 "number of intermediate LPs solved to trigger reevaluation of strong branching value for a variable that was already evaluated at the current node",
1096 "branching/multaggr/maxproprounds",
1097 "maximum number of propagation rounds to be performed during multaggr branching before solving the LP (-1: no limit, -2: parameter settings)",
1100 "branching/multaggr/probingbounds",
1101 "should valid bounds be identified in a probing-like fashion during multaggr branching (only with propagation)?",
full strong LP branching rule
#define BRANCHRULE_PRIORITY
#define DEFAULT_PROBINGBOUNDS
#define DEFAULT_REEVALAGE
static SCIP_RETCODE selectVarMultAggrBranching(SCIP *scip, SCIP_VAR **bestcand, SCIP_Real *bestscore, SCIP_Real *bestsol, SCIP_Real *bestdown, SCIP_Real *bestup, SCIP_Bool *bestdownvalid, SCIP_Bool *bestupvalid, SCIP_Real *provedbound, SCIP_Real *estimatedown, SCIP_Real *estimateup, SCIP_RESULT *result)
static SCIP_DECL_BRANCHINIT(branchInitMultAggr)
static SCIP_DECL_BRANCHCOPY(branchCopyMultAggr)
static SCIP_DECL_BRANCHEXECLP(branchExeclpMultAggr)
#define DEFAULT_MAXPROPROUNDS
static SCIP_DECL_BRANCHFREE(branchFreeMultAggr)
#define BRANCHRULE_MAXDEPTH
#define BRANCHRULE_MAXBOUNDDIST
static SCIP_DECL_BRANCHEXIT(branchExitMultAggr)
fullstrong branching on fractional and multi-aggregated variables
Constraint handler for linear constraints in their most general form, .
#define SCIP_MAXTREEDEPTH
SCIP_RETCODE SCIPselectVarStrongBranching(SCIP *scip, SCIP_VAR **lpcands, SCIP_Real *lpcandssol, SCIP_Real *lpcandsfrac, SCIP_Bool *skipdown, SCIP_Bool *skipup, int nlpcands, int npriolpcands, int ncomplete, int *start, int maxproprounds, SCIP_Bool probingbounds, SCIP_Bool forcestrongbranch, int *bestcand, SCIP_Real *bestdown, SCIP_Real *bestup, SCIP_Real *bestscore, SCIP_Bool *bestdownvalid, SCIP_Bool *bestupvalid, SCIP_Real *provedbound, SCIP_RESULT *result)
SCIP_RETCODE SCIPincludeBranchruleMultAggr(SCIP *scip)
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_Bool SCIPisExactSolve(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
int SCIPgetNFixedVars(SCIP *scip)
SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)
SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPaddLongintParam(SCIP *scip, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
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 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 SCIPgetLongintParam(SCIP *scip, const char *name, SCIP_Longint *value)
SCIP_RETCODE SCIPsetBranchruleExit(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXIT((*branchexit)))
SCIP_RETCODE SCIPsetBranchruleExecLp(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECLP((*branchexeclp)))
SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetBranchruleCopy(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHCOPY((*branchcopy)))
SCIP_RETCODE SCIPincludeBranchruleBasic(SCIP *scip, SCIP_BRANCHRULE **branchruleptr, const char *name, const char *desc, int priority, int maxdepth, SCIP_Real maxbounddist, SCIP_BRANCHRULEDATA *branchruledata)
const char * SCIPbranchruleGetName(SCIP_BRANCHRULE *branchrule)
SCIP_BRANCHRULEDATA * SCIPbranchruleGetData(SCIP_BRANCHRULE *branchrule)
SCIP_RETCODE SCIPsetBranchruleFree(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHFREE((*branchfree)))
SCIP_RETCODE SCIPsetBranchruleInit(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINIT((*branchinit)))
void SCIPbranchruleSetData(SCIP_BRANCHRULE *branchrule, SCIP_BRANCHRULEDATA *branchruledata)
SCIP_RETCODE SCIPbranchVarVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
SCIP_RETCODE SCIPgetLPBranchCands(SCIP *scip, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)
int SCIPgetNLPBranchCands(SCIP *scip)
SCIP_RETCODE SCIPcreateChild(SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)
SCIP_Real SCIPgetBranchScore(SCIP *scip, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
SCIP_Bool SCIPallColsInLP(SCIP *scip)
SCIP_Real SCIPgetLPObjval(SCIP *scip)
#define SCIPfreeBlockMemoryArray(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 SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
SCIP_Real SCIPnodeGetEstimate(SCIP_NODE *node)
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPendProbing(SCIP *scip)
int SCIPgetNRuns(SCIP *scip)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_RETCODE SCIPstopClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPgetDepth(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)
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)
memory allocation routines
#define BMSclearMemoryArray(ptr, num)
public methods for branching rules
public methods for managing constraints
public methods for message output
public methods for branch and bound tree
public methods for problem variables
public methods for branching rule plugins and branching
public methods for constraint handler plugins and constraints
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 querying solving statistics
public methods for timing
public methods for the branch-and-bound tree
public methods for SCIP variables
struct SCIP_BranchruleData SCIP_BRANCHRULEDATA
enum SCIP_LPSolStat SCIP_LPSOLSTAT
@ SCIP_LPSOLSTAT_NOTSOLVED
@ SCIP_LPSOLSTAT_TIMELIMIT
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
@ SCIP_LPSOLSTAT_ITERLIMIT
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARSTATUS_MULTAGGR
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4