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

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

SCIP Doxygen Documentation: applications/Ringpacking/src/probdata_rpa.c Source File

ncppatternsunknownbeg;

assert(probdata !=

);

assert(demands !=

);

assert(rints !=

);

assert(rexts !=

);

assert(height > 0.0);

assert(width >= height);

( ncpatterns > 0 )

(*probdata)->ncpatterns = ncpatterns;

(*probdata)->cpatternsize = ncpatterns;

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

( nrpatterns > 0 )

(*probdata)->nrpatterns = nrpatterns;

(*probdata)->rpatternsize = nrpatterns;

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

( patternconss !=

)

(*probdata)->ntypes = ntypes;

(*probdata)->width = width;

(*probdata)->height = height;

assert(probdata !=

);

assert(*probdata !=

);

( (*probdata)->randnumgen !=

)

( (*probdata)->patternconss !=

)

( (*probdata)->patternconss[i] !=

)

( i = 0; i < (*probdata)->ncpatterns; ++i )

assert((*probdata)->cpatterns[i] !=

);

( (*probdata)->cvars[i] !=

)

( i = 0; i < (*probdata)->nrpatterns; ++i )

assert((*probdata)->rpatterns[i] !=

);

assert((*probdata)->rvars[i] !=

);

( (*probdata)->rvars[i] !=

)

assert(probdata !=

);

( p = 0; p < probdata->ncpatterns; ++p )

assert(probdata !=

);

newsize =

(size, 2 * probdata->cpatternsize);

probdata->cpatternsize = newsize;

newsize =

(size, 2 * probdata->rpatternsize);

probdata->rpatternsize = newsize;

assert(probdata !=

);

assert(probdata->ncpatterns > 0);

assert(probdata->nrpatterns > 0);

( k = 0; k < probdata->ncpatterns; ++k )

pattern = probdata->cpatterns[k];

assert(pattern !=

);

(void) strcat(name, strtmp);

probdata->cvars[k] = var;

( k = 0; k < probdata->nrpatterns; ++k )

pattern = probdata->rpatterns[k];

assert(pattern !=

);

(void) strcat(name, strtmp);

probdata->rvars[k] = var;

rintscaled = _rint / rext;

assert(rintscaled >= 1.0);

(

(

, rintscaled, 2.1547005383792515) )

(

(

, rintscaled, 2.414213562373095) )

(

(

, rintscaled, 2.7013016167040798) )

(

(

, rintscaled, 3.3047648709624866) )

(

(

, rintscaled, 3.613125929752753) )

( i = 0; i < ntypes && (pdomq || qdomp); ++i )

( count[i] > 0 )

( i = 0; i < probdata->ncpatterns - 1; ++i )

( j = i + 1; j < probdata->ncpatterns; ++j )

( i = 0; i < probdata->ncpatterns; ++i )

cpatterns[ncpatterns] = probdata->cpatterns[i];

assert(ncpatterns > 0);

probdata->ncpatterns = ncpatterns;

assert(pattern !=

);

assert(timeleft !=

);

lasttype = ntypes -1;

timelim =

(heurtilim, *timeleft);

timelim =

(*timeleft, nlptilim);

volume -=

(rexts[t]) *

* nselected[t];

( t > type && (nselected[t] == ms[t] ||

(

, volume, maxvolume)) )

volume -=

(rexts[t]) *

* nselected[t];

assert(nselected[t] < ms[t]);

volume +=

(rexts[t]) *

;

assert(probdata !=

);

probdata->totaltilimsoft, probdata->nlpnodelimsoft, probdata->heuriterlimsoft) );

( t = 0; t < ntypes; ++t )

( t = 0; t < ntypes; ++t )

( p = 0; p < probdata->ncpatterns; ++p )

pattern = probdata->cpatterns[p];

assert(pattern !=

);

var = probdata->cvars[p];

assert(var !=

);

( t = 0; t < ntypes; ++t )

( p = 0; p < probdata->ncpatterns; ++p )

