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

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

SCIP Doxygen Documentation: sepa_eccuts.c Source File

[] = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192 };

assert(ecaggr !=

);

assert(nquadvars > 0);

assert(nquadterms >= nquadvars);

(*ecaggr)->nvars = 0;

(*ecaggr)->nterms = 0;

(*ecaggr)->varsize = nquadvars;

(*ecaggr)->termsize = nquadterms;

assert(ecaggr !=

);

assert(ecaggr->

+ 1 <= ((ecaggr->

+ 1) * ecaggr->

) / 2);

( i = 0; i < ecaggr->

&& (idx1 == -1 || idx2 == -1); ++i )

( ecaggr->

[i] ==

)

( ecaggr->

[i] ==

)

assert(idx1 != -1 && idx2 != -1);

assert(ecaggr !=

);

( i = 0; i < ecaggr->

; ++i )

( i = 0; i < ecaggr->

; ++i )

assert(nlrowaggr !=

);

assert(linvars !=

|| nlinvars == 0);

assert(lincoefs !=

|| nlinvars == 0);

assert(nlinvars >= 0);

( i = 0; i < nlrowaggr->

; ++i )

assert(nlrowaggr !=

);

assert(linvar !=

);

assert(nlrowaggr !=

);

assert(quadvar !=

);

assert(nlrowaggr !=

);

assert(nlrow !=

);

assert(nlrowaggr !=

);

assert(quadvar2aggr !=

);

(*nlrowaggr)->nlrow = nlrow;

(*nlrowaggr)->rhsaggr = rhsaggr;

(*nlrowaggr)->quadvars =

;

(*nlrowaggr)->nquadvars = 0;

(*nlrowaggr)->quadvarssize = 0;

(*nlrowaggr)->quadvar2aggr =

;

(*nlrowaggr)->remtermcoefs =

;

(*nlrowaggr)->remtermvars1 =

;

(*nlrowaggr)->remtermvars2 =

;

(*nlrowaggr)->nremterms = 0;

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

( lincoef != 0.0 )

( quadvar2aggr[i] >= 0)

++aggrnvars[ quadvar2aggr[i] ];

idx1 = quadvar2aggr[i];

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

( qterm1 != qterm )

idx2 = quadvar2aggr[pos2];

( idx1 >= 0 && idx2 >= 0 && idx1 == idx2 )

assert((*nlrowaggr)->nquadvars == nquadvars);

(*nlrowaggr)->remtermsize = nremterms;

(*nlrowaggr)->necaggr = nfound;

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

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

idx = quadvar2aggr[i];

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

idx1 = quadvar2aggr[i];

(

,

, coef, idx1);

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

( qterm1 != qterm )

idx2 = quadvar2aggr[pos2];

( idx1 >= 0 && idx2 >= 0 && idx1 == idx2 )

(

,

, coef, i, pos2, idx1);

(

,

, coef, i, pos2);

assert(nlrowaggr !=

);

assert(*nlrowaggr !=

);

(*nlrowaggr)->nlrow =

;

assert((*nlrowaggr)->quadvars !=

);

assert((*nlrowaggr)->nquadvars > 0);

assert((*nlrowaggr)->nremterms >= 0);

( (*nlrowaggr)->nlinvars > 0 )

( i = 0; i < (*nlrowaggr)->necaggr; ++i )

( i = 0; i < nlrowaggr->

; ++i )

( i = 0; i < nlrowaggr->

; ++i )

( i = 0; i < nlrowaggr->

; ++i )

assert(sepadata !=

);

assert(sepadata !=

);

( sepadata->nlrowaggrs !=

)

( i = sepadata->nnlrowaggrs - 1; i >= 0; --i )

sepadata->nlrowaggrs =

;

sepadata->nnlrowaggrs = 0;

sepadata->nlrowaggrssize = 0;

assert(sepadata !=

);

assert(*sepadata !=

);

( (*sepadata)->lpi !=

)

(*sepadata)->lpisize = 0;

