RetroSearch Browse

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

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

SCIP Doxygen Documentation: cutsel_ensemble.c Source File

45#define CUTSEL_NAME "ensemble" 46#define CUTSEL_DESC "weighted sum of many terms with optional filtering and penalties" 47#define CUTSEL_PRIORITY 7000 49#define RANDSEED 0x5EED 51#define DEFAULT_MINSCORE 0.0 52#define DEFAULT_EFFICACYWEIGHT 0.75 53#define DEFAULT_DIRCUTOFFDISTWEIGHT 0.0 54#define DEFAULT_OBJPARALWEIGHT 0.25 55#define DEFAULT_INTSUPPORTWEIGHT 0.45 56#define DEFAULT_EXPIMPROVWEIGHT 0.1 57#define DEFAULT_PSCOSTWEIGHT 0.75 58#define DEFAULT_NLOCKSWEIGHT 0.25 59#define DEFAULT_MAXSPARSITYBONUS 0.5 60#define DEFAULT_SPARSITYENDBONUS 0.2 61#define DEFAULT_GOODNUMERICBONUS 0.0 62#define DEFAULT_MAXCOEFRATIOBONUS 10000 63#define DEFAULT_PENALISELOCKS TRUE 64#define DEFAULT_PENALISEOBJPARAL TRUE 65#define DEFAULT_FILTERPARALCUTS FALSE 66#define DEFAULT_MAXPARAL 0.95 67#define DEFAULT_PENALISEPARALCUTS TRUE 68#define DEFAULT_PARALPENALTY 0.25 69#define DEFAULT_FILTERDENSECUTS TRUE 70#define DEFAULT_MAXCUTDENSITY 0.425 71#define DEFAULT_MAXNONZEROROOTROUND 4.5 72#define DEFAULT_MAXNONZEROTREEROUND 9.5 73#define DEFAULT_MAXCUTS 200 74#define DEFAULT_MAXNUMVARS 50000 105 int

maxcoefratiobonus;

153 for

(

int

i = 0; i < ncuts; ++i )

166

cutdensities[i] = ncutcols / ncols;

170 for

(

int

j = 0; j < (int) ncutcols; ++j )

189

l1dist =

(colval - (cutalpha * cutvals[j]));

192

cutlocks[i] = cutlocks[i] / ncutcols;

194 if

( cutlocks[i] > maxlocks )

195

maxlocks = cutlocks[i];

197 if

( pscosts[i] > maxpscost )

198

maxpscost = pscosts[i];

203

maxlocks =

(maxlocks, 1);

205 for

(

int

i = 0; i < ncuts; i++ )

207

cutlocks[i] = cutlocks[i] / maxlocks;

209 if

( cutseldata->penaliselocks )

210

cutlocks[i] = 1 - cutlocks[i];

211

pscosts[i] = pscosts[i] / maxpscost;

215 if

( sol !=

&& root )

217 for

(

int

i = 0; i < ncuts; i++ )

220

maxdcd =

(maxdcd, dcds[i]);

224 for

(

int

i = 0; i < ncuts; ++i )

228

maxeff =

(maxeff, effs[i]);

229

maxexp =

(maxexp, exps[i]);

233 for

(

int

i = 0; i < ncuts; ++i )

250

intsupport *= cutseldata->intsupportweight;

253 if

( ! cutseldata->penaliseobjparal )

259 density

= (cutseldata->maxsparsitybonus / cutseldata->endsparsitybonus) * -1 * cutdensities[i];

260 density

+= cutseldata->maxsparsitybonus;

267

pscost = cutseldata->pscostweight * pscosts[i];

268

cutlock = cutseldata->locksweight * cutlocks[i];

273

mincutval = mincutval > 0.0 ? mincutval : 1.0;

274

dynamism = cutseldata->maxcoefratiobonus >= maxcutval / mincutval ? cutseldata->goodnumericsbonus : 0.0;

277 if

( sol !=

&& root )

282

scaleddcd = cutseldata->dircutoffdistweight *

(

(dcds[i]) /

(maxdcd));

292

scaledexp = cutseldata->expimprovweight *

(

(exps[i]) /

(maxexp));

300 if

( sol !=

&& root )

301

scaledeff = cutseldata->efficacyweight *

(

(effs[i]) /

(maxeff));

303

scaledeff = (cutseldata->efficacyweight + cutseldata->dircutoffdistweight) *

(

(effs[i]) /

(maxeff));