* var = probdata->cvars[p];

assert(pattern !=

);

assert(var !=

);

assert(type >= 0 && type < ntypes);

( t = 0; t < ntypes; ++t )

( p = 0; p < probdata->nrpatterns; ++p )

* var = probdata->rvars[p];

assert(pattern !=

);

assert(var !=

);

( t = 0; t < ntypes; ++t )

minrext = rexts[ntypes-1];

( t = 0; t < ntypes; ++t )

vol =

* (

(rexts[t]) -

(rints[t]));

volume += vol * demands[t];

assert(probdata !=

);

( !probdata->isdualinvalid )

dualbound = probdata->dualbound;

( t = 0; t < ntypes; ++t )

nrings += demands[t];

maxrint =

(maxrint, rints[t]);

minrext =

(minrext, rexts[t]);

(

, file,

,

,

,

,

,

,

,

,

,

,

,

,

);

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

dist =

(

- xs[i]) +

(

- ys[i]);

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

c = sqrt(xs[i]*xs[i] + ys[i]*ys[i]);

( !

(

, c + rexts[elements[i]] + 2.0*rexts[elements[pos]], rbound)

||

(

, rexts[elements[pos]] + rexts[elements[i]], rbound) )

= rexts[elements[pos]] + rexts[elements[i]];

= rbound - rexts[elements[pos]];

(

, xs, ys, rexts, rexts[elements[pos]], rbound, -1.0, -1.0, rmax,

,

ispacked, elements, nelements, bestx, besty, -rbound + rexts[elements[pos]], 0.0, ncalls);

(

, xs, ys, rexts, rexts[elements[pos]], rbound, -1.0, -1.0, rmax,

,

ispacked, elements, nelements, bestx, besty, +rbound - rexts[elements[pos]], 0.0, ncalls);

alpha = (c*c -

*

+

*

) / (2*c);

(

*

>= alpha*alpha )

= sqrt(

(

*

- alpha*alpha, 0.0));

u = (c - alpha) * xs[i] / c;

v = (c - alpha) * ys[i] / c;

(

, xs, ys, rexts, rexts[elements[pos]], rbound, -1.0, -1.0, rmax,

,

ispacked, elements, nelements, bestx, besty, u + n1, v + n2, ncalls);

(

, xs, ys, rexts, rexts[elements[pos]], rbound, -1.0, -1.0, rmax,

,

ispacked, elements, nelements, bestx, besty, u - n1, v - n2, ncalls);

xcands[4] = {-rbound + rext, +rbound - rext, 0.0, 0.0};

ycands[4] = {0.0, 0.0, -rbound + rext, +rbound - rext};

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

(

, xs, ys, rexts, rexts[elements[pos]], rbound, width, height, rmax, patterntype,

ispacked, elements, nelements, bestx, besty, xcands[i], ycands[i], ncalls);

xcands[4] = {rext, width - rext, rext, width - rext};

ycands[4] = {rext, rext, height - rext, height - rext};

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

(

, xs, ys, rexts, rexts[elements[pos]], rbound, width, height, rmax, patterntype,

ispacked, elements, nelements, bestx, besty, xcands[i], ycands[i], ncalls);

rext = rexts[elements[pos]];

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

xfix[2] = {rext, width - rext};

yfix[2] = {rext, height - rext};

Ri = rexts[elements[i]];

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

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

rext = rexts[elements[pos]];

( i = 0; i < nelements - 1; ++i )

Ri = rexts[elements[i]];

( j = i + 1; j < nelements; ++j )

Rj = rexts[elements[j]];

dist = sqrt(

(xs[i] - xs[j]) +

(ys[i] - ys[j]));

assert(dist != 0.0);

alpha = (dist*dist -

*

+

*

) / (2.0*dist);

assert(

*

>= alpha*alpha);

= sqrt(

(

*

- alpha*alpha, 0.0));

u = xs[i] + (alpha / dist) * (xs[j] - xs[i]);