assert(sepadata !=

);

assert(nlrowaggr !=

);

( sepadata->nlrowaggrssize == 0 )

sepadata->nlrowaggrssize = 2;

( sepadata->nlrowaggrssize < sepadata->nnlrowaggrs + 1 )

sepadata->nlrowaggrssize *= 2;

assert(sepadata->nlrowaggrssize >= sepadata->nnlrowaggrs + 1);

sepadata->nlrowaggrs[ sepadata->nnlrowaggrs ] = nlrowaggr;

++(sepadata->nnlrowaggrs);

( i = 0; i < nlrowaggr->

; ++i )

sepadata->maxecsize =

(sepadata->maxecsize, nlrowaggr->

[i]->

);

++(sepadata->nrhsnlrowaggrs);

++(sepadata->nlhsnlrowaggrs);

(ub - val, val - lb) / (ub - lb);

assert(subscip !=

);

assert(forwardarcs !=

);

assert(backwardarcs !=

);

assert(nedges !=

);

assert(sepadata->minaggrsize <= sepadata->maxaggrsize);

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

(

,

, i, i,

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

( qterm1 != qterm )

edgeweight = nodeweights[i] + nodeweights[pos2];

(

,

, i, pos2,

assert(noddcyclearcs < 2*nbilinexprs-1);

oddcyclearcs[noddcyclearcs++] = forwardarcs[i];

oddcyclearcs[noddcyclearcs++] = backwardarcs[i];

assert(noddcyclearcs < 2*nbilinexprs-1);

oddcyclearcs[noddcyclearcs++] = forwardarcs[i];

oddcyclearcs[noddcyclearcs++] = backwardarcs[i];

assert(*

> 0);

( i = 0; i < *

; ++i )

( i = 0; i <

; ++i )

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

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

( qterm1 != qterm )

assert(arcidx == *

);

( i = 0; i <

; ++i )

assert(subscip !=

);

assert(nlrow !=

);

assert(forwardarcs !=

);

assert(backwardarcs !=

);

assert(quadvar2aggr !=

);

assert(nedges !=

);

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

( quadvar2aggr[i] != -1 )

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

( qterm1 != qterm )

( quadvar2aggr[i] != -1 || quadvar2aggr[pos2] != -1 )

assert(subscip !=

);

assert(nlrow !=

);

assert(forwardarcs !=

);

assert(backwardarcs !=

);

assert(quadvar2aggr !=

);

assert(nfoundsofar >= 0);

assert(sol !=

);

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

assert(quadvar2aggr[i] == -1 || quadvar2aggr[i] == nfoundsofar);

quadvar2aggr[i] = nfoundsofar;

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

( qterm1 != qterm )

assert(quadvar2aggr[i] == -1 || quadvar2aggr[i] == nfoundsofar);

assert(quadvar2aggr[pos2] == -1 || quadvar2aggr[pos2] == nfoundsofar);

quadvar2aggr[i] = nfoundsofar;

quadvar2aggr[pos2] = nfoundsofar;

assert(subscip !=

);

assert(aggrleft !=

);

assert(found !=

);

assert(nedges >= 0);

(

(subscip, timelimit, 0.0) )

assert(graph !=

);

assert(nlrow !=

);

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

nodeweight = 100 + (int)(100 * nodeweights[i]);

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

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

( qterm1 != qterm )

* maxcliquenodes;

nmaxcliquenodes;

maxcliqueweight;

assert(graph !=

);

assert(nfoundsofar >= 0);

assert(foundaggr !=

);

assert(foundclique !=

);

*foundaggr =

;

*foundclique =

;

assert(nquadexprs == tcliqueGetNNodes(graph));

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

( quadvar2aggr[i] != -1 )

( status !=

|| nmaxcliquenodes < sepadata->minaggrsize )

*foundclique =

;

aggrsize =

(sepadata->maxaggrsize, nmaxcliquenodes);

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

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

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

( qterm1 != qterm )

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

( degrees[i] == 2 )

( noddcycleedges == 0 || (aggrsize == 3 && noddcycleedges == 2) || (aggrsize == 4 && ntwodegrees == 4) )

*foundaggr =

;

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

quadvar2aggr[ maxcliquenodes[i] ] = *foundaggr ? nfoundsofar : -2;

(

,

, *foundaggr ?

:

, maxcliquenodes[i]);

( cliquemap !=

)

assert(subscip !=

);

assert(quadvar2aggr !=

);

assert(nfound !=

);

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

quadvar2aggr[i] = -1;

assert(nedges >= 0);

( nedges < sepadata->minaggrsize )

( timelimit <= 0.0 )

( graph ==

)

&foundaggr, &foundclique),

(&graph) );

