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;
176 assert(!readerdata->readerror);
178 scip = readerdata->scip;
181 readerdata->retcode = createProb(
scip, readerdata, name);
184 return (Lps*) readerdata;
196bool xlp_conname_exists(
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);
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 )
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));
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 )
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;
945 (*zplvar) = (Var*)
var;
957 VarClass usevarclass,
960 const Numb* priority,
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,
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(
1104 scip = readerdata->scip;
1112VarClass xlp_getclass(
1135 readerdata->readerror =
TRUE;
1153 BoundType boundtype;
1160 scip = readerdata->scip;
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);
1204 BoundType boundtype;
1211 scip = readerdata->scip;
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);
1258 scip = readerdata->scip;
1261 if( readerdata->retcode !=
SCIP_OKAY || readerdata->readerror )
1282 scip = readerdata->scip;
1285 if( readerdata->retcode !=
SCIP_OKAY || readerdata->readerror )
1288 readerdata->retcode = addObjTerm(
scip, readerdata, term);
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 )
1540 if( readerdata->readerror )
1546 if( readerdata->sol !=
NULL )
1571#ifdef SCIP_WITH_ZIMPL
1572#if (ZIMPL_VERSION >= 341)
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);
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
struct SCIP_Cons SCIP_CONS
struct SCIP_Expr SCIP_EXPR
struct SCIP_HashMap SCIP_HASHMAP
struct SCIP_HashMapEntry SCIP_HASHMAPENTRY
enum SCIP_Objsense SCIP_OBJSENSE
type definitions for input file readers
struct SCIP_ReaderData SCIP_READERDATA
struct SCIP_Reader SCIP_READER
#define SCIP_DECL_READERREAD(x)
#define SCIP_DECL_READERCOPY(x)
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARTYPE_CONTINUOUS
enum SCIP_Vartype SCIP_VARTYPE