307

score = scaledeff + scaleddcd + scaledexp + objparallelism + intsupport +

+ dynamism + pscost + cutlock;

337

assert(cuts !=

);

338

assert(scores !=

);

340

bestscore = scores[0];

343 for

(

int

i = 1; i < ncuts; ++i )

345 if

( scores[i] > bestscore )

348

bestscore = scores[i];

367

assert( cut !=

);

368

assert( ncuts == 0 || cuts !=

);

369

assert( ncuts == 0 || scores !=

);

371 for

(

int

i = ncuts - 1; i >= 0; --i )

377 if

( thisparallel > maxparallel )

400

assert( cut !=

);

401

assert( ncuts == 0 || cuts !=

);

402

assert( ncuts == 0 || scores !=

);

404 for

(

int

i = ncuts - 1; i >= 0; --i )

417 else if

( thisparallel > maxparallel )

419

scores[i] -= paralpenalty;

438

assert( ncuts == 0 || cuts !=

);

442 for

(

int

i = ncuts - 1; i >= 0; --i )

448 if

( maxdensity < nvals / ncols )

469

assert(cutsel !=

);

502

assert(cutseldata !=

);

516

assert(cutseldata !=

);

517

assert(cutseldata->randnumgen !=

);

530

assert(cutsel !=

);

531

assert(result !=

);

534

assert(cutseldata !=

);

536 if

( ncuts > cutseldata->maxcuts ||

(

) > cutseldata->maxnumvars )

545

maxnselectedcuts, nselectedcuts) );

570

assert(cutsel !=

);

585 "cutoff distance in cut score calculation"

, &cutseldata->dircutoffdistweight,

,

616 "(ratio of coefficients) in cut score calculation"

, &cutseldata->goodnumericsbonus,

,

634 "applied cuts (root). multiple num LP cols."

, &cutseldata->maxnonzerorootround,

,

638 "applied cuts (tree). multiple num LP cols."

, &cutseldata->maxnonzerotreeround,

,

699

assert(cuts !=

&& ncuts > 0);

700

assert(forcedcuts !=

|| nforcedcuts == 0);

701

assert(nselectedcuts !=

);

707 if

( cutseldata->filterdensecuts )

716

origscoresptr = scores;

724 for

(

int

i = 0; i < nforcedcuts && ncuts > 0; ++i )

726 if

( cutseldata->filterparalcuts )

728 else if

( cutseldata->penaliseparalcuts )

733

nonzerobudget = root ? cutseldata->maxnonzerorootround : cutseldata->maxnonzerotreeround;

741

selectedcut = cuts[0];

744 if

( scores[0] < cutseldata->minscore )

750 if

( *nselectedcuts == maxselectedcuts )

761 if

( cutseldata->filterparalcuts && ncuts > 0)

763 else if

( cutseldata->penaliseparalcuts && ncuts > 0 )

767 if

( nonzerobudget - budgettaken < 1 && ncuts > 0 )

#define DEFAULT_SPARSITYENDBONUS

static SCIP_DECL_CUTSELEXIT(cutselExitEnsemble)

#define DEFAULT_EFFICACYWEIGHT

#define DEFAULT_MAXNONZEROTREEROUND

#define DEFAULT_OBJPARALWEIGHT

#define DEFAULT_FILTERDENSECUTS

#define DEFAULT_MAXSPARSITYBONUS

#define DEFAULT_PARALPENALTY

#define DEFAULT_PENALISEPARALCUTS

#define DEFAULT_GOODNUMERICBONUS

#define DEFAULT_PENALISELOCKS

static SCIP_DECL_CUTSELCOPY(cutselCopyEnsemble)

static SCIP_DECL_CUTSELINIT(cutselInitEnsemble)

#define DEFAULT_NLOCKSWEIGHT

static SCIP_RETCODE scoring(SCIP *scip, SCIP_ROW **cuts, SCIP_CUTSELDATA *cutseldata, SCIP_Real *scores, SCIP_Bool root, int ncuts)

static void selectBestCut(SCIP_ROW **cuts, SCIP_Real *scores, int ncuts)

static int filterWithDensity(SCIP *scip, SCIP_ROW **cuts, SCIP_Real maxdensity, int ncuts)

static int penaliseWithParallelism(SCIP *scip, SCIP_ROW *cut, SCIP_ROW **cuts, SCIP_Real *scores, int ncuts, SCIP_Real maxparallel, SCIP_Real paralpenalty)

