RetroSearch Browse

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

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

SCIP Doxygen Documentation: heur_oneopt.c Source File

61#define HEUR_NAME "oneopt" 62#define HEUR_DESC "1-opt heuristic which tries to improve setting of single integer variables" 63#define HEUR_DISPCHAR SCIP_HEURDISPCHAR_ITERATIVE 64#define HEUR_PRIORITY -20000 67#define HEUR_MAXDEPTH -1 68#define HEUR_TIMING SCIP_HEURTIMING_BEFOREPRESOL | SCIP_HEURTIMING_AFTERNODE 69#define HEUR_USESSUBSCIP FALSE 71#define DEFAULT_WEIGHTEDOBJ TRUE 72#define DEFAULT_DURINGROOT TRUE 73#define DEFAULT_BEFOREPRESOL FALSE 74#define DEFAULT_FORCELPCONSTRUCTION FALSE 75#define DEFAULT_USELOOP TRUE 126 else if

( obj < 0.0 )

140 SCIPdebugMsg

(

scip

" lb:<%g> <= val:<%g> <= ub:<%g> and obj:<%g> by at most: <%g>\n"

, lb, solval, ub, obj, newsolval - solval );

148

assert(ncolrows == 0 || (colrows !=

NULL

&& colvals !=

NULL

));

151 for

(

int

i = 0; i < ncolrows; ++i )

166

left = shiftdown == ( colvals[i] > 0 );

175

newsolvalrow = solval + (side - activities[rowpos]) / colvals[i];

178 if

( ( shiftdown && newsolvalrow > newsolval ) || ( !shiftdown && newsolvalrow < newsolval ) )

182

activity = activities[rowpos] + colvals[i] * ((shiftdown ? floor(newsolvalrow) : ceil(newsolvalrow)) - solval);

187

newsolval = floor(newsolvalrow);

189

newsolval = ceil(newsolvalrow);

191 SCIPdebugMsg

(

scip

" -> The shift value has to be set to <%g>, because of row <%s>.\n"

206 return SCIPisInfinity

(

scip

, shiftdown ? -newsolval : newsolval) ? 0.0 : newsolval - solval;

225

assert(activities !=

NULL

);

232

assert(ncolrows == 0 || (colrows !=

NULL

&& colvals !=

NULL

));

235 for

(

int

i = 0; i < ncolrows; ++i )

247

activities[rowpos] += shiftval * colvals[i];

277

assert(subscip !=

NULL

);

278

assert(heur !=

NULL

);

292 for

(

int

i = 0; i < nvars; ++i )

295 if

( subvars[i] !=

NULL

)

335 SCIPwarningMessage

(

scip

"unfixing parameter heuristics/oneopt/freq in subscip of oneopt heuristic\n"

);

342 SCIPwarningMessage

(

scip

"unfixing parameter heuristics/oneopt/forcelpconstruction in subscip of oneopt heuristic\n"

);

350 SCIPwarningMessage

(

scip

"unfixing parameter heuristics/oneopt/beforepresol in subscip of oneopt heuristic\n"

);

389

assert(heur !=

NULL

);

404

assert(heur !=

NULL

);

410

assert(heurdata !=

NULL

);

428

assert(heurdata !=

NULL

);

441

assert(heur !=

NULL

);

456

assert(heur !=

NULL

);

461

assert(heurdata !=

NULL

);

464

heurdata->lastsolindex = -1;

495 int

nsuccessfulshifts;

498

assert(heur !=

NULL

);

500

assert(result !=

NULL

);

504

assert(heurdata !=

NULL

);

519

nintvars += nbinvars;

535 if

( !heurdata->beforepresol )

582

nintvars += nbinvars;

599 for

(

int

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

627 SCIPdebugMsg

(

scip

"number of bound changes (due to global bounds) = %d\n"

, nchgbound);

635 for

(

int

i = 0; i < nlprows; ++i )

659 SCIPdebugMsg

(

scip

"Some global bound changes were not valid in lp rows.\n"

);

671

nsuccessfulshifts = 0;

679 SCIPdebugMsg

(

scip

"Starting 1-opt heuristic iteration #%d\n"

, niterations);

685 for

(

int

i = 0; i < nintvars; ++i )

701 if

( nshiftcands == shiftcandssize)

707

shiftcands[nshiftcands] = vars[i];

708

shiftvals[nshiftcands] = shiftval;

715 if

( nshiftcands > 0 )

722 if

( nshiftcands == 1 )

725

assert(var !=

NULL

);

727

shiftval = shiftvals[0];

729 SCIPdebugMsg

(

scip

" Only one shiftcand found, var <%s>, which is now shifted by<%1.1f> \n"

744 if

( heurdata->weightedobj )

746 for

(

int

i = 0; i < nshiftcands; ++i )

751 for

(

int

i = 0; i < nshiftcands; ++i )

759 for

(

int

i = 0; i < nshiftcands; ++i )

762

assert(var !=

NULL

);

783 while

( heurdata->useloop && shifted );

785 if

( nsuccessfulshifts > 0 )

813 SCIPdebugMsg

(

scip

"shifted solution should be feasible -> solve LP to fix continuous variables to best values\n"

);

819 for

(

int

i = 0; i < nvars; ++i )

828 for

(

int

i = 0; i < nintvars; ++i )

850 SCIPwarningMessage

(

scip

"Error while solving LP in 1-opt heuristic; LP solve terminated with code <%d>\n"

,retstat);

885 if

( heurdata->useloop )

919

assert(heur !=

NULL

);

930 "should the objective be weighted with the potential shifting value when sorting the shifting candidates?"

934 "should the heuristic be called before and during the root node?"

938 "should the construction of the LP be forced even if LP solving is deactivated?"

942 "should the heuristic be called before presolving?"

946 "should the heuristic continue to run as long as improvements are found?"

#define SCIP_CALL_ABORT(x)

#define SCIP_LONGINT_FORMAT

SCIP_RETCODE SCIPtranslateSubSols(SCIP *scip, SCIP *subscip, SCIP_HEUR *heur, SCIP_VAR **subvars, SCIP_Bool *success, int *solindex)

SCIP_RETCODE SCIPcopy(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool threadsafe, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)

SCIP_RETCODE SCIPcheckCopyLimits(SCIP *sourcescip, SCIP_Bool *success)

SCIP_RETCODE SCIPcopyLimits(SCIP *sourcescip, SCIP *targetscip)

SCIP_RETCODE SCIPfree(SCIP **scip)

SCIP_RETCODE SCIPcreate(SCIP **scip)

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

int SCIPgetNVars(SCIP *scip)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)

void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)

SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)

SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)

SCIP_RETCODE SCIPsetHeuristics(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)

SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)

SCIP_RETCODE SCIPunfixParam(SCIP *scip, const char *name)

SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)

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 SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)

SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)

SCIP_RETCODE SCIPincludeHeurOneopt(SCIP *scip)

SCIP_Real * SCIPcolGetVals(SCIP_COL *col)

SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)

int SCIPcolGetNLPNonz(SCIP_COL *col)

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

void SCIPheurSetTimingmask(SCIP_HEUR *heur, SCIP_HEURTIMING timingmask)

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

int SCIPheurGetFreqofs(SCIP_HEUR *heur)

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_RETCODE SCIPchgVarLbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)

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

SCIP_RETCODE SCIPstartDive(SCIP *scip)

SCIP_RETCODE SCIPsolveDiveLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)

SCIP_RETCODE SCIPendDive(SCIP *scip)

SCIP_RETCODE SCIPflushLP(SCIP *scip)

SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)

SCIP_RETCODE SCIPconstructLP(SCIP *scip, SCIP_Bool *cutoff)

SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)

int SCIPgetNLPRows(SCIP *scip)

SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

int SCIProwGetLPPos(SCIP_ROW *row)

SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)

SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)

const char * SCIProwGetName(SCIP_ROW *row)

SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)

SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)

SCIP_SOL * SCIPgetBestSol(SCIP *scip)

SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)

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

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

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

SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)

int SCIPsolGetIndex(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 SCIPtrySolFree(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_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)

void SCIPsolSetHeur(SCIP_SOL *sol, SCIP_HEUR *heur)

SCIP_RETCODE SCIPtransformProb(SCIP *scip)

SCIP_RETCODE SCIPsolve(SCIP *scip)

SCIP_Longint SCIPgetNNodes(SCIP *scip)

SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)

SCIP_Longint SCIPgetNLPIterations(SCIP *scip)

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

SCIP_Real SCIPinfinity(SCIP *scip)

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

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

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

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

SCIP_RETCODE SCIPcutoffNode(SCIP *scip, SCIP_NODE *node)

SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)

SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

void SCIPsortRealPtr(SCIP_Real *realarray, void **ptrarray, int len)

static SCIP_RETCODE setupAndSolveSubscipOneopt(SCIP *scip, SCIP *subscip, SCIP_HEUR *heur, SCIP_VAR **vars, SCIP_VAR **subvars, SCIP_SOL *bestsol, SCIP_RESULT *result, SCIP_Bool *valid)

#define DEFAULT_FORCELPCONSTRUCTION

static SCIP_DECL_HEUREXEC(heurExecOneopt)

static SCIP_RETCODE updateRowActivities(SCIP *scip, SCIP_Real *activities, SCIP_VAR *var, SCIP_Real shiftval)

static SCIP_DECL_HEURINITSOL(heurInitsolOneopt)

#define DEFAULT_WEIGHTEDOBJ

#define DEFAULT_DURINGROOT

static SCIP_Real calcShiftVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solval, SCIP_Real *activities)

static SCIP_DECL_HEURFREE(heurFreeOneopt)

#define DEFAULT_BEFOREPRESOL

static SCIP_DECL_HEUREXITSOL(heurExitsolOneopt)

static SCIP_DECL_HEURCOPY(heurCopyOneopt)

static SCIP_DECL_HEURINIT(heurInitOneopt)

Improvement heuristic that alters single variable values.

memory allocation routines

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

public methods for primal heuristics

public methods for LP management

public methods for message output

public data structures and miscellaneous methods

methods for sorting joint arrays of various types

public methods for primal CIP solutions

public methods for problem variables

public methods for problem copies

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 the branch-and-bound tree

struct SCIP_HeurData SCIP_HEURDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

#define SCIP_HEURTIMING_BEFOREPRESOL

#define SCIP_HEURTIMING_DURINGLPLOOP

#define SCIP_HEURTIMING_BEFORENODE

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