assert(foundclique);

(

,

);

( nunsucces >= sepadata->maxstallrounds && *nfound == 0 )

(

,

, nunsucces);

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

( graph !=

)

( i = 0; i <

; ++i )

retcode =

(

, subscip, sepadata, nlrow, sol, rhsaggr, quadvar2aggr, nfound);

ninterestingnodes;

assert(rhscandidate !=

);

assert(lhscandidate !=

);

*rhscandidate =

;

*lhscandidate =

;

takerow = nquadvars >= sepadata->minaggrsize;

*rhscandidate =

;

*lhscandidate =

;

*rhscandidate =

;

*lhscandidate =

;

ninterestingnodes = 0;

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

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

( qterm1 != qterm )

( degrees[i] == 2 )

++ninterestingnodes;

( degrees[pos2] == 2 )

++ninterestingnodes;

(

,

, nposedges + nnegedges);

( nposedges + nnegedges > sepadata->maxbilinterms || nposedges + nnegedges < sepadata->minaggrsize

|| ninterestingnodes < sepadata->minaggrsize )

*rhscandidate =

;

*lhscandidate =

;

( nposedges == 0 || (nposedges + nnegedges == 3 && (nposedges % 2) == 0) )

*rhscandidate =

;

( nnegedges == 0 || (nposedges + nnegedges == 3 && (nnegedges % 2) == 0) )

*lhscandidate =

;

assert(nlrow !=

);

assert(sepadata !=

);

(

,

);

(

,

, rhscandidate, lhscandidate);

( !rhscandidate && !lhscandidate )

assert(nlrow !=

);

assert(nlrow !=

);

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

ncorner;

assert(ecaggr !=

);

assert(fvals !=

);

assert(facet !=

);

val = facet[ecaggr->

];

( i = 0; i < (

) ecaggr->

; ++i )

maxviolation =

(val - fvals[0], maxviolation);

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

gray = i ^ (i >> 1);

( (diff >>= 1) != 0 )

maxviolation =

(val - fvals[gray], maxviolation);

(

,

, maxviolation);

facet[ecaggr->

] -= maxviolation;

assert(sepadata !=

);

assert(sepadata->nnlrowaggrs > 0);

( sepadata->lpi !=

&& sepadata->lpisize >= sepadata->maxecsize )

( sepadata->lpi !=

)

sepadata->lpi =

;

assert(sepadata->lpi ==

);

sepadata->lpisize = sepadata->maxecsize;

nrows = sepadata->maxecsize + 1;

nnonz = (ncols * (nrows + 1)) / 2;

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

( (

& i) != 0 )

(

,

, nrows - 1, i, k);

assert(nrows <= ncols);

assert(ecaggr !=

);

( i = 0; i < ecaggr->

; ++i )

assert(idx1 >= 0 && idx1 < ecaggr->nvars);

assert(idx2 >= 0 && idx2 < ecaggr->nvars);

val += coef * bound1 * bound2;

val =

(val, ub);

val =

(val, lb);

val = (val - lb) / (ub - lb);

assert(val >= 0.0 && val <= 1.0);

assert(sepadata !=

);

assert(ecaggr !=

);

assert(facet !=

);

assert(facetval !=

);

assert(success !=

);

