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

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

SCIP Doxygen Documentation: nlhdlr_default.c Source File

assert(expr !=

);

assert(childvar !=

);

assert(nlhdlr !=

);

assert(expr !=

);

assert(enforcing !=

);

assert(participating !=

);

assert(nlhdlrexprdata !=

);

assert(exprhdlr !=

);

( !*participating )

*enforcing |= *participating;

estimatebelowusesactivity = !isconvex;

estimateaboveusesactivity = !isconcave;

assert(expr !=

);

assert(auxvalue !=

);

assert(expr !=

);

assert(infeasible !=

);

*infeasible =

;

assert(auxvar !=

);

(

,

, i);

( i = 0; i < 2 && !*infeasible; ++i )

( i == 0 && underestimate )

( SCIPcallExprInitestimates(

, expr, childrenbounds,

, coefs, constant, &nreturned) );

( i == 1 && overestimate )

( SCIPcallExprInitestimates(

, expr, childrenbounds,

, coefs, constant, &nreturned) );

( j = 0; j < nreturned && !*infeasible; ++j )

( success && scalefactor == 1.0 && underestimate && overestimate )

assert(expr !=

);

assert(rowpreps !=

);

assert(success !=

);

*addedbranchscores =

;

( c = 0; c < nchildren; ++c )

assert(auxvar !=

);

branchcand[c] =

;

( SCIPcallExprEstimate(

, expr, localbounds, globalbounds, refpoint, overestimate, targetvalue,

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

overestimate ?

:

,

sol !=

?

:

,

( addbranchscores )

assert(violation > 0.0);

( nchildren == 1 )

( c = 0; c < nchildren; ++c )

( *addedbranchscores )

assert(expr !=

);

( !overestimate && !underestimate )

( c = 0; c < nchildren; ++c )

assert(auxvar !=

);

( rnd = (overestimate ? 0 : 1); rnd < (underestimate ? 2 : 1); ++rnd )

( c = 0; c < nchildren; ++c )

branchcand[c] =

;

( SCIPcallExprEstimate(

, expr, bounds, bounds, refpoint, rnd == 0,

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

assert(expr !=

);

( SCIPcallExprInteval(

, expr, interval, intevalvar, intevalvardata) );

assert(expr !=

);

assert(infeasible !=

);

assert(nreductions !=

);

( SCIPcallExprReverseprop(

, expr, bounds, childrenbounds, infeasible) );

infeasible, nreductions) );

assert(targetscip !=

);

assert(sourcenlhdlr !=

);

assert(nlhdlrexprdata !=

);

*nlhdlrexprdata =

;

assert(nlhdlr !=

);

constraint handler for nonlinear constraints specified by algebraic expressions

#define SCIP_INTERVAL_INFINITY

#define SCIP_LONGINT_FORMAT

SCIP_RETCODE SCIPgetExprRelAuxViolationNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_Real auxvalue, SCIP_SOL *sol, SCIP_Real *viol, SCIP_Bool *violunder, SCIP_Bool *violover)

SCIP_VAR * SCIPgetExprAuxVarNonlinear(SCIP_EXPR *expr)

SCIP_RETCODE SCIPtightenExprIntervalNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_INTERVAL newbounds, SCIP_Bool *cutoff, int *ntightenings)

SCIP_RETCODE SCIPaddExprsViolScoreNonlinear(SCIP *scip, SCIP_EXPR **exprs, int nexprs, SCIP_Real violscore, SCIP_SOL *sol, SCIP_Bool *success)

SCIP_RETCODE SCIPregisterExprUsageNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool useauxvar, SCIP_Bool useactivityforprop, SCIP_Bool useactivityforsepabelow, SCIP_Bool useactivityforsepaabove)

SCIP_INTERVAL SCIPgetExprBoundsNonlinear(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPgetExprAbsAuxViolationNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_Real auxvalue, SCIP_SOL *sol, SCIP_Real *viol, SCIP_Bool *violunder, SCIP_Bool *violover)

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

SCIP_RETCODE SCIPincludeNlhdlrDefault(SCIP *scip)

SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)

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

SCIP_RETCODE SCIPsetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx, void *val)

const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)

void SCIPexprhdlrIncrementNDomainReductions(SCIP_EXPRHDLR *exprhdlr, int nreductions)

void SCIPexprhdlrIncrementNBranchings(SCIP_EXPRHDLR *exprhdlr)

SCIP_Bool SCIPexprhdlrHasReverseProp(SCIP_EXPRHDLR *exprhdlr)

SCIP_Bool SCIPexprhdlrHasInitEstimates(SCIP_EXPRHDLR *exprhdlr)

SCIP_Bool SCIPexprhdlrHasEstimate(SCIP_EXPRHDLR *exprhdlr)

SCIP_Bool SCIPexprhdlrHasIntEval(SCIP_EXPRHDLR *exprhdlr)

int SCIPexprGetNChildren(SCIP_EXPR *expr)

SCIP_Bool SCIPisExprSum(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPcallExprEval(SCIP *scip, SCIP_EXPR *expr, SCIP_Real *childrenvalues, SCIP_Real *val)

SCIP_RETCODE SCIPprintExpr(SCIP *scip, SCIP_EXPR *expr, FILE *file)

SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)

SCIP_INTERVAL SCIPexprGetActivity(SCIP_EXPR *expr)

SCIP_RETCODE SCIPevalExprActivity(SCIP *scip, SCIP_EXPR *expr)

