A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://scip.zib.de/doc/html/branch__fullstrong_8c_source.php below:

SCIP Doxygen Documentation: branch_fullstrong.c Source File

54#define BRANCHRULE_NAME "fullstrong" 55#define BRANCHRULE_DESC "full strong branching" 56#define BRANCHRULE_PRIORITY 0 57#define BRANCHRULE_MAXDEPTH -1 58#define BRANCHRULE_MAXBOUNDDIST 1.0 60#define DEFAULT_REEVALAGE 10LL 62#define DEFAULT_MAXPROPROUNDS -2 64#define DEFAULT_PROBINGBOUNDS TRUE 66#define DEFAULT_FORCESTRONGBRANCH FALSE 70struct

SCIP_BranchruleData

95

assert(branchrule !=

NULL

);

112

assert(branchruledata !=

NULL

);

132

assert(branchruledata !=

NULL

);

134

branchruledata->lastcand = 0;

147

assert(branchruledata !=

NULL

);

148

assert((branchruledata->skipdown !=

NULL

) == (branchruledata->skipup !=

NULL

));

150 if

( branchruledata->skipdown !=

NULL

)

154

branchruledata->skipdown =

NULL

;

155

branchruledata->skipup =

NULL

;

156

branchruledata->skipsize = 0;

226

assert(lpcands !=

NULL

);

227

assert(lpcandssol !=

NULL

);

228

assert(lpcandsfrac !=

NULL

);

229

assert(bestcand !=

NULL

);

230

assert(skipdown !=

NULL

);

231

assert(skipup !=

NULL

);

232

assert(bestdown !=

NULL

);

233

assert(bestup !=

NULL

);

234

assert(bestscore !=

NULL

);

235

assert(bestdownvalid !=

NULL

);

236

assert(bestupvalid !=

NULL

);

237

assert(provedbound !=

NULL

);

238

assert(result !=

NULL

);

239

assert(nlpcands > 0);

254

*provedbound = lpobjval;

257

*bestdown = lpobjval;

259

*bestdownvalid =

FALSE

;

260

*bestupvalid =

FALSE

;

274

assert(branchrule !=

NULL

);

278

assert(branchruledata !=

NULL

);

281

reevalage = branchruledata->reevalage;

284

propagate = (maxproprounds != 0);

287 if

( !propagate && maxproprounds > -3 )

288

probingbounds =

FALSE

;

308 for

( i = 0, c = *start; i < nlpcands && (!bothgains || i < ncomplete); ++i, ++c )

311

assert(lpcands[c] !=

NULL

);

323

downgain =

MAX

(down - lastlpobjval, 0.0);

324

upgain =

MAX

(up - lastlpobjval, 0.0);

329

downconflict =

FALSE

;

337 SCIPdebugMsg

(

scip

,

"applying strong branching%s on variable <%s> with solution %g\n"

,

338

propagate ?

"with propagation"

:

""

,

SCIPvarGetName

(lpcands[c]), lpcandssol[c]);

339

assert(i >= ncomplete || (!skipdown[i] && !skipup[i]));

348

maxproprounds, skipdown[i] ?

NULL

: &down, skipup[i] ?

NULL

: &up, &downvalid,

349

&upvalid,

NULL

,

NULL

, &downinf, &upinf, &downconflict, &upconflict, &lperror, newlbs, newubs) );

351 SCIPdebugMsg

(

scip

,

"-> down=%.9g (gain=%.9g, valid=%u, inf=%u, conflict=%u), up=%.9g (gain=%.9g, valid=%u, inf=%u, conflict=%u)\n"

,

352

down, down - lpobjval, downvalid, downinf, downconflict, up, up - lpobjval, upvalid, upinf, upconflict);

357

skipdown[i] ?

NULL

: &down, skipup[i] ?

NULL

: &up, &downvalid, &upvalid, &downinf, &upinf,

358

&downconflict, &upconflict, &lperror) );

372 "(node %" SCIP_LONGINT_FORMAT ") error in strong branching call%s for variable <%s> with solution %g\n"

,

378

down =

MAX

(down, lpobjval);

379

up =

MAX

(up, lpobjval);

380

downgain = down - lpobjval;

381

upgain = up - lpobjval;

387

assert(downinf || !downconflict);

388

assert(upinf || !upconflict);

391 if

( !downinf && downvalid )

395 if

( !upinf && upvalid )

401 if

( downinf || upinf )

404

assert(allcolsinlp || propagate);

407 if

( downinf && upinf )

424

assert(tightened || propagate);

441

assert(tightened || propagate);

448 else if

( allcolsinlp && !exactsolve && downvalid && upvalid )

453

minbound =

MIN

(down, up);

454

*provedbound =

MAX

(*provedbound, minbound);

462

assert(vars !=

NULL

);

464

assert(newlbs !=

NULL

);

465

assert(newubs !=

NULL

);

469 for

( v = 0; v < nvars; ++v )

473 SCIPdebugMsg