assert(ecaggr->

<= sepadata->maxecsize);

assert(sepadata->lpi !=

);

assert(sepadata->lpisize >= ecaggr->

);

assert(ncorner <= ncols);

assert(ecaggr->

+ 1 <= nrows);

assert(nrows <= ncols);

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

fvals[i] = i < ncorner ?

(ecaggr, i) : 0.0;

ub[i] = i < ncorner ? 1.0 : 0.0;

(

,

, i, lb[i], ub[i], fvals[i]);

perturbation = 0.001;

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

( i < ecaggr->nvars )

= ecaggr->

[i];

assert(

!=

);

side[i] += side[i] > perturbation ? -perturbation : perturbation;

perturbation /= 1.2;

side[i] = (i == nrows - 1) ? 1.0 : 0.0;

( ecaggr->

+ 1 == ncols )

( i = 0; i < ecaggr->

; ++i )

facet[i] = dualsol[i];

facet[ecaggr->

] = dualsol[nrows - 1];

( i = 0; i < ecaggr->

; ++i )

( i = 0; i < ecaggr->

; ++i )

facet[ecaggr->

] -= (facet[i] * varlb) / (varub - varlb);

facet[i] = facet[i] / (varub - varlb);

*facetval += facet[ecaggr->

];

assert(cut !=

);

assert(facet !=

);

assert(vars !=

);

assert(cutconstant !=

);

assert(cutactivity !=

);

assert(success !=

);

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

*cutconstant += facet[nvars];

*cutactivity += facet[nvars];

assert(cut !=

);

assert(

!=

);

assert(cutconstant !=

);

assert(cutactivity !=

);

assert(success !=

);

*cutconstant += activity;

*cutactivity += activity;

assert(cut !=

);

assert(

!=

);

assert(

!=

);

assert(cutconstant !=

);

assert(cutactivity !=

);

assert(success !=

);

*cutactivity += lincoef * refpoint + linconst;

*cutconstant += linconst;

*cutactivity += lincoefx * refpointx + lincoefy * refpointy + linconst;

*cutconstant += linconst;

assert(separated !=

);

assert(cutoff !=

);

assert(nlrowaggr->

> 0);

*separated =

;

sepadata->dynamiccuts) );

cutconstant = nlrowaggr->

;

bestfacetsize = sepadata->maxaggrsize + 1;

( i = 0; i < nlrowaggr->

; ++i )

ecaggr = nlrowaggr->

[i];

assert(ecaggr !=

);

found ?

:

);

printFacet(

, ecaggr->

, ecaggr->

, bestfacet, bestfacetval);

( i = 0; i < nlrowaggr->

; ++i )

assert(

!=

);

assert(

!=

);

( i = 0; i < nlrowaggr->

; ++i )

assert(

!=

);

(

,

, cutactivity, nlrowaggr->

);

(

(

, cutactivity - nlrowaggr->

, sepadata->minviolation) )

( !(*cutoff) && !islocalcut )

assert(nlrowaggr !=

);

( i = 0; i < nlrowaggr->

; ++i )

assert(var !=

);

(

,

);

(

,

);

( sepadata->nnlrowaggrs == 0 )

nmaxcuts = depth == 0 ? sepadata->maxsepacutsroot : sepadata->maxsepacuts;

( i = 0; i < sepadata->nnlrowaggrs && ncuts < nmaxcuts && !

(

); ++i )

nlrowaggr = sepadata->nlrowaggrs[i];

assert(nlrowaggr !=

);

(

,

, i);

(

,

, separated ?

:

, cutoff ?

:

);

assert(sepa !=

);

assert(sepadata !=

);

assert(sepadata !=

);

sepadata->searchedforaggr =

;

assert(sepadata !=

);

( sepadata->maxaggrsize < sepadata->minaggrsize )

( sepadata->maxdepth >= 0 && depth > sepadata->maxdepth )

