A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: relax.c Source File

74

assert(paramdata !=

NULL

);

88

assert(relax !=

NULL

);

92 if

( relax->relaxcopy !=

NULL

)

124

assert(relax !=

NULL

);

125

assert(name !=

NULL

);

126

assert(desc !=

NULL

);

128

assert(relaxexec !=

NULL

);

135

(*relax)->priority = priority;

136

(*relax)->freq = freq;

137

(*relax)->relaxcopy = relaxcopy;

138

(*relax)->relaxfree = relaxfree;

139

(*relax)->relaxinit = relaxinit;

140

(*relax)->relaxexit = relaxexit;

141

(*relax)->relaxinitsol = relaxinitsol;

142

(*relax)->relaxexitsol = relaxexitsol;

143

(*relax)->relaxexec = relaxexec;

144

(*relax)->relaxdata = relaxdata;

147

(*relax)->ncalls = 0;

148

(*relax)->ncutoffs = 0;

149

(*relax)->nimprbounds = 0;

150

(*relax)->imprtime = 0.0;

151

(*relax)->naddedconss = 0;

152

(*relax)->nreduceddom = 0;

153

(*relax)->nseparated = 0;

154

(*relax)->lastsolvednode = -1;

155

(*relax)->initialized =

FALSE

;

161

&(*relax)->priority,

FALSE

, priority, INT_MIN/4, INT_MAX/4,

164

(void)

SCIPsnprintf

(paramdesc,

SCIP_MAXSTRLEN

,

"frequency for calling relaxation handler <%s> (-1: never, 0: only in root node)"

, name);

191

assert(relax !=

NULL

);

192

assert(name !=

NULL

);

193

assert(desc !=

NULL

);

195

assert(relaxexec !=

NULL

);

197 SCIP_CALL_FINALLY

(

doRelaxCreate

(relax,

set

, messagehdlr, blkmem, name, desc, priority, freq, relaxcopy, relaxfree,

198

relaxinit, relaxexit, relaxinitsol, relaxexitsol, relaxexec, relaxdata), (

void

)

SCIPrelaxFree

(relax,

set

) );

209

assert(relax !=

NULL

);

210 if

( *relax ==

NULL

)

212

assert(!(*relax)->initialized);

216 if

( (*relax)->relaxfree !=

NULL

)

236

assert(relax !=

NULL

);

245 if

(

set

->misc_resetstat )

259 if

( relax->relaxinit !=

NULL

)

280

assert(relax !=

NULL

);

289 if

( relax->relaxexit !=

NULL

)

310

assert(relax !=

NULL

);

314 if

( relax->relaxinitsol !=

NULL

)

334

assert(relax !=

NULL

);

338 if

( relax->relaxexitsol !=

NULL

)

363

assert(relax !=

NULL

);

364

assert(relax->relaxexec !=

NULL

);

365

assert(relax->

freq

>= -1);

369

assert(result !=

NULL

);

379 if

( (depth == 0 && relax->

freq

== 0) || (relax->

freq

> 0 && depth % relax->

freq

== 0) )

395 SCIP_CALL

( relax->relaxexec(

set

->scip, relax, lowerbound, result) );

409 SCIPerrorMessage

(

"execution method of relaxation handler <%s> returned invalid result <%d>\n"

,

410

relax->

name

, *result);

459

assert(relax !=

NULL

);

470

assert(relax !=

NULL

);

481

assert(relax !=

NULL

);

483

relax->relaxcopy = relaxcopy;

492

assert(relax !=

NULL

);

494

relax->relaxfree = relaxfree;

503

assert(relax !=

NULL

);

505

relax->relaxinit = relaxinit;

514

assert(relax !=

NULL

);

516

relax->relaxexit = relaxexit;

525

assert(relax !=

NULL

);

527

relax->relaxinitsol = relaxinitsol;

536

assert(relax !=

NULL

);

538

relax->relaxexitsol = relaxexitsol;

546

assert(relax !=

NULL

);

548 return

relax->

name

;

556

assert(relax !=

NULL

);

558 return

relax->

desc

;

566

assert(relax !=

NULL

);

578

assert(relax !=

NULL

);

590

assert(relax !=

NULL

);

592 return

relax->

freq

;

600

assert(relax !=

NULL

);

611

assert(relax !=

NULL

);

622

assert(relax !=

NULL

);

632

assert(relax !=

NULL

);

642

assert(relax !=

NULL

);

652

assert(relax !=

NULL

);

662

assert(relax !=

NULL

);

672

assert(relax !=

NULL

);

682

assert(relax !=

NULL

);

692

assert(relax !=

NULL

);

702

assert(relax !=

NULL

);

713

assert(relax !=

NULL

);

714

assert(stat !=

NULL

);

724

assert(relax !=

NULL

);

743

assert(relaxation !=

NULL

);

744

assert(blkmem !=

NULL

);

746

assert(stat !=

NULL

);

747

