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

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

SCIP Doxygen Documentation: sepa_interminor.c Source File

assert(sepadata !=

);

assert(auxvarxik !=

);

assert(auxvarxil !=

);

assert(auxvarxjk !=

);

assert(auxvarxjl !=

);

assert(auxvarxik != auxvarxil);

assert(auxvarxjk != auxvarxjl);

( sepadata->minorssize < 4 * (sepadata->nminors + 1) )

assert(newsize >= 4 * (sepadata->nminors + 1));

sepadata->minorssize = newsize;

sepadata->minors[4 * sepadata->nminors] = auxvarxik;

sepadata->minors[4 * sepadata->nminors + 1] = auxvarxil;

sepadata->minors[4 * sepadata->nminors + 2] = auxvarxjk;

sepadata->minors[4 * sepadata->nminors + 3] = auxvarxjl;

sepadata->isdiagonal[4 * sepadata->nminors] = isauxvarxikdiag;

sepadata->isdiagonal[4 * sepadata->nminors + 1] = isauxvarxildiag;

sepadata->isdiagonal[4 * sepadata->nminors + 2] = isauxvarxjkdiag;

sepadata->isdiagonal[4 * sepadata->nminors + 3] = isauxvarxjldiag;

++(sepadata->nminors);

assert(sepadata !=

);

( i = 0; i < 4 * sepadata->nminors; ++i )

assert(sepadata->minors[i] !=

);

sepadata->nminors = 0;

sepadata->minorssize = 0;

assert(auxvarxik !=

);

assert(auxvarxil !=

);

assert(auxvarxjk !=

);

assert(auxvarxjl !=

);

*auxvarxik = sepadata->minors[4 * idx];

*auxvarxil = sepadata->minors[4 * idx + 1];

*auxvarxjk = sepadata->minors[4 * idx + 2];

*auxvarxjl = sepadata->minors[4 * idx + 3];

*isauxvarxikdiag = sepadata->isdiagonal[4 * idx];

*isauxvarxildiag = sepadata->isdiagonal[4 * idx + 1];

*isauxvarxjkdiag = sepadata->isdiagonal[4 * idx + 2];

*isauxvarxjldiag = sepadata->isdiagonal[4 * idx + 3];

assert(newsize > arr->

+ 1);

* rowvars =

;

assert(sepadata !=

);

( sepadata->detectedminors )

assert(sepadata->minors ==

);

assert(sepadata->nminors == 0);

sepadata->detectedminors =

;

assert(cons !=

);

assert(root !=

);

( auxvar ==

)

assert(children[0] !=

);

assert(quadvar !=

);

assert(children[0] !=

);

assert(children[1] !=

);

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

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

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

( p = 0; p < ninter - 1; ++p )

( q = p + 1; q < ninter; ++q )

isauxvarikdiag =

;

isauxvarildiag =

;

isauxvarjkdiag =

;

isauxvarjldiag =

;

isauxvarikdiag, isauxvarildiag, isauxvarjkdiag, isauxvarjldiag) );

(

,

, sepadata->nminors);

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

( basisind[i] >= 0 )

map[basisind[i]] = i;

eigenvectors[16] = {1.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 1.0, -1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0};

eigenvalues[4] = {0.5, 0.5, -0.5, -0.5};

eigencoef = 0.7071067811865475244008443621048490;

memset(coefs, 0, 5 *

(

));

memset(coefs4b, 0, 5 *

(

));

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

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

vdotray += eigencoef * eigenvectors[4 * i + j] * ray[j];

vzlp += eigencoef * eigenvectors[4 * i + j] *

(vars[j]);

( eigenvalues[i] > 0 )

*d += eigenvalues[i] * vzlp * vdotray;

*e += eigenvalues[i] *

( vzlp );

norm1 += eigenvalues[i] * (1 -

( ad[posidx] )) *

( vzlp );

norm2 += sqrt( eigenvalues[i] ) * ad[posidx] * vzlp;

*

-= eigenvalues[i] *

( vdotray );

*

-= 2.0 * eigenvalues[i] * vzlp * vdotray;

*c -= eigenvalues[i] *

( vzlp );

coefs4b[0] -= eigenvalues[i] * (1 -

( ad[negidx] )) *

( vdotray );

coefs4b[1] -= 2.0 * eigenvalues[i] * (1 -

( ad[negidx] )) * vzlp * vdotray;

coefs4b[2] -= eigenvalues[i] * (1 -

( ad[negidx] )) *