v = ys[i] + (alpha / dist) * (ys[j] - ys[i]);

n1 =

* ((ys[j] - ys[i]) / dist);

n2 =

* ((xs[i] - xs[j]) / dist);

assert(n1*n1 + n2*n2 > 0.0);

(

, xs, ys, rexts, rext, rbound, width, height, rmax, patterntype, ispacked, elements,

nelements, bestx, besty, u + n1, v + n2, ncalls);

(

, xs, ys, rexts, rext, rbound, width, height, rmax, patterntype, ispacked, elements,

nelements, bestx, besty, u - n1, v - n2, ncalls);

assert(rexts !=

);

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

( iter == 1 )

( iter <= 10 )

( iter <= 20 )

sourcedata->ncpatterns, sourcedata->rpatterns, sourcedata->rvars, sourcedata->nrpatterns,

sourcedata->demands, sourcedata->rints, sourcedata->rexts, sourcedata->ntypes,

sourcedata->width, sourcedata->height) );

(*targetdata)->patternconss) );

(*targetdata)->ncppatternsunknownbeg = sourcedata->ncppatternsunknownbeg;

(*targetdata)->enumtime = sourcedata->enumtime;

(*targetdata)->dualbound = sourcedata->dualbound;

(*targetdata)->isdualinvalid = sourcedata->isdualinvalid;

* probname,

( t = 0; t < ntypes -1; ++t )

assert(rexts[t] >= rexts[t+1]);

(

(

, &probdata,

,

,

, 0,

,

, 0, demands, rints, rexts, ntypes, width,

assert(probdata !=

);

assert(probdata !=

);

( t = 0; t < ntypes; ++t )

( k = t+1; k < ntypes; ++k )

heuriterlim, &timeleft) );

assert(probdata !=

);

probdata->ntypes;

assert(probdata !=

);

probdata->rexts;

assert(probdata !=

);

probdata->rints;

assert(probdata !=

);

probdata->demands;

assert(probdata !=

);

probdata->width;

assert(probdata !=

);

probdata->height;

assert(probdata !=

);

( cpatterns !=

)

*cpatterns = probdata->cpatterns;

( cvars !=

)

*cvars= probdata->cvars;

( ncpatterns !=

)

*ncpatterns = probdata->ncpatterns;

assert(probdata !=

);

( rpatterns !=

)

*rpatterns = probdata->rpatterns;

( rvars !=

)

*rvars= probdata->rvars;

( nrpatterns !=

)

*nrpatterns = probdata->nrpatterns;

assert(probdata !=

);

probdata->patternconss;

assert(probdata !=

);

assert(pattern !=

);

probdata->cpatterns[probdata->ncpatterns] = copy;

probdata->cvars[probdata->ncpatterns] = var;

++(probdata->ncpatterns);

probdata->rpatterns[probdata->nrpatterns] = copy;

probdata->rvars[probdata->nrpatterns] = var;

++(probdata->nrpatterns);

assert(probdata !=

);

( !probdata->isdualinvalid &&

(

, probdata->dualbound, dualbound) )

probdata->dualbound = dualbound;

assert(probdata !=

);

( !probdata->isdualinvalid )

probdata->isdualinvalid =

;

assert(probdata !=

);

probdata->isdualinvalid;

assert(rexts !=

);

assert(xs !=

);

assert(ys !=

);

assert(ispacked !=

);

assert(elements !=

);

assert(nelements > 0);

assert(npacked !=

);

assert(rexts[elements[0]] <= rbounding);

xs[0] = rexts[elements[0]] - rbounding;

assert(2.0 * rexts[elements[0]] <= width);

assert(2.0 * rexts[elements[0]] <= height);

xs[0] = rexts[elements[0]];

ys[0] = rexts[elements[0]];

ispacked[0] =

;

rmax = rexts[elements[0]];

( i = 1; i < nelements; ++i )

( rexts[elements[i]] > rmax )

rmax = rexts[elements[i]];

