RetroSearch Browse

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

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

SCIP Doxygen Documentation: expr_abs.c Source File

40#define EXPRHDLR_NAME "abs" 41#define EXPRHDLR_DESC "absolute value expression" 42#define EXPRHDLR_PRECEDENCE 70000 43#define EXPRHDLR_HASHKEY SCIPcalcFibHash(7187.0) 72

coefs[*nreturned][0] = -1.0;

73

constant[*nreturned] = 0.0;

77

coefs[*nreturned][0] = 1.0;

78

constant[*nreturned] = 0.0;

97

coefs[*nreturned][0] = -1.0;

98

constant[*nreturned] = 0.0;

104

coefs[*nreturned][0] = 1.0;

105

constant[*nreturned] = 0.0;

119

coefs[*nreturned][0] = alpha;

120

constant[*nreturned] =

REALABS

(ub) - alpha * ub;

147

assert(expr !=

NULL

);

148

assert(simplifiedexpr !=

NULL

);

152

assert(child !=

NULL

);

161

*simplifiedexpr = expr;

183

assert(expr !=

NULL

);

187

assert(childexpr !=

NULL

);

191

assert(*expr !=

NULL

);

205

assert(expr !=

NULL

);

221

assert(expr !=

NULL

);

222

assert(childidx == 0);

226

assert(child !=

NULL

);

240

assert(expr !=

NULL

);

258

assert(expr !=

NULL

);

261

assert(coefs !=

NULL

);

262

assert(constant !=

NULL

);

263

assert(islocal !=

NULL

);

264

assert(branchcand !=

NULL

);

265

assert(*branchcand ==

TRUE

);

266

assert(success !=

NULL

);

268 SCIPdebugMsg

(

scip

"%sestimate |child| over locdom=[%g,%g] glbdom=[%g,%g]\n"

, overestimate ?

"over"

"under"

269

localbounds[0].inf, localbounds[0].sup, globalbounds[0].inf, globalbounds[0].sup);

276 if

( refpoint[0] <= 0.0 )

282

*branchcand =

FALSE

;

290

lb = localbounds[0].inf;

291

ub = localbounds[0].sup;

299

*branchcand =

FALSE

;

307

*branchcand =

FALSE

;

320

alpha = (ub + lb) / (ub - lb);

323

*constant = -lb - alpha * lb;

326 else if

( lb == -ub )

341 SCIPdebugMsg

(

scip

"-> %g * <child> %+g, local=%u branchcand=%u\n"

, *coefs, *constant, *islocal, *branchcand);

352

assert(expr !=

NULL

);

371

assert(expr !=

NULL

);

373

assert(bounds.inf >= 0.0);

380

childbounds = childrenbounds[0];

400

assert(expr !=

NULL

);

402

assert(hashkey !=

NULL

);

403

assert(childrenhashes !=

NULL

);

406

*hashkey ^= childrenhashes[0];

421

assert(expr !=

NULL

);

423

assert(success !=

NULL

);

424

assert(childcurv !=

NULL

);

428

assert(child !=

NULL

);

438 if

( childinf >= 0.0 )

439

childcurv[0] = exprcurvature;

440 else if

( childsup <= 0.0 )

459

assert(expr !=

NULL

);

460

assert(result !=

NULL

);

461

assert(childidx == 0);

464

assert(child !=

NULL

);

470 if

( childbounds.

sup

<= 0.0 )

472 else if

( childbounds.

inf

>= 0.0 )

488

assert(expr !=

NULL

);

489

assert(isintegral !=

NULL

);

493

assert(child !=

NULL

);

510

assert(exprhdlr !=

NULL

);

533 void

* ownercreatedata

536

assert(expr !=

NULL

);

537

assert(child !=

NULL

);

551

assert(expr !=

NULL

);

#define SCIP_INTERVAL_INFINITY

private functions to work with algebraic expressions

static SCIP_DECL_EXPRREVERSEPROP(reversepropAbs)

static SCIP_DECL_EXPRCURVATURE(curvatureAbs)

static SCIP_RETCODE computeCutsAbs(SCIP *scip, SCIP_INTERVAL bounds, SCIP_Bool overestimate, SCIP_Real **coefs, SCIP_Real *constant, int *nreturned)

static SCIP_DECL_EXPRESTIMATE(estimateAbs)

