RetroSearch Browse

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

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

SCIP Doxygen Documentation: reader_nl.cpp Source File

61#pragma GCC diagnostic ignored "-Wshadow" 63#pragma GCC diagnostic ignored "-Wimplicit-fallthrough" 67#include "mp/nl-reader.h" 69#define READER_NAME "nlreader" 70#define READER_DESC "AMPL .nl file reader" 71#define READER_EXTENSION "nl" 75#define SCIP_CALL_THROW(x) \ 78 SCIP_RETCODE throw_retcode; \ 79 if( ((throw_retcode) = (x)) != SCIP_OKAY ) \ 80 throw std::logic_error("Error <"

+ std::to_string((long long)throw_retcode) + "> in function call"); \

94 int

amplopts[mp::MAX_AMPL_OPTIONS];

123

std::vector<SCIP_EXPR*> varexprs;

127

std::vector<std::vector<std::pair<SCIP_Real, SCIP_VAR*> > > nlconslin;

135

std::vector<SCIP_EXPR*> commonexprs;

143

std::vector<SCIP_EXPR*> exprstorelease;

152

std::map<int, std::vector<int> > sosvars;

153

std::vector<int> sosweights;

165 const char

*& namesbegin,

166 const char

* namesend,

170 if

( namesbegin ==

NULL

)

176 while

( namesbegin != namesend )

185 if

( *namesbegin ==

'\n'

)

191

*(name++) = *(namesbegin++);

204 void

