78#define READER_NAME "mpsreader"
79#define READER_DESC "file reader for MIQPs in IBM's Mathematical Programming System format"
80#define READER_EXTENSION "mps"
82#define DEFAULT_LINEARIZE_ANDS TRUE
83#define DEFAULT_AGGRLINEARIZATION_ANDS TRUE
89#define MPS_MAX_LINELEN 1024
90#define MPS_MAX_NAMELEN 256
91#define MPS_MAX_VALUELEN 26
92#define MPS_MAX_FIELDLEN 20
188 (*mpsi)->haserror =
FALSE;
189 (*mpsi)->isinteger =
FALSE;
190 (*mpsi)->isnewformat =
FALSE;
191 (*mpsi)->buf [0] =
'\0';
192 (*mpsi)->probname[0] =
'\0';
193 (*mpsi)->objname [0] =
'\0';
227 return mpsi->section;
304 return mpsi->objname;
315 return mpsi->objsense;
326 return mpsi->haserror;
337 return mpsi->isinteger;
349 mpsi->section = section;
361 assert(strlen(probname) <
sizeof(mpsi->probname));
375 assert(strlen(objname) <
sizeof(mpsi->objname));
389 mpsi->objsense = sense;
401 mpsi->haserror =
TRUE;
410 const char* what_name,
412 const char* entity_name,
423 "Warning line %d: %s \"%s\" for %s \"%s\" ignored\n", mpsi->lineno, what, what_name, entity, entity_name);
435 for(
i = pos;
i < 80;
i++)
450 while( (beg <= end) && (buf[end] ==
BLANK) )
453 while( (beg <= end) && (buf[beg] ==
BLANK) )
456 for(
i = beg;
i <= end;
i++ )
477 mpsi->f0 = mpsi->f1 = mpsi->f2 = mpsi->f3 = mpsi->f4 = mpsi->f5 = 0;
484 if(
NULL ==
SCIPfgets(mpsi->buf, (
int)
sizeof(mpsi->buf), mpsi->fp) )
488 while( *mpsi->buf ==
'*' );
491 len = (
unsigned int) strlen(mpsi->buf);
493 for(
i = 0;
i < len;
i++ )
494 if( (mpsi->buf[
i] ==
'\t') || (mpsi->buf[
i] ==
'\n') || (mpsi->buf[
i] ==
'\r') )
498 while( len > 0 && mpsi->buf[len-1] ==
BLANK )
506 assert(strlen(mpsi->buf) >= 80);
509 if( *mpsi->buf !=
BLANK )
511 mpsi->f0 =
SCIPstrtok(&mpsi->buf[0],
" ", &nexttok);
521 if( !mpsi->isnewformat )
524 if( (mpsi->buf[14] ==
'$') && (mpsi->buf[13] ==
' ') )
526 else if( (mpsi->buf[39] ==
'$') && (mpsi->buf[38] ==
' ') )
530 space = mpsi->buf[12] | mpsi->buf[13]
531 | mpsi->buf[22] | mpsi->buf[23]
532 | mpsi->buf[36] | mpsi->buf[37] | mpsi->buf[38]
533 | mpsi->buf[47] | mpsi->buf[48]
534 | mpsi->buf[61] | mpsi->buf[62] | mpsi->buf[63];
544 number = isdigit((
unsigned char)mpsi->buf[24]) || isdigit((
unsigned char)mpsi->buf[25])
545 || isdigit((
unsigned char)mpsi->buf[26]) || isdigit((
unsigned char)mpsi->buf[27])
546 || isdigit((
unsigned char)mpsi->buf[28]) || isdigit((
unsigned char)mpsi->buf[29])
547 || isdigit((
unsigned char)mpsi->buf[30]) || isdigit((
unsigned char)mpsi->buf[31])
548 || isdigit((
unsigned char)mpsi->buf[32]) || isdigit((
unsigned char)mpsi->buf[33])
549 || isdigit((
unsigned char)mpsi->buf[34]) || isdigit((
unsigned char)mpsi->buf[35]);
565 mpsi->isnewformat =
TRUE;
570 mpsi->isnewformat =
TRUE;
594 if( !strcmp(mpsi->f2,
"'MARKER'") )
604 if( !strcmp(mpsi->f3,
"'INTORG'") )
605 mpsi->isinteger =
TRUE;
606 else if( !strcmp(mpsi->f3,
"'INTEND'") )
607 mpsi->isinteger =
FALSE;
611 if( !strcmp(mpsi->f3,
"'MARKER'") )
621 if( !strcmp(mpsi->f4,
"'INTORG'") )
622 mpsi->isinteger =
TRUE;
623 else if( !strcmp(mpsi->f4,
"'INTEND'") )
624 mpsi->isinteger =
FALSE;
634 is_empty = (mpsi->f0 ==
NULL && mpsi->f1 ==
NULL);
636 while( is_marker || is_empty );
683 const char*** varnames,
691 if( varnames !=
NULL )
705 const char*** consnames,
713 if( consnames !=
NULL )
874 const char*** consnames,
932 dynamic = mpsi->dynamicconss;
939 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable,
FALSE) );
943 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable,
FALSE) );
947 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable,
FALSE) );
970 const char*** varnames,
1023 SCIPerrorMessage(
"Coeffients of column <%s> don't appear consecutively (line: %d)\n",
1024 colname, mpsi->lineno);
1146 if( *rhsname ==
'\0' )
1291 if( *rngname ==
'\0' )
1426 goto READBOUNDS_FINISH;
1491 if( *bndname ==
'\0' )
1608 if( semicontsize <= nsemicont )
1611 if( semicont ==
NULL )
1621 semicont[nsemicont] =
var;
1682 assert(*bndname !=
'\0');
1708 for(
i = 0;
i < nsemicont; ++
i )
1785 initial = mpsi->initialconss;
1791 dynamic = mpsi->dynamicconss;
1792 removable = mpsi->dynamicrows;
1830 assert( type == 1 || type == 2 );
1853 SCIP_CALL(
SCIPcreateConsSOS1(
scip, &cons, name, 0,
NULL,
NULL, initial, separate, enforce, check,
propagate,
1854 local, dynamic, removable,
FALSE) );
1859 SCIP_CALL(
SCIPcreateConsSOS2(
scip, &cons, name, 0,
NULL,
NULL, initial, separate, enforce, check,
propagate,
1860 local, dynamic, removable,
FALSE) );
1873 if( consType != 1 && consType != 2 )
1906 assert( consType == 1 || consType == 2 );
1971 SCIPdebugMsg(
scip,
"read %s objective\n", isQuadObj ?
"QUADOBJ" :
"QMATRIX");
2020 for( k = 1; k <= 2; ++k )
2046 coef = strtod(field, &endptr);
2047 if( endptr == field || *endptr !=
'\0' )
2068 quadvars1[cnt] = var1;
2069 quadvars2[cnt] = var2;
2070 quadcoefs[cnt] = coef;
2075 if( var1 == var2 || !isQuadObj )
2076 quadcoefs[cnt] /= 2.0;
2099 SCIP_Bool local, modifiable, dynamic, removable;
2135 retcode =
SCIPcreateConsQuadraticNonlinear(
scip, &cons,
"qmatrix", 1, &qmatrixvar, &minusone, cnt, quadvars1, quadvars2, quadcoefs, lhs, rhs,
2136 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable);
2196 if( lincons ==
NULL )
2288 quadvars1[cnt] = var1;
2289 quadvars2[cnt] = var2;
2290 quadcoefs[cnt] = coef;
2374 initial = mpsi->initialconss;
2380 dynamic = mpsi->dynamicconss;
2381 removable = mpsi->dynamicrows;
2382 stickingatnode =
FALSE;
2412 SCIPerrorMessage(
"Indicator constraints need to be introduced by 'IF' in column 1.\n");
2419 if( lincons ==
NULL )
2437 if( binvar ==
NULL )
2496 for(
i = 0;
i < nlinvars; ++
i )
2499 vals[
i] = -linvals[
i];
2507 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode);
2536 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
2566 const char* filename,
2567 const char*** varnames,
2568 const char*** consnames,
2595 SCIP_CALL_TERMINATE( retcode,
SCIPcreateProb(
scip, mpsi->probname,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL), TERMINATE );
2685 return (
void*)consnamefreq->
consname;
2692 const char* string1 = (
const char*)key1;
2693 const char* string2 = (
const char*)key2;
2729 width =
MAX(8u, width);
2741 unsigned int maxnamelen
2744 unsigned int fieldwidth;
2752 assert( maxnamelen > 0 );
2770 unsigned int fieldwidth;
2776 assert( strlen(col1) <= 2 );
2778 assert( maxnamelen == -1 || maxnamelen > 0 );
2780 if( maxnamelen < 0 )
2788 (void)
SCIPsnprintf(format, 32,
" %%-2.2s %%-%ds ", fieldwidth);
2799 const char* varname,
2803 unsigned int maxnamelen
2810 assert( *recordcnt >= 0 && *recordcnt < 2 );
2814 if( *recordcnt == 0 )
2824 if( *recordcnt == 2 )
2879 (*matrix)->nentries = 0;
2880 (*matrix)->sentries = slots;
2896 if( matrix->nentries + capacity >= matrix->sentries )
2898 matrix->sentries = matrix->sentries * 2 + capacity;
2954 nactivevars =
nvars;
2965 for( v = 0; v < nactivevars; ++v )
2966 activevals[v] = 1.0;
2974 if( requiredsize > nactivevars )
2980 assert( requiredsize <= nactivevars );
2985 for( v = 0; v < nactivevars; ++v )
2995 activeconstant += activevals[v];
2996 activevals[v] *= -1.0;
3003 assert( matrix->nentries + nactivevars < matrix->sentries );
3005 for( v = 0; v < nactivevars; ++v )
3007 matrix->values[matrix->nentries] = activevals[v];
3008 matrix->columns[matrix->nentries] = activevars[v];
3009 matrix->rows[matrix->nentries] =
consname;
3014 (*rhs) -= activeconstant;
3044 for( v = 0; v <
nvars; ++v )
3061 if ( *saggvars <= *naggvars )
3065 assert( newsize > *saggvars );
3067 *saggvars = newsize;
3070 (*aggvars)[*naggvars] =
var;
3073 assert( *naggvars <= *saggvars );
3087 unsigned int* maxnamelen,
3088 const char*** varnames,
3108 for( v = 0; v <
nvars; ++v )
3124 (*maxnamelen) =
MAX(*maxnamelen, (
unsigned int) l);
3134 (*varnames)[v] = varname;
3139 SCIPwarningMessage(
scip,
"there are %d variable names which have to be cut down to %d characters; LP might be corrupted\n",
3152 unsigned int* maxnamelen,
3153 const char*** consnames,
3172 hashGetKeyNamefreq, hashKeyEqString, SCIPhashKeyValString,
NULL) );
3174 for(
i = 0;
i < nconss; ++
i )
3190 SCIPwarningMessage(
scip,
"At least one name of a constraint is empty, so file will be written with generic names.\n");
3197 consnamefreqs[
i].
freq = 0;
3203 consnamefreq->
freq += 1;
3204 consnamefreqs[
i] = *consnamefreq;
3215 SCIPwarningMessage(
scip,
"Constraints have duplicate name and are too long to fix, so file will be written with generic names.\n");
3221 (*maxnamelen) =
MAX(*maxnamelen, (
unsigned int) l);
3259 unsigned int maxnamelen
3264 const char* varname;
3270 SCIPsortPtrPtrReal((
void**) matrix->columns, (
void**) matrix->rows, matrix->values, SCIPvarComp, matrix->nentries);
3277 for( v = 0; v < matrix->nentries; )
3279 var = matrix->columns[v];
3320 value = matrix->values[v];
3323 printEntry(
scip, file, varname, matrix->rows[v], value, &recordcnt, maxnamelen);
3326 while( v < matrix->nentries &&
var == matrix->columns[v] );
3328 if( recordcnt == 1 )
3349 const char** consnames,
3351 unsigned int maxnamelen,
3364 for(
c = 0;
c < nconss; ++
c )
3372 printEntry(
scip, file,
"RHS", consnames[
c], rhss[
c], &recordcnt, maxnamelen);
3378 printEntry(
scip, file,
"RHS",
"Obj", -objoffset, &recordcnt, maxnamelen);
3381 if( recordcnt == 1 )
3393 const char** consnames,
3395 unsigned int maxnamelen
3402 const char* conshdlrname;
3411 for(
c = 0;
c < nconss; ++
c )
3428 if( strcmp(conshdlrname,
"linear") == 0 )
3433 else if( strcmp(conshdlrname,
"varbound") == 0 )
3444 printEntry(
scip, file,
"RANGE", consnames[
c], rhs - lhs, &recordcnt, maxnamelen);
3474 const char** varnames,
3476 unsigned int maxnamelen
3484 const char* varname;
3491 sectionName =
FALSE;
3494 for( v = 0; v <
nvars; ++v )
3504 varname = varnames[v];
3652 for( v = 0; v < naggvars; ++v )
3664 varname = varnames[
nvars + v];
3684 for( v = 0; v < nfixvars; ++v )
3697 varname = varnames[
nvars + naggvars + v];
3809 "reading/" READER_NAME "/linearize-and-constraints",
3810 "should possible \"and\" constraint be linearized when writing the mps file?",
3814 "should an aggregated linearization for and constraints be used?",
3825 const char* filename,
3827 const char*** varnames,
3828 const char*** consnames,
3841 retcode =
readMps(
scip, filename, varnames, consnames, varnamessize, consnamessize, nvarnames, nconsnames);
3891 const char** consnames;
3894 const char* conshdlrname;
3902 const char* varname;
3903 const char** varnames;
3934 unsigned int maxnamelen;
3980 saggvars = nfixedvars;
3984 if( nfixedvars > 0 )
3989 varFixedHash =
NULL;
3996 indicatorSlackHash =
NULL;
4008 if( readerdata->linearizeands )
4012 if( andconshdlr !=
NULL )
4016 for(
c = nconss - 1;
c >= 0; --
c )
4023 if( strcmp(conshdlrname,
"and") == 0 )
4025 if( readerdata->aggrlinearizationands )
4047 SCIPinfoMessage(
scip, file,
"* Variables : %d (%d binary, %d integer, %d implicit integer, %d continuous)\n",
4066 for( v = 0; v <
nvars; ++v )
4080 assert( matrix->nentries < matrix->sentries );
4082 matrix->values[matrix->nentries] =
objscale * value;
4083 matrix->columns[matrix->nentries] =
var;
4084 matrix->rows[matrix->nentries] =
"Obj";
4091 for(
c = 0;
c < nconss; ++
c )
4112 if( strcmp(conshdlrname,
"linear") == 0 )
4138 else if( strcmp(conshdlrname,
"setppc") == 0 )
4159 else if( strcmp(conshdlrname,
"logicor") == 0 )
4169 else if( strcmp(conshdlrname,
"knapsack") == 0 )
4181 for(
i = 0;
i < nconsvars; ++
i )
4191 else if( strcmp(conshdlrname,
"varbound") == 0 )
4229 else if( strcmp(conshdlrname,
"indicator") == 0 )
4258 consIndicator[nConsIndicator++] = cons;
4261 else if( strcmp(conshdlrname,
"SOS1") == 0 )
4264 consSOS1[nConsSOS1++] = cons;
4276 else if( strcmp(conshdlrname,
"SOS2") == 0 )
4279 consSOS2[nConsSOS2++] = cons;
4290 else if( strcmp(conshdlrname,
"nonlinear") == 0 )
4315 consQuadratic[nConsQuadratic++] = cons;
4325 for( j = 0; j < nquadexprs; ++j )
4362 for( j = 0; j < nlinexprs; ++j )
4377 consvars = quadvars;
4378 nconsvars = nquadexprs;
4385 else if( strcmp(conshdlrname,
"and") == 0 )
4387 if( readerdata->linearizeands )
4410 if( !readerdata->aggrlinearizationands )
4412 rowvars[0] = resultant;
4418 n = (int) log10((
double)nrowvars) + 1 + l;
4425 maxnamelen =
MAX(maxnamelen, (
unsigned int) n);
4428 for( v = 0; v < nrowvars; ++v )
4434 n = (int) log10((
double)v) + 2;
4447 assert(k < nconss + naddrows);
4448 consnames[k] = rowname;
4451 rowvars[1] = operands[v];
4465 for( v = nrowvars - 1; v >= 0; --v )
4467 rowvars[v] = operands[v];
4471 rowvars[nrowvars] = resultant;
4474 if( readerdata->aggrlinearizationands )
4487 maxnamelen =
MAX(maxnamelen, (
unsigned int) n);
4492 assert(k < nconss + naddrows);
4493 consnames[k] = rowname;
4498 rowvals[nrowvars] = (
SCIP_Real) nrowvars;
4512 rowvals[nrowvars] = 1.0;
4517 rhss[
c] = -nrowvars + 1.0;
4545 SCIPwarningMessage(
scip,
"there are %d and-constraint-rownames which have to be cut down to %d characters; MPS file might be corrupted\n",
4550 if( varFixedHash !=
NULL )
4553 if( indicatorSlackHash !=
NULL && nConsIndicator == 0 )
4568 for(
c = 0;
c < naggvars; ++
c )
4579 maxnamelen =
MAX(maxnamelen, (
unsigned int) l);
4585 varnames[
nvars +
c] = namestr;
4594 l = strlen(namestr);
4595 maxnamelen =
MAX(maxnamelen, (
unsigned int) l);
4596 consnames[nconss + naddrows +
c] = namestr;
4597 rhss[nconss + naddrows +
c] = 0.0;
4604 matrix->values[matrix->nentries] = -1.0;
4605 matrix->columns[matrix->nentries] = aggvars[
c];
4606 matrix->rows[matrix->nentries] = namestr;
4613 if( nfixedvars > 0 )
4615 int startpos =
nvars + naggvars;
4624 for( v = nfixedvars - 1; v >= 0; --v )
4636 maxnamelen =
MAX(maxnamelen, (
unsigned int) l);
4641 varnames[startpos + nfixvars] = namestr;
4642 fixvars[nfixvars] =
var;
4651 matrix->values[matrix->nentries] = 0.0;
4652 matrix->columns[matrix->nentries] =
var;
4653 matrix->rows[matrix->nentries] =
"Obj";
4670 printBoundSection(
scip, file,
vars,
nvars, aggvars, naggvars, fixvars, nfixvars, transformed, varnames, indicatorSlackHash, maxnamelen);
4672 if( nfixedvars > 0 )
4678 if( nConsSOS1 > 0 || nConsSOS2 > 0 )
4688 for(
c = 0;
c < nConsSOS1; ++
c )
4699 for( v = 0; v < nconsvars; ++v )
4707 if( sosweights !=
NULL )
4717 for(
c = 0;
c < nConsSOS2; ++
c )
4728 for( v = 0; v < nconsvars; ++v )
4736 if( sosweights !=
NULL )
4750 if( nConsQuadratic > 0 )
4752 const char* varname2;
4755 SCIPdebugMsg(
scip,
"start printing QCMATRIX sections for quadratic constraints\n");
4758 for(
c = 0;
c < nConsQuadratic; ++
c )
4762 cons = consQuadratic[
c];
4772 for( v = 0; v < nconsvars; ++v )
4779 if( sqrcoef == 0.0 )
4800 for( v = 0; v < nbilin; ++v )
4845 if( nConsIndicator > 0 )
4853 for(
c = 0;
c < nConsIndicator; ++
c )
4859 cons = consIndicator[
c];
4906 if( indicatorSlackHash !=
NULL )
4922 for( v =
nvars + naggvars + nfixvars - 1; v >= 0; --v )
4926 for(
c = nconss + naddrows + naggvars - 1;
c >= 0; --
c )
Constraint handler for AND constraints, .
constraint handler for bound disjunction constraints
constraint handler for indicator 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 SOS type 1 constraints
constraint handler for SOS type 2 constraints
Constraint handler for variable bound constraints .
#define SCIP_HASHSIZE_NAMES
#define SCIP_CALL_TERMINATE(retcode, x, TERM)
SCIP_FILE * SCIPfopen(const char *path, const char *mode)
int SCIPfclose(SCIP_FILE *fp)
char * SCIPfgets(char *s, int size, SCIP_FILE *stream)
SCIP_RETCODE SCIPcheckQuadraticNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *isquadratic)
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_RETCODE SCIPchgRhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
SCIP_Real * SCIPgetWeightsSOS2(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsSOS2(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR * SCIPgetResultantAnd(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddVarSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real weight)
SCIP_RETCODE SCIPcreateConsBounddisjunction(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds, 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 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)
int SCIPgetNVarsAnd(SCIP *scip, SCIP_CONS *cons)
SCIP_Real * SCIPgetValsLinear(SCIP *scip, SCIP_CONS *cons)
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_VAR * SCIPgetVbdvarVarbound(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsSetppc(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsSOS2(SCIP *scip, SCIP_CONS *cons)
SCIP_Real * SCIPgetWeightsSOS1(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_VAR * SCIPgetBinaryVarIndicator(SCIP_CONS *cons)
SCIP_VAR * SCIPgetVarVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_Longint * SCIPgetWeightsKnapsack(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR * SCIPgetSlackVarIndicator(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_CONS * SCIPgetLinearConsIndicator(SCIP_CONS *cons)
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_VAR ** SCIPgetVarsSOS1(SCIP *scip, SCIP_CONS *cons)
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_RETCODE SCIPcreateConsQuadraticNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadterms, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, 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 SCIPcreateConsIndicatorLinConsPure(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, 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 SCIPchgLhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
int SCIPgetNVarsSOS1(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetLhsNonlinear(SCIP_CONS *cons)
SCIP_RETCODE SCIPaddVarSOS2(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real weight)
@ SCIP_SETPPCTYPE_PARTITIONING
@ SCIP_SETPPCTYPE_COVERING
@ SCIP_SETPPCTYPE_PACKING
SCIP_RETCODE SCIPwriteMps(SCIP *scip, SCIP_READER *reader, 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_VAR **fixedvars, int nfixedvars, SCIP_CONS **conss, int nconss, SCIP_RESULT *result)
SCIP_RETCODE SCIPreadMps(SCIP *scip, SCIP_READER *reader, const char *filename, SCIP_RESULT *result, const char ***varnames, const char ***consnames, int *varnamessize, int *consnamessize, int *nvarnames, int *nconsnames)
SCIP_RETCODE SCIPincludeReaderMps(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)
SCIP_RETCODE SCIPaddOrigObjoffset(SCIP *scip, SCIP_Real addval)
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_VAR * SCIPfindVar(SCIP *scip, const char *name)
SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
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)
void * SCIPhashtableRetrieve(SCIP_HASHTABLE *hashtable, void *key)
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)
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)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
void SCIPexprGetQuadraticBilinTerm(SCIP_EXPR *expr, int termidx, SCIP_EXPR **expr1, SCIP_EXPR **expr2, SCIP_Real *coef, int *pos2, SCIP_EXPR **prodexpr)
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_Bool SCIPisExprVar(SCIP *scip, 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)
#define SCIPfreeBuffer(scip, ptr)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPensureBlockMemoryArray(scip, ptr, arraysizeptr, minsize)
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)
#define SCIPallocBuffer(scip, ptr)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, 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_READERDATA * SCIPreaderGetData(SCIP_READER *reader)
SCIP_RETCODE SCIPsetReaderWrite(SCIP *scip, SCIP_READER *reader,)
SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader,)
const char * SCIPreaderGetName(SCIP_READER *reader)
SCIP_RETCODE SCIPsetReaderFree(SCIP *scip, SCIP_READER *reader,)
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
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 SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
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)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
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_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
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_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(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 SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
void SCIPsortPtrPtrReal(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
void SCIPprintSysError(const char *message)
char * SCIPstrtok(char *s, const char *delim, char **ptrptr)
int SCIPmemccpy(char *dest, const char *src, char stop, unsigned int cnt)
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
memory allocation routines
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for managing constraints
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
methods for sorting joint arrays of various types
public methods for input file readers
public methods for problem variables
#define DEFAULT_AGGRLINEARIZATION_ANDS
#define DEFAULT_LINEARIZE_ANDS
static void mpsinputEntryIgnored(SCIP *scip, MPSINPUT *mpsi, const char *what, const char *what_name, const char *entity, const char *entity_name, SCIP_VERBLEVEL verblevel)
static void mpsinputInsertField4(MPSINPUT *mpsi, const char *str)
static const char * mpsinputField5(const MPSINPUT *mpsi)
static SCIP_RETCODE checkVarnames(SCIP *scip, SCIP_VAR **vars, int nvars, unsigned int *maxnamelen, const char ***varnames, SCIP_HASHMAP **varnameHashmap)
static SCIP_RETCODE readSOS(MPSINPUT *mpsi, SCIP *scip)
static void printRhsSection(SCIP *scip, FILE *file, int nconss, const char **consnames, SCIP_Real *rhss, unsigned int maxnamelen, SCIP_Real objoffset)
struct SparseMatrix SPARSEMATRIX
static const char * mpsinputField1(const MPSINPUT *mpsi)
static SCIP_RETCODE readObjsen(SCIP *scip, MPSINPUT *mpsi)
static SCIP_RETCODE checkSparseMatrixCapacity(SCIP *scip, SPARSEMATRIX *matrix, int capacity)
static SCIP_RETCODE readQMatrix(MPSINPUT *mpsi, SCIP_Bool isQuadObj, SCIP *scip)
static SCIP_Bool mpsinputHasError(const MPSINPUT *mpsi)
static SCIP_RETCODE readRows(MPSINPUT *mpsi, SCIP *scip, const char ***consnames, int *consnamessize, int *nconsnames)
static void printBoundSectionName(SCIP *scip, FILE *file)
static const char * mpsinputField2(const MPSINPUT *mpsi)
static void clearFrom(char *buf, unsigned int pos)
static SCIP_RETCODE readRhs(MPSINPUT *mpsi, SCIP *scip)
static void mpsinputSetObjname(MPSINPUT *mpsi, const char *objname)
static SCIP_RETCODE initializeMatrix(SCIP *scip, SPARSEMATRIX **matrix, int slots)
static void freeMatrix(SCIP *scip, SPARSEMATRIX *matrix)
static SCIP_RETCODE readObjname(SCIP *scip, MPSINPUT *mpsi)
enum MpsSection MPSSECTION
static SCIP_Bool mpsinputIsInteger(const MPSINPUT *mpsi)
static SCIP_RETCODE getLinearCoeffs(SCIP *scip, const char *consname, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool transformed, SPARSEMATRIX *matrix, SCIP_Real *rhs)
static void mpsinputSetProbname(MPSINPUT *mpsi, const char *probname)
static void printRangeSection(SCIP *scip, FILE *file, SCIP_CONS **conss, int nconss, const char **consnames, SCIP_Bool transformed, unsigned int maxnamelen)
static SCIP_OBJSENSE mpsinputObjsense(const MPSINPUT *mpsi)
static SCIP_RETCODE readCols(MPSINPUT *mpsi, SCIP *scip, const char ***varnames, int *varnamessize, int *nvarnames)
static SCIP_Bool mpsinputReadLine(MPSINPUT *mpsi)
static void mpsinputSetObjsense(MPSINPUT *mpsi, SCIP_OBJSENSE sense)
static void mpsinputInsertName(MPSINPUT *mpsi, const char *name, SCIP_Bool second)
static MPSSECTION mpsinputSection(const MPSINPUT *mpsi)
static SCIP_RETCODE addVarNameToStorage(SCIP *scip, const char ***varnames, int *varnamessize, int *nvars, const char *colname)
static const char * mpsinputField3(const MPSINPUT *mpsi)
static SCIP_RETCODE checkConsnames(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool transformed, unsigned int *maxnamelen, const char ***consnames, SCIP_Bool *error)
static SCIP_RETCODE addConsNameToStorage(SCIP *scip, const char ***consnames, int *consnamessize, int *ncons, const char *rowname)
static void printColumnSection(SCIP *scip, FILE *file, SPARSEMATRIX *matrix, SCIP_HASHMAP *varnameHashmap, SCIP_HASHTABLE *indicatorSlackHash, unsigned int maxnamelen)
static SCIP_RETCODE readMps(SCIP *scip, const char *filename, const char ***varnames, const char ***consnames, int *varnamessize, int *consnamessize, int *nvarnames, int *nconsnames)
static void printRowType(SCIP *scip, FILE *file, SCIP_Real lhs, SCIP_Real rhs, const char *name)
static SCIP_RETCODE readRanges(MPSINPUT *mpsi, SCIP *scip)
static SCIP_RETCODE mpsinputCreate(SCIP *scip, MPSINPUT **mpsi, SCIP_FILE *fp)
static unsigned int computeFieldWidth(unsigned int width)
struct ConsNameFreq CONSNAMEFREQ
static void printBoundSection(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_VAR **aggvars, int naggvars, SCIP_VAR **fixvars, int nfixvars, SCIP_Bool transformed, const char **varnames, SCIP_HASHTABLE *indicatorSlackHash, unsigned int maxnamelen)
static const char * mpsinputField4(const MPSINPUT *mpsi)
static void printEntry(SCIP *scip, FILE *file, const char *varname, const char *consname, SCIP_Real value, int *recordcnt, unsigned int maxnamelen)
static void printStart(SCIP *scip, FILE *file, const char *col1, const char *col2, int maxnamelen)
static SCIP_RETCODE readIndicators(MPSINPUT *mpsi, SCIP *scip)
static void mpsinputSetSection(MPSINPUT *mpsi, MPSSECTION section)
static void printRecord(SCIP *scip, FILE *file, const char *col1, const char *col2, unsigned int maxnamelen)
static const char * mpsinputObjname(const MPSINPUT *mpsi)
static const char * mpsinputField0(const MPSINPUT *mpsi)
static void mpsinputSyntaxerror(MPSINPUT *mpsi)
static SCIP_RETCODE collectAggregatedVars(SCIP *scip, SCIP_VAR **vars, int nvars, SCIP_VAR ***aggvars, int *naggvars, int *saggvars, SCIP_HASHTABLE *varAggregated)
static SCIP_RETCODE readName(SCIP *scip, MPSINPUT *mpsi)
static SCIP_RETCODE readQCMatrix(MPSINPUT *mpsi, SCIP *scip)
static SCIP_RETCODE readBounds(MPSINPUT *mpsi, SCIP *scip)
static void patchField(char *buf, int beg, int end)
static void mpsinputFree(SCIP *scip, MPSINPUT **mpsi)
(extended) MPS file reader
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 querying solving statistics
public methods for SCIP variables
struct SCIP_Cons SCIP_CONS
struct SCIP_Conshdlr SCIP_CONSHDLR
struct SCIP_Expr SCIP_EXPR
enum SCIP_BoundType SCIP_BOUNDTYPE
enum SCIP_VerbLevel SCIP_VERBLEVEL
struct SCIP_HashMap SCIP_HASHMAP
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
struct SCIP_HashTable SCIP_HASHTABLE
enum SCIP_Objsense SCIP_OBJSENSE
#define SCIP_DECL_READERWRITE(x)
struct SCIP_ReaderData SCIP_READERDATA
struct SCIP_Reader SCIP_READER
#define SCIP_DECL_READERREAD(x)
#define SCIP_DECL_READERCOPY(x)
#define SCIP_DECL_READERFREE(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
enum SCIP_Vartype SCIP_VARTYPE
enum SCIP_Varstatus SCIP_VARSTATUS