SCIP_EXPRHDLR * SCIPexprGetHdlr(SCIP_EXPR *expr)

void SCIPintervalIntersectEps(SCIP_INTERVAL *resultant, SCIP_Real eps, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)

void SCIPintervalIntersect(SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)

SCIP_Bool SCIPintervalIsEmpty(SCIP_Real infinity, SCIP_INTERVAL operand)

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

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

void SCIPnlhdlrSetCopyHdlr(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRCOPYHDLR((*copy)))

void SCIPnlhdlrSetFreeExprData(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRFREEEXPRDATA((*freeexprdata)))

void SCIPnlhdlrSetProp(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRINTEVAL((*inteval)), SCIP_DECL_NLHDLRREVERSEPROP((*reverseprop)))

void SCIPnlhdlrSetSollinearize(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRSOLLINEARIZE((*sollinearize)))

void SCIPnlhdlrSetSepa(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRINITSEPA((*initsepa)), SCIP_DECL_NLHDLRENFO((*enfo)), SCIP_DECL_NLHDLRESTIMATE((*estimate)), SCIP_DECL_NLHDLREXITSEPA((*exitsepa)))

const char * SCIPnlhdlrGetName(SCIP_NLHDLR *nlhdlr)

SCIP_RETCODE SCIPincludeNlhdlrNonlinear(SCIP *scip, SCIP_NLHDLR **nlhdlr, const char *name, const char *desc, int detectpriority, int enfopriority, SCIP_DECL_NLHDLRDETECT((*detect)), SCIP_DECL_NLHDLREVALAUX((*evalaux)), SCIP_NLHDLRDATA *nlhdlrdata)

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

SCIP_RETCODE SCIPchgRowLhs(SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)

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

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

int SCIPsolGetIndex(SCIP_SOL *sol)

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

SCIP_Longint SCIPgetNLPs(SCIP *scip)

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPgetHugeValue(SCIP *scip)

SCIP_Real SCIPepsilon(SCIP *scip)

int SCIPgetDepth(SCIP *scip)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

void SCIProwprepReset(SCIP_ROWPREP *rowprep)

SCIP_RETCODE SCIPcleanupRowprep2(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, SCIP_Real maxcoefbound, SCIP_Bool *success)

SCIP_RETCODE SCIPensureRowprepSize(SCIP *scip, SCIP_ROWPREP *rowprep, int size)

SCIP_Real SCIPscaleupRowprep(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_Real minscaleup, SCIP_Bool *success)

SCIP_Real * SCIProwprepGetCoefs(SCIP_ROWPREP *rowprep)

char * SCIProwprepGetName(SCIP_ROWPREP *rowprep)

void SCIProwprepSetSidetype(SCIP_ROWPREP *rowprep, SCIP_SIDETYPE sidetype)

SCIP_Bool SCIProwprepIsLocal(SCIP_ROWPREP *rowprep)

void SCIPprintRowprepSol(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_SOL *sol, FILE *file)

void SCIProwprepAddConstant(SCIP_ROWPREP *rowprep, SCIP_Real constant)

SCIP_SIDETYPE SCIProwprepGetSidetype(SCIP_ROWPREP *rowprep)

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

SCIP_RETCODE SCIPgetRowprepRowCons(SCIP *scip, SCIP_ROW **row, SCIP_ROWPREP *rowprep, SCIP_CONS *cons)

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

int SCIProwprepGetNVars(SCIP_ROWPREP *rowprep)

void SCIProwprepSetLocal(SCIP_ROWPREP *rowprep, SCIP_Bool islocal)

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

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

#define NLHDLR_DETECTPRIORITY

static SCIP_DECL_NLHDLRSOLLINEARIZE(nlhdlrSollinearizeDefault)

static SCIP_DECL_NLHDLRDETECT(nlhdlrDetectDefault)

static SCIP_DECL_NLHDLRFREEEXPRDATA(nlhdlrFreeExprDataDefault)

#define NLHDLR_ENFOPRIORITY

static SCIP_DECL_NLHDLREVALAUX(nlhdlrEvalAuxDefault)

#define OVERESTIMATEUSESACTIVITY

static SCIP_DECL_NLHDLRINITSEPA(nlhdlrInitSepaDefault)

#define UNDERESTIMATEUSESACTIVITY

#define infty2infty(infty1, infty2, val)

static SCIP_DECL_NLHDLRCOPYHDLR(nlhdlrCopyhdlrDefault)

static SCIP_DECL_NLHDLRESTIMATE(nlhdlrEstimateDefault)

static SCIP_DECL_NLHDLRINTEVAL(nlhdlrIntevalDefault)

static SCIP_RETCODE evalExprInAux(SCIP *scip, SCIP_EXPR *expr, SCIP_Real *val, SCIP_SOL *sol)

static SCIP_DECL_NLHDLRREVERSEPROP(nlhdlrReversepropDefault)

default nonlinear handler that calls expression handler methods

public functions of nonlinear handlers of nonlinear constraints

#define SCIP_EXPR_MAXINITESTIMATES

#define SCIP_NLHDLR_METHOD_SEPAABOVE

#define SCIP_NLHDLR_METHOD_SEPABOTH

#define SCIP_NLHDLR_METHOD_ACTIVITY

struct SCIP_NlhdlrExprData SCIP_NLHDLREXPRDATA

#define SCIP_NLHDLR_METHOD_SEPABELOW

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