( vzlp );

coefs4b[3] += sqrt( -eigenvalues[i] ) * ad[negidx] * vdotray;

coefs4b[4] += sqrt( -eigenvalues[i] ) * ad[negidx] * vzlp;

( sqrt( *c ) - sqrt( *e ) >= 0.0 )

assert(sqrt( *c ) - sqrt( *e ) < 1e-6);

coefscondition[0] = norm2 / sqrt( *e );

coefscondition[1] = coefs4b[3];

coefscondition[2] = coefs4b[4];

coefs4b[0] *= norm1 / *e;

coefs4b[1] *= norm1 / *e;

coefs4b[2] *= norm1 / *e;

coefs4b[3] *= norm2 / sqrt( *e );

coefs4b[4] *= norm2 / sqrt( *e );

coefs4b[3] += *d / sqrt( *e );

coefs4b[4] += sqrt( *e );

assert( sqrt( coefs4b[2] ) - coefs4b[4] < 0.0 );

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

absval =

(coefs[i]);

( absval != 0.0 && absval < min )

printf(

, max / min);

assert(sqrt( *c ) - *e < 0);

(

,

,

, coefs[0], coefs[1], coefs[2], coefs[3], coefs[4]);

sqrt(

* t * t +

* t + c ) - ( d * t + e );

curr = (lb + ub) / 2.0;

printf(

, i, lb, ub, curr, phival,

(

, lb,

,

, c, d, e));

(coefscondition[0] * sqrt( coefs[0] *

( tsol ) + coefs[1] * tsol + coefs[2] ) + coefscondition[1] *

tsol + coefscondition[2]) <= 0.0;

( sqrt(

) <= d )

e, -(c - e * e), bounds);

printf(

, sol,

(sol,

,

, c, d, e));

printf(

);

printf(

,

(

, sol,

,

, c, d, e));

assert(coefs !=

);

assert(coefs4b !=

);

assert(coefscondition !=

);

(

(sol, coefs, coefscondition) )

(sol, sol4b);

assert(col !=

);

assert(row !=

);

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

* basicvarpos2tableaurow,

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

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

israynonzero =

;

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

( tableaurows[v] !=

)

rays[(*nrays) * 4 + v] = factor * (

(

, tableaurows[v][i]) ? 0.0 : tableaurows[v][i]);

rays[(*nrays) * 4 + v] = -factor;

rays[(*nrays) * 4 + v] = 0.0;

israynonzero = israynonzero || (rays[(*nrays) * 4 + v] != 0.0);

( ! israynonzero )

( *success ==

)

interpoints[*nrays] = interpoint;

rayslppos[*nrays] = i;

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

israynonzero =

;

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

( tableaurows[v] !=

)

rays[(*nrays) * 4 + v] = factor * (

(

, tableaurows[v][idx]) ? 0.0 : tableaurows[v][idx]);

rays[(*nrays) * 4 + v] = 0.0;

israynonzero = israynonzero || (rays[(*nrays) * 4 + v] != 0.0);

( ! israynonzero )

( *success ==

)

interpoints[*nrays] = interpoint;

rayslppos[*nrays] = -i - 1;

-cutcoef, row, success) );

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

*coef = ray1[i] / ray2[i];

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

currentrho = coef * interpoints[i];

alpha = (lb + ub) / 2.0;

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

newray[k] = alpha * rays[4 * i + k] - (1 - alpha) * rays[4 * idx + k];

currentrho = (alpha - 1) * interpoints[i] / alpha;

( currentrho < *rho )

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

(

(

, rays, nrays, i, interpoints, vars, &rho, usebounds, ad, success) );

lppos = rayslppos[i];

-cutcoef, rows[lppos], success) );

cutcoef, cols[lppos]) );

* basicvarpos2tableaurow,

* vars[4] = {xik, xjl, xil, xjk};

( sepadata->usebounds )

(

(

, vars, tableaurows, rowprep, rays, &nrays, rayslppos, interpoints, sepadata->usebounds, ad, &success) );

(

(

, vars, tableaurows, rowprep, rays, &nrays, rayslppos, interpoints, sepadata->usebounds, ad, &success) );

( sepadata->usestrengthening )

* basicvarpos2tableaurow =

;

assert(sepa !=

);

assert(result !=

);

assert(sepadata !=

);

( sepadata->nminors == 0 )

( i = 0; i < sepadata->nminors && (*result !=

); ++i )

