RetroSearch Browse

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

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

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

40#define SEPA_NAME "partition" 41#define SEPA_DESC "separator to separate partition-inequalities in cycle-clustering application" 42#define SEPA_PRIORITY 1500 44#define SEPA_MAXBOUNDDIST 0.0 45#define SEPA_USESSUBSCIP FALSE 46#define SEPA_DELAY FALSE 48#define MAXCUTSCREATED 10000 50#define MAXTRIANGLEDISTANCE -0.2 78

assert(

NULL

!= edgevars);

80 if

( *cutsize - 1 <= *ncutscreated )

82

*cutsize = *cutsize * 2;

87

(*violations)[*ncutscreated] = violation;

96 for

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

98 for

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

100

inda =

MAX

(firstpart[i], firstpart[j]);

101

indb =

MIN

(firstpart[i], firstpart[j]);

106 for

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

108 for

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

110

inda =

MAX

(secondpart[i], secondpart[j]);

111

indb =

MIN

(secondpart[i], secondpart[j]);

116 for

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

118 for

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

138

assert(sepa !=

NULL

);

200

assert(

NULL

!= edgevars);

201

assert(

NULL

!= edgegraph);

222 for

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

225

fractionality[i] = 0;

229 for

( j = 0; j < nsuccessors[0]; ++j )

232

states[1] = successors[0][j];

236

fractionality[states[0]] +=

MIN

(lpvalforward, 1 - lpvalforward) +

MIN

(1 - lpvalincluster, lpvalincluster);

250 for

( j = 0; j < nsuccessors[0] && ncutscreated <

MAXCUTSCREATED

; ++j )

252

states[1] = successors[0][j];

256 for

( k = 0; k < nsuccessors[1] && ncutscreated <

MAXCUTSCREATED

; ++k )

258

states[2] = successors[1][k];

266 if

( states[1] > states[2] )

270

firstpart[0] = states[0];

273

secondpart[0] = states[1];

274

secondpart[1] = states[2];

288 for

( l = 0; l < nsuccessors[2]; ++l )

290

states[3] = successors[2][l];

300 if

( violationchg > bestvalue )

302

bestvalue = violationchg;

303

secondpart[2] = states[3];

307

states[3] = secondpart[2];

310 if

( states[3] == -1 )

317

violation += bestvalue;

321 for

( l = 0; l < nsuccessors[3]; ++l )

323

states[4] = successors[3][l];

330 MAX

(states[0], states[4]),

MIN

(states[0],states[4]),

INCLUSTER

)) - 1.0;

338

firstpart[1] = states[4];

341

nfirst, nsecond, &violations, violation + violationchg) );

350

firstpart[0] = states[1];

351

firstpart[1] = states[2];

354

secondpart[0] = states[0];

367 for

( l = 0; l < nsuccessors[2]; ++l )

369

states[3] = successors[2][l];

379 if

( violationchg > bestvalue )

381

bestvalue = violationchg;

382

firstpart[2] = states[3];

386

states[3] = firstpart[2];

388 if

( states[3] == -1 )

395

violation += bestvalue;

399 for

( l = 0; l < nsuccessors[3]; ++l )

401

states[4] = successors[3][l];

407 MAX

(states[0], states[4]),

MIN

(states[0],states[4]),

INCLUSTER

)) - 1.0;

415

secondpart[1] = states[4];

418

secondpart, nfirst, nsecond, &violations, violation + violationchg) );

430 if

( usecutselection )

442

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

443

ncutscreated, 0,

MAXCUTS

, &ncutsapplied) );

451 for

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

462 for

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

486

assert(sepa !=

NULL

);

Constraint handler for linear constraints in their most general form, .

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 SCIPfreeBlockMemoryArray(scip, ptr, num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

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 SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)

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_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)

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

void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, 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_RETCODE createPartitionCut(SCIP *scip, SCIP_SEPA *sepa, SCIP_ROW ***cuts, int *cutsize, int *ncutscreated, int *firstpart, int *secondpart, int nfirst, int nsecond, SCIP_Real **violations, SCIP_Real violation)

static SCIP_DECL_SEPAEXECLP(sepaExeclpPartition)

#define MAXTRIANGLEDISTANCE

#define SEPA_MAXBOUNDDIST

static SCIP_DECL_SEPACOPY(sepaCopyPartition)

SCIP_RETCODE SCIPincludeSepaPartition(SCIP *scip)

simple partition-separator

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