68#define READER_NAME "pipreader"
69#define READER_DESC "file reader for polynomial mixed-integer programs in PIP format"
70#define READER_EXTENSION "pip"
76#define PIP_MAX_LINELEN 65536
77#define PIP_MAX_PUSHEDTOKENS 2
78#define PIP_INIT_MONOMIALSSIZE 128
79#define PIP_INIT_FACTORSSIZE 16
80#define PIP_MAX_PRINTLEN 561
81#define PIP_MAX_NAMELEN 256
82#define PIP_PRINTLEN 100
129 SCIP_Bool initialconss;
130 SCIP_Bool dynamicconss;
131 SCIP_Bool dynamiccols;
132 SCIP_Bool dynamicrows;
159 SCIPerrorMessage(
"Syntax error in line %d: %s ('%s')\n", pipinput->linenumber, msg, pipinput->token);
160 if( pipinput->linebuf[strlen(pipinput->linebuf)-1] ==
'\n' )
168 (void)
SCIPsnprintf(formatstr, 256,
" %%%ds\n", pipinput->linepos);
171 pipinput->haserror =
TRUE;
182 return pipinput->haserror;
216 if( isdigit((
unsigned char)
c) )
218 else if( (*exptype ==
PIP_EXP_NONE) && !(*hasdot) && (
c ==
'.') && isdigit((
unsigned char)nextc) )
223 else if( !firstchar && (*exptype ==
PIP_EXP_NONE) && (
c ==
'e' ||
c ==
'E') )
225 if( nextc ==
'+' || nextc ==
'-' )
230 else if( isdigit((
unsigned char)nextc) )
263 pipinput->linepos = 0;
265 if(
SCIPfgets(pipinput->linebuf, (
int)
sizeof(pipinput->linebuf), pipinput->file) ==
NULL )
267 pipinput->linenumber++;
271 pipinput->haserror =
TRUE;
282 if( commentstart !=
NULL )
284 *commentstart =
'\0';
285 *(commentstart+1) =
'\0';
302 *pointer1 = *pointer2;
322 if( pipinput->npushedtokens > 0 )
324 swapPointers(&pipinput->token, &pipinput->pushedtokens[pipinput->npushedtokens-1]);
325 pipinput->npushedtokens--;
326 SCIPdebugMsg(
scip,
"(line %d) read token again: '%s'\n", pipinput->linenumber, pipinput->token);
331 buf = pipinput->linebuf;
334 if( buf[pipinput->linepos] ==
'\0' )
342 assert(pipinput->linepos == 0);
353 if(
isValueChar(buf[pipinput->linepos], buf[pipinput->linepos+1],
TRUE, &hasdot, &exptype) )
361 pipinput->token[tokenlen] = buf[pipinput->linepos];
365 while(
isValueChar(buf[pipinput->linepos], buf[pipinput->linepos+1],
FALSE, &hasdot, &exptype) );
374 pipinput->token[tokenlen] = buf[pipinput->linepos];
377 if( tokenlen == 1 &&
isTokenChar(pipinput->token[0]) )
386 && (pipinput->token[tokenlen-1] ==
'<' || pipinput->token[tokenlen-1] ==
'>' || pipinput->token[tokenlen-1] ==
'=')
387 && buf[pipinput->linepos] ==
'=' )
391 else if( pipinput->token[tokenlen-1] ==
'=' && (buf[pipinput->linepos] ==
'<' || buf[pipinput->linepos] ==
'>') )
393 pipinput->token[tokenlen-1] = buf[pipinput->linepos];
398 pipinput->token[tokenlen] =
'\0';
400 SCIPdebugMsg(
scip,
"(line %d) read token: '%s'\n", pipinput->linenumber, pipinput->token);
414 swapPointers(&pipinput->pushedtokens[pipinput->npushedtokens], &pipinput->token);
415 pipinput->npushedtokens++;
427 swapPointers(&pipinput->pushedtokens[pipinput->npushedtokens], &pipinput->tokenbuf);
428 pipinput->npushedtokens++;
460 iscolon = (strcmp(pipinput->token,
":") == 0);
475 SCIPdebugMsg(
scip,
"(line %d) new section: OBJECTIVE\n", pipinput->linenumber);
485 SCIPdebugMsg(
scip,
"(line %d) new section: OBJECTIVE\n", pipinput->linenumber);
499 SCIPdebugMsg(
scip,
"(line %d) new section: CONSTRAINTS\n", pipinput->linenumber);
517 SCIPdebugMsg(
scip,
"(line %d) new section: CONSTRAINTS\n", pipinput->linenumber);
531 SCIPdebugMsg(
scip,
"(line %d) new section: CONSTRAINTS\n", pipinput->linenumber);
539 SCIPdebugMsg(
scip,
"(line %d) new section: BOUNDS\n", pipinput->linenumber);
551 SCIPdebugMsg(
scip,
"(line %d) new section: GENERALS\n", pipinput->linenumber);
560 SCIPdebugMsg(
scip,
"(line %d) new section: BINARIES\n", pipinput->linenumber);
584 assert(*sign == +1 || *sign == -1);
586 if( pipinput->token[1] ==
'\0' )
588 if( *pipinput->token ==
'+' )
590 else if( *pipinput->token ==
'-' )
621 val = strtod(pipinput->token, &endptr);
622 if( endptr != pipinput->token && *endptr ==
'\0' )
641 if( strcmp(pipinput->token,
"<") == 0 )
647 else if( strcmp(pipinput->token,
">") == 0 )
653 else if( strcmp(pipinput->token,
"=") == 0 )
668 SCIP_Bool dynamiccols,
693 if( created !=
NULL )
696 else if( created !=
NULL )
728 SCIP_Real** monomialscoef,
739 assert(*monomials !=
NULL || *monomialssize == 0);
741 if( minnmonomials <= *monomialssize )
746 if( *monomials !=
NULL )
754 if( *monomialscoef !=
NULL )
762 *monomialssize = newsize;
772 SCIP_Real** exponents,
783 assert(*exponents !=
NULL || *factorssize == 0);
786 if( minnfactors <= *factorssize )
791 if( *exponents !=
NULL )
801 *factorssize = newsize;
815 SCIP_Bool* newsection
830 SCIP_Real* monomialscoef;
836 SCIP_Real* exponents;
866 if( strcmp(pipinput->token,
":") == 0 )
870 SCIPdebugMsg(
scip,
"(line %d) read constraint name: '%s'\n", pipinput->linenumber, name);
911 SCIP_Bool isnewsection;
918 ((nfactors > 0 || havevalue) && (issign =
isSign(pipinput, &nextcoefsign))) )
923 if( coefsign * coef != 0.0 )
927 monomialscoef[nmonomials] = coefsign * coef;
933 constant += coefsign * coef;
936 if( monomialdegree > 1 )
962 coefsign = nextcoefsign;
963 SCIPdebugMsg(
scip,
"(line %d) read coefficient sign: %+d\n", pipinput->linenumber, coefsign);
971 if(
isSign(pipinput, &coefsign) )
973 SCIPdebugMsg(
scip,
"(line %d) read coefficient sign: %+d\n", pipinput->linenumber, coefsign);
975 if( nfactors > 0 || havevalue )
977 syntaxError(
scip, pipinput,
"sign can only be at beginning of monomial");
978 goto TERMINATE_READPOLYNOMIAL;
986 if( strcmp(pipinput->token,
"*") == 0 )
990 syntaxError(
scip, pipinput,
"cannot have '*' before first variable in monomial");
991 goto TERMINATE_READPOLYNOMIAL;
998 if( nmonomials > 0 && !havesign )
1000 syntaxError(
scip, pipinput,
"expected sign ('+' or '-') or sense ('<' or '>')");
1001 goto TERMINATE_READPOLYNOMIAL;
1005 if( strcmp(pipinput->token,
"^") == 0 )
1010 goto TERMINATE_READPOLYNOMIAL;
1014 syntaxError(
scip, pipinput,
"cannot have '^' before first variable in monomial");
1015 goto TERMINATE_READPOLYNOMIAL;
1017 exponents[nfactors-1] = exponent;
1019 monomialdegree += (int)exponent - 1;
1023 SCIPdebugMsg(
scip,
"(line %d) read exponent value %g for variable %s\n", pipinput->linenumber, exponent,
1031 SCIPdebugMsg(
scip,
"(line %d) read coefficient value: %g with sign %+d\n", pipinput->linenumber, coef, coefsign);
1036 goto TERMINATE_READPOLYNOMIAL;
1041 syntaxError(
scip, pipinput,
"coefficients can only be at the beginning of a monomial");
1042 goto TERMINATE_READPOLYNOMIAL;
1057 exponents[nfactors] = 1.0;
1064 syntaxError(
scip, pipinput,
"string ended before monomial has finished");
1065 goto TERMINATE_READPOLYNOMIAL;
1072 for(
i = 0;
i < nmonomials; ++
i )
1084 TERMINATE_READPOLYNOMIAL:
1103 SCIP_Bool newsection;
1110 SCIP_Bool modifiable;
1112 SCIP_Bool removable;
1140 if( constant != 0.0 )
1204 SCIP_CALL(
SCIPcreateConsNonlinear(
scip, &nonlinobjcons,
"nonlinobj", expr, lhs, rhs, initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable) );
1237 SCIP_Real sidevalue;
1240 SCIP_Bool newsection;
1247 SCIP_Bool modifiable;
1249 SCIP_Bool removable;
1261 syntaxError(
scip, pipinput,
"expected constraint sense '<=', '=', or '>='");
1271 if ( !
isSense(pipinput, &sense) )
1273 syntaxError(
scip, pipinput,
"expected constraint sense '<=', '=', or '>='");
1284 if (
isSign(pipinput, &sidesign) )
1297 sidevalue *= sidesign;
1300 initial = pipinput->initialconss;
1307 dynamic = pipinput->dynamicconss;
1308 removable = pipinput->dynamicrows;
1348 for(
i = 0;
i < nchildren; ++
i )
1365 SCIP_CALL(
SCIPcreateConsLinear(
scip, &cons, name, nchildren,
vars, coefs, lhs, rhs, initial, separate, enforce,
1366 check,
propagate, local, modifiable, dynamic, removable,
FALSE) );
1373 SCIP_CALL(
SCIPcreateConsNonlinear(
scip, &cons, name, expr, lhs, rhs, initial, separate, enforce, check,
propagate,
1374 local, modifiable, dynamic, removable) );
1380 SCIPdebugMsg(
scip,
"(line %d) created constraint: ", pipinput->linenumber);
1423 hassign =
isSign(pipinput, &sign);
1436 syntaxError(
scip, pipinput,
"expected bound sense '<=', '=', or '>='");
1480 if(
isSense(pipinput, &rightsense) )
1495 hassign =
isSign(pipinput, &sign);
1510 switch( rightsense )
1538 syntaxError(
scip, pipinput,
"variable with bound is marked as 'free'");
1577 SCIP_Bool infeasible;
1612 SCIP_Bool infeasible;
1648 const char* filename
1654 pipinput->file =
SCIPfopen(filename,
"r");
1655 if( pipinput->file ==
NULL )
1669 switch( pipinput->section )
1744 SCIP_Real* constant,
1745 SCIP_Bool transformed
1763 if( requiredsize > *
nvars )
1781 for( v = 0; v < *
nvars; ++v )
1791 *constant += (*scalars)[v];
1792 (*scalars)[v] *= -1.0;
1883 linebuffer[0] =
'\0';
1900 if( (*linecnt) > 0 )
1902 linebuffer[(*linecnt)] =
'\0';
1916 const char* extension
1929 (void) strncat(linebuffer, extension,
PIP_MAX_PRINTLEN - strlen(linebuffer));
1931 (*linecnt) += (int) strlen(extension);
1933 SCIPdebugMsg(
scip,
"linebuffer <%s>, length = %lu\n", linebuffer, (
unsigned long)strlen(linebuffer));
1945 const char* rowname,
1946 const char* rownameextension,
1953 SCIP_Bool transformed
1966 assert( strcmp(type,
"=") == 0 || strcmp(type,
"<=") == 0 || strcmp(type,
">=") == 0 );
1975 if ( strlen(rowname) > 0 || strlen(rownameextension) > 0 )
1982 for( v = 0; v < nlinvars; ++v )
2003 if( quadexpr !=
NULL )
2007 SCIP_Real* activevals;
2008 SCIP_Real* lincoefs;
2010 SCIP_Real activeconstant = 0.0;
2011 int nbilinexprterms;
2023 nactivevars = nlinexprs;
2025 for( v = 0; v < nlinexprs; ++v )
2036 constant += activeconstant;
2039 for( v = 0; v < nactivevars; ++v )
2046 var = activevars[v];
2068 for( v = 0; v < nquadexprs; ++v )
2082 if( lincoef == 0.0 )
2096 for( v = 0; v < nquadexprs; ++v )
2110 if( sqrcoef == 0.0 )
2124 for( v = 0; v < nbilinexprterms; ++v )
2130 SCIP_Real bilincoef;
2201 else if( coef == 1.0 && needsign )
2205 else if( coef == -1.0 )
2267 const char* rowname,
2268 const char* rownameextension,
2280 assert(strcmp(type,
"=") == 0 || strcmp(type,
"<=") == 0 || strcmp(type,
">=") == 0);
2289 if( strlen(rowname) > 0 || strlen(rownameextension) > 0 )
2298 SCIP_Bool needsign =
FALSE;
2335 const char* rowname,
2353 if( strlen(rowname) > 0 )
2383 const char* rowname,
2390 SCIP_Bool transformed
2395 SCIP_Real* activevals =
NULL;
2397 SCIP_Real activeconstant = 0.0;
2409 nactivevars = nlinvars;
2414 if( linvals !=
NULL )
2422 for( v = 0; v < nactivevars; ++v )
2423 activevals[v] = 1.0;
2437 rhs - activeconstant, transformed) );
2445 activevals, nactivevars, quadexpr, lhs - activeconstant, transformed) );
2451 activevals, nactivevars, quadexpr, rhs - activeconstant, transformed) );
2470 const char* rowname,
2514 int* nAggregatedVars,
2522 for (j = 0; j <
nvars; ++j)
2539 (*aggregatedVars)[(*nAggregatedVars)++] =
var;
2554 SCIP_Bool transformed,
2556 int nAggregatedVars,
2563 SCIP_Real* activevals;
2565 SCIP_Real activeconstant = 0.0;
2574 for (j = 0; j < nAggregatedVars; ++j)
2579 activevars[0] = aggregatedVars[j];
2580 activevals[0] = 1.0;
2581 activeconstant = 0.0;
2586 activevals[nactivevars] = -1.0;
2587 activevars[nactivevars] = aggregatedVars[j];
2592 SCIP_CALL(
printRow(
scip, file, consname,
"",
"=", activevars, activevals, nactivevars,
NULL, - activeconstant,
2626 if( isdigit(name[0]) )
2629 for(
i = 0;
i < len; ++
i )
2632 if( isalnum(name[
i]) )
2660 for( v = 0; v <
nvars; ++v )
2676 SCIP_Bool transformed
2682 const char* conshdlrname;
2687 for(
c = 0;
c < nconss; ++
c )
2708 if( strcmp(conshdlrname,
"linear") == 0 )
2731 SCIP_Bool transformed,
2735 SCIP_Real objoffset,
2757 const char* conshdlrname;
2766 int nAggregatedVars;
2773 SCIP_Real* consvals;
2782 nAggregatedVars = 0;
2795 SCIPinfoMessage(
scip, file,
"\\ Variables : %d (%d binary, %d integer, %d implicit integer, %d continuous)\n",
2805 for (v = 0; v <
nvars; ++v)
2846 for (
c = 0;
c < nconss; ++
c)
2861 if( strcmp(conshdlrname,
"linear") == 0 )
2867 else if( strcmp(conshdlrname,
"setppc") == 0 )
2876 consvars,
NULL, nconsvars,
NULL, 1.0, 1.0, transformed) );
2888 else if ( strcmp(conshdlrname,
"logicor") == 0 )
2894 else if ( strcmp(conshdlrname,
"knapsack") == 0 )
2896 SCIP_Longint* weights;
2904 for( v = 0; v < nconsvars; ++v )
2905 consvals[v] = (SCIP_Real)weights[v];
2912 else if ( strcmp(conshdlrname,
"varbound") == 0 )
2929 else if( strcmp(conshdlrname,
"nonlinear") == 0 )
2931 SCIP_Bool ispolynomial;
2932 SCIP_Bool isquadratic;
2943 SCIP_Bool infeasible;
2979 consNonlinear[nConsNonlinear++] = cons;
2982 if( simplifiedexpr !=
NULL )
2987 else if( strcmp(conshdlrname,
"and") == 0 )
2991 consAnd[nConsAnd++] = cons;
3007 for(
c = 0;
c < nConsNonlinear; ++
c )
3015 if( ntmpvars > tmpvarssize )
3027 for (
c = 0;
c < nConsAnd; ++
c)
3044 for (v = 0; v <
nvars; ++v)
3093 for (v = 0; v < nAggregatedVars; ++v)
3095 var = aggregatedVars[v];
3113 for (v = 0; v <
nvars; ++v)
3134 for (v = 0; v <
nvars; ++v)
3230 const char* filename,
3242 pipinput.file =
NULL;
3243 pipinput.linebuf[0] =
'\0';
3244 pipinput.probname[0] =
'\0';
3245 pipinput.objname[0] =
'\0';
3247 pipinput.token[0] =
'\0';
3249 pipinput.tokenbuf[0] =
'\0';
3255 pipinput.npushedtokens = 0;
3256 pipinput.linenumber = 0;
3257 pipinput.linepos = 0;
3260 pipinput.haserror =
FALSE;
3282 if( pipinput.haserror )
Constraint handler for AND constraints, .
Constraint handler for knapsack constraints of the form , x binary and .
Constraint handler for linear constraints in their most general form, .
Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...
constraint handler for nonlinear constraints specified by algebraic expressions
Constraint handler for the set partitioning / packing / covering constraints .
Constraint handler for variable bound constraints .
variable expression handler
SCIP_FILE * SCIPfopen(const char *path, const char *mode)
int SCIPfclose(SCIP_FILE *fp)
char * SCIPfgets(char *s, int size, SCIP_FILE *stream)
int SCIPgetNVarsKnapsack(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetVbdcoefVarbound(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsLogicor(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR * SCIPgetResultantAnd(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsAnd(SCIP *scip, SCIP_CONS *cons)
SCIP_Real * SCIPgetValsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR * SCIPgetVbdvarVarbound(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_EXPR * SCIPgetExprNonlinear(SCIP_CONS *cons)
SCIP_Real SCIPgetRhsNonlinear(SCIP_CONS *cons)
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_VAR * SCIPgetVarVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_Longint * SCIPgetWeightsKnapsack(SCIP *scip, SCIP_CONS *cons)
SCIP_Longint SCIPgetCapacityKnapsack(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetLhsVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_SETPPCTYPE SCIPgetTypeSetppc(SCIP *scip, SCIP_CONS *cons)
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_VAR ** SCIPgetVarsLogicor(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetRhsVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsAnd(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsKnapsack(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetLhsNonlinear(SCIP_CONS *cons)
@ SCIP_SETPPCTYPE_PARTITIONING
@ SCIP_SETPPCTYPE_COVERING
@ SCIP_SETPPCTYPE_PACKING
SCIP_RETCODE SCIPcreateExprVar(SCIP *scip, SCIP_EXPR **expr, SCIP_VAR *var, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
void SCIPsetConstantExprSum(SCIP_EXPR *expr, SCIP_Real constant)
SCIP_RETCODE SCIPappendExprSumExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *child, SCIP_Real childcoef)
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 SCIPwritePip(SCIP *scip, FILE *file, const char *name, SCIP_Bool transformed, SCIP_OBJSENSE objsense, SCIP_Real objscale, SCIP_Real objoffset, SCIP_VAR **vars, int nvars, int nbinvars, int nintvars, int nimplvars, int ncontvars, SCIP_CONS **conss, int nconss, SCIP_RESULT *result)
SCIP_RETCODE SCIPreadPip(SCIP *scip, SCIP_READER *reader, const char *filename, SCIP_RESULT *result)
SCIP_RETCODE SCIPincludeReaderPip(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 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)
int SCIPgetNTotalVars(SCIP *scip)
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)
SCIP_RETCODE SCIPhashtableCreate(SCIP_HASHTABLE **hashtable, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)
SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)
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,...)
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_RETCODE SCIPcreateExprMonomial(SCIP *scip, SCIP_EXPR **expr, int nfactors, SCIP_VAR **vars, SCIP_Real *exponents, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
int SCIPexprGetNChildren(SCIP_EXPR *expr)
void SCIPexprGetQuadraticBilinTerm(SCIP_EXPR *expr, int termidx, SCIP_EXPR **expr1, SCIP_EXPR **expr2, SCIP_Real *coef, int *pos2, SCIP_EXPR **prodexpr)
SCIP_Real SCIPgetExponentExprPow(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprProduct(SCIP *scip, SCIP_EXPR *expr)
SCIP_Bool SCIPisExprSum(SCIP *scip, SCIP_EXPR *expr)
SCIP_Bool SCIPexprAreQuadraticExprsVariables(SCIP_EXPR *expr)
void SCIPexprGetQuadraticData(SCIP_EXPR *expr, SCIP_Real *constant, int *nlinexprs, SCIP_EXPR ***linexprs, SCIP_Real **lincoefs, int *nquadexprs, int *nbilinexprs, SCIP_Real **eigenvalues, SCIP_Real **eigenvectors)
SCIP_Real * SCIPgetCoefsExprSum(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprValue(SCIP *scip, SCIP_EXPR *expr)
SCIP_Real SCIPgetCoefExprProduct(SCIP_EXPR *expr)
SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)
SCIP_Bool SCIPisExprVar(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPprintExpr(SCIP *scip, SCIP_EXPR *expr, FILE *file)
SCIP_Real SCIPgetValueExprValue(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprPower(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPcheckExprQuadratic(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool *isquadratic)
SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)
SCIP_Real SCIPgetConstantExprSum(SCIP_EXPR *expr)
SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)
void SCIPexprGetQuadraticQuadTerm(SCIP_EXPR *quadexpr, int termidx, SCIP_EXPR **expr, SCIP_Real *lincoef, SCIP_Real *sqrcoef, int *nadjbilin, int **adjbilin, SCIP_EXPR **sqrexpr)
SCIP_RETCODE SCIPduplicateExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR **copyexpr, SCIP_DECL_EXPR_MAPEXPR((*mapexpr)), void *mapexprdata, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPsimplifyExpr(SCIP *scip, SCIP_EXPR *rootexpr, SCIP_EXPR **simplified, SCIP_Bool *changed, SCIP_Bool *infeasible, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
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 SCIPallocBlockMemoryArray(scip, ptr, num)
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 SCIPsetReaderWrite(SCIP *scip, SCIP_READER *reader,)
SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader,)
const char * SCIPreaderGetName(SCIP_READER *reader)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetIndex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
SCIP_Real SCIPvarGetLbLocal(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 SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
int SCIPstrcasecmp(const char *s1, const char *s2)
int SCIPsnprintf(char *t, int len, const char *s,...)
void SCIPprintSysError(const char *message)
int SCIPstrncpy(char *t, const char *s, int size)
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
static const SCIP_Real scalars[]
memory allocation routines
#define BMSclearMemoryArray(ptr, num)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for managing constraints
public functions to work with algebraic expressions
wrapper functions to map file i/o to standard or zlib file i/o
struct SCIP_File SCIP_FILE
public methods for message output
#define SCIPdebugPrintCons(x, y, z)
public data structures and miscellaneous methods
public methods for NLP management
public methods for input file readers
public methods for problem variables
static SCIP_Bool isExprSignomial(SCIP *scip, SCIP_EXPR *expr)
static SCIP_RETCODE getActiveVariables(SCIP *scip, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
static SCIP_RETCODE readPolynomial(SCIP *scip, PIPINPUT *pipinput, char *name, SCIP_EXPR **expr, SCIP_Bool *islinear, SCIP_Bool *newsection)
#define PIP_MAX_PUSHEDTOKENS
static SCIP_RETCODE getVariable(SCIP *scip, char *name, SCIP_Bool dynamiccols, SCIP_VAR **var, SCIP_Bool *created)
static void clearLine(char *linebuffer, int *linecnt)
static SCIP_Bool hasError(PIPINPUT *pipinput)
static SCIP_Bool isNewSection(SCIP *scip, PIPINPUT *pipinput)
static SCIP_Bool getNextToken(SCIP *scip, PIPINPUT *pipinput)
static SCIP_RETCODE readGenerals(SCIP *scip, PIPINPUT *pipinput)
static SCIP_RETCODE readStart(SCIP *scip, PIPINPUT *pipinput)
static SCIP_Bool isExprPolynomial(SCIP *scip, SCIP_EXPR *expr)
static const char tokenchars[]
static SCIP_Bool isSign(PIPINPUT *pipinput, int *sign)
static SCIP_Bool getNextLine(SCIP *scip, PIPINPUT *pipinput)
static const char commentchars[]
static void checkVarnames(SCIP *scip, SCIP_VAR **vars, int nvars)
static SCIP_RETCODE ensureMonomialsSize(SCIP *scip, SCIP_EXPR ***monomials, SCIP_Real **monomialscoef, int *monomialssize, int minnmonomials)
static void printSignomial(SCIP *scip, FILE *file, char *linebuffer, int *linecnt, SCIP_EXPR *expr, SCIP_Real coef, SCIP_Bool needsign)
static const char namechars[]
static SCIP_RETCODE printAggregatedCons(SCIP *scip, FILE *file, SCIP_Bool transformed, int nvars, int nAggregatedVars, SCIP_VAR **aggregatedVars)
static SCIP_Bool isNameValid(const char *name)
static void swapTokenBuffer(PIPINPUT *pipinput)
static SCIP_Bool isValueChar(char c, char nextc, SCIP_Bool firstchar, SCIP_Bool *hasdot, PIPEXPTYPE *exptype)
static SCIP_RETCODE printNonlinearCons(SCIP *scip, FILE *file, const char *rowname, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs)
static SCIP_RETCODE collectAggregatedVars(int nvars, SCIP_VAR **vars, int *nAggregatedVars, SCIP_VAR ***aggregatedVars, SCIP_HASHTABLE **varAggregated)
static SCIP_RETCODE printQuadraticCons(SCIP *scip, FILE *file, const char *rowname, SCIP_VAR **linvars, SCIP_Real *linvals, int nlinvars, SCIP_EXPR *quadexpr, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool transformed)
static SCIP_RETCODE readBinaries(SCIP *scip, PIPINPUT *pipinput)
enum PipSection PIPSECTION
#define PIP_INIT_MONOMIALSSIZE
static SCIP_Bool isSense(PIPINPUT *pipinput, PIPSENSE *sense)
static void pushBufferToken(PIPINPUT *pipinput)
static void endLine(SCIP *scip, FILE *file, char *linebuffer, int *linecnt)
static void pushToken(PIPINPUT *pipinput)
static void syntaxError(SCIP *scip, PIPINPUT *pipinput, const char *msg)
static void printRowAnd(SCIP *scip, FILE *file, const char *rowname, SCIP_CONS *cons)
#define PIP_INIT_FACTORSSIZE
static SCIP_Bool isDelimChar(char c)
static SCIP_RETCODE readConstraints(SCIP *scip, PIPINPUT *pipinput)
static void swapPointers(char **pointer1, char **pointer2)
static void printRowNl(SCIP *scip, FILE *file, const char *rowname, const char *rownameextension, const char *type, SCIP_EXPR *expr, SCIP_Real rhs)
enum PipExpType PIPEXPTYPE
static SCIP_RETCODE printRow(SCIP *scip, FILE *file, const char *rowname, const char *rownameextension, const char *type, SCIP_VAR **linvars, SCIP_Real *linvals, int nlinvars, SCIP_EXPR *quadexpr, SCIP_Real rhs, SCIP_Bool transformed)
static SCIP_RETCODE readObjective(SCIP *scip, PIPINPUT *pipinput)
static SCIP_RETCODE ensureFactorsSize(SCIP *scip, SCIP_VAR ***vars, SCIP_Real **exponents, int *factorssize, int minnfactors)
static SCIP_Bool isValue(SCIP *scip, PIPINPUT *pipinput, SCIP_Real *value)
static void checkConsnames(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool transformed)
static SCIP_RETCODE readPIPFile(SCIP *scip, PIPINPUT *pipinput, const char *filename)
static const char delimchars[]
static void appendLine(SCIP *scip, FILE *file, char *linebuffer, int *linecnt, const char *extension)
static SCIP_RETCODE readBounds(SCIP *scip, PIPINPUT *pipinput)
static SCIP_Bool isTokenChar(char c)
file reader for polynomial mixed-integer programs in PIP format
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 SCIP variables
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
enum SCIP_Objsense SCIP_OBJSENSE
#define SCIP_DECL_READERWRITE(x)
#define SCIP_DECL_READERREAD(x)
#define SCIP_DECL_READERCOPY(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_ORIGINAL
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
enum SCIP_Varstatus SCIP_VARSTATUS