RetroSearch Browse

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

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

SCIP Doxygen Documentation: branch_allfullstrong.c Source File

68#define BRANCHRULE_NAME "allfullstrong" 69#define BRANCHRULE_DESC "all variables full strong branching" 70#define BRANCHRULE_PRIORITY -1000 71#define BRANCHRULE_MAXDEPTH -1 72#define BRANCHRULE_MAXBOUNDDIST 1.0 76struct

SCIP_BranchruleData

105 int

npriopseudocands;

108

assert(branchrule !=

NULL

);

111

assert(result !=

NULL

);

123

assert(branchruledata !=

NULL

);

125 if

( branchruledata->skipdown ==

NULL

)

127

assert(branchruledata->skipup ==

NULL

);

138

assert(npseudocands > 0);

139

assert(npriopseudocands > 0);

144

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

149 if

( allcolsinlp && !exactsolve )

163

assert(0 <= bestpseudocand && bestpseudocand < npseudocands);

166

var = pseudocandscopy[bestpseudocand];

169 SCIPdebugMsg

(

scip

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

171

bestdown, bestup, bestscore);

175 if

( allcolsinlp && !exactsolve )

177 if

( downchild !=

NULL

&& bestdownvalid )

182 if

( upchild !=

NULL

&& bestupvalid )

208

assert(branchrule !=

NULL

);

243

branchruledata->lastcand = 0;

253

assert(result !=

NULL

);

269

assert(result !=

NULL

);

301 int

npriopseudocands,

302 int

* bestpseudocand,

317

assert(pseudocands !=

NULL

);

318

assert(bestpseudocand !=

NULL

);

319

assert(skipdown !=

NULL

);

320

assert(skipup !=

NULL

);

321

assert(bestdown !=

NULL

);

322

assert(bestup !=

NULL

);

323

assert(bestscore !=

NULL

);

324

assert(bestdownvalid !=

NULL

);

325

assert(bestupvalid !=

NULL

);

326

assert(provedbound !=

NULL

);

327

assert(result !=

NULL

);

343

*bestdown = lpobjval;

345

*bestdownvalid =

FALSE

;

346

*bestupvalid =

FALSE

;

348

*provedbound = lpobjval;

349 if

( npseudocands > 1 )

373

assert(branchrule !=

NULL

);

377

assert(branchruledata !=

NULL

);

386 for

( i = 0, c = branchruledata->lastcand; i < npseudocands; ++i, ++c )

388

c = c % npseudocands;

389

assert(pseudocands[c] !=

NULL

);

398 SCIPdebugMsg

(

scip

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

408

skipdown[c] ?

NULL

: &down, skipup[c] ?

NULL

: &up, &downvalid, &upvalid, &downinf, &upinf, &downconflict, &upconflict, &lperror) );

413

skipdown[c] ?

NULL

: &down, skipup[c] ?

NULL

: &up, &downvalid, &upvalid, &downinf, &upinf, &downconflict, &upconflict, &lperror) );

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

433

down =

MAX

(down, lpobjval);

434

up =

MAX

(up, lpobjval);

435

downgain = down - lpobjval;

436

upgain = up - lpobjval;

439

assert(downinf || !downconflict);

440

assert(upinf || !upconflict);

443 if

( downinf || upinf )

448 if

( downinf && upinf )

460 SCIPdebugMsg

(

scip

" -> integral variable <%s> is infeasible in both directions\n"

468 SCIPdebugMsg

(

scip

" -> fractional variable <%s> is infeasible in both directions\n"

506 else if

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

511

minbound =

MIN

(down, up);

512

*provedbound =

MAX

(*provedbound, minbound);

516 if

( c < npriopseudocands )

525 else if

( skipup[c] )

543 if

( score > *bestscore )

548

*bestdownvalid = downvalid;

549

*bestupvalid = upvalid;

570 SCIPdebugMsg

(

scip

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

576

branchruledata->lastcand = c;

595

branchruledata->lastcand = 0;

596

branchruledata->skipsize = 0;

597

branchruledata->skipup =

NULL

;

598

branchruledata->skipdown =

NULL

;

604

assert(branchrule !=

NULL

);

static SCIP_RETCODE branch(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_RESULT *result)

SCIP_RETCODE SCIPselectVarPseudoStrongBranching(SCIP *scip, SCIP_VAR **pseudocands, SCIP_Bool *skipdown, SCIP_Bool *skipup, int npseudocands, int npriopseudocands, int *bestpseudocand, SCIP_Real *bestdown, SCIP_Real *bestup, SCIP_Real *bestscore, SCIP_Bool *bestdownvalid, SCIP_Bool *bestupvalid, SCIP_Real *provedbound, SCIP_RESULT *result)

static SCIP_DECL_BRANCHCOPY(branchCopyAllfullstrong)

#define BRANCHRULE_PRIORITY

SCIP_RETCODE SCIPincludeBranchruleAllfullstrong(SCIP *scip)

static SCIP_DECL_BRANCHFREE(branchFreeAllfullstrong)

static SCIP_DECL_BRANCHEXECLP(branchExeclpAllfullstrong)

static SCIP_DECL_BRANCHINIT(branchInitAllfullstrong)

#define BRANCHRULE_MAXDEPTH

#define BRANCHRULE_MAXBOUNDDIST

static SCIP_DECL_BRANCHEXECPS(branchExecpsAllfullstrong)

all variables full strong LP branching rule

#define SCIP_LONGINT_FORMAT

SCIP_Bool SCIPisExactSolve(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

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

SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)

SCIP_Real SCIPgetLocalLowerbound(SCIP *scip)

void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)

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)

SCIP_RETCODE SCIPsetBranchruleExecPs(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECPS((*branchexecps)))

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 SCIPgetPseudoBranchCands(SCIP *scip, SCIP_VAR ***pseudocands, int *npseudocands, int *npriopseudocands)

SCIP_Real SCIPgetBranchScoreMultiple(SCIP *scip, SCIP_VAR *var, int nchildren, SCIP_Real *gains)

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

SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)

SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)

SCIP_Bool SCIPallColsInLP(SCIP *scip)

SCIP_Real SCIPgetLPObjval(SCIP *scip)

#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_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_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 SCIPgetVarStrongbranchInt(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 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)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)

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 SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)

SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)

SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)

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