assert(primal !=

NULL

);

748

assert(tree !=

NULL

);

752

(*relaxation)->relaxsolobjval = 0.0;

753

(*relaxation)->relaxsolvalid =

FALSE

;

754

(*relaxation)->relaxsolincludeslp =

FALSE

;

755

(*relaxation)->relaxsolzero =

TRUE

;

756

(*relaxation)->lastsolrelax =

NULL

;

766

assert(relaxation !=

NULL

);

779

assert(relaxation !=

NULL

);

789

assert(relaxation !=

NULL

);

801

assert(relaxation !=

NULL

);

812

assert(relaxation !=

NULL

);

822

assert(relaxation !=

NULL

);

833

assert(relaxation !=

NULL

);

843

assert(relaxation !=

NULL

);

854

assert(relaxation !=

NULL

);

870

assert(relaxation !=

NULL

);

872

assert(var !=

NULL

);

885

assert(relaxation !=

NULL

);

895

assert(relaxation !=

NULL

);

void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)

void SCIPclockEnableOrDisable(SCIP_CLOCK *clck, SCIP_Bool enable)

void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)

SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)

void SCIPclockReset(SCIP_CLOCK *clck)

void SCIPclockFree(SCIP_CLOCK **clck)

SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)

internal methods for clocks and timing issues

common defines and data types used in all packages of SCIP

#define SCIP_MAXTREEDEPTH

#define SCIP_CALL_FINALLY(x, y)

int SCIPgetNCuts(SCIP *scip)

SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)

SCIP_Bool SCIPinProbing(SCIP *scip)

void SCIPrelaxMarkUnsolved(SCIP_RELAX *relax)

SCIP_Longint SCIPrelaxGetNAddedConss(SCIP_RELAX *relax)

SCIP_Bool SCIPrelaxIsInitialized(SCIP_RELAX *relax)

SCIP_Real SCIPrelaxGetTime(SCIP_RELAX *relax)

int SCIPrelaxGetFreq(SCIP_RELAX *relax)

const char * SCIPrelaxGetName(SCIP_RELAX *relax)

SCIP_DECL_SORTPTRCOMP(SCIPrelaxComp)

SCIP_Real SCIPrelaxGetSetupTime(SCIP_RELAX *relax)

SCIP_RETCODE SCIPsetRelaxPriority(SCIP *scip, SCIP_RELAX *relax, int priority)

SCIP_Longint SCIPrelaxGetNCutoffs(SCIP_RELAX *relax)

SCIP_Longint SCIPrelaxGetNSeparatedCuts(SCIP_RELAX *relax)

void SCIPrelaxSetData(SCIP_RELAX *relax, SCIP_RELAXDATA *relaxdata)

const char * SCIPrelaxGetDesc(SCIP_RELAX *relax)

SCIP_Longint SCIPrelaxGetNReducedDomains(SCIP_RELAX *relax)

SCIP_Real SCIPrelaxGetImprovedLowerboundTime(SCIP_RELAX *relax)

int SCIPrelaxGetPriority(SCIP_RELAX *relax)

SCIP_Longint SCIPrelaxGetNImprovedLowerbound(SCIP_RELAX *relax)

SCIP_Longint SCIPrelaxGetNCalls(SCIP_RELAX *relax)

SCIP_RELAXDATA * SCIPrelaxGetData(SCIP_RELAX *relax)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

int SCIPsnprintf(char *t, int len, const char *s,...)

static const char * paramname[]

#define BMSfreeMemory(ptr)

#define BMSduplicateMemoryArray(ptr, source, num)

#define BMSclearMemory(ptr)

struct BMS_BlkMem BMS_BLKMEM

#define BMSfreeMemoryArrayNull(ptr)

#define BMSallocMemory(ptr)

SCIP_PARAMDATA * SCIPparamGetData(SCIP_PARAM *param)

int SCIPparamGetInt(SCIP_PARAM *param)

internal methods for handling parameter settings

public methods for message output

public data structures and miscellaneous methods

void SCIPrelaxSetExitsol(SCIP_RELAX *relax, SCIP_DECL_RELAXEXITSOL((*relaxexitsol)))

void SCIPrelaxSetInitsol(SCIP_RELAX *relax, SCIP_DECL_RELAXINITSOL((*relaxinitsol)))

SCIP_RETCODE SCIPrelaxInit(SCIP_RELAX *relax, SCIP_SET *set)

SCIP_Bool SCIPrelaxationIsSolZero(SCIP_RELAXATION *relaxation)

SCIP_RETCODE SCIPrelaxCreate(SCIP_RELAX **relax, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, int freq, SCIP_DECL_RELAXCOPY((*relaxcopy)), SCIP_DECL_RELAXFREE((*relaxfree)), SCIP_DECL_RELAXINIT((*relaxinit)), SCIP_DECL_RELAXEXIT((*relaxexit)), SCIP_DECL_RELAXINITSOL((*relaxinitsol)), SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), SCIP_DECL_RELAXEXEC((*relaxexec)), SCIP_RELAXDATA *relaxdata)