LogicalExprToVarVal(

210

assert(expr !=

NULL

);

238

OnUnhandled(

"logical expression must be binary or constant"

);

247 const char

* filename

258

assert(filename !=

NULL

);

263 const char

* extstart = strrchr(

const_cast<char

>

(filename),

'.'

);

264 if

( extstart !=

NULL

)

265

probdata->filenamestublen = extstart - filename;

267

probdata->filenamestublen = strlen(filename);

268

assert(probdata->filenamestublen > 0);

270

memcpy(probdata->filenamestub, filename, probdata->filenamestublen);

271

probdata->filenamestub[probdata->filenamestublen] =

'\0'

;

274 const char

* probname = strrchr(probdata->filenamestub,

'/'

);

275 if

( probname ==

NULL

)

276

probname = probdata->filenamestub;

287

probdata->filenamestub[probdata->filenamestublen] =

'.'

;

288

probdata->filenamestub[probdata->filenamestublen+1] =

'c'

;

289

probdata->filenamestub[probdata->filenamestublen+2] =

'o'

;

290

probdata->filenamestub[probdata->filenamestublen+3] =

'l'

;

291

probdata->filenamestub[probdata->filenamestublen+4] =

'\0'

;

292

colfile =

new

fmt::File(probdata->filenamestub, fmt::File::RDONLY);

294

probdata->filenamestub[probdata->filenamestublen+1] =

'r'

;

295

probdata->filenamestub[probdata->filenamestublen+3] =

'w'

;

296

rowfile =

new

fmt::File(probdata->filenamestub, fmt::File::RDONLY);

298 catch

(

const

fmt::SystemError& e )

303

probdata->filenamestub[probdata->filenamestublen] =

'\0'

;

315

assert(varexprs.empty());

316

assert(exprstorelease.empty());

326 const

mp::NLHeader&

h 332

assert(probdata->vars ==

NULL

);

333

assert(probdata->conss ==

NULL

);

335

probdata->namplopts =

.num_ampl_options;

340

mp::MemoryMappedFile<> mapped_colfile;

341 if

( colfile !=

NULL

)

342

mapped_colfile.map(*colfile,

"colfile"

);

343 const char

* varnamesbegin = mapped_colfile.start();

344 const char

* varnamesend = mapped_colfile.start() + mapped_colfile.size();

346

mp::MemoryMappedFile<> mapped_rowfile;

347 if

( rowfile !=

NULL

)

348

mapped_rowfile.map(*rowfile,

"rowfile"

);

349 const char

* consnamesbegin = mapped_rowfile.start();

350 const char

* consnamesend = mapped_rowfile.start() + mapped_rowfile.size();

352

probdata->nvars =

.num_vars;

356

nnlvars =

MAX

(

.num_nl_vars_in_cons,

.num_nl_vars_in_objs);

357

varexprs.resize(nnlvars);

361 for

(

int

i = 0; i <

.num_vars; ++i )

365 if

( i <

.num_nl_vars_in_both -

.num_nl_integer_vars_in_both )

367 else if

( i <

.num_nl_vars_in_both )

370 else if

( i <

.num_nl_vars_in_cons -

.num_nl_integer_vars_in_cons )

372 else if

( i <

.num_nl_vars_in_cons )

375 else if

( i <

.num_nl_vars_in_objs -

.num_nl_integer_vars_in_objs )

377 else if

( i <

.num_nl_vars_in_objs )

380 else if

( i <

.num_vars -

.num_linear_binary_vars -

.num_linear_integer_vars )

382 else if

( i <

.num_vars -

.num_linear_integer_vars )

387 if

( !nextName(varnamesbegin, varnamesend, name) )

421

probdata->nconss =

.num_algebraic_cons;

423

nlconslin.resize(

.num_nl_cons);

429 for

(

int

i = 0; i <

.num_nl_cons; ++i )

432 if

( !nextName(consnamesbegin, consnamesend, name) )

440 for

(

int

i =

.num_nl_cons; i <

.num_algebraic_cons; ++i )

442 if

( !nextName(consnamesbegin, consnamesend, name) )

447 if

(

.num_nl_cons == 0 &&

.num_logical_cons == 0 &&

.num_integer_vars() == 0 )

448

probdata->islp =

true

;

451

commonexprs.resize(

.num_common_exprs());

464

exprstorelease.push_back(expr);

474

assert(variableIndex >= 0);

475

assert(variableIndex < (

int

)varexprs.size());

476

assert(varexprs[variableIndex] !=

NULL

);

478 return

varexprs[variableIndex];

489

assert(child !=

NULL

);

493 case

mp::expr::MINUS:

516 case

mp::expr::LOG10:

539

OnUnhandled(mp::expr::str(kind));

544

exprstorelease.push_back(expr);

557 SCIP_EXPR

* children[2] = { firstChild, secondChild };

559

assert(firstChild !=

NULL

);

560

assert(secondChild !=

NULL

);

585 case

mp::expr::POW_CONST_BASE:

586 case

mp::expr::POW_CONST_EXP:

626

OnUnhandled(mp::expr::str(kind));

631

exprstorelease.push_back(expr);

642

std::shared_ptr<std::vector<SCIP_EXPR*> >

;

650 v

->reserve(num_args);

679

exprstorelease.push_back(expr);

690 if

( objectiveIndex >= 1 )

691

OnUnhandled(

"multiple objective functions"

);

695

assert(objexpr ==

NULL

);

709

objexpr = nonlinearExpression;

758 if

( num_linear_terms > 0 )

761

amplph.commonexprs[index] = commonexpr;

762

amplph.exprstorelease.push_back(commonexpr);

772

assert(commonexpr !=

NULL

);

777 if

( var_index < (

int

)amplph.varexprs.size() )

784

assert(var_index < amplph.probdata->nvars);

800

assert(index < (

int

)commonexprs.size());

812 if

( commonexprs[index] !=

NULL

)

820 else if

( expr !=

NULL

)

822

commonexprs[index] = expr;

831

assert(expr_index >= 0);

832

assert(expr_index < (

int

)commonexprs.size());

833

assert(commonexprs[expr_index] !=

NULL

);

834 return

commonexprs[expr_index];

844

assert(variableIndex >= 0);

845

assert(variableIndex < probdata->nvars);

868

assert(index < probdata->nconss);

871 if

( index < (

int

)nlconslin.size() )

901 if

( initsol ==

NULL

)

922 return

ColumnSizeHandler();

964 case

mp::suf::Kind::CON:

965 if

( strncmp(name.data(),

"initial"

, name.size()) == 0 )

967

suffix = CONSINITIAL;

969 else if

( strncmp(name.data(),

"separate"

, name.size()) == 0 )

971

suffix = CONSSEPARATE;

973 else if

( strncmp(name.data(),

"enforce"

, name.size()) == 0 )

975

suffix = CONSENFORCE;

977 else if

( strncmp(name.data(),

"check"

, name.size()) == 0 )

981 else if

( strncmp(name.data(),

"propagate"

, name.size()) == 0 )

983

suffix = CONSPROPAGATE;

985 else if

( strncmp(name.data(),

"dynamic"

, name.size()) == 0 )

987

suffix = CONSDYNAMIC;

989 else if

( strncmp(name.data(),

"removable"

, name.size()) == 0 )

991

suffix = CONSREMOVABLE;

999 case

mp::suf::Kind::CON_BIT:

1003 case

mp::suf::Kind::VAR:

1005 if

( strncmp(name.data(),

"initial"

, name.size()) == 0 )

1007

suffix = VARINITIAL;

1009 else if

( strncmp(name.data(),

"removable"

, name.size()) == 0 )

1011

suffix = VARREMOVABLE;

1013 else if

( strncmp(name.data(),

"sosno"

, name.size()) == 0 )

1018 else if

( strncmp(name.data(),

"ref"

, name.size()) == 0 )

1022

amplph.sosweights.resize(amplph.probdata->nvars, 0);

1030 case

mp::suf::Kind::VAR_BIT:

1034 case

mp::suf::Kind::OBJ:

1038 case

mp::suf::Kind::OBJ_BIT:

1046 case

mp::suf::Kind::PROB_BIT:

1093

assert(index < amplph.probdata->nvars);

1098

assert(index < amplph.probdata->nvars);

1104

amplph.sosvars[(int)value].push_back(index);

1109

amplph.sosweights[index] = (int)value;

1118

fmt::StringRef name,

1129

fmt::StringRef name,

1146 int

constraintIndex;

1152 int

constraintIndex_

1155

constraintIndex(constraintIndex_)

1157

assert(constraintIndex_ >= 0);

1158

assert(constraintIndex_ < amplph.probdata->nconss);

1174

assert(variableIndex >= 0);

1175

assert(variableIndex < amplph.probdata->nvars);

1177 if

( coefficient == 0.0 )

1180 if

( constraintIndex < 0 )

1184 else if

( constraintIndex < (

int

)amplph.nlconslin.size() )

1186

amplph.nlconslin[constraintIndex].push_back(std::pair<SCIP_Real, SCIP_VAR*>(coefficient, amplph.probdata->vars[variableIndex]));

1190 SCIP_CONS

* lincons = amplph.probdata->conss[constraintIndex];

1204 if

( objectiveIndex >= 1 )

1205

OnUnhandled(

"multiple objective functions"

);

1214 int

constraintIndex,

1231

exprstorelease.push_back(expr);

1245

LogicalExprToVarVal(arg, var, val);

1257

exprstorelease.push_back(expr);

1264

mp::expr::Kind kind,

1275

assert(lhs !=

NULL

);

1276

assert(rhs !=

NULL

);

1278

LogicalExprToVarVal(lhs, lhsvar, lhsval);

1279

LogicalExprToVarVal(rhs, rhsvar, rhsval);

1285 if

( lhsvar ==

NULL

&& rhsvar ==

NULL

)

1288

exprstorelease.push_back(expr);

1292 if

( (lhsvar ==

NULL

&& lhsval != 0.0) || (rhsvar ==

NULL

&& rhsval != 0.0) )

1296

exprstorelease.push_back(expr);

1300 if

( lhsvar ==

NULL

)

1303

assert(lhsval == 0.0);

1308 if

( rhsvar ==

NULL

)

1311

assert(rhsval == 0.0);

1321

std::string name = std::string(

"_logic"

) + std::to_string((

long long

)logiccount++);

1325

exprstorelease.push_back(expr);

1341 if

( lhsvar ==

NULL

&& rhsvar ==

NULL

)

1344

exprstorelease.push_back(expr);

1348 if

( (lhsvar ==

NULL

&& lhsval == 0.0) || (rhsvar ==

NULL

&& rhsval == 0.0) )

1352

exprstorelease.push_back(expr);

1356 if

( lhsvar ==

NULL

)

1359

assert(lhsval != 0.0);

1364 if

( rhsvar ==

NULL

)

1367

assert(rhsval != 0.0);

1377

std::string name = std::string(

"_logic"

) + std::to_string((

long long

)logiccount++);

1381

exprstorelease.push_back(expr);

1399 if

( lhsvar ==

NULL

&& rhsvar ==

NULL

)

1402

exprstorelease.push_back(expr);

1406 if

( lhsvar ==

NULL

)

1408

std::swap(lhs, rhs);

1409

std::swap(lhsval, rhsval);

1410

std::swap(lhsvar, rhsvar);

1412

assert(lhsvar !=

NULL

);

1414 if

( rhsvar ==

NULL

)

1418 if

( rhsval ==

TRUE

)

1426

exprstorelease.push_back(expr);

1436

std::string name = std::string(

"_logic"

) + std::to_string((

long long

)logiccount++);

1440

exprstorelease.push_back(expr);

1455

OnUnhandled(mp::expr::str(kind));

1465

mp::expr::Kind kind,

1476

assert(lhs !=

NULL

);

1477

assert(rhs !=

NULL

);

1479

LogicalExprToVarVal(lhs, lhsvar, lhsval);

1480

LogicalExprToVarVal(rhs, rhsvar, rhsval);

1487 bool

isne = (kind == mp::expr::NE);

1488 if

( lhsvar ==

NULL

&& rhsvar ==

NULL

)

1491

exprstorelease.push_back(expr);

1495 if

( lhsvar ==

NULL

)

1497

std::swap(lhs, rhs);

1498

std::swap(lhsval, rhsval);

1499

std::swap(lhsvar, rhsvar);

1501

assert(lhsvar !=

NULL

);

1503 if

( rhsvar ==

NULL

)

1515

exprstorelease.push_back(expr);

1526

std::string name = std::string(

"_logic"

) + std::to_string((

long long

)logiccount++);

1530

exprstorelease.push_back(expr);

1545

OnUnhandled(mp::expr::str(kind));

1562 if

( objexpr !=

NULL

)

1576 if

( initsol !=

NULL

)

1586 SCIPwarningMessage

(

scip

"Objective function could not be evaluated in initial point. Domain error."

);

1595 for

(

size_t

i = 0; i < nlconslin.size(); ++i )

1597 for

(

size_t

j = 0; j < nlconslin[i].size(); ++j )

1604 for

(

int

i = 0; i < probdata->nconss; ++i )

1610

std::vector<SCIP_VAR*> setvars;

1611

std::vector<SCIP_Real> setweights;

1612 if

( !sosvars.empty() )

1614

setvars.resize(probdata->nvars);

1615

probdata->islp =

false

;

1617 if

( !sosweights.empty() )

1618

setweights.resize(probdata->nvars);

1619 for

( std::map<

int

, std::vector<int> >::iterator sosit(sosvars.begin()); sosit != sosvars.end(); ++sosit )

1621

assert(sosit->first != 0);

1622

assert(!sosit->second.empty());

1625 bool

issos2 = sosit->first < 0;

1627 if

( issos2 && sosweights.empty() )

1632

OnUnhandled(

"SOS2 requires variable .ref suffix"

);

1635 for

(

size_t

i = 0; i < sosit->second.size(); ++i )

1637 int

varidx = sosit->second[i];

1638

setvars[i] = probdata->vars[varidx];

1640 if

( issos2 && sosweights[varidx] == 0 )

1642

OnUnhandled(

"Missing .ref value for SOS2 variable"

);

1643 if

( !sosweights.empty() )

1644

setweights[i] = (

SCIP_Real

)sosweights[varidx];

1651

(void)

SCIPsnprintf

(name, 20,

"sos1_%d"

, sosit->first);

1656

(void)

SCIPsnprintf

(name, 20,

"sos2_%d"

, -sosit->first);

1664 if

( initsol !=

NULL

)

1681 if

( initsol !=

NULL

)

1687 while

( !exprstorelease.empty() )

1690

exprstorelease.pop_back();

1694 while

( !varexprs.empty() )

1697

varexprs.pop_back();

1715

assert((*probdata)->vars !=

NULL

|| (*probdata)->nvars == 0);

1716

assert((*probdata)->conss !=

NULL

|| (*probdata)->conss == 0);

1718 for

( i = 0; i < (*probdata)->nconss; ++i )

1724 for

( i = 0; i < (*probdata)->nvars; ++i )

1757

assert(reader !=

NULL

);

1758

assert(filename !=

NULL

);

1759

assert(result !=

NULL

);

1767

mp::ReadNLFile(filename, handler);

1769 catch

(

const

mp::UnsupportedError& e )

1771 SCIPerrorMessage

(

"unsupported construct in AMPL .nl file %s: %s\n"

, filename, e.what());

1777 catch

(

const

mp::Error& e )

1786 catch

(

const

fmt::SystemError& e )

1795 catch

(

const

std::bad_alloc& e )

1804 catch

(

const

std::exception& e )

1828

assert(reader !=

NULL

);

1852 if

( probdata ==

NULL

)

1854 SCIPerrorMessage

(

"No AMPL nl file read. Cannot write AMPL solution.\n"

);

1858

probdata->filenamestub[probdata->filenamestublen] =

'.'

;

1859

probdata->filenamestub[probdata->filenamestublen+1] =

's'

;

1860

probdata->filenamestub[probdata->filenamestublen+2] =

'o'

;

1861

probdata->filenamestub[probdata->filenamestublen+3] =

'l'

;

1862

probdata->filenamestub[probdata->filenamestublen+4] =

'\0'

;

1864

FILE* solfile = fopen(probdata->filenamestub,

"w"

);

1865 if

( solfile ==

NULL

)

1867 SCIPerrorMessage

(

"could not open file <%s> for writing\n"

, probdata->filenamestub);

1868

probdata->filenamestub[probdata->filenamestublen] =

'\0'

;

1872

probdata->filenamestub[probdata->filenamestublen] =

'\0'

;

1879 for

(

int

i = 0; i < probdata->namplopts; ++i )

1885 SCIPinfoMessage

(

scip

, solfile,

"%d\n%d\n"

, probdata->nconss, havedual ? probdata->nconss : 0);

1886 SCIPinfoMessage

(

scip

, solfile,

"%d\n%d\n"

, probdata->nvars, haveprimal ? probdata->nvars : 0);

1891 for

(

int

c = 0; c < probdata->nconss; ++c )

1900 if

( transcons ==

NULL

)

1912 for

(

int

i = 0; i < probdata->nvars; ++i )

1918 int

solve_result_num = mp::sol::FAILURE;

1926

solve_result_num = mp::sol::LIMIT_FEAS_INTERRUPT;

1928

solve_result_num = mp::sol::LIMIT_NO_FEAS_INTERRUPT;

1934

solve_result_num = mp::sol::LIMIT_FEAS_NODES;

1936

solve_result_num = mp::sol::LIMIT_NO_FEAS_NODES;

1940

solve_result_num = mp::sol::LIMIT_FEAS_TIME;

1942

solve_result_num = mp::sol::LIMIT_NO_FEAS_TIME;

1946

solve_result_num = mp::sol::LIMIT_FEAS_SOFTMEM;

1948

solve_result_num = mp::sol::LIMIT_NO_FEAS_SOFTMEM;

1953

solve_result_num = mp::sol::LIMIT_FEAS_WORK;

1955

solve_result_num = mp::sol::LIMIT_NO_FEAS_WORK;

1958

solve_result_num = mp::sol::LIMIT_FEAS_BESTOBJ;

1962

solve_result_num = mp::sol::LIMIT_FEAS_BESTBND;

1964

solve_result_num = mp::sol::LIMIT_NO_FEAS_BESTBND;

1968

solve_result_num = mp::sol::LIMIT_FEAS_NUMSOLS;

1970

solve_result_num = mp::sol::LIMIT_NO_FEAS;

1976

solve_result_num = mp::sol::LIMIT_FEAS;

1978

solve_result_num = mp::sol::LIMIT_NO_FEAS;

1981

solve_result_num = mp::sol::SOLVED;

1984

solve_result_num = mp::sol::INFEASIBLE;

1988

solve_result_num = mp::sol::UNBOUNDED_FEAS;

1990

solve_result_num = mp::sol::UNBOUNDED_NO_FEAS;

1993

solve_result_num = mp::sol::LIMIT_INF_UNB;

1998 if

( fclose(solfile) != 0 )

void AddTerm(int var_index, double coef)

receives notification of a term in the linear expression

LinearExprHandler(AMPLProblemHandler &amplph_, int index, int num_linear_terms)

constructor

LinearPartHandler(AMPLProblemHandler &amplph_)

void AddTerm(int variableIndex, double coefficient)

LinearPartHandler(AMPLProblemHandler &amplph_, int constraintIndex_)

NumericArgHandler(int num_args)

constructor

void AddArg(SCIP_EXPR *term)

adds term to sum

std::shared_ptr< std::vector< SCIP_EXPR * > > v

void SetValue(int index, T value)

SuffixHandler(AMPLProblemHandler &amplph_, fmt::StringRef name, mp::suf::Kind kind)

constructor

implementation of AMPL/MPs NLHandler that constructs a SCIP problem while a .nl file is read

void EndCommonExpr(int index, SCIP_EXPR *expr, int)

receive notification of the end of a common expression

LinearPartHandler LinearObjHandler

NumericArgHandler BeginSum(int num_args)

receive notification of the beginning of a summation

void OnAlgebraicCon(int constraintIndex, SCIP_EXPR *expr)

receive notification of an algebraic constraint expression

LinearPartHandler OnLinearObjExpr(int objectiveIndex, int)

receive notification of the linear part of an objective

LogicalExpr OnBinaryLogical(mp::expr::Kind kind, LogicalExpr lhs, LogicalExpr rhs)

receives notification of a binary logical expression <mp::expr::FIRST_BINARY_LOGICAL>

LogicalExpr OnNot(LogicalExpr arg)

receives notification of a logical not <mp::expr::NOT>

SCIP_EXPR * OnBinary(mp::expr::Kind kind, SCIP_EXPR *firstChild, SCIP_EXPR *secondChild)

receive notification of a binary expression

SCIP_EXPR * OnNumber(double value)

receive notification of a number in a nonlinear expression

LogicalExpr OnRelational(mp::expr::Kind kind, NumericExpr lhs, NumericExpr rhs)

SuffixHandler< int > IntSuffixHandler

LinearExprHandler BeginCommonExpr(int index, int num_linear_terms)

receive notification of the beginning of a common expression (defined variable)

AMPLProblemHandler(const AMPLProblemHandler &)=delete

LinearConHandler OnLinearConExpr(int constraintIndex, int)

receive notification of the linear part of a constraint

void OnInitialValue(int var_index, double value)

receive notification of the initial value for a variable

SCIP_EXPR * OnVariableRef(int variableIndex)

receive notification of a variable reference in a nonlinear expression

AMPLProblemHandler(SCIP *scip_, const char *filename)

ColumnSizeHandler OnColumnSizes()

receives notification of Jacobian column sizes

AMPLProblemHandler & operator=(const AMPLProblemHandler &)=delete

LinearPartHandler LinearConHandler

void OnVarBounds(int variableIndex, double variableLB, double variableUB)

receive notification of variable bounds

SCIP_EXPR * OnCommonExprRef(int expr_index)

receive notification of a common expression (defined variable) reference

void OnHeader(const mp::NLHeader &h)

void OnLogicalCon(int index, LogicalExpr expr)

receives notification of a logical constraint expression

DblSuffixHandler OnDblSuffix(fmt::StringRef name, mp::suf::Kind kind, int)

receive notification of a double suffix

void OnConBounds(int index, double lb, double ub)

receive notification of constraint sides

IntSuffixHandler OnIntSuffix(fmt::StringRef name, mp::suf::Kind kind, int)

receive notification of an integer suffix

LogicalExpr OnBool(bool value)

receives notification of a Boolean value <mp::expr::BOOL>

SCIP_EXPR * OnUnary(mp::expr::Kind kind, SCIP_EXPR *child)

receive notification of a unary expression

SCIP_EXPR * EndSum(NumericArgHandler handler)

receive notification of the end of a summation

void OnInitialDualValue(int, double)

receives notification of the initial value for a dual variable

SuffixHandler< SCIP_Real > DblSuffixHandler

void OnObj(int objectiveIndex, mp::obj::Type type, SCIP_EXPR *nonlinearExpression)

receive notification of an objective type and the nonlinear part of an objective expression

Constraint handler for AND constraints, .

Constraint handler for linear constraints in their most general form, .

constraint handler for nonlinear constraints specified by algebraic expressions

Constraint handler for "or" constraints, .

constraint handler for SOS type 1 constraints

constraint handler for SOS type 2 constraints

Constraint handler for XOR constraints, .

absolute expression handler

exponential expression handler

logarithm expression handler

power and signed power expression handlers

product expression handler

handler for sin expressions

constant value expression handler

variable expression handler

SCIP_Real SCIPgetDualsolLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPaddLinearVarNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real coef)