(

(sepadata, i, &auxvarxik, &auxvarxil, &auxvarxjk, &auxvarxjl, &isauxvarxikdiag,

&isauxvarxildiag, &isauxvarxjkdiag, &isauxvarxjldiag) );

det = solxik * solxjl - solxil * solxjk;

( basicvarpos2tableaurow ==

)

assert(tableau !=

);

&isauxvarxildiag, &isauxvarxjkdiag, &isauxvarxjldiag, basicvarpos2tableaurow, tableau, result) );

&isauxvarxikdiag, &isauxvarxjldiag, &isauxvarxjkdiag, basicvarpos2tableaurow, tableau, result) );

( basicvarpos2tableaurow ==

)

( entry !=

)

assert(sepa !=

);

assert(sepadata !=

);

assert(sepadata->minors ==

);

assert(sepadata->nminors == 0);

assert(sepadata->minorssize == 0);

assert(sepadata !=

);

assert(sepadata->randnumgen ==

);

assert(sepadata !=

);

assert(sepadata->randnumgen !=

);

assert(sepadata !=

);

assert(sepadata !=

);

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

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

sepaExeclpMinor,

,

assert(sepa !=

);

,

,

,

,

,

,

,

constraint handler for nonlinear constraints specified by algebraic expressions

#define SCIPquadprecSqrtQ(r, a)

#define SCIPquadprecProdDD(r, a, b)

#define SCIPquadprecProdQD(r, a, b)

#define SCIPquadprecSumQD(r, a, b)

#define QUAD_ASSIGN(a, constant)

#define SCIPquadprecSquareD(r, a)

#define SCIPquadprecSumQQ(r, a, b)

#define SCIP_INTERVAL_INFINITY

private functions to work with algebraic expressions

power and signed power expression handlers

product expression handler

variable expression handler

void SCIPcomputeArraysIntersectionInt(int *array1, int narray1, int *array2, int narray2, int *intersectarray, int *nintersectarray)

SCIP_VAR * SCIPgetExprAuxVarNonlinear(SCIP_EXPR *expr)

SCIP_EXPR * SCIPgetExprNonlinear(SCIP_CONS *cons)

const char * SCIPgetProbName(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

void * SCIPhashmapEntryGetImage(SCIP_HASHMAPENTRY *entry)

void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)

int SCIPhashmapGetNEntries(SCIP_HASHMAP *hashmap)

SCIP_HASHMAPENTRY * SCIPhashmapGetEntry(SCIP_HASHMAP *hashmap, int entryidx)

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

SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)

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

SCIP_Bool SCIPisIpoptAvailableIpopt(void)

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 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 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)

int SCIPcolGetLPPos(SCIP_COL *col)

SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)

SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)

SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)

int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)

SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)

SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)

const char * SCIPconsGetName(SCIP_CONS *cons)

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

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

int SCIPexprGetNChildren(SCIP_EXPR *expr)

SCIP_Real SCIPgetExponentExprPow(SCIP_EXPR *expr)

SCIP_Bool SCIPisExprProduct(SCIP *scip, SCIP_EXPR *expr)

SCIP_Bool SCIPexpriterIsEnd(SCIP_EXPRITER *iterator)

SCIP_EXPR * SCIPexpriterRestartDFS(SCIP_EXPRITER *iterator, SCIP_EXPR *expr)

SCIP_RETCODE SCIPcreateExpriter(SCIP *scip, SCIP_EXPRITER **iterator)

SCIP_Bool SCIPisExprPower(SCIP *scip, SCIP_EXPR *expr)

SCIP_EXPR * SCIPexpriterGetNext(SCIP_EXPRITER *iterator)

SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)

void SCIPfreeExpriter(SCIP_EXPRITER **iterator)

SCIP_RETCODE SCIPexpriterInit(SCIP_EXPRITER *iterator, SCIP_EXPR *expr, SCIP_EXPRITER_TYPE type, SCIP_Bool allowrevisit)

SCIP_Real SCIPintervalGetInf(SCIP_INTERVAL interval)

SCIP_Bool SCIPintervalIsEmpty(SCIP_Real infinity, SCIP_INTERVAL operand)

void SCIPintervalSetBounds(SCIP_INTERVAL *resultant, SCIP_Real inf, SCIP_Real sup)

void SCIPintervalSolveUnivariateQuadExpressionPositiveAllScalar(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_Real sqrcoeff, SCIP_Real lincoeff, SCIP_Real rhs, SCIP_INTERVAL xbnds)

SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)

SCIP_ROW ** SCIPgetLPRows(SCIP *scip)

int SCIPgetNLPRows(SCIP *scip)

SCIP_RETCODE SCIPgetLPBInvARow(SCIP *scip, int r, SCIP_Real *binvrow, SCIP_Real *coefs, int *inds, int *ninds)

SCIP_COL ** SCIPgetLPCols(SCIP *scip)

int SCIPgetNLPCols(SCIP *scip)

SCIP_RETCODE SCIPgetLPBInvRow(SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)

#define SCIPfreeBuffer(scip, ptr)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPallocBuffer(scip, ptr)

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

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPfreeBufferArrayNull(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

int SCIProwGetNLPNonz(SCIP_ROW *row)

int SCIProwGetLPPos(SCIP_ROW *row)

SCIP_Real SCIPgetRowActivity(SCIP *scip, SCIP_ROW *row)

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

SCIP_Real SCIProwGetConstant(SCIP_ROW *row)

SCIP_Real * SCIProwGetVals(SCIP_ROW *row)

SCIP_BASESTAT SCIProwGetBasisStatus(SCIP_ROW *row)

SCIP_RETCODE SCIPsetSepaExit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXIT((*sepaexit)))

SCIP_RETCODE SCIPsetSepaInitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINITSOL((*sepainitsol)))

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_RETCODE SCIPsetSepaInit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINIT((*sepainit)))

SCIP_Real SCIPgetTotalTime(SCIP *scip)

SCIP_Real SCIPinfinity(SCIP *scip)

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

SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisHugeValue(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisFeasNegative(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 SCIPisFeasPositive(SCIP *scip, SCIP_Real val)

int SCIPgetDepth(SCIP *scip)

SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

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

SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)

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

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

void SCIPmergeRowprepTerms(SCIP *scip, SCIP_ROWPREP *rowprep)

void SCIProwprepAddConstant(SCIP_ROWPREP *rowprep, SCIP_Real constant)

SCIP_RETCODE SCIPgetRowprepRowSepa(SCIP *scip, SCIP_ROW **row, SCIP_ROWPREP *rowprep, SCIP_SEPA *sepa)

SCIP_RETCODE SCIPaddRowprepTerm(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_VAR *var, SCIP_Real coef)

SCIP_RETCODE SCIPcreateRowprep(SCIP *scip, SCIP_ROWPREP **rowprep, SCIP_SIDETYPE sidetype, SCIP_Bool local)

void SCIProwprepAddSide(SCIP_ROWPREP *rowprep, SCIP_Real side)

SCIP_RETCODE SCIPcleanupRowprep(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Real minviol, SCIP_Real *viol, SCIP_Bool *success)

void SCIPfreeRowprep(SCIP *scip, SCIP_ROWPREP **rowprep)

SCIP_RETCODE SCIPincludeSepaInterminor(SCIP *scip)

void SCIPsortInt(int *intarray, int len)

#define BMSclearMemory(ptr)

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

#define SCIPstatisticMessage

static SCIP_RETCODE insertIndex(SCIP *scip, SCIP_HASHMAP *rowmap, SCIP_VAR *row, SCIP_VAR *col, SCIP_VAR *auxvar, int *rowindices, int *nrows)

static SCIP_Real computeIntersectionPoint(SCIP *scip, SCIP_Bool usebounds, SCIP_Real *coefs, SCIP_Real *coefs4b, SCIP_Real *coefscondition)

#define DEFAULT_USEBOUNDS

static SCIP_DECL_SEPAINIT(sepaInitMinor)

#define DEFAULT_USESTRENGTHENING

static SCIP_RETCODE addRows(SCIP *scip, SCIP_VAR **vars, SCIP_Real **tableaurows, SCIP_ROWPREP *rowprep, SCIP_Real *rays, int *nrays, int *rayslppos, SCIP_Real *interpoints, SCIP_Bool usebounds, SCIP_Real *ad, SCIP_Bool *success)

static SCIP_RETCODE getMinorVars(SCIP_SEPADATA *sepadata, int idx, SCIP_VAR **auxvarxik, SCIP_VAR **auxvarxil, SCIP_VAR **auxvarxjk, SCIP_VAR **auxvarxjl, SCIP_Bool *isauxvarxikdiag, SCIP_Bool *isauxvarxildiag, SCIP_Bool *isauxvarxjkdiag, SCIP_Bool *isauxvarxjldiag)

static SCIP_DECL_SEPAEXECLP(sepaExeclpMinor)

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

static SCIP_RETCODE findRho(SCIP *scip, SCIP_Real *rays, int nrays, int idx, SCIP_Real *interpoints, SCIP_VAR **vars, SCIP_Real *rho, SCIP_Bool usebounds, SCIP_Real *ad, SCIP_Bool *success)

#define DEFAULT_MAXROUNDSROOT

static SCIP_RETCODE getTableauRows(SCIP *scip, SCIP_VAR **vars, int *basicvarpos2tableaurow, SCIP_HASHMAP *tableau, SCIP_Real **tableaurows, SCIP_Bool *success)

static SCIP_DECL_SEPAFREE(sepaFreeMinor)

static SCIP_DECL_SEPACOPY(sepaCopyMinor)

static SCIP_Real isCase4a(SCIP_Real tsol, SCIP_Real *coefs, SCIP_Real *coefscondition)

static SCIP_RETCODE addRowToCut(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_Real cutcoef, SCIP_ROW *row, SCIP_Bool *success)

static SCIP_RETCODE separateDeterminant(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata, SCIP_VAR *xik, SCIP_VAR *xil, SCIP_VAR *xjk, SCIP_VAR *xjl, SCIP_Bool *isxikdiag, SCIP_Bool *isxildiag, SCIP_Bool *isxjkdiag, SCIP_Bool *isxjldiag, int *basicvarpos2tableaurow, SCIP_HASHMAP *tableau, SCIP_RESULT *result)

static SCIP_DECL_SEPAEXITSOL(sepaExitsolMinor)

static SCIP_Real computeRoot(SCIP *scip, SCIP_Real *coefs)

static SCIP_Real evalPhiAtRay(SCIP *scip, SCIP_Real t, SCIP_Real a, SCIP_Real b, SCIP_Real c, SCIP_Real d, SCIP_Real e)

#define DEFAULT_MINCUTVIOL

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

static SCIP_RETCODE sepadataAddMinor(SCIP *scip, SCIP_SEPADATA *sepadata, SCIP_VAR *auxvarxik, SCIP_VAR *auxvarxil, SCIP_VAR *auxvarxjk, SCIP_VAR *auxvarxjl, SCIP_Bool isauxvarxikdiag, SCIP_Bool isauxvarxildiag, SCIP_Bool isauxvarxjkdiag, SCIP_Bool isauxvarxjldiag)

#define SEPA_MAXBOUNDDIST

static SCIP_RETCODE addCols(SCIP *scip, SCIP_VAR **vars, SCIP_Real **tableaurows, SCIP_ROWPREP *rowprep, SCIP_Real *rays, int *nrays, int *rayslppos, SCIP_Real *interpoints, SCIP_Bool usebounds, SCIP_Real *ad, SCIP_Bool *success)

static SCIP_DECL_SEPAEXIT(sepaExitMinor)

static SCIP_DECL_SEPAINITSOL(sepaInitsolMinor)

#define BINSEARCH_MAXITERS

#define DEFAULT_MAXROUNDS

static SCIP_RETCODE computeNegCutcoefs(SCIP *scip, SCIP_VAR **vars, SCIP_Real *rays, int nrays, int *rayslppos, SCIP_Real *interpoints, SCIP_ROWPREP *rowprep, SCIP_Bool usebounds, SCIP_Real *ad, SCIP_Bool *success)

static void doBinarySearch(SCIP *scip, SCIP_Real a, SCIP_Real b, SCIP_Real c, SCIP_Real d, SCIP_Real e, SCIP_Real *sol)

static SCIP_RETCODE addColToCut(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_Real cutcoef, SCIP_COL *col)

static SCIP_RETCODE constructBasicVars2TableauRowMap(SCIP *scip, int *map)

static SCIP_RETCODE computeRestrictionToRay(SCIP *scip, SCIP_Real *ray, SCIP_VAR **vars, SCIP_Real *coefs, SCIP_Real *coefs4b, SCIP_Real *coefscondition, SCIP_Bool usebounds, SCIP_Real *ad, SCIP_Bool *success)

static SCIP_Bool raysAreDependent(SCIP *scip, SCIP_Real *ray1, SCIP_Real *ray2, SCIP_Real *coef)

static SCIP_RETCODE separatePoint(SCIP *scip, SCIP_SEPA *sepa, SCIP_RESULT *result)

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