78#include "zimpl/attribute.h"
79#include "zimpl/ratlptypes.h"
80#include "zimpl/lint.h"
83#include "zimpl/numb.h"
84#include "zimpl/bound.h"
85#include "zimpl/mono.h"
86#include "zimpl/term.h"
88#include "zimpl/xlpglue.h"
89#include "zimpl/zimpllib.h"
99#pragma clang diagnostic ignored "-Wnonnull"
102#define READER_NAME "zplreader"
103#define READER_DESC "file reader for ZIMPL model files"
104#define READER_EXTENSION "zpl"
111#if (ZIMPL_VERSION >= 341)
120 SCIP_Bool branchpriowarning;
122 SCIP_Bool initialconss;
123 SCIP_Bool dynamicconss;
124 SCIP_Bool dynamiccols;
125 SCIP_Bool dynamicrows;
138 SCIP_Bool usestartsol;
150 readerdata->valid =
TRUE;
171 assert(!readerdata->readerror);
173 scip = readerdata->scip;
176 readerdata->retcode = createProb(
scip, readerdata, name);
179 return (Lps*) readerdata;
191bool xlp_conname_exists(
224 if( term_get_degree(term) == 2 )
232 SCIP_Real* quadcoefs;
245 for(
i = 0;
i < term_get_elements(term); ++
i )
247 monom = term_get_element(term,
i);
248 assert(!numb_equal(mono_get_coeff(monom), numb_zero()));
249 assert(mono_get_degree(monom) <= 2);
250 assert(mono_get_degree(monom) > 0);
251 if (mono_get_degree(monom) == 1)
253 linvars [nlinvars] = (
SCIP_VAR*)mono_get_var(monom, 0);
254 lincoefs[nlinvars] = numb_todbl(mono_get_coeff(monom));
259 assert(mono_get_degree(monom) == 2);
260 quadvar1 [nquadterms] = (
SCIP_VAR*)mono_get_var(monom, 0);
261 quadvar2 [nquadterms] = (
SCIP_VAR*)mono_get_var(monom, 1);
262 quadcoefs[nquadterms] = numb_todbl(mono_get_coeff(monom));
267 SCIP_CALL(
SCIPcreateExprQuadratic(
scip, expr, nlinvars, linvars, lincoefs, nquadterms, quadvar1, quadvar2, quadcoefs,
NULL,
NULL) );
302 for(
i = 0;
i < term_get_elements(term); ++
i )
304 monomial = term_get_element(term,
i);
306 assert(!numb_equal(mono_get_coeff(monomial), numb_zero()));
307 assert(mono_get_degree(monomial) > 0);
310 if( monomialssize == 0 )
316 else if( monomialssize < nmonomials + 1 )
326 for( j = 0; j < mono_get_degree(monomial); ++j )
331 exponent = exponent ==
SCIP_INVALID ? 1.0 : exponent + 1.0;
362 if( mono_get_function(monomial) == MFUN_NONE )
364 monomials[nmonomials] = monomialexpr;
365 coefs[nmonomials] = numb_todbl(mono_get_coeff(monomial));
372 coefs[nmonomials] = 1.0;
375 switch( mono_get_function(monomial) )
382 coefs[nmonomials] = 1.0 / log(10.0);
413 numb_todbl(mono_get_coeff(monomial)),
NULL,
NULL) );
417 numb_todbl(mono_get_coeff(monomial)),
NULL,
NULL) );
422 SCIPerrorMessage(
"ZIMPL function %d invalid here.\n", mono_get_function(monomial));
426 SCIPerrorMessage(
"ZIMPL function %d not supported\n", mono_get_function(monomial));
446 for( j = nmonomials - 1; j >= 0; --j )
448 if( monomials[j] !=
NULL )
488 SCIP_Bool modifiable;
514 assert(sciplhs == sciprhs);
520 readerdata->readerror =
TRUE;
527 initial = readerdata->initialconss;
535 usercut = (flags & LP_FLAG_CON_SEPAR) != 0;
536 lazycut = (flags & LP_FLAG_CON_CHECK) != 0;
539 if( usercut && lazycut )
558 if( term_is_linear(term) )
561 if ( flags & LP_FLAG_CON_INDIC )
563 bool lhsIndCons =
FALSE;
564 bool rhsIndCons =
FALSE;
583 SCIPerrorMessage(
"invalid constraint type <%d> in ZIMPL callback xlp_addcon()\n", type);
584 readerdata->readerror =
TRUE;
592 initial, separate, enforce, check,
propagate, local, readerdata->dynamicconss, readerdata->dynamicrows,
FALSE) );
595 for(
i = 0;
i < term_get_elements(term);
i++ )
599 const Mono* mono = term_get_element(term,
i);
602 scipvar = (
SCIP_VAR*)mono_get_var(mono, 0);
605 mfun = mono_get_function(mono);
606 if (mfun == MFUN_TRUE || mfun == MFUN_FALSE)
608 scipvar = (
SCIP_VAR*)mono_get_var(mono, 0);
613 assert(!numb_equal(mono_get_coeff(mono), numb_zero()));
614 assert(mono_is_linear(mono));
616 scipval = -numb_todbl(mono_get_coeff(mono));
628 initial, separate, enforce, check,
propagate, local, readerdata->dynamicconss, readerdata->dynamicrows,
FALSE) );
631 for(
i = 0;
i < term_get_elements(term);
i++ )
635 const Mono* mono = term_get_element(term,
i);
638 scipvar = (
SCIP_VAR*)mono_get_var(mono, 0);
641 mfun = mono_get_function(mono);
642 if (mfun == MFUN_TRUE || mfun == MFUN_FALSE)
644 scipvar = (
SCIP_VAR*)mono_get_var(mono, 0);
649 assert(!numb_equal(mono_get_coeff(mono), numb_zero()));
650 assert(mono_is_linear(mono));
652 scipval = numb_todbl(mono_get_coeff(mono));
663 initial, separate, enforce, check,
propagate, local, modifiable, readerdata->dynamicconss, readerdata->dynamicrows,
FALSE) );
666 for(
i = 0;
i < term_get_elements(term);
i++ )
671 assert(!numb_equal(mono_get_coeff(term_get_element(term,
i)), numb_zero()));
672 assert(mono_is_linear(term_get_element(term,
i)));
674 scipvar = (
SCIP_VAR*)mono_get_var(term_get_element(term,
i), 0);
675 scipval = numb_todbl(mono_get_coeff(term_get_element(term,
i)));
699 initial, separate, enforce, check,
propagate, local, modifiable, readerdata->dynamicconss, readerdata->dynamicrows) );
729 if( term_is_linear(term) )
732 for(
i = 0;
i < term_get_elements(term);
i++ )
737 assert(!numb_equal(mono_get_coeff(term_get_element(term,
i)), numb_zero()));
738 assert(mono_is_linear(term_get_element(term,
i)));
740 scipvar = (
SCIP_VAR*)mono_get_var(term_get_element(term,
i), 0);
741 scipval = numb_todbl(mono_get_coeff(term_get_element(term,
i)));
757 SCIPerrorMessage(
"Could not convert ZIMPL objective term into SCIP expression due to unsupported ZIMPL function.\n");
777 objoffset = numb_todbl(term_get_constant(term));
799 SCIP_Bool created =
FALSE;
804 scip = readerdata->scip;
807 if( readerdata->retcode !=
SCIP_OKAY || readerdata->readerror )
810 readerdata->retcode = addConsTerm(
scip, readerdata, name, type, lhs, rhs, flags, term, &created);
821 VarClass usevarclass,
824 const Numb* priority,
825 const Numb* startval,
837 switch( bound_get_type(lower) )
840 lb = (
SCIP_Real)numb_todbl(bound_get_value(lower));
845 case BOUND_MINUS_INFTY:
850 SCIPerrorMessage(
"invalid lower bound type <%d> in ZIMPL reader\n", bound_get_type(lower));
855 switch( bound_get_type(upper) )
858 ub = (
SCIP_Real)numb_todbl(bound_get_value(upper));
863 case BOUND_MINUS_INFTY:
868 SCIPerrorMessage(
"invalid upper bound type <%d> in ZIMPL reader\n", bound_get_type(upper));
873 switch( usevarclass )
887 readerdata->readerror =
TRUE;
890 initial = !(readerdata->dynamiccols);
891 removable = readerdata->dynamiccols;
894 SCIP_CALL(
SCIPcreateVar(
scip, &
var, name, lb, ub, 0.0, vartype, initial, removable,
NULL,
NULL,
NULL,
NULL,
NULL) );
899 if( !numb_equal(priority, numb_unknown()) )
901 if( numb_is_int(priority) )
902 branchpriority = numb_toint(priority);
905 if( !readerdata->branchpriowarning )
908 "ZIMPL reader: fractional branching priorities in input - rounding down to integer values\n");
909 readerdata->branchpriowarning =
TRUE;
911 branchpriority = (int)numb_todbl(priority);
919 if( readerdata->valid )
922 if( numb_equal(startval, numb_unknown()) )
924 SCIPdebugMsg(
scip,
"primal solution candidate contains an unknown value for variable <%s>(%g)\n",
926 readerdata->valid =
FALSE;
940 (*zplvar) = (Var*)
var;
952 VarClass usevarclass,
955 const Numb* priority,
966 scip = readerdata->scip;
971 if( readerdata->retcode !=
SCIP_OKAY || readerdata->readerror )
974 readerdata->retcode = addVar(
scip, readerdata, name, usevarclass, lower, upper, priority, startval, &zplvar);
1007 readerdata->initialconss, separate, enforce, check,
propagate, local, readerdata->dynamicconss, readerdata->dynamicrows,
FALSE) );
1010 for(
i = 0;
i < term_get_elements(term);
i++ )
1015 assert( mono_is_linear(term_get_element(term,
i)) );
1017 var = (
SCIP_VAR*) mono_get_var(term_get_element(term,
i), 0);
1018 weight = numb_todbl(mono_get_coeff(term_get_element(term,
i)));
1032 readerdata->initialconss, separate, enforce, check,
propagate, local, readerdata->dynamicconss, readerdata->dynamicrows,
FALSE) );
1034 for(
i = 0;
i < term_get_elements(term);
i++ )
1039 assert( mono_is_linear(term_get_element(term,
i)) );
1041 var = (
SCIP_VAR*) mono_get_var(term_get_element(term,
i), 0);
1042 weight = numb_todbl(mono_get_coeff(term_get_element(term,
i)));
1051 SCIPerrorMessage(
"invalid SOS type <%d> in ZIMPL callback xlp_addsos_term()\n", type);
1052 readerdata->readerror =
TRUE;
1064 const Numb* priority,
1075 scip = readerdata->scip;
1078 if( readerdata->retcode !=
SCIP_OKAY || readerdata->readerror )
1081 readerdata->retcode = addSOS(
scip, readerdata, name, type, term);
1087const char* xlp_getvarname(
1099 scip = readerdata->scip;
1107VarClass xlp_getclass(
1130 readerdata->readerror =
TRUE;
1148 BoundType boundtype;
1155 scip = readerdata->scip;
1167 boundtype = BOUND_MINUS_INFTY;
1169 boundtype = BOUND_INFTY;
1172 boundtype = BOUND_VALUE;
1176 numb = numb_new_ascii(s);
1180 bound = bound_new(boundtype, numb);
1199 BoundType boundtype;
1206 scip = readerdata->scip;
1218 boundtype = BOUND_MINUS_INFTY;
1220 boundtype = BOUND_INFTY;
1223 boundtype = BOUND_VALUE;
1225 numb = numb_new_ascii(s);
1229 bound = bound_new(boundtype, numb);
1253 scip = readerdata->scip;
1256 if( readerdata->retcode !=
SCIP_OKAY || readerdata->readerror )
1277 scip = readerdata->scip;
1280 if( readerdata->retcode !=
SCIP_OKAY || readerdata->readerror )
1283 readerdata->retcode = addObjTerm(
scip, readerdata, term);
1321 SCIP_Bool changedir;
1335 if( compression !=
NULL )
1338 *compextension =
'\0';
1347 if( chdir(path) != 0 )
1353 filename = namewithoutpath;
1377 readerdata->scip =
scip;
1378 readerdata->sol =
NULL;
1379 readerdata->valid =
FALSE;
1380 readerdata->branchpriowarning =
FALSE;
1381 readerdata->readerror =
FALSE;
1390 if( strcmp(paramstr,
"-") == 0 )
1393 if( !zpl_read(filename,
TRUE, (
void*)readerdata) )
1394 readerdata->readerror =
TRUE;
1401 return readerdata->retcode;
1407 char dummy[2] =
"x";
1413 len = (int) strlen(paramstr);
1427 while( p < len && paramstr[p] ==
' ' )
1431 while( p < len && paramstr[p] !=
' ' )
1433 switch( paramstr[p] )
1438 while( p < len && paramstr[p] !=
'"' )
1440 argv[argc][arglen] = paramstr[p];
1449 argv[argc][arglen] = paramstr[p];
1454 argv[argc][arglen] = paramstr[p];
1460 argv[argc][arglen] =
'\0';
1479 for(
i = 1;
i < argc; ++
i )
1486 if( !zpl_read_with_args(argv, argc,
TRUE, (
void*)readerdata) )
1487 readerdata->readerror =
TRUE;
1490 for(
i = argc - 1;
i >= 1; --
i )
1499 return readerdata->retcode;
1508 if( chdir(oldpath) != 0 )
1515 if( readerdata->valid )
1535 if( readerdata->readerror )
1541 if( readerdata->sol !=
NULL )
1566#ifdef SCIP_WITH_ZIMPL
1567#if (ZIMPL_VERSION >= 341)
1586 "reading/zplreader/changedir",
"should the current directory be changed to that of the ZIMPL file before parsing?",
1589 "reading/zplreader/usestartsol",
"should ZIMPL starting solutions be forwarded to SCIP?",
1592 "reading/zplreader/parameters",
"additional parameter string passed to the ZIMPL parser (or - for no additional parameters)",
1595 (void)
SCIPsnprintf(extcodename,
SCIP_MAXSTRLEN,
"ZIMPL %d.%d.%d", ZIMPL_VERSION/100, (ZIMPL_VERSION%100)/10, ZIMPL_VERSION%10);
1600 SCIPwarningMessage(
scip,
"SCIP does only support ZIMPL 3.4.1 and higher. Please update your ZIMPL version %d.%d.%d\n",
1601 ZIMPL_VERSION/100, (ZIMPL_VERSION%100)/10, ZIMPL_VERSION%10);
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 SCIPsetReaderCopy(SCIP *scip, SCIP_READER *reader,)
SCIP_RETCODE SCIPincludeReaderBasic(SCIP *scip, SCIP_READER **readerptr, const char *name, const char *desc, const char *extension, SCIP_READERDATA *readerdata)
SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader,)
const char * SCIPreaderGetName(SCIP_READER *reader)
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)
SCIPfreeSol(scip, &heurdata->sol))
SCIPcreateSol(scip, &heurdata->sol, heur))
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
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_READERREAD(x)
#define SCIP_DECL_READERCOPY(x)
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARTYPE_CONTINUOUS
enum SCIP_Vartype SCIP_VARTYPE