( (depth == 0 && sepadata->maxroundsroot >= 0 && ncalls >= sepadata->maxroundsroot)

|| (depth > 0 && sepadata->maxrounds >= 0 && ncalls >= sepadata->maxrounds) )

( !sepadata->searchedforaggr )

sepadata->searchedforaggr =

;

assert(sepa !=

);

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

Constraint handler for XOR constraints, .

#define SCIP_CALL_TERMINATE(retcode, x, TERM)

#define SCIP_CALL_FINALLY(x, y)

void SCIPaddSquareLinearization(SCIP *scip, SCIP_Real sqrcoef, SCIP_Real refpoint, SCIP_Bool isint, SCIP_Real *lincoef, SCIP_Real *linconstant, SCIP_Bool *success)

void SCIPaddSquareSecant(SCIP *scip, SCIP_Real sqrcoef, SCIP_Real lb, SCIP_Real ub, SCIP_Real *lincoef, SCIP_Real *linconstant, SCIP_Bool *success)

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

SCIP_RETCODE SCIPcreateConsBasicXor(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_Bool rhs, int nvars, SCIP_VAR **vars)

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_Bool SCIPisStopped(SCIP *scip)

SCIP_RETCODE SCIPfree(SCIP **scip)

SCIP_RETCODE SCIPcreate(SCIP **scip)

SCIP_STATUS SCIPgetStatus(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

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

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

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

SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)

SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)

SCIP_RETCODE SCIPlpiAddRows(SCIP_LPI *lpi, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)

SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)

SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)

SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)

SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiAddCols(SCIP_LPI *lpi, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)

SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)

SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)

SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)

SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)

#define SCIPdebugMsgPrint

SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)

void SCIPaddBilinMcCormick(SCIP *scip, SCIP_Real bilincoef, SCIP_Real lbx, SCIP_Real ubx, SCIP_Real refpointx, SCIP_Real lby, SCIP_Real uby, SCIP_Real refpointy, SCIP_Bool overestimate, SCIP_Real *lincoefx, SCIP_Real *lincoefy, SCIP_Real *linconstant, SCIP_Bool *success)

SCIP_RETCODE SCIPaddIntParam(SCIP *scip, 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_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)

SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

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

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

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

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

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

SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)

SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)

SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)

SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)

void SCIPexprGetQuadraticBilinTerm(SCIP_EXPR *expr, int termidx, SCIP_EXPR **expr1, SCIP_EXPR **expr2, SCIP_Real *coef, int *pos2, SCIP_EXPR **prodexpr)

SCIP_Bool SCIPexprAreQuadraticExprsVariables(SCIP_EXPR *expr)

void SCIPexprGetQuadraticData(SCIP_EXPR *expr, SCIP_Real *constant, int *nlinexprs, SCIP_EXPR ***linexprs, SCIP_Real **lincoefs, int *nquadexprs, int *nbilinexprs, SCIP_Real **eigenvalues, SCIP_Real **eigenvectors)

SCIP_Bool SCIPisExprVar(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPcheckExprQuadratic(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool *isquadratic)

SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)

void SCIPexprGetQuadraticQuadTerm(SCIP_EXPR *quadexpr, int termidx, SCIP_EXPR **expr, SCIP_Real *lincoef, SCIP_Real *sqrcoef, int *nadjbilin, int **adjbilin, SCIP_EXPR **sqrexpr)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

#define SCIPensureBlockMemoryArray(scip, ptr, arraysizeptr, minsize)

#define SCIPallocClearBufferArray(scip, ptr, num)

