RetroSearch Browse

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

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

SCIP Doxygen Documentation: applications/CycleClustering/src/sepa_edge.c Source File

39#define SEPA_NAME "edge" 40#define SEPA_DESC "separator to separate triangle-inequalities in cycle-clustering application" 41#define SEPA_PRIORITY 5000 43#define SEPA_MAXBOUNDDIST 0.0 44#define SEPA_USESSUBSCIP FALSE 45#define SEPA_DELAY FALSE 47#define MAXCUTSCREATED 10000 55

assert(sepa !=

NULL

);

109

assert(

NULL

!= edgevars);

110

assert(

NULL

!= edgegraph);

124 for

( j = 0; j < 3; ++j )

128 for

( k = 0; k < 3; ++k )

140 for

( states[0] = 0; states[0] < nstates && ncutscreated <

MAXCUTSCREATED

; ++states[0] )

147

states[1] = succs1[j];

153

states[2] = succs2[k];

158 if

( (states[0] != states[1] && states[0] != states[2] && states[1] > states[2]) )

161 for

( l = 0; l < 3 ; ++l )

163

violation[ncutscreated] = sign[l][0]

165

violation[ncutscreated] += sign[l][1]

167

violation[ncutscreated] += sign[l][2]

170 if

( violation[ncutscreated] > 0 )

179 getEdgevar

(edgevars, states[1], states[2], 0), sign[l][2]) );

181 getEdgevar

(edgevars, states[0], states[1], 1), sign[l][0]) );

183 getEdgevar

(edgevars, states[0], states[2], 1), sign[l][1]) );

187 if

( ncutscreated >= size - 1 )

197

violation[ncutscreated] = sign[l][0]

199

violation[ncutscreated] += sign[l][1]

201

violation[ncutscreated] += sign[l][2]

204 if

( violation[ncutscreated] > 0)

213 getEdgevar

(edgevars, states[1], states[2], 0), sign[l][2]) );

215 getEdgevar

(edgevars, states[1], states[0], 1), sign[l][0]) );

217 getEdgevar

(edgevars, states[2], states[0], 1), sign[l][1]) );

221 if

( ncutscreated >= size - 1 )

233 if

( states[0] > states[1] && states[1] > states[2] )

235 for

( l = 0; l < 3; ++l )

237

violation[ncutscreated] = sign[l][0]

239

violation[ncutscreated] += sign[l][1]

241

violation[ncutscreated] += sign[l][2]

244 if

( violation[ncutscreated] > 0 )

250 getEdgevar

(edgevars, states[0], states[1], 0), sign[l][0]) );

252 getEdgevar

(edgevars, states[0], states[2], 0), sign[l][1]) );

254 getEdgevar

(edgevars, states[1], states[2], 0), sign[l][2]) );

256 if

( ncutscreated >= size - 1 )

274 for

( states[0] = 0; states[0] < nstates; ++states[0] )

281

states[1] = succs1[j];

287

states[2] = succs2[k];

296 if

( violation[ncutscreated] > 0 )

305 getEdgevar

(edgevars, states[0], states[1], 1), 1.0) );

307 getEdgevar

(edgevars, states[1], states[2], 1), 1.0) );

309 getEdgevar

(edgevars, states[2], states[0], 1), -1.0) );

313 if

( ncutscreated >= size - 1 )

327 if

( ncutscreated > 0 )

330 if

( usecutselection )

342

goodmaxparall, maxparall, dircutoffdist, efficacyweight, objparalweight, intsuppweight,

343

ncutscreated, 0,

MAXCUTS

, &ncutsapplied) );

351 for

( j = 0; j < ncutsapplied; ++j )

359 for

( j = 0; j < ncutscreated; ++j )

365 for

( j = 0; j < 3; ++j )

384

sepaExeclpEdge,

NULL

387

assert(sepa !=

NULL

);

SCIP_RETCODE SCIPselectCutsHybrid(SCIP *scip, SCIP_ROW **cuts, SCIP_ROW **forcedcuts, SCIP_RANDNUMGEN *randnumgen, SCIP_Real goodscorefac, SCIP_Real badscorefac, SCIP_Real goodmaxparall, SCIP_Real maxparall, SCIP_Real dircutoffdistweight, SCIP_Real efficacyweight, SCIP_Real objparalweight, SCIP_Real intsupportweight, int ncuts, int nforcedcuts, int maxselectedcuts, int *nselectedcuts)

int SCIPdigraphGetNSuccessors(SCIP_DIGRAPH *digraph, int node)

int * SCIPdigraphGetSuccessors(SCIP_DIGRAPH *digraph, int node)

SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)

SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)

SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)

#define SCIPallocMemoryArray(scip, ptr, num)

#define SCIPallocClearBufferArray(scip, ptr, num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPallocClearMemoryArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPfreeMemoryArray(scip, ptr)

SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)

SCIP_RETCODE SCIPcreateEmptyRowSepa(SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPincludeSepaBasic(SCIP *scip, SCIP_SEPA **sepa, const char *name, const char *desc, int priority, int freq, SCIP_Real maxbounddist, SCIP_Bool usessubscip, SCIP_Bool delay, SCIP_DECL_SEPAEXECLP((*sepaexeclp)), SCIP_DECL_SEPAEXECSOL((*sepaexecsol)), SCIP_SEPADATA *sepadata)

const char * SCIPsepaGetName(SCIP_SEPA *sepa)

int SCIPsepaGetNCallsAtNode(SCIP_SEPA *sepa)

SCIP_RETCODE SCIPsetSepaCopy(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPACOPY((*sepacopy)))

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)

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

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

SCIP_Bool edgesExist(SCIP_VAR ****edgevars, int *states, int nstates)

SCIP_VAR **** SCIPcycGetEdgevars(SCIP *scip)

int SCIPcycGetNBins(SCIP *scip)

SCIP_VAR * getEdgevar(SCIP_VAR ****edgevars, int state1, int state2, EDGETYPE edgetype)

int SCIPcycGetNCluster(SCIP *scip)

SCIP_DIGRAPH * SCIPcycGetEdgeGraph(SCIP *scip)

problem data for cycle clustering problem

static SCIP_DECL_SEPACOPY(sepaCopyEdge)

SCIP_RETCODE SCIPincludeSepaEdge(SCIP *scip)

static SCIP_DECL_SEPAEXECLP(sepaExeclpEdge)

#define SEPA_MAXBOUNDDIST

edge-separator. Separates triangle-inequalities in cycle clustering problem

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