A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: reader_zpl.c Source File

83#include "zimpl/attribute.h" 84#include "zimpl/ratlptypes.h" 85#include "zimpl/lint.h" 88#include "zimpl/numb.h" 89#include "zimpl/bound.h" 90#include "zimpl/mono.h" 91#include "zimpl/term.h" 93#include "zimpl/xlpglue.h" 94#include "zimpl/zimpllib.h" 103#if defined(__clang__) 104#pragma clang diagnostic ignored "-Wnonnull" 107#define READER_NAME "zplreader" 108#define READER_DESC "file reader for ZIMPL model files" 109#define READER_EXTENSION "zpl" 116#if (ZIMPL_VERSION >= 341) 155

readerdata->valid =

TRUE

;

174

assert(readerdata !=

NULL

);

175

assert(readerdata->retcode ==

SCIP_OKAY

);

176

assert(!readerdata->readerror);

178 scip

= readerdata->scip;

181

readerdata->retcode = createProb(

scip

, readerdata, name);

184 return

(Lps*) readerdata;

196bool

xlp_conname_exists(

204

assert(readerdata !=

NULL

);

223

assert(readerdata !=

NULL

);

224

assert(expr !=

NULL

);

225

assert(term !=

NULL

);

229 if

( term_get_degree(term) == 2 )

250 for

( i = 0; i < term_get_elements(term); ++i )

252

monom = term_get_element(term, i);

253

assert(!numb_equal(mono_get_coeff(monom), numb_zero()));

254

assert(mono_get_degree(monom) <= 2);

255

assert(mono_get_degree(monom) > 0);

256 if

(mono_get_degree(monom) == 1)

258

linvars [nlinvars] = (

SCIP_VAR

*)mono_get_var(monom, 0);

259

lincoefs[nlinvars] = numb_todbl(mono_get_coeff(monom));

264

assert(mono_get_degree(monom) == 2);

265

quadvar1 [nquadterms] = (

SCIP_VAR

*)mono_get_var(monom, 0);

266

quadvar2 [nquadterms] = (

SCIP_VAR

*)mono_get_var(monom, 1);

267

quadcoefs[nquadterms] = numb_todbl(mono_get_coeff(monom));

272 SCIP_CALL

(

SCIPcreateExprQuadratic

(

scip

, expr, nlinvars, linvars, lincoefs, nquadterms, quadvar1, quadvar2, quadcoefs,

NULL

,

NULL

) );

307 for

( i = 0; i < term_get_elements(term); ++i )

309

monomial = term_get_element(term, i);

310

assert(monomial !=

NULL

);

311

assert(!numb_equal(mono_get_coeff(monomial), numb_zero()));

312

assert(mono_get_degree(monomial) > 0);

315 if

( monomialssize == 0 )

321 else if

( monomialssize < nmonomials + 1 )

327

assert(monomials !=

NULL

);

328

assert(coefs !=

NULL

);

331 for

( j = 0; j < mono_get_degree(monomial); ++j )

336

exponent = exponent ==

SCIP_INVALID

? 1.0 : exponent + 1.0;

367 if

( mono_get_function(monomial) == MFUN_NONE )

369

monomials[nmonomials] = monomialexpr;

370

coefs[nmonomials] = numb_todbl(mono_get_coeff(monomial));

377

coefs[nmonomials] = 1.0;

380 switch

( mono_get_function(monomial) )

387

coefs[nmonomials] = 1.0 / log(10.0);

418

numb_todbl(mono_get_coeff(monomial)),

NULL

,

NULL

) );

422

numb_todbl(mono_get_coeff(monomial)),

NULL

,

NULL

) );

427 SCIPerrorMessage

(

"ZIMPL function %d invalid here.\n"

, mono_get_function(monomial));

431 SCIPerrorMessage

(

"ZIMPL function %d not supported\n"

, mono_get_function(monomial));

451 for

( j = nmonomials - 1; j >= 0; --j )

453 if

( monomials[j] !=

NULL

)

519