int SCIPcalcMemGrowSize(SCIP *scip, int 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_Bool SCIPisNLPConstructed(SCIP *scip)

int SCIPgetNNLPNlRows(SCIP *scip)

SCIP_NLROW ** SCIPgetNLPNlRows(SCIP *scip)

SCIP_Real SCIPnlrowGetRhs(SCIP_NLROW *nlrow)

SCIP_Real SCIPnlrowGetLhs(SCIP_NLROW *nlrow)

int SCIPnlrowGetNLinearVars(SCIP_NLROW *nlrow)

SCIP_VAR ** SCIPnlrowGetLinearVars(SCIP_NLROW *nlrow)

SCIP_Real SCIPnlrowGetConstant(SCIP_NLROW *nlrow)

SCIP_EXPR * SCIPnlrowGetExpr(SCIP_NLROW *nlrow)

SCIP_Bool SCIPnlrowIsInNLP(SCIP_NLROW *nlrow)

SCIP_Real * SCIPnlrowGetLinearCoefs(SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPprintNlRow(SCIP *scip, SCIP_NLROW *nlrow, FILE *file)

SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)

SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)

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)

const char * SCIProwGetName(SCIP_ROW *row)

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)

int SCIProwGetRank(SCIP_ROW *row)

SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)

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

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 SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))

SCIP_RETCODE SCIPsetSepaExitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXITSOL((*sepaexitsol)))

SCIP_SEPADATA * SCIPsepaGetData(SCIP_SEPA *sepa)

void SCIPsepaSetData(SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata)

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

SCIP_SOL * SCIPgetBestSol(SCIP *scip)

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

int SCIPgetNSols(SCIP *scip)

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

SCIP_RETCODE SCIPfreeTransform(SCIP *scip)

SCIP_RETCODE SCIPsolve(SCIP *scip)

SCIP_Real SCIPgetSolvingTime(SCIP *scip)

SCIP_Real SCIPgetTotalTime(SCIP *scip)

SCIP_Real SCIPinfinity(SCIP *scip)

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

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

SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisNegative(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)

int SCIPgetDepth(SCIP *scip)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

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

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

int SCIPvarGetIndex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

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

SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbGlobal(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 SCIPincludeSepaEccuts(SCIP *scip)

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

#define BMSclearMemory(ptr)

#define BMSclearMemoryArray(ptr, num)

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

internal methods for NLP management

#define SCIPstatisticMessage

SCIP_RETCODE SCIPincludeDefaultPlugins(SCIP *scip)

static SCIP_RETCODE doSeachEcAggr(SCIP *scip, SCIP *subscip, SCIP_SEPADATA *sepadata, SCIP_NLROW *nlrow, SCIP_SOL *sol, SCIP_Bool rhsaggr, int *quadvar2aggr, int *nfound)

static SCIP_RETCODE ecaggrAddBilinTerm(SCIP *scip, SCIP_ECAGGR *ecaggr, SCIP_VAR *x, SCIP_VAR *y, SCIP_Real coef)

static SCIP_RETCODE sepadataCreate(SCIP *scip, SCIP_SEPADATA **sepadata)

static SCIP_RETCODE searchEcAggrWithMIP(SCIP *subscip, SCIP_Real timelimit, int nedges, SCIP_Bool *aggrleft, SCIP_Bool *found)

static SCIP_RETCODE nlrowaggrCreate(SCIP *scip, SCIP_NLROW *nlrow, SCIP_NLROWAGGR **nlrowaggr, int *quadvar2aggr, int nfound, SCIP_Bool rhsaggr)

static SCIP_DECL_SEPAFREE(sepaFreeEccuts)

static SCIP_RETCODE ecaggrAddQuadvar(SCIP_ECAGGR *ecaggr, SCIP_VAR *x)

static SCIP_Real transformValue(SCIP *scip, SCIP_Real lb, SCIP_Real ub, SCIP_Real val)

#define CLIQUE_MAXFIRSTNODEWEIGHT

static SCIP_RETCODE separateCuts(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata, int depth, SCIP_SOL *sol, SCIP_RESULT *result)

#define DEFAULT_DYNAMICCUTS

static SCIP_RETCODE addFacetToCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Real *facet, SCIP_VAR **vars, int nvars, SCIP_Real *cutconstant, SCIP_Real *cutactivity, SCIP_Bool *success)

static SCIP_RETCODE sepadataAddNlrowaggr(SCIP *scip, SCIP_SEPADATA *sepadata, SCIP_NLROWAGGR *nlrowaggr)

