RetroSearch Browse

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

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

SCIP Doxygen Documentation: expr_log.c Source File

41#define EXPRHDLR_NAME "log" 42#define EXPRHDLR_DESC "natural logarithm expression" 43#define EXPRHDLR_PRECEDENCE 80000 44#define EXPRHDLR_HASHKEY SCIPcalcFibHash(16273.0) 51struct

SCIP_ExprhdlrData

79

assert(lincoef !=

NULL

);

80

assert(linconstant !=

NULL

);

81

assert(success !=

NULL

);

98

coef = (log(ub) - log(lb)) / (ub - lb);

99

constant = log(ub) - coef * ub;

109

*linconstant += constant;

127

assert(lincoef !=

NULL

);

128

assert(linconstant !=

NULL

);

129

assert(success !=

NULL

);

140

assert(refpoint != 0.0);

141

coef = 1.0 / refpoint;

142

constant = log(refpoint) - 1.0;

152

coef = log((f+1.0) / f);

153

constant = log(f) - coef * f;

163

*linconstant += constant;

183

assert(expr !=

NULL

);

184

assert(simplifiedexpr !=

NULL

);

188

assert(child !=

NULL

);

201

*simplifiedexpr = expr;

223

assert(exprhdlrdata !=

NULL

);

224

assert(*exprhdlrdata !=

NULL

);

235

assert(targetexprdata !=

NULL

);

236

assert(sourceexpr !=

NULL

);

239

*targetexprdata =

NULL

;

248

assert(expr !=

NULL

);

261

assert(expr !=

NULL

);

265

assert(childexpr !=

NULL

);

269

assert(*expr !=

NULL

);

283

assert(expr !=

NULL

);

309

assert(expr !=

NULL

);

310

assert(childidx == 0);

314

assert(child !=

NULL

);

330

assert(expr !=

NULL

);

335

assert(exprhdlrdata !=

NULL

);

340 if

( childinterval.

inf

< exprhdlrdata->minzerodistance && exprhdlrdata->minzerodistance > 0.0 )

345 "Check your model formulation or use option expr/" EXPRHDLR_NAME "/minzerodistance to avoid this warning.\n"

346

childinterval.

inf

, exprhdlrdata->minzerodistance);

350

exprhdlrdata->warnedonpole =

TRUE

;

352

childinterval.

inf

= exprhdlrdata->minzerodistance;

374

assert(expr !=

NULL

);

377

assert(coefs !=

NULL

);

378

assert(constant !=

NULL

);

379

assert(islocal !=

NULL

);

380

assert(branchcand !=

NULL

);

381

assert(*branchcand ==

TRUE

);

382

assert(success !=

NULL

);

383

assert(refpoint !=

NULL

);

385

lb = localbounds[0].inf;

386

ub = localbounds[0].sup;

403 if

( localbounds[0].sup < 0.2 )

404

refpoint[0] = 0.5 * lb + 0.5 * ub;

411

*branchcand =

FALSE

;

435

assert(expr !=

NULL

);

441

assert(child !=

NULL

);

452

lb =

MAX

(lb,

MIN

(0.5 * lb + 0.5 * ub, 0.1));

454

refpointsover[0] = lb;

461 for

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

463 if

( (overest[i] && !overestimate) || (!overest[i] && (overestimate ||

SCIPisInfinity

(

scip

, ub))) )

469

coefs[*nreturned][0] = 0.0;

470

constant[*nreturned] = 0.0;

479 SCIPdebugMsg

(

scip

"init overestimate log(x) at x=%g -> %g*x+%g\n"

, refpointsover[i], coefs[*nreturned][0], constant[*nreturned]);

484 addLogSecant

(

scip

, lb, ub, coefs[*nreturned], &constant[*nreturned], &success);

487 SCIPdebugMsg

(

scip

"init underestimate log(x) on x=[%g,%g] -> %g*x+%g\n"

, lb, ub, coefs[*nreturned][0], constant[*nreturned]);

507

assert(expr !=

NULL

);

511

assert(exprhdlrdata !=

NULL

);

522 if

( childrenbounds[0].inf < exprhdlrdata->minzerodistance )

524 SCIPdebugMsg

(

scip

"Pushing child lower bound from %g to %g; upper bound remains at %g\n"

, childrenbounds[0].inf,

SCIPepsilon

(

scip

), childrenbounds[0].sup);