( i = 1; i < nelements; ++i )

(

, elements, nelements, rexts, xs, ys, i, ispacked, rmax, rbounding, width, height,

patterntype, &bestx, &besty, ncalls);

(

, elements, nelements, rexts, xs, ys, i, ispacked, rmax, rbounding, &bestx,

(

, elements, nelements, rexts, xs, ys, i, ispacked, rmax, width, height, &bestx,

(

, elements, nelements, rexts, xs, ys, i, ispacked, rmax, rbounding, width, height,

patterntype, &bestx, &besty, ncalls);

assert(!ispacked[i]);

ispacked[i] =

;

assert(probdata !=

);

assert(pattern !=

);

assert(iterlim > 0);

( timelim <= 0.0 )

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

ispacked[i] =

;

( npacked == nelements )

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

(

,

, niters + 1);

assert(probdata !=

);

assert(pattern !=

);

( timelim <= 0.0 )

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

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

( l = k + 1; l < nelems; ++l )

quadvars1[0] = xvars[k]; quadvars2[0] = xvars[k]; quadcoefs[0] = 1.0;

quadvars1[1] = xvars[k]; quadvars2[1] = xvars[l]; quadcoefs[1] = -2.0;

quadvars1[2] = xvars[l]; quadvars2[2] = xvars[l]; quadcoefs[2] = 1.0;

quadvars1[3] = yvars[k]; quadvars2[3] = yvars[k]; quadcoefs[3] = 1.0;

quadvars1[4] = yvars[k]; quadvars2[4] = yvars[l]; quadcoefs[4] = -2.0;

quadvars1[5] = yvars[l]; quadvars2[5] = yvars[l]; quadcoefs[5] = 1.0;

quadcoefs,

(rexts[elemtype1] + rexts[elemtype2]),

(subscip),

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

quadvars1[0] = xvars[k]; quadvars2[0] = xvars[k]; quadcoefs[0] = 1.0;

quadvars1[1] = yvars[k]; quadvars2[1] = yvars[k]; quadcoefs[1] = 1.0;

(

(subscip, &cons, name, 0,

,

, 2, quadvars1, quadvars2, quadcoefs,

0.0,

(rints[type] - rexts[elemtype]),

( k = 0; k < nelems - 1; ++k )

( l = k + 1; l < nelems; ++l )

( elemtype1 != elemtype2 )

(

,

);

(

,

);

(

,

,

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

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

assert(probdata !=

);

assert(pattern !=

);

assert(patterntype >= 0);

assert(

(

, distance, rints[patterntype] - rexts[typei]));

SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPcreateConsBasicLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs)

SCIP_RETCODE SCIPcreateConsQuadraticNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadterms, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable)

SCIP_RETCODE SCIPfree(SCIP **scip)

SCIP_RETCODE SCIPcreate(SCIP **scip)

SCIP_STATUS SCIPgetStatus(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPsetObjIntegral(SCIP *scip)

SCIP_RETCODE SCIPsetProbDeltrans(SCIP *scip, SCIP_DECL_PROBDELTRANS((*probdeltrans)))

SCIP_RETCODE SCIPsetProbTrans(SCIP *scip, SCIP_DECL_PROBTRANS((*probtrans)))

SCIP_RETCODE SCIPsetProbDelorig(SCIP *scip, SCIP_DECL_PROBDELORIG((*probdelorig)))

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_PROBDATA * SCIPgetProbData(SCIP *scip)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

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

SCIP_RETCODE SCIPsetProbData(SCIP *scip, SCIP_PROBDATA *probdata)

SCIP_RETCODE SCIPupdateLocalDualbound(SCIP *scip, SCIP_Real newbound)

void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)

#define SCIPdebugMsgPrint

void SCIPsetMessagehdlrQuiet(SCIP *scip, SCIP_Bool quiet)

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

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

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

SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)

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

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

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

SCIP_RETCODE SCIPtransformConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)

SCIP_RETCODE SCIPsetConsModifiable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool modifiable)

SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPallocBlockMemory(scip, ptr)

#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)

SCIP_SOL * SCIPgetBestSol(SCIP *scip)

int SCIPgetNSols(SCIP *scip)

SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)

SCIP_RETCODE SCIPsolve(SCIP *scip)

SCIP_Real SCIPgetDualbound(SCIP *scip)

SCIP_TABLE * SCIPfindTable(SCIP *scip, const char *name)

SCIP_RETCODE SCIPincludeTable(SCIP *scip, const char *name, const char *desc, SCIP_Bool active, SCIP_DECL_TABLECOPY((*tablecopy)), SCIP_DECL_TABLEFREE((*tablefree)), SCIP_DECL_TABLEINIT((*tableinit)), SCIP_DECL_TABLEEXIT((*tableexit)), SCIP_DECL_TABLEINITSOL((*tableinitsol)), SCIP_DECL_TABLEEXITSOL((*tableexitsol)), SCIP_DECL_TABLEOUTPUT((*tableoutput)), SCIP_TABLEDATA *tabledata, int position, SCIP_STAGE earlieststage)

SCIP_Real SCIPgetTotalTime(SCIP *scip)

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

SCIP_Real SCIPinfinity(SCIP *scip)

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

SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)

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

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

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

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

SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

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

SCIP_RETCODE SCIPtransformVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)

SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)

SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)

SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)

void SCIPfreeRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen)

SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)

SCIP_RETCODE SCIPcreateRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen, unsigned int initialseed, SCIP_Bool useglobalseed)

void SCIPsortDownRealIntInt(SCIP_Real *realarray, int *intarray1, int *intarray2, int len)

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

#define BMSclearMemory(ptr)

#define BMScopyMemoryArray(ptr, source, num)

#define BMSclearMemoryArray(ptr, num)

SCIP_Real SCIPpatternGetElementPosY(SCIP_PATTERN *pattern, int elem)

SCIP_RETCODE SCIPpatternAddElement(SCIP_PATTERN *pattern, int type, SCIP_Real x, SCIP_Real y)

void SCIPpatternSetPackableStatus(SCIP_PATTERN *pattern, SCIP_PACKABLE packable)

SCIP_Real SCIPpatternGetElementPosX(SCIP_PATTERN *pattern, int elem)

SCIP_RETCODE SCIPpatternCreateRectangular(SCIP *scip, SCIP_PATTERN **pattern)

SCIP_PATTERNTYPE SCIPpatternGetPatternType(SCIP_PATTERN *pattern)

int SCIPpatternCountElements(SCIP_PATTERN *pattern, int type)

void SCIPpatternSetElementPos(SCIP_PATTERN *pattern, int elem, SCIP_Real x, SCIP_Real y)

void SCIPpatternRemoveLastElements(SCIP_PATTERN *pattern, int k)

SCIP_RETCODE SCIPpatternCreateCircular(SCIP *scip, SCIP_PATTERN **pattern, int type)

SCIP_PACKABLE SCIPpatternGetPackableStatus(SCIP_PATTERN *pattern)

void SCIPpatternSetType(SCIP_PATTERN *pattern, int type)

int SCIPpatternGetElementType(SCIP_PATTERN *pattern, int i)

void SCIPpatternRelease(SCIP *scip, SCIP_PATTERN **pattern)

int SCIPpatternGetNElemens(SCIP_PATTERN *pattern)

void SCIPpatternCapture(SCIP_PATTERN *pattern)

SCIP_RETCODE SCIPpatternCopy(SCIP *scip, SCIP_PATTERN *pattern, SCIP_PATTERN **copy)

int SCIPpatternGetCircleType(SCIP_PATTERN *pattern)

enum SCIP_Patterntype SCIP_PATTERNTYPE

enum SCIP_Packable SCIP_PACKABLE

@ SCIP_PATTERNTYPE_RECTANGULAR

@ SCIP_PATTERNTYPE_CIRCULAR