SCIP_RETCODE SCIPchgRhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)

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 SCIPchgLhsNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)

SCIP_RETCODE SCIPcreateConsBasicOr(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, int nvars, SCIP_VAR **vars)

SCIP_RETCODE SCIPchgRhsNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)

SCIP_RETCODE SCIPcreateConsBasicSOS1(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights)

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_RETCODE SCIPcreateConsBasicNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs)

SCIP_RETCODE SCIPcreateConsBasicAnd(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, int nvars, SCIP_VAR **vars)

SCIP_RETCODE SCIPchgExprNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_EXPR *expr)

SCIP_RETCODE SCIPchgLhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)

SCIP_RETCODE SCIPcreateConsBasicSOS2(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights)

SCIP_RETCODE SCIPcreateExprVar(SCIP *scip, SCIP_EXPR **expr, SCIP_VAR *var, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprProduct(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real coefficient, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

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

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

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

SCIP_RETCODE SCIPappendExprSumExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *child, SCIP_Real childcoef)

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

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

SCIP_RETCODE SCIPcreateExprSum(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real *coefficients, SCIP_Real constant, 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 SCIPcreateExprPow(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_Real exponent, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_Bool SCIPhasPerformedPresolve(SCIP *scip)

SCIP_RETCODE SCIPprintStatus(SCIP *scip, FILE *file)

SCIP_STATUS SCIPgetStatus(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_PROBDATA * SCIPgetProbData(SCIP *scip)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)

SCIP_RETCODE SCIPcreateProb(SCIP *scip, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata)

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

void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)

void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_RETCODE SCIPsetConsSeparated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool separate)

SCIP_RETCODE SCIPsetConsDynamic(SCIP *scip, SCIP_CONS *cons, SCIP_Bool dynamic)

SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)