(

scip

,

"better lower bound for variable <%s>: %.9g -> %.9g (strongbranching on var <%s>\n"

,

481 SCIPdebugMsg

(

scip

,

"better upper bound for variable <%s>: %.9g -> %.9g (strongbranching on var <%s>\n"

,

489 if

( nboundchgs > 0 )

492 SCIPdebugMsg

(

scip

,

" -> strong branching with propagation on variable <%s> led to %d bound changes\n"

,

501 if

( c < npriolpcands )

504 if

( score > *bestscore )

509

*bestdownvalid = downvalid;

510

*bestupvalid = upvalid;

519 SCIPdebugMsg

(

scip

,

" -> cand %d/%d (prio:%d) var <%s> (solval=%g, downgain=%g, upgain=%g, score=%g) -- best: <%s> (%g)\n"

,

520

c, nlpcands, npriolpcands,

SCIPvarGetName

(lpcands[c]), lpcandssol[c], downgain, upgain, score,

531

assert(newlbs !=

NULL

);

532

assert(newubs !=

NULL

);

562

assert(branchrule !=

NULL

);

565

assert(result !=

NULL

);

573

assert(branchruledata !=

NULL

);

577

assert(nlpcands > 0);

578

assert(npriolpcands > 0);

587 if

( branchruledata->skipdown ==

NULL

)

589

assert(branchruledata->skipup ==

NULL

);

599

branchruledata->skipup, nlpcands, npriolpcands, nlpcands, &branchruledata->lastcand,

600

branchruledata->maxproprounds, branchruledata->probingbounds, branchruledata->forcestrongbranch, &bestcand,

601

&bestdown, &bestup, &bestscore, &bestdownvalid, &bestupvalid, &provedbound, result) );

617 if

( allcolsinlp && !exactsolve )

630

assert(0 <= bestcand && bestcand < nlpcands);

633

var = lpcands[bestcand];

634

val = lpcandssol[bestcand];

637 SCIPdebugMsg

(

scip

,

" -> %d candidates, selected candidate %d: variable <%s> (solval=%g, down=%g, up=%g, score=%g)\n"

,

638

nlpcands, bestcand,

SCIPvarGetName

(var), lpcandssol[bestcand], bestdown, bestup, bestscore);

642 if

( allcolsinlp && !exactsolve )

644 if

( downchild !=

NULL

&& bestdownvalid )

649 if

( upchild !=

NULL

&& bestupvalid )

682

branchruledata->lastcand = 0;

683

branchruledata->skipsize = 0;

684

branchruledata->skipup =

NULL

;

685

branchruledata->skipdown =

NULL

;

691

assert(branchrule !=

NULL

);

702 "branching/fullstrong/reevalage"

,

703 "number of intermediate LPs solved to trigger reevaluation of strong branching value for a variable that was already evaluated at the current node"

,

706 "branching/fullstrong/maxproprounds"

,

707 "maximum number of propagation rounds to be performed during strong branching before solving the LP (-1: no limit, -2: parameter settings)"

,

710 "branching/fullstrong/probingbounds"

,

711 "should valid bounds be identified in a probing-like fashion during strong branching (only with propagation)?"

,

714 "branching/fullstrong/forcestrongbranch"

,

715 "should strong branching be applied even if there is just a single candidate?"

,

#define BRANCHRULE_PRIORITY

#define DEFAULT_PROBINGBOUNDS

static SCIP_DECL_BRANCHEXIT(branchExitFullstrong)

#define DEFAULT_REEVALAGE

static SCIP_DECL_BRANCHINIT(branchInitFullstrong)

static SCIP_DECL_BRANCHFREE(branchFreeFullstrong)

#define DEFAULT_FORCESTRONGBRANCH

#define DEFAULT_MAXPROPROUNDS

#define BRANCHRULE_MAXDEPTH

static SCIP_DECL_BRANCHCOPY(branchCopyFullstrong)

#define BRANCHRULE_MAXBOUNDDIST

static SCIP_DECL_BRANCHEXECLP(branchExeclpFullstrong)

full strong LP branching rule

#define SCIP_LONGINT_FORMAT

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 SCIPincludeBranchruleFullstrong(SCIP *scip)

SCIP_Bool SCIPisStopped(SCIP *scip)

SCIP_Bool SCIPisExactSolve(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)

SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)

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 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 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)

SCIP_Real SCIPgetBranchScore(SCIP *scip, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)

SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)

SCIP_Bool SCIPallColsInLP(SCIP *scip)

SCIP_Real SCIPgetLPObjval(SCIP *scip)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPduplicateBufferArray(scip, ptr, source, num)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPallocBlockMemory(scip, ptr)

SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)

SCIP_Longint SCIPgetNNodes(SCIP *scip)

SCIP_Real SCIPgetCutoffbound(SCIP *scip)

SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)

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_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfeasFloor(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)

int SCIPgetDepth(SCIP *scip)

SCIP_RETCODE SCIPgetVarStrongbranchFrac(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Bool idempotent, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)

SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_RETCODE SCIPendStrongbranch(SCIP *scip)

SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)

SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)

SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation(SCIP *scip, SCIP_VAR *var, SCIP_Real solval, SCIP_Real lpobjval, int itlim, int maxproprounds, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Longint *ndomredsdown, SCIP_Longint *ndomredsup, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror, SCIP_Real *newlbs, SCIP_Real *newubs)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)

SCIP_RETCODE SCIPgetVarStrongbranchLast(SCIP *scip, SCIP_VAR *var, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)

SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)

memory allocation routines

#define BMSclearMemoryArray(ptr, num)

public methods for branching rules

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 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 querying solving statistics

public methods for the branch-and-bound tree

public methods for SCIP variables

struct SCIP_BranchruleData SCIP_BRANCHRULEDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

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