void SCIPrelaxationSetSolZero(SCIP_RELAXATION *relaxation, SCIP_Bool iszero)

SCIP_RETCODE SCIPrelaxExit(SCIP_RELAX *relax, SCIP_SET *set)

void SCIPrelaxationUpdateVarObj(SCIP_RELAXATION *relaxation, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real newobj)

void SCIPrelaxationSetSolValid(SCIP_RELAXATION *relaxation, SCIP_Bool isvalid, SCIP_Bool includeslp)

void SCIPrelaxSetInit(SCIP_RELAX *relax, SCIP_DECL_RELAXINIT((*relaxinit)))

void SCIPrelaxSetExit(SCIP_RELAX *relax, SCIP_DECL_RELAXEXIT((*relaxexit)))

static SCIP_DECL_PARAMCHGD(paramChgdRelaxPriority)

SCIP_RETCODE SCIPrelaxFree(SCIP_RELAX **relax, SCIP_SET *set)

void SCIPrelaxationSetSolObj(SCIP_RELAXATION *relaxation, SCIP_Real obj)

void SCIPrelaxSetFree(SCIP_RELAX *relax, SCIP_DECL_RELAXFREE((*relaxfree)))

SCIP_Real SCIPrelaxationGetSolObj(SCIP_RELAXATION *relaxation)

void SCIPrelaxSetCopy(SCIP_RELAX *relax, SCIP_DECL_RELAXCOPY((*relaxcopy)))

void SCIPrelaxationSolObjAdd(SCIP_RELAXATION *relaxation, SCIP_Real val)

SCIP_RETCODE SCIPrelaxCopyInclude(SCIP_RELAX *relax, SCIP_SET *set)

void SCIPrelaxationSetSolRelax(SCIP_RELAXATION *relaxation, SCIP_RELAX *relax)

SCIP_Bool SCIPrelaxIsSolved(SCIP_RELAX *relax, SCIP_STAT *stat)

static SCIP_RETCODE doRelaxCreate(SCIP_RELAX **relax, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, int freq, SCIP_DECL_RELAXCOPY((*relaxcopy)), SCIP_DECL_RELAXFREE((*relaxfree)), SCIP_DECL_RELAXINIT((*relaxinit)), SCIP_DECL_RELAXEXIT((*relaxexit)), SCIP_DECL_RELAXINITSOL((*relaxinitsol)), SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), SCIP_DECL_RELAXEXEC((*relaxexec)), SCIP_RELAXDATA *relaxdata)

SCIP_RETCODE SCIPrelaxationFree(SCIP_RELAXATION **relaxation)

void SCIPrelaxEnableOrDisableClocks(SCIP_RELAX *relax, SCIP_Bool enable)

SCIP_RETCODE SCIPrelaxationCreate(SCIP_RELAXATION **relaxation, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree)

SCIP_RELAX * SCIPrelaxationGetSolRelax(SCIP_RELAXATION *relaxation)

SCIP_RETCODE SCIPrelaxInitsol(SCIP_RELAX *relax, SCIP_SET *set)

SCIP_RETCODE SCIPrelaxExec(SCIP_RELAX *relax, SCIP_SET *set, SCIP_TREE *tree, SCIP_STAT *stat, int depth, SCIP_Real *lowerbound, SCIP_RESULT *result)

void SCIPrelaxSetPriority(SCIP_RELAX *relax, SCIP_SET *set, int priority)

SCIP_Bool SCIPrelaxationIsLpIncludedForSol(SCIP_RELAXATION *relaxation)

SCIP_Bool SCIPrelaxationIsSolValid(SCIP_RELAXATION *relaxation)

SCIP_RETCODE SCIPrelaxExitsol(SCIP_RELAX *relax, SCIP_SET *set)

internal methods for relaxators

public methods for cuts and aggregation rows

SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, 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_Real SCIPsetInfinity(SCIP_SET *set)

SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsRelGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

internal methods for global SCIP settings

internal methods for storing primal CIP solutions

internal methods for problem statistics

SCIP_RELAXDATA * relaxdata

SCIP_Longint lastsolvednode

SCIP_Bool relaxsolincludeslp

SCIP_RELAX * lastsolrelax

data structures for relaxators

SCIP_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)

internal methods for branch and bound tree

struct SCIP_ParamData SCIP_PARAMDATA

#define SCIP_DECL_RELAXINIT(x)

#define SCIP_DECL_RELAXEXITSOL(x)

#define SCIP_DECL_RELAXFREE(x)

#define SCIP_DECL_RELAXINITSOL(x)

#define SCIP_DECL_RELAXCOPY(x)

#define SCIP_DECL_RELAXEXEC(x)

#define SCIP_DECL_RELAXEXIT(x)

struct SCIP_RelaxData SCIP_RELAXDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)

internal methods for problem variables

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