SCIP_RETCODE SCIPpricerRpaActivate(SCIP *scip)

Ringpacking variable pricer.

static SCIP_RETCODE enumeratePatterns(SCIP *scip, SCIP_PROBDATA *probdata, SCIP_PATTERN *pattern, int *ms, int *nselected, SCIP_Real nlptilim, SCIP_Real heurtilim, SCIP_Longint nlpnodelim, int heuriterlim, SCIP_Real *timeleft)

#define TABLE_POSITION_RPA

SCIP_Real SCIPprobdataGetHeight(SCIP_PROBDATA *probdata)

SCIP_Bool SCIPprobdataIsDualboundInvalid(SCIP_PROBDATA *probdata)

static SCIP_RETCODE createPatternVars(SCIP *scip, SCIP_PROBDATA *probdata)

SCIP_RETCODE SCIPverifyCircularPatternNLP(SCIP *scip, SCIP_PROBDATA *probdata, SCIP_PATTERN *pattern, SCIP_Real timelim, SCIP_Longint nodelim)

static SCIP_DECL_PROBDELORIG(probdelorigRingpacking)

static SCIP_DECL_PROBTRANS(probtransRingpacking)

static void updateBestCandidate(SCIP *scip, SCIP_Real *xs, SCIP_Real *ys, SCIP_Real *rexts, SCIP_Real rext, SCIP_Real rbounding, SCIP_Real wbounding, SCIP_Real hbounding, SCIP_Real rmax, SCIP_PATTERNTYPE patterntype, SCIP_Bool *ispacked, int *elements, int nelements, SCIP_Real *bestx, SCIP_Real *besty, SCIP_Real x, SCIP_Real y, int ncalls)

static SCIP_RETCODE probdataCreate(SCIP *scip, SCIP_PROBDATA **probdata, SCIP_CONS **patternconss, SCIP_PATTERN **cpatterns, SCIP_VAR **cvars, int ncpatterns, SCIP_PATTERN **rpatterns, SCIP_VAR **rvars, int nrpatterns, int *demands, SCIP_Real *rints, SCIP_Real *rexts, int ntypes, SCIP_Real width, SCIP_Real height)

#define TABLE_EARLIEST_STAGE_RPA

static SCIP_RETCODE setupProblem(SCIP *scip, SCIP_PROBDATA *probdata)

int * SCIPprobdataGetDemands(SCIP_PROBDATA *probdata)

void SCIPprobdataGetRInfos(SCIP_PROBDATA *probdata, SCIP_PATTERN ***rpatterns, SCIP_VAR ***rvars, int *nrpatterns)

static int maxCircles(SCIP *scip, SCIP_PROBDATA *probdata, int type, int elemtype)

static SCIP_RETCODE ensureSize(SCIP *scip, SCIP_PROBDATA *probdata, SCIP_PATTERNTYPE type, int size)

int SCIPprobdataGetNTypes(SCIP_PROBDATA *probdata)

static SCIP_RETCODE filterPatterns(SCIP *scip, SCIP_PROBDATA *probdata)

static void computeScores(SCIP *scip, SCIP_PROBDATA *probdata, int *elements, int nelements, SCIP_Real *scores, int iter)

SCIP_RETCODE SCIPprobdataCreate(SCIP *scip, const char *probname, int *demands, SCIP_Real *rints, SCIP_Real *rexts, int ntypes, SCIP_Real width, SCIP_Real height)

static void computePosCircleCircle(SCIP *scip, int *elements, int nelements, SCIP_Real *rexts, SCIP_Real *xs, SCIP_Real *ys, int pos, SCIP_Bool *ispacked, SCIP_Real rmax, SCIP_Real rbound, SCIP_Real width, SCIP_Real height, SCIP_PATTERNTYPE patterntype, SCIP_Real *bestx, SCIP_Real *besty, int ncalls)