static SCIP_DECL_CUTSELSELECT(cutselSelectEnsemble)

static int filterWithParallelism(SCIP_ROW *cut, SCIP_ROW **cuts, SCIP_Real *scores, int ncuts, SCIP_Real maxparallel)

#define DEFAULT_EXPIMPROVWEIGHT

#define DEFAULT_MAXCOEFRATIOBONUS

#define DEFAULT_DIRCUTOFFDISTWEIGHT

#define DEFAULT_MAXCUTDENSITY

#define DEFAULT_MAXNONZEROROOTROUND

static SCIP_DECL_CUTSELFREE(cutselFreeEnsemble)

#define DEFAULT_PENALISEOBJPARAL

#define DEFAULT_MAXNUMVARS

#define DEFAULT_PSCOSTWEIGHT

#define DEFAULT_FILTERPARALCUTS

#define DEFAULT_INTSUPPORTWEIGHT

static const SCIP_Real density

SCIP_RETCODE SCIPselectCutsEnsemble(SCIP *scip, SCIP_ROW **cuts, SCIP_ROW **forcedcuts, SCIP_CUTSELDATA *cutseldata, SCIP_Bool root, int ncuts, int nforcedcuts, int maxselectedcuts, int *nselectedcuts)

SCIP_RETCODE SCIPincludeCutselEnsemble(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

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

void SCIPswapPointers(void **pointer1, void **pointer2)

void SCIPswapReals(SCIP_Real *value1, SCIP_Real *value2)

SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)

SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)

SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)

SCIP_Real SCIPgetCutLPSolCutoffDistance(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)

SCIP_RETCODE SCIPsetCutselInit(SCIP *scip, SCIP_CUTSEL *cutsel, SCIP_DECL_CUTSELINIT((*cutselinit)))

SCIP_RETCODE SCIPincludeCutselBasic(SCIP *scip, SCIP_CUTSEL **cutsel, const char *name, const char *desc, int priority, SCIP_DECL_CUTSELSELECT((*cutselselect)), SCIP_CUTSELDATA *cutseldata)

SCIP_RETCODE SCIPsetCutselCopy(SCIP *scip, SCIP_CUTSEL *cutsel, SCIP_DECL_CUTSELCOPY((*cutselcopy)))

SCIP_CUTSELDATA * SCIPcutselGetData(SCIP_CUTSEL *cutsel)

SCIP_RETCODE SCIPsetCutselFree(SCIP *scip, SCIP_CUTSEL *cutsel, SCIP_DECL_CUTSELFREE((*cutselfree)))

void SCIPcutselSetData(SCIP_CUTSEL *cutsel, SCIP_CUTSELDATA *cutseldata)

const char * SCIPcutselGetName(SCIP_CUTSEL *cutsel)

SCIP_RETCODE SCIPsetCutselExit(SCIP *scip, SCIP_CUTSEL *cutsel, SCIP_DECL_CUTSELEXIT((*cutselexit)))

int SCIPgetNLPCols(SCIP *scip)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)

SCIP_Real SCIPgetRowFeasibility(SCIP *scip, SCIP_ROW *row)

SCIP_Real SCIProwGetParallelism(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)

int SCIProwGetNNonz(SCIP_ROW *row)

SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

SCIP_Real SCIProwGetNorm(SCIP_ROW *row)

SCIP_Real SCIPgetRowObjParallelism(SCIP *scip, SCIP_ROW *row)

int SCIPgetRowNumIntCols(SCIP *scip, SCIP_ROW *row)

SCIP_Real * SCIProwGetVals(SCIP_ROW *row)

SCIP_SOL * SCIPgetBestSol(SCIP *scip)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPepsilon(SCIP *scip)

SCIP_Real SCIPsumepsilon(SCIP *scip)

SCIP_Bool SCIPisSumLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

int SCIPvarGetNLocksDown(SCIP_VAR *var)

int SCIPvarGetNLocksUp(SCIP_VAR *var)

SCIP_Real SCIPgetVarPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)

void SCIPfreeRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen)

SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)

SCIP_RETCODE SCIPcreateRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen, unsigned int initialseed, SCIP_Bool useglobalseed)

#define BMSclearMemory(ptr)

public methods for cuts and aggregation rows

public methods for cut selector plugins

public methods for the LP relaxation, rows and columns

public methods for random numbers

struct SCIP_CutselData SCIP_CUTSELDATA

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