529 "Check your model formulation or use option expr/" EXPRHDLR_NAME "/minzerodistance to avoid this warning.\n"

530

childrenbounds[0].inf, exprhdlrdata->minzerodistance);

534

exprhdlrdata->warnedonpole =

TRUE

;

537

childrenbounds[0].inf = exprhdlrdata->minzerodistance;

548

assert(expr !=

NULL

);

550

assert(hashkey !=

NULL

);

551

assert(childrenhashes !=

NULL

);

554

*hashkey ^= childrenhashes[0];

564

assert(expr !=

NULL

);

565

assert(childcurv !=

NULL

);

585

assert(expr !=

NULL

);

586

assert(result !=

NULL

);

587

assert(childidx == 0);

607

assert(exprhdlr !=

NULL

);

622 "minimal distance from zero to enforce for child in bound tightening"

635 void

* ownercreatedata

638

assert(expr !=

NULL

);

639

assert(child !=

NULL

);

653

assert(expr !=

NULL

);

#define SCIP_INTERVAL_INFINITY

static SCIP_DECL_EXPRHASH(hashLog)

static void addLogLinearization(SCIP *scip, SCIP_Real refpoint, SCIP_Bool isint, SCIP_Real *lincoef, SCIP_Real *linconstant, SCIP_Bool *success)

static SCIP_DECL_EXPRFREEHDLR(freehdlrLog)

static SCIP_DECL_EXPRBWDIFF(bwdiffLog)

static SCIP_DECL_EXPRINITESTIMATES(initestimatesLog)

static SCIP_DECL_EXPRFREEDATA(freedataLog)

static SCIP_DECL_EXPRCOPYDATA(copydataLog)

static SCIP_DECL_EXPRMONOTONICITY(monotonicityLog)

static SCIP_DECL_EXPRPARSE(parseLog)

static SCIP_DECL_EXPRESTIMATE(estimateLog)

static SCIP_DECL_EXPRREVERSEPROP(reversepropLog)

static SCIP_DECL_EXPRCOPYHDLR(copyhdlrLog)

static SCIP_DECL_EXPRSIMPLIFY(simplifyLog)

static SCIP_DECL_EXPREVAL(evalLog)

static void addLogSecant(SCIP *scip, SCIP_Real lb, SCIP_Real ub, SCIP_Real *lincoef, SCIP_Real *linconstant, SCIP_Bool *success)

#define EXPRHDLR_PRECEDENCE

static SCIP_DECL_EXPRCURVATURE(curvatureLog)

static SCIP_DECL_EXPRINTEVAL(intevalLog)

logarithm expression handler

constant value expression handler

SCIP_Bool SCIPisExprLog(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPcreateExprLog(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 SCIPincludeExprhdlrLog(SCIP *scip)

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

SCIP_VERBLEVEL SCIPgetVerbLevel(SCIP *scip)

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)

const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)

void SCIPexprhdlrSetCopyFreeData(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRCOPYDATA((*copydata)), SCIP_DECL_EXPRFREEDATA((*freedata)))

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

SCIP_EXPRHDLRDATA * SCIPexprhdlrGetData(SCIP_EXPRHDLR *exprhdlr)

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)

void SCIPexprSetData(SCIP_EXPR *expr, SCIP_EXPRDATA *exprdata)

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_EXPRDATA * SCIPexprGetData(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_RETCODE SCIPprintExpr(SCIP *scip, SCIP_EXPR *expr, FILE *file)

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_EXPRHDLR * SCIPexprGetHdlr(SCIP_EXPR *expr)

SCIP_Real SCIPintervalGetInf(SCIP_INTERVAL interval)

SCIP_Bool SCIPintervalIsEmpty(SCIP_Real infinity, SCIP_INTERVAL operand)

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

SCIP_Real SCIPintervalGetSup(SCIP_INTERVAL interval)

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

void SCIPintervalSetEmpty(SCIP_INTERVAL *resultant)

#define SCIPallocClearBlockMemory(scip, ptr)

#define SCIPfreeBlockMemory(scip, ptr)

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

SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)

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

SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisInfinity(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_Real SCIPepsilon(SCIP *scip)

#define SCIP_DECL_EXPR_OWNERCREATE(x)

struct SCIP_ExprhdlrData SCIP_EXPRHDLRDATA

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