SCIP_RETCODE SCIPprobdataAddVar(SCIP *scip, SCIP_PROBDATA *probdata, SCIP_PATTERN *pattern, SCIP_VAR *var)

void SCIPprobdataGetCInfos(SCIP_PROBDATA *probdata, SCIP_PATTERN ***cpatterns, SCIP_VAR ***cvars, int *ncpatterns)

static int isPatternDominating(SCIP_PATTERN *p, SCIP_PATTERN *q, int *count, int ntypes)

static SCIP_DECL_TABLEOUTPUT(tableOutputRpa)

static void computePosRingCircle(SCIP *scip, int *elements, int nelements, SCIP_Real *rexts, SCIP_Real *xs, SCIP_Real *ys, int pos, SCIP_Bool *ispacked, SCIP_Real rmax, SCIP_Real rbound, SCIP_Real *bestx, SCIP_Real *besty, int ncalls)

SCIP_Real * SCIPprobdataGetRexts(SCIP_PROBDATA *probdata)

SCIP_CONS ** SCIPprobdataGetPatternConss(SCIP_PROBDATA *probdata)

static int getNCPatterns(SCIP *scip, SCIP_PROBDATA *probdata, SCIP_PACKABLE status)

SCIP_RETCODE SCIPverifyCircularPatternHeuristic(SCIP *scip, SCIP_PROBDATA *probdata, SCIP_PATTERN *pattern, SCIP_Real timelim, int iterlim)

static void computePosTrivial(SCIP *scip, int *elements, int nelements, SCIP_Real *rexts, SCIP_Real *xs, SCIP_Real *ys, int pos, SCIP_Bool *ispacked, SCIP_Real rmax, SCIP_Real rbound, SCIP_Real width, SCIP_Real height, SCIP_PATTERNTYPE patterntype, SCIP_Real *bestx, SCIP_Real *besty, int ncalls)

SCIP_RETCODE SCIPprobdataEnumeratePatterns(SCIP *scip, SCIP_PROBDATA *probdata, SCIP_Real nlptilim, SCIP_Real heurtilim, SCIP_Real totaltilim, SCIP_Longint nlpnodelim, int heuriterlim)

static SCIP_RETCODE probdataFree(SCIP *scip, SCIP_PROBDATA **probdata)

static void computePosRectangleCircle(SCIP *scip, int *elements, int nelements, SCIP_Real *rexts, SCIP_Real *xs, SCIP_Real *ys, int pos, SCIP_Bool *ispacked, SCIP_Real rmax, SCIP_Real width, SCIP_Real height, SCIP_Real *bestx, SCIP_Real *besty, int ncalls)

SCIP_Real * SCIPprobdataGetRints(SCIP_PROBDATA *probdata)

void SCIPprobdataUpdateDualbound(SCIP *scip, SCIP_PROBDATA *probdata, SCIP_Real dualbound)

void SCIPprobdataInvalidateDualbound(SCIP *scip, SCIP_PROBDATA *probdata)

SCIP_RETCODE SCIPprobdataSetupProblem(SCIP *scip)

static SCIP_DECL_PROBDELTRANS(probdeltransRingpacking)

void SCIPcheckPattern(SCIP *scip, SCIP_PROBDATA *probdata, SCIP_PATTERN *pattern)

void SCIPpackCirclesGreedy(SCIP *scip, SCIP_Real *rexts, SCIP_Real *xs, SCIP_Real *ys, SCIP_Real rbounding, SCIP_Real width, SCIP_Real height, SCIP_Bool *ispacked, int *elements, int nelements, SCIP_PATTERNTYPE patterntype, int *npacked, int ncalls)

SCIP_Real SCIPprobdataGetWidth(SCIP_PROBDATA *probdata)

Problem data for ringpacking problem.

SCIP_RETCODE SCIPincludeDefaultPlugins(SCIP *scip)

@ SCIP_PARAMEMPHASIS_FEASIBILITY

struct SCIP_ProbData SCIP_PROBDATA

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_VARTYPE_CONTINUOUS

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