RetroSearch Browse

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

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

SCIP Doxygen Documentation: heur_simplerounding.c Source File

54#define HEUR_NAME "simplerounding" 55#define HEUR_DESC "simple and fast LP rounding heuristic" 56#define HEUR_DISPCHAR SCIP_HEURDISPCHAR_ROUNDING 57#define HEUR_PRIORITY -30 60#define HEUR_MAXDEPTH -1 61#define HEUR_TIMING SCIP_HEURTIMING_DURINGLPLOOP | SCIP_HEURTIMING_DURINGPRICINGLOOP 62#define HEUR_USESSUBSCIP FALSE 64#define DEFAULT_ONCEPERNODE FALSE 92 int

nunroundableimplints = 0;

95 for

(c = 0; c < ncands; ++c)

103

oldsolval = candssol[c];

109 SCIPdebugMsg

(

scip

"simple rounding heuristic: var <%s>, val=%g, rounddown=%u, roundup=%u\n"

113 if

( mayrounddown && mayroundup )

121 else if

( mayrounddown )

123 else if

( mayroundup )

127

++nunroundableimplints;

144 if

( nunroundableimplints > 0 )

150

checklprows =

FALSE

;

221 if

( nlpcands > heurdata->nroundablevars )

226

assert( sol !=

NULL

);

233 if

( nlps == heurdata->lastlp )

235

heurdata->lastlp = nlps;

238 SCIPdebugMsg

(

scip

"executing simple LP-rounding heuristic, fractionals: %d + %d\n"

, nlpcands, nfracimplvars);

269

ndiscretevars = nbinvars + nintvars + nimplvars;

276 for

(v = 0; v < nbinvars + nintvars; ++v)

283

relaxcands[nrelaxcands] = vars[v];

284

relaxcandssol[nrelaxcands++] = val;

292 if

( nrelaxcands > heurdata->nroundablevars )

300 for

( v = nbinvars + nintvars; v < ndiscretevars; ++v )

307

relaxcands[nrelaxcands] = vars[v];

308

relaxcandssol[nrelaxcands++] = val;

313

assert( sol !=

NULL

);

319 SCIPdebugMsg

(

scip

"executing simple rounding heuristic on relaxation solution: %d fractionals\n"

, nrelaxcands);

339

assert(heur !=

NULL

);

354

assert(heur !=

NULL

);

360

assert(heurdata !=

NULL

);

376

assert(heurdata !=

NULL

);

380

heurdata->lastlp = -1;

381

heurdata->nroundablevars = -1;

397

assert(heurdata !=

NULL

);

413

assert(heurdata !=

NULL

);

414

heurdata->lastlp = -1;

417 if

( heurdata->oncepernode )

442

assert(result !=

NULL

);

457

assert(heurdata !=

NULL

);

474 for

( i = 0; i < nbinintvars; ++i )

479

heurdata->nroundablevars = nroundablevars;

517

assert(heur !=

NULL

);

528 "should the heuristic only be called once per node?"

int SCIPgetNIntVars(SCIP *scip)

SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

int SCIPgetNBinVars(SCIP *scip)

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

SCIP_RETCODE SCIPgetLPBranchCands(SCIP *scip, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)

SCIP_RETCODE SCIPsetHeurExitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))

SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))

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 SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))

SCIP_RETCODE SCIPsetHeurExit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXIT((*heurexit)))

void SCIPheurSetTimingmask(SCIP_HEUR *heur, SCIP_HEURTIMING timingmask)

SCIP_RETCODE SCIPsetHeurInitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))

SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))

const char * SCIPheurGetName(SCIP_HEUR *heur)

void SCIPheurSetData(SCIP_HEUR *heur, SCIP_HEURDATA *heurdata)

SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)

SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)

SCIP_Bool SCIPallColsInLP(SCIP *scip)

SCIP_Real SCIPgetLPObjval(SCIP *scip)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)

SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)

SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)

SCIP_RETCODE SCIPadjustImplicitSolVals(SCIP *scip, SCIP_SOL *sol, SCIP_Bool uselprows)

SCIP_RETCODE SCIPlinkRelaxSol(SCIP *scip, SCIP_SOL *sol)

SCIP_RETCODE SCIPtrySol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)

SCIP_RETCODE SCIPlinkLPSol(SCIP *scip, SCIP_SOL *sol)

SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)

SCIP_Longint SCIPgetNLPs(SCIP *scip)

SCIP_Real SCIPgetCutoffbound(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 SCIPvarMayRoundUp(SCIP_VAR *var)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Bool SCIPvarMayRoundDown(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPgetRelaxSolVal(SCIP *scip, SCIP_VAR *var)

SCIP_Bool SCIPisRelaxSolValid(SCIP *scip)

static SCIP_DECL_HEURFREE(heurFreeSimplerounding)

static SCIP_DECL_HEUREXITSOL(heurExitsolSimplerounding)

#define DEFAULT_ONCEPERNODE

static SCIP_DECL_HEURCOPY(heurCopySimplerounding)

static SCIP_DECL_HEURINITSOL(heurInitsolSimplerounding)

static SCIP_RETCODE performSimpleRounding(SCIP *scip, SCIP_SOL *sol, SCIP_VAR **cands, SCIP_Real *candssol, int ncands, SCIP_RESULT *result)

static SCIP_RETCODE performLPSimpleRounding(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_HEURTIMING heurtiming, SCIP_RESULT *result)

static SCIP_DECL_HEUREXEC(heurExecSimplerounding)

static SCIP_DECL_HEURINIT(heurInitSimplerounding)

static SCIP_RETCODE performRelaxSimpleRounding(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_RESULT *result)

static SCIP_DECL_HEUREXIT(heurExitSimplerounding)

Simple and fast LP rounding heuristic.

memory allocation routines

public methods for primal heuristics

public methods for message output

public methods for problem variables

public methods for branching rule plugins and branching

public methods for primal heuristic plugins and divesets

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 solutions

public methods for querying solving statistics

public methods for SCIP variables

struct SCIP_HeurData SCIP_HEURDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

#define SCIP_HEURTIMING_DURINGPRICINGLOOP

unsigned int SCIP_HEURTIMING

#define SCIP_HEURTIMING_AFTERLPNODE

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