static SCIP_RETCODE findAndStoreEcAggregations(SCIP *scip, SCIP_SEPADATA *sepadata, SCIP_NLROW *nlrow, SCIP_SOL *sol)

static SCIP_RETCODE nlrowaggrAddLinearTerm(SCIP *scip, SCIP_NLROWAGGR *nlrowaggr, SCIP_VAR *linvar, SCIP_Real lincoef)

#define DEFAULT_MAXROUNDSROOT

static SCIP_RETCODE updateMIP(SCIP *subscip, SCIP_NLROW *nlrow, SCIP_VAR **forwardarcs, SCIP_VAR **backwardarcs, int *quadvar2aggr, int *nedges)

static SCIP_RETCODE searchEcAggr(SCIP *scip, SCIP_SEPADATA *sepadata, SCIP_NLROW *nlrow, SCIP_SOL *sol, SCIP_Bool rhsaggr, int *quadvar2aggr, int *nfound)

static SCIP_RETCODE nlrowaggrAddQuadraticVar(SCIP *scip, SCIP_NLROWAGGR *nlrowaggr, SCIP_VAR *quadvar)

static SCIP_RETCODE addBilinearTermToCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_VAR *x, SCIP_VAR *y, SCIP_Real coeff, SCIP_Real *cutconstant, SCIP_Real *cutactivity, SCIP_Bool *success)

static SCIP_Bool isPossibleToComputeCut(SCIP *scip, SCIP_SOL *sol, SCIP_NLROWAGGR *nlrowaggr)

static SCIP_Real phi(SCIP *scip, SCIP_Real val, SCIP_Real lb, SCIP_Real ub)

#define DEFAULT_MINVIOLATION

static SCIP_RETCODE sepadataFreeNlrows(SCIP *scip, SCIP_SEPADATA *sepadata)

#define CLIQUE_BACKTRACKFREQ

#define CLIQUE_MAXNTREENODES

static SCIP_RETCODE nlrowaggrFree(SCIP *scip, SCIP_NLROWAGGR **nlrowaggr)

static SCIP_RETCODE nlrowaggrAddRemBilinTerm(SCIP_NLROWAGGR *nlrowaggr, SCIP_VAR *x, SCIP_VAR *y, SCIP_Real coef)

static SCIP_RETCODE addLinearTermToCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_VAR *x, SCIP_Real coeff, SCIP_Real *cutconstant, SCIP_Real *cutactivity, SCIP_Bool *success)

static SCIP_RETCODE storeAggrFromMIP(SCIP *subscip, SCIP_NLROW *nlrow, SCIP_VAR **forwardarcs, SCIP_VAR **backwardarcs, int *quadvar2aggr, int nfoundsofar)

static SCIP_DECL_SEPAEXITSOL(sepaExitsolEccuts)

#define DEFAULT_MAXSEPACUTSROOT

static SCIP_DECL_SEPACOPY(sepaCopyEccuts)

static SCIP_DECL_SEPAEXECLP(sepaExeclpEccuts)

static SCIP_RETCODE computeCut(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata, SCIP_NLROWAGGR *nlrowaggr, SCIP_SOL *sol, SCIP_Bool *separated, SCIP_Bool *cutoff)

static SCIP_RETCODE sepadataFree(SCIP *scip, SCIP_SEPADATA **sepadata)

#define DEFAULT_MAXAGGRSIZE

static SCIP_RETCODE createTcliqueGraph(SCIP_NLROW *nlrow, TCLIQUE_GRAPH **graph, SCIP_Real *nodeweights)

static SCIP_RETCODE ecaggrFree(SCIP *scip, SCIP_ECAGGR **ecaggr)

#define SEPA_MAXBOUNDDIST

static SCIP_RETCODE createLP(SCIP *scip, SCIP_SEPADATA *sepadata)

#define DEFAULT_MINAGGRSIZE