assert(sciplhs == sciprhs);

525

readerdata->readerror =

TRUE

;

532

initial = readerdata->initialconss;

540

usercut = (flags & LP_FLAG_CON_SEPAR) != 0;

541

lazycut = (flags & LP_FLAG_CON_CHECK) != 0;

544 if

( usercut && lazycut )

563 if

( term_is_linear(term) )

566 if

( flags & LP_FLAG_CON_INDIC )

568 bool

lhsIndCons =

FALSE

;

569 bool

rhsIndCons =

FALSE

;

588 SCIPerrorMessage

(

"invalid constraint type <%d> in ZIMPL callback xlp_addcon()\n"

, type);

589

readerdata->readerror =

TRUE

;

597

initial, separate, enforce, check, propagate, local, readerdata->dynamicconss, readerdata->dynamicrows,

FALSE

) );

600 for

( i = 0; i < term_get_elements(term); i++ )

604 const

Mono* mono = term_get_element(term, i);

607

scipvar = (

SCIP_VAR

*)mono_get_var(mono, 0);

610

mfun = mono_get_function(mono);

611 if

(mfun == MFUN_TRUE || mfun == MFUN_FALSE)

613

scipvar = (

SCIP_VAR

*)mono_get_var(mono, 0);

618

assert(!numb_equal(mono_get_coeff(mono), numb_zero()));

619

assert(mono_is_linear(mono));

621

scipval = -numb_todbl(mono_get_coeff(mono));

633

initial, separate, enforce, check, propagate, local, readerdata->dynamicconss, readerdata->dynamicrows,

FALSE

) );

636 for

( i = 0; i < term_get_elements(term); i++ )

640 const

Mono* mono = term_get_element(term, i);

643

scipvar = (

SCIP_VAR

*)mono_get_var(mono, 0);

646

mfun = mono_get_function(mono);

647 if

(mfun == MFUN_TRUE || mfun == MFUN_FALSE)

649

scipvar = (

SCIP_VAR

*)mono_get_var(mono, 0);

654

assert(!numb_equal(mono_get_coeff(mono), numb_zero()));

655

assert(mono_is_linear(mono));

657

scipval = numb_todbl(mono_get_coeff(mono));

668

initial, separate, enforce, check, propagate, local, modifiable, readerdata->dynamicconss, readerdata->dynamicrows,

FALSE

) );

671 for

( i = 0; i < term_get_elements(term); i++ )

676

assert(!numb_equal(mono_get_coeff(term_get_element(term, i)), numb_zero()));

677

assert(mono_is_linear(term_get_element(term, i)));

679

scipvar = (

SCIP_VAR

*)mono_get_var(term_get_element(term, i), 0);

680

scipval = numb_todbl(mono_get_coeff(term_get_element(term, i)));

704

initial, separate, enforce, check, propagate, local, modifiable, readerdata->dynamicconss, readerdata->dynamicrows) );

734 if

( term_is_linear(term) )

737 for

( i = 0; i < term_get_elements(term); i++ )

742

assert(!numb_equal(mono_get_coeff(term_get_element(term, i)), numb_zero()));

743

assert(mono_is_linear(term_get_element(term, i)));

745

scipvar = (

SCIP_VAR

*)mono_get_var(term_get_element(term, i), 0);

746

scipval = numb_todbl(mono_get_coeff(term_get_element(term, i)));

762 SCIPerrorMessage

(

"Could not convert ZIMPL objective term into SCIP expression due to unsupported ZIMPL function.\n"

);

782

objoffset = numb_todbl(term_get_constant(term));

807

assert(readerdata !=

NULL

);

809 scip

= readerdata->scip;

812 if

( readerdata->retcode !=

SCIP_OKAY

|| readerdata->readerror )

815

readerdata->retcode = addConsTerm(

scip

, readerdata, name, type, lhs, rhs, flags, term, &created);

826

VarClass usevarclass,

829 const

Numb* priority,

830 const

Numb* startval,

842 switch

( bound_get_type(lower) )