static SCIP_DECL_EXPRBWDIFF(bwdiffAbs)

static SCIP_DECL_EXPREVAL(evalAbs)

static SCIP_DECL_EXPRMONOTONICITY(monotonicityAbs)

static SCIP_DECL_EXPRPARSE(parseAbs)

static SCIP_DECL_EXPRINTEVAL(intevalAbs)

static SCIP_DECL_EXPRSIMPLIFY(simplifyAbs)

static SCIP_DECL_EXPRHASH(hashAbs)

static SCIP_DECL_EXPRINTEGRALITY(integralityAbs)

#define EXPRHDLR_PRECEDENCE

static SCIP_DECL_EXPRINITESTIMATES(initEstimatesAbs)

static SCIP_DECL_EXPRCOPYHDLR(copyhdlrAbs)

absolute expression handler

constant value expression handler

SCIP_Bool SCIPisExprAbs(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPcreateExprAbs(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprValue(SCIP *scip, SCIP_EXPR **expr, SCIP_Real value, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPincludeExprhdlrAbs(SCIP *scip)

const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)

void SCIPexprhdlrSetIntegrality(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRINTEGRALITY((*integrality)))

void SCIPexprhdlrSetHash(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRHASH((*hash)))

void SCIPexprhdlrSetCopyFreeHdlr(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRCOPYHDLR((*copyhdlr)), SCIP_DECL_EXPRFREEHDLR((*freehdlr)))

void SCIPexprhdlrSetDiff(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRBWDIFF((*bwdiff)), SCIP_DECL_EXPRFWDIFF((*fwdiff)), SCIP_DECL_EXPRBWFWDIFF((*bwfwdiff)))

void SCIPexprhdlrSetReverseProp(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRREVERSEPROP((*reverseprop)))

void SCIPexprhdlrSetParse(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRPARSE((*parse)))

void SCIPexprhdlrSetEstimate(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRINITESTIMATES((*initestimates)), SCIP_DECL_EXPRESTIMATE((*estimate)))

void SCIPexprhdlrSetMonotonicity(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRMONOTONICITY((*monotonicity)))

void SCIPexprhdlrSetIntEval(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRINTEVAL((*inteval)))

void SCIPexprhdlrSetCurvature(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRCURVATURE((*curvature)))

SCIP_RETCODE SCIPincludeExprhdlr(SCIP *scip, SCIP_EXPRHDLR **exprhdlr, const char *name, const char *desc, unsigned int precedence, SCIP_DECL_EXPREVAL((*eval)), SCIP_EXPRHDLRDATA *data)

SCIP_EXPRHDLR * SCIPfindExprhdlr(SCIP *scip, const char *name)

void SCIPexprhdlrSetSimplify(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRSIMPLIFY((*simplify)))

SCIP_RETCODE SCIPcreateExpr(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPRHDLR *exprhdlr, SCIP_EXPRDATA *exprdata, int nchildren, SCIP_EXPR **children, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

int SCIPexprGetNChildren(SCIP_EXPR *expr)

SCIP_Bool SCIPexprIsIntegral(SCIP_EXPR *expr)

SCIP_Bool SCIPisExprValue(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)

SCIP_RETCODE SCIPparseExpr(SCIP *scip, SCIP_EXPR **expr, const char *exprstr, const char **finalpos, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_Real SCIPgetValueExprValue(SCIP_EXPR *expr)

SCIP_Real SCIPexprGetEvalValue(SCIP_EXPR *expr)

SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)

SCIP_INTERVAL SCIPexprGetActivity(SCIP_EXPR *expr)

void SCIPcaptureExpr(SCIP_EXPR *expr)

SCIP_RETCODE SCIPevalExprActivity(SCIP *scip, SCIP_EXPR *expr)

SCIP_EXPRCURV SCIPexprcurvNegate(SCIP_EXPRCURV curvature)

SCIP_EXPRHDLR * SCIPexprGetHdlr(SCIP_EXPR *expr)

SCIP_Real SCIPintervalGetInf(SCIP_INTERVAL interval)

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

void SCIPintervalAbs(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand)

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)

SCIP_Real SCIPintervalGetSup(SCIP_INTERVAL interval)

void SCIPintervalSetEmpty(SCIP_INTERVAL *resultant)

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

SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)

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

#define SCIP_DECL_EXPR_OWNERCREATE(x)

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