SCIP_RETCODE SCIPsetConsEnforced(SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)

SCIP_RETCODE SCIPsetConsRemovable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)

SCIP_RETCODE SCIPgetTransformedCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)

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

SCIP_RETCODE SCIPsetConsPropagated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool propagate)

SCIP_RETCODE SCIPsetConsChecked(SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)

SCIP_RETCODE SCIPevalExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag)

SCIP_Bool SCIPisExprValue(SCIP *scip, SCIP_EXPR *expr)

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

SCIP_Bool SCIPisExprVar(SCIP *scip, SCIP_EXPR *expr)

SCIP_Real SCIPgetValueExprValue(SCIP_EXPR *expr)

SCIP_Real SCIPexprGetEvalValue(SCIP_EXPR *expr)

SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)

SCIP_RETCODE SCIPincludeExternalCodeInformation(SCIP *scip, const char *name, const char *description)

#define SCIPallocClearMemory(scip, ptr)

#define SCIPfreeMemory(scip, ptr)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

SCIP_RETCODE SCIPincludeReaderBasic(SCIP *scip, SCIP_READER **readerptr, const char *name, const char *desc, const char *extension, SCIP_READERDATA *readerdata)

SCIP_RETCODE SCIPsetReaderCopy(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERCOPY((*readercopy)))

SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERREAD((*readerread)))

SCIP_SOL * SCIPgetBestSol(SCIP *scip)

SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)

SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)

SCIP_RETCODE SCIPaddSolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool *stored)

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

SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)

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

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_RETCODE SCIPvarSetInitial(SCIP_VAR *var, SCIP_Bool initial)

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

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

SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)

SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)

SCIP_RETCODE SCIPvarSetRemovable(SCIP_VAR *var, SCIP_Bool removable)

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

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 SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)

SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

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

#define BMScopyMemoryArray(ptr, source, num)

SCIP_RETCODE SCIPincludeReaderNl(SCIP *scip)

static SCIP_DECL_PROBDELORIG(probdataDelOrigNl)

#define SCIP_CALL_THROW(x)

SCIP_RETCODE SCIPwriteSolutionNl(SCIP *scip)

static SCIP_DECL_READERCOPY(readerCopyNl)

static SCIP_DECL_READERREAD(readerReadNl)

struct SCIP_ProbData SCIP_PROBDATA

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STATUS_TOTALNODELIMIT

@ SCIP_STATUS_BESTSOLLIMIT

@ SCIP_STATUS_PRIMALLIMIT

@ SCIP_STATUS_USERINTERRUPT

@ SCIP_STATUS_STALLNODELIMIT

@ SCIP_STATUS_RESTARTLIMIT

@ SCIP_VARTYPE_CONTINUOUS

enum SCIP_Vartype SCIP_VARTYPE

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