845

lb = (

SCIP_Real

)numb_todbl(bound_get_value(lower));

850 case

BOUND_MINUS_INFTY:

855 SCIPerrorMessage

(

"invalid lower bound type <%d> in ZIMPL reader\n"

, bound_get_type(lower));

860 switch

( bound_get_type(upper) )

863

ub = (

SCIP_Real

)numb_todbl(bound_get_value(upper));

868 case

BOUND_MINUS_INFTY:

873 SCIPerrorMessage

(

"invalid upper bound type <%d> in ZIMPL reader\n"

, bound_get_type(upper));

878 switch

( usevarclass )

890 SCIPwarningMessage

(

scip

,

"invalid variable class <%d> in ZIMPL callback xlp_addvar()\n"

, usevarclass);

892

readerdata->readerror =

TRUE

;

895

initial = !(readerdata->dynamiccols);

896

removable = readerdata->dynamiccols;

899 SCIP_CALL

(

SCIPcreateVar

(

scip

, &var, name, lb, ub, 0.0, vartype, initial, removable,

NULL

,

NULL

,

NULL

,

NULL

,

NULL

) );

904 if

( !numb_equal(priority, numb_unknown()) )

906 if

( numb_is_int(priority) )

907

branchpriority = numb_toint(priority);

910 if

( !readerdata->branchpriowarning )

913 "ZIMPL reader: fractional branching priorities in input - rounding down to integer values\n"

);

914

readerdata->branchpriowarning =

TRUE

;

916

branchpriority = (int)numb_todbl(priority);

924 if

( readerdata->valid )

927 if

( numb_equal(startval, numb_unknown()) )

929 SCIPdebugMsg

(

scip

,

"primal solution candidate contains an unknown value for variable <%s>(%g)\n"

,

931

readerdata->valid =

FALSE

;

935

assert(readerdata->sol !=

NULL

);

945

(*zplvar) = (Var*)var;

957

VarClass usevarclass,

960 const

Numb* priority,

969

assert(readerdata !=

NULL

);

971 scip

= readerdata->scip;

976 if

( readerdata->retcode !=

SCIP_OKAY

|| readerdata->readerror )

979

readerdata->retcode = addVar(

scip

, readerdata, name, usevarclass, lower, upper, priority, startval, &zplvar);

1012

readerdata->initialconss, separate, enforce, check, propagate, local, readerdata->dynamicconss, readerdata->dynamicrows,

FALSE

) );

1015 for

( i = 0; i < term_get_elements(term); i++ )

1020

assert( mono_is_linear(term_get_element(term, i)) );

1022

var = (

SCIP_VAR

*) mono_get_var(term_get_element(term, i), 0);

1023

weight = numb_todbl(mono_get_coeff(term_get_element(term, i)));

1037

readerdata->initialconss, separate, enforce, check, propagate, local, readerdata->dynamicconss, readerdata->dynamicrows,

FALSE

) );

1039 for

( i = 0; i < term_get_elements(term); i++ )

1044

assert( mono_is_linear(term_get_element(term, i)) );

1046

var = (

SCIP_VAR

*) mono_get_var(term_get_element(term, i), 0);

1047

weight = numb_todbl(mono_get_coeff(term_get_element(term, i)));

1056 SCIPerrorMessage

(

"invalid SOS type <%d> in ZIMPL callback xlp_addsos_term()\n"

, type);

1057

readerdata->readerror =

TRUE

;

1069 const

Numb* priority,

1078

assert(readerdata !=

NULL

);

1080 scip

= readerdata->scip;

1083 if

( readerdata->retcode !=

SCIP_OKAY

|| readerdata->readerror )

1086

readerdata->retcode = addSOS(

scip

, readerdata, name, type, term);

1092const char