static SCIP_RETCODE computeConvexEnvelopeFacet(SCIP *scip, SCIP_SEPADATA *sepadata, SCIP_SOL *sol, SCIP_ECAGGR *ecaggr, SCIP_Real *facet, SCIP_Real *facetval, SCIP_Bool *success)

static SCIP_RETCODE createMIP(SCIP *scip, SCIP *subscip, SCIP_SEPADATA *sepadata, SCIP_NLROW *nlrow, SCIP_Bool rhsaggr, SCIP_VAR **forwardarcs, SCIP_VAR **backwardarcs, SCIP_Real *nodeweights, int *nedges, int *narcs)

static SCIP_Bool checkRikun(SCIP *scip, SCIP_ECAGGR *ecaggr, SCIP_Real *fvals, SCIP_Real *facet)

#define DEFAULT_MAXSEPACUTS

#define DEFAULT_MAXSTALLROUNDS

#define SUBSCIP_NODELIMIT

#define DEFAULT_MAXBILINTERMS

#define DEFAULT_MAXROUNDS

static SCIP_RETCODE searchEcAggrWithCliques(SCIP *scip, TCLIQUE_GRAPH *graph, SCIP_SEPADATA *sepadata, SCIP_NLROW *nlrow, int *quadvar2aggr, int nfoundsofar, SCIP_Bool rhsaggr, SCIP_Bool *foundaggr, SCIP_Bool *foundclique)

static SCIP_RETCODE ecaggrCreateEmpty(SCIP *scip, SCIP_ECAGGR **ecaggr, int nquadvars, int nquadterms)

static SCIP_Real evalCorner(SCIP_ECAGGR *ecaggr, int k)

#define DEFAULT_CUTMAXRANGE

static SCIP_RETCODE isCandidate(SCIP *scip, SCIP_SEPADATA *sepadata, SCIP_NLROW *nlrow, SCIP_Bool *rhscandidate, SCIP_Bool *lhscandidate)

static const int poweroftwo[]

static SCIP_RETCODE nlrowaggrStoreLinearTerms(SCIP *scip, SCIP_NLROWAGGR *nlrowaggr, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nlinvars)

edge concave cut separator

void tcliqueChangeWeight(TCLIQUE_GRAPH *tcliquegraph, int node, TCLIQUE_WEIGHT weight)

void tcliqueFree(TCLIQUE_GRAPH **tcliquegraph)

enum TCLIQUE_Status TCLIQUE_STATUS

void tcliqueMaxClique(TCLIQUE_GETNNODES((*getnnodes)), TCLIQUE_GETWEIGHTS((*getweights)), TCLIQUE_ISEDGE((*isedge)), TCLIQUE_SELECTADJNODES((*selectadjnodes)), TCLIQUE_GRAPH *tcliquegraph, TCLIQUE_NEWSOL((*newsol)), TCLIQUE_DATA *tcliquedata, int *maxcliquenodes, int *nmaxcliquenodes, TCLIQUE_WEIGHT *maxcliqueweight, TCLIQUE_WEIGHT maxfirstnodeweight, TCLIQUE_WEIGHT minweight, int maxntreenodes, int backtrackfreq, int maxnzeroextensions, int fixednode, int *ntreenodes, TCLIQUE_STATUS *status)

TCLIQUE_Bool tcliqueFlush(TCLIQUE_GRAPH *tcliquegraph)

struct TCLIQUE_Graph TCLIQUE_GRAPH

TCLIQUE_Bool tcliqueCreate(TCLIQUE_GRAPH **tcliquegraph)

TCLIQUE_Bool tcliqueAddNode(TCLIQUE_GRAPH *tcliquegraph, int node, TCLIQUE_WEIGHT weight)

TCLIQUE_Bool tcliqueAddEdge(TCLIQUE_GRAPH *tcliquegraph, int node1, int node2)

@ SCIP_PARAMSETTING_AGGRESSIVE

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

struct SCIP_SepaData SCIP_SEPADATA

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