* xlp_getvarname(

1102

assert(readerdata !=

NULL

);

1104 scip

= readerdata->scip;

1112

VarClass xlp_getclass(

1121

assert(readerdata !=

NULL

);

1135

readerdata->readerror =

TRUE

;

1143Bound

* xlp_getlower(

1153

BoundType boundtype;

1158

assert(readerdata !=

NULL

);

1160 scip

= readerdata->scip;

1164

assert(scipvar !=

NULL

);

1172

boundtype = BOUND_MINUS_INFTY;

1174

boundtype = BOUND_INFTY;

1177

boundtype = BOUND_VALUE;

1181

numb = numb_new_ascii(s);

1185 bound

= bound_new(boundtype, numb);

1194Bound

* xlp_getupper(

1204

BoundType boundtype;

1209

assert(readerdata !=

NULL

);

1211 scip

= readerdata->scip;

1215

assert(scipvar !=

NULL

);

1223

boundtype = BOUND_MINUS_INFTY;

1225

boundtype = BOUND_INFTY;

1228

boundtype = BOUND_VALUE;

1230

numb = numb_new_ascii(s);

1234 bound

= bound_new(boundtype, numb);

1256

assert(readerdata !=

NULL

);

1258 scip

= readerdata->scip;

1261 if

( readerdata->retcode !=

SCIP_OKAY

|| readerdata->readerror )

1280

assert(readerdata !=

NULL

);

1282 scip

= readerdata->scip;

1285 if

( readerdata->retcode !=

SCIP_OKAY

|| readerdata->readerror )

1288

readerdata->retcode = addObjTerm(

scip

, readerdata, term);

1300

assert(reader !=

NULL

);

1340 if

( compression !=

NULL

)

1343

*compextension =

'\0'

;

1352 if

( chdir(path) != 0 )

1358

filename = namewithoutpath;

1382

readerdata->scip =

scip

;

1383

readerdata->sol =

NULL

;

1384

readerdata->valid =

FALSE

;

1385

readerdata->branchpriowarning =

FALSE

;

1386

readerdata->readerror =

FALSE

;

1395 if

( strcmp(paramstr,

"-"

) == 0 )

1398 if

( !zpl_read(filename,

TRUE

, (

void

*)readerdata) )

1399

readerdata->readerror =

TRUE

;

1406 return

readerdata->retcode;

1412 char

dummy[2] =

"x"

;

1418

len = (int) strlen(paramstr);

1432 while

( p < len && paramstr[p] ==

' '

)

1436 while

( p < len && paramstr[p] !=

' '

)

1438 switch

( paramstr[p] )

1443 while

( p < len && paramstr[p] !=

'"'

)

1445

argv[argc][arglen] = paramstr[p];

1454

argv[argc][arglen] = paramstr[p];

1459

argv[argc][arglen] = paramstr[p];

1465

argv[argc][arglen] =

'\0'

;

1484 for

( i = 1; i < argc; ++i )

1491 if

( !zpl_read_with_args(argv, argc,

TRUE

, (

void

*)readerdata) )

1492

readerdata->readerror =

TRUE

;

1495 for

( i = argc - 1; i >= 1; --i )

1504 return

readerdata->retcode;

1513 if

( chdir(oldpath) != 0 )

1520 if

( readerdata->valid )

1524

assert(readerdata->sol !=

NULL

);

1540 if

( readerdata->readerror )

1546 if

( readerdata->sol !=

NULL

)

1571#ifdef SCIP_WITH_ZIMPL 1572#if (ZIMPL_VERSION >= 341) 1584

assert(reader !=

NULL

);

1591 "reading/zplreader/changedir"

,

"should the current directory be changed to that of the ZIMPL file before parsing?"

,

1594 "reading/zplreader/usestartsol"

,

"should ZIMPL starting solutions be forwarded to SCIP?"

,

1597 "reading/zplreader/parameters"

,

"additional parameter string passed to the ZIMPL parser (or - for no additional parameters)"

,

1600

(void)

SCIPsnprintf

(extcodename,

SCIP_MAXSTRLEN

,

"ZIMPL %d.%d.%d"

, ZIMPL_VERSION/100, (ZIMPL_VERSION%100)/10, ZIMPL_VERSION%10);

1605 SCIPwarningMessage

(

scip

,

"SCIP does only support ZIMPL 3.4.1 and higher. Please update your ZIMPL version %d.%d.%d\n"

,

1606

ZIMPL_VERSION/100, (ZIMPL_VERSION%100)/10, ZIMPL_VERSION%10);

SCIP_DECL_READERREAD(ReaderTSP::scip_read)

constraint handler for indicator constraints

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

constraint handler for nonlinear constraints specified by algebraic expressions

constraint handler for SOS type 1 constraints

constraint handler for SOS type 2 constraints

absolute expression handler

exponential expression handler

logarithm expression handler

power and signed power expression handlers

product expression handler

handler for sin expressions

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

SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPaddVarSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real weight)

SCIP_RETCODE SCIPcreateConsIndicator(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPcreateConsSOS1(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPcreateConsNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable)

SCIP_RETCODE SCIPcreateConsSOS2(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPsetBinaryVarIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *binvar)

SCIP_RETCODE SCIPaddVarIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPaddVarSOS2(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real weight)

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 SCIPcreateExprSignpower(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_Real exponent, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

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 SCIPcreateExprPow(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_Real exponent, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

void SCIPsplitFilename(char *filename, char **path, char **name, char **extension, char **compression)

SCIP_RETCODE SCIPincludeReaderZpl(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

SCIP_RETCODE SCIPaddOrigObjoffset(SCIP *scip, SCIP_Real addval)

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)

SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

SCIP_Real SCIPhashmapGetImageReal(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapSetImageReal(SCIP_HASHMAP *hashmap, void *origin, SCIP_Real image)

int SCIPhashmapGetNElements(SCIP_HASHMAP *hashmap)

int SCIPhashmapGetNEntries(SCIP_HASHMAP *hashmap)

SCIP_HASHMAPENTRY * SCIPhashmapGetEntry(SCIP_HASHMAP *hashmap, int entryidx)

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

void * SCIPhashmapEntryGetOrigin(SCIP_HASHMAPENTRY *entry)

SCIP_RETCODE SCIPhashmapRemoveAll(SCIP_HASHMAP *hashmap)

SCIP_Real SCIPhashmapEntryGetImageReal(SCIP_HASHMAPENTRY *entry)

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

SCIP_VERBLEVEL SCIPgetVerbLevel(SCIP *scip)

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

SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)

SCIP_RETCODE SCIPaddStringParam(SCIP *scip, const char *name, const char *desc, char **valueptr, SCIP_Bool isadvanced, const char *defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

SCIP_RETCODE SCIPgetStringParam(SCIP *scip, const char *name, char **value)

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)

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

SCIP_RETCODE SCIPcreateExprQuadratic(SCIP *scip, SCIP_EXPR **expr, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadterms, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprMonomial(SCIP *scip, SCIP_EXPR **expr, int nfactors, SCIP_VAR **vars, SCIP_Real *exponents, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

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

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

#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 SCIPduplicateBufferArray(scip, ptr, source, num)

#define SCIPallocBuffer(scip, ptr)

#define SCIPfreeBufferArrayNull(scip, ptr)

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

const char * SCIPreaderGetName(SCIP_READER *reader)

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

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 SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)

const char * SCIPvarGetName(SCIP_VAR *var)

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

SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

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

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

int SCIPstrncpy(char *t, const char *s, int size)

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

public functions to work with algebraic expressions

public data structures and miscellaneous methods

public methods for NLP management

public methods for input file readers

public methods for problem variables

public methods for constraint handler plugins and constraints

public methods for memory management

public methods for message handling

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for global and local (sub)problems

public methods for reader plugins

public methods for solutions

public methods for SCIP variables

miscellaneous datastructures

enum SCIP_Objsense SCIP_OBJSENSE

type definitions for input file readers

struct SCIP_ReaderData SCIP_READERDATA

#define SCIP_DECL_READERCOPY(x)

enum SCIP_Retcode SCIP_RETCODE

@ 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