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') )
502 assert(strlen(mpsi->buf) >= 80);
505 if( *mpsi->buf !=
BLANK )
507 mpsi->f0 =
SCIPstrtok(&mpsi->buf[0],
" ", &nexttok);
517 if( !mpsi->isnewformat )
520 if( (mpsi->buf[14] ==
'$') && (mpsi->buf[13] ==
' ') )
522 else if( (mpsi->buf[39] ==
'$') && (mpsi->buf[38] ==
' ') )
526 space = mpsi->buf[12] | mpsi->buf[13]
527 | mpsi->buf[22] | mpsi->buf[23]
528 | mpsi->buf[36] | mpsi->buf[37] | mpsi->buf[38]
529 | mpsi->buf[47] | mpsi->buf[48]
530 | mpsi->buf[61] | mpsi->buf[62] | mpsi->buf[63];
540 number = isdigit((
unsigned char)mpsi->buf[24]) || isdigit((
unsigned char)mpsi->buf[25])
541 || isdigit((
unsigned char)mpsi->buf[26]) || isdigit((
unsigned char)mpsi->buf[27])
542 || isdigit((
unsigned char)mpsi->buf[28]) || isdigit((
unsigned char)mpsi->buf[29])
543 || isdigit((
unsigned char)mpsi->buf[30]) || isdigit((
unsigned char)mpsi->buf[31])
544 || isdigit((
unsigned char)mpsi->buf[32]) || isdigit((
unsigned char)mpsi->buf[33])
545 || isdigit((
unsigned char)mpsi->buf[34]) || isdigit((
unsigned char)mpsi->buf[35]);
561 mpsi->isnewformat =
TRUE;
566 mpsi->isnewformat =
TRUE;
590 if( !strcmp(mpsi->f2,
"'MARKER'") )
600 if( !strcmp(mpsi->f3,
"'INTORG'") )
601 mpsi->isinteger =
TRUE;
602 else if( !strcmp(mpsi->f3,
"'INTEND'") )
603 mpsi->isinteger =
FALSE;
607 if( !strcmp(mpsi->f3,
"'MARKER'") )
617 if( !strcmp(mpsi->f4,
"'INTORG'") )
618 mpsi->isinteger =
TRUE;
619 else if( !strcmp(mpsi->f4,
"'INTEND'") )
620 mpsi->isinteger =
FALSE;
630 is_empty = (mpsi->f0 ==
NULL && mpsi->f1 ==
NULL);
632 while( is_marker || is_empty );
679 const char*** varnames,
687 if( varnames !=
NULL )
701 const char*** consnames,
709 if( consnames !=
NULL )
870 const char*** consnames,
927 dynamic = mpsi->dynamicconss;
934 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable,
FALSE) );
938 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable,
FALSE) );
942 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable,
FALSE) );
965 const char*** varnames,
1018 SCIPerrorMessage(
"Coeffients of column <%s> don't appear consecutively (line: %d)\n",
1019 colname, mpsi->lineno);
1141 if( *rhsname ==
'\0' )
1286 if( *rngname ==
'\0' )
1421 goto READBOUNDS_FINISH;
1486 if( *bndname ==
'\0' )
1603 if( semicontsize <= nsemicont )
1606 if( semicont ==
NULL )
1616 semicont[nsemicont] =
var;
1674 assert(*bndname !=
'\0');
1700 for(
i = 0;
i < nsemicont; ++
i )
1777 initial = mpsi->initialconss;
1783 dynamic = mpsi->dynamicconss;
1784 removable = mpsi->dynamicrows;
1822 assert( type == 1 || type == 2 );
1845 SCIP_CALL(
SCIPcreateConsSOS1(
scip, &cons, name, 0,
NULL,
NULL, initial, separate, enforce, check,
propagate,
1846 local, dynamic, removable,
FALSE) );
1851 SCIP_CALL(
SCIPcreateConsSOS2(
scip, &cons, name, 0,
NULL,
NULL, initial, separate, enforce, check,
propagate,
1852 local, dynamic, removable,
FALSE) );
1865 if( consType != 1 && consType != 2 )
1898 assert( consType == 1 || consType == 2 );
1963 SCIPdebugMsg(
scip,
"read %s objective\n", isQuadObj ?
"QUADOBJ" :
"QMATRIX");
2012 for( k = 1; k <= 2; ++k )
2038 coef = strtod(field, &endptr);
2039 if( endptr == field || *endptr !=
'\0' )
2060 quadvars1[cnt] = var1;
2061 quadvars2[cnt] = var2;
2062 quadcoefs[cnt] = coef;
2067 if( var1 == var2 || !isQuadObj )
2068 quadcoefs[cnt] /= 2.0;
2091 SCIP_Bool local, modifiable, dynamic, removable;
2127 retcode =
SCIPcreateConsQuadraticNonlinear(
scip, &cons,
"qmatrix", 1, &qmatrixvar, &minusone, cnt, quadvars1, quadvars2, quadcoefs, lhs, rhs,
2128 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable);
2188 if( lincons ==
NULL )
2280 quadvars1[cnt] = var1;
2281 quadvars2[cnt] = var2;
2282 quadcoefs[cnt] = coef;
2366 initial = mpsi->initialconss;
2372 dynamic = mpsi->dynamicconss;
2373 removable = mpsi->dynamicrows;
2374 stickingatnode =
FALSE;
2404 SCIPerrorMessage(
"Indicator constraints need to be introduced by 'IF' in column 1.\n");
2411 if( lincons ==
NULL )
2429 if( binvar ==
NULL )
2488 for(
i = 0;
i < nlinvars; ++
i )
2491 vals[
i] = -linvals[
i];
2499 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode);
2528 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
2558 const char* filename,
2559 const char*** varnames,
2560 const char*** consnames,
2587 SCIP_CALL_TERMINATE( retcode,
SCIPcreateProb(
scip, mpsi->probname,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL), TERMINATE );
2677 return (
void*)consnamefreq->
consname;
2684 const char* string1 = (
const char*)key1;
2685 const char* string2 = (
const char*)key2;
2721 width =
MAX(8u, width);
2733 unsigned int maxnamelen
2736 unsigned int fieldwidth;
2744 assert( maxnamelen > 0 );
2762 unsigned int fieldwidth;
2768 assert( strlen(col1) <= 2 );
2770 assert( maxnamelen == -1 || maxnamelen > 0 );
2772 if( maxnamelen < 0 )
2780 (void)
SCIPsnprintf(format, 32,
" %%-2.2s %%-%ds ", fieldwidth);
2791 const char* varname,
2795 unsigned int maxnamelen
2802 assert( *recordcnt >= 0 && *recordcnt < 2 );
2806 if( *recordcnt == 0 )
2816 if( *recordcnt == 2 )
2871 (*matrix)->nentries = 0;
2872 (*matrix)->sentries = slots;
2888 if( matrix->nentries + capacity >= matrix->sentries )
2890 matrix->sentries = matrix->sentries * 2 + capacity;
2946 nactivevars =
nvars;
2957 for( v = 0; v < nactivevars; ++v )
2958 activevals[v] = 1.0;
2966 if( requiredsize > nactivevars )
2972 assert( requiredsize <= nactivevars );
2977 for( v = 0; v < nactivevars; ++v )
2987 activeconstant += activevals[v];
2988 activevals[v] *= -1.0;
2995 assert( matrix->nentries + nactivevars < matrix->sentries );
2997 for( v = 0; v < nactivevars; ++v )
2999 matrix->values[matrix->nentries] = activevals[v];
3000 matrix->columns[matrix->nentries] = activevars[v];
3001 matrix->rows[matrix->nentries] =
consname;
3006 (*rhs) -= activeconstant;
3036 for( v = 0; v <
nvars; ++v )
3053 if ( *saggvars <= *naggvars )
3057 assert( newsize > *saggvars );
3059 *saggvars = newsize;
3062 (*aggvars)[*naggvars] =
var;
3065 assert( *naggvars <= *saggvars );
3079 unsigned int* maxnamelen,
3080 const char*** varnames,
3100 for( v = 0; v <
nvars; ++v )
3116 (*maxnamelen) =
MAX(*maxnamelen, (
unsigned int) l);
3126 (*varnames)[v] = varname;
3131 SCIPwarningMessage(
scip,
"there are %d variable names which have to be cut down to %d characters; LP might be corrupted\n",
3144 unsigned int* maxnamelen,
3145 const char*** consnames,
3164 hashGetKeyNamefreq, hashKeyEqString, SCIPhashKeyValString,
NULL) );
3166 for(
i = 0;
i < nconss; ++
i )
3182 SCIPwarningMessage(
scip,
"At least one name of a constraint is empty, so file will be written with generic names.\n");
3189 consnamefreqs[
i].
freq = 0;
3195 consnamefreq->
freq += 1;
3196 consnamefreqs[
i] = *consnamefreq;
3207 SCIPwarningMessage(
scip,
"Constraints have duplicate name and are too long to fix, so file will be written with generic names.\n");
3213 (*maxnamelen) =
MAX(*maxnamelen, (
unsigned int) l);
3251 unsigned int maxnamelen
3256 const char* varname;
3262 SCIPsortPtrPtrReal((
void**) matrix->columns, (
void**) matrix->rows, matrix->values, SCIPvarComp, matrix->nentries);
3269 for( v = 0; v < matrix->nentries; )
3271 var = matrix->columns[v];
3312 value = matrix->values[v];
3315 printEntry(
scip, file, varname, matrix->rows[v], value, &recordcnt, maxnamelen);
3318 while( v < matrix->nentries &&
var == matrix->columns[v] );
3320 if( recordcnt == 1 )
3341 const char** consnames,
3343 unsigned int maxnamelen,
3356 for(
c = 0;
c < nconss; ++
c )
3364 printEntry(
scip, file,
"RHS", consnames[
c], rhss[
c], &recordcnt, maxnamelen);
3370 printEntry(
scip, file,
"RHS",
"Obj", -objoffset, &recordcnt, maxnamelen);
3373 if( recordcnt == 1 )
3385 const char** consnames,
3387 unsigned int maxnamelen
3394 const char* conshdlrname;
3403 for(
c = 0;
c < nconss; ++
c )
3420 if( strcmp(conshdlrname,
"linear") == 0 )
3425 else if( strcmp(conshdlrname,
"varbound") == 0 )
3436 printEntry(
scip, file,
"RANGE", consnames[
c], rhs - lhs, &recordcnt, maxnamelen);
3466 const char** varnames,
3468 unsigned int maxnamelen
3476 const char* varname;
3483 sectionName =
FALSE;
3486 for( v = 0; v <
nvars; ++v )
3496 varname = varnames[v];
3644 for( v = 0; v < naggvars; ++v )
3656 varname = varnames[
nvars + v];
3676 for( v = 0; v < nfixvars; ++v )
3689 varname = varnames[
nvars + naggvars + v];
3801 "reading/" READER_NAME "/linearize-and-constraints",
3802 "should possible \"and\" constraint be linearized when writing the mps file?",
3806 "should an aggregated linearization for and constraints be used?",
3817 const char* filename,
3819 const char*** varnames,
3820 const char*** consnames,
3833 retcode =
readMps(
scip, filename, varnames, consnames, varnamessize, consnamessize, nvarnames, nconsnames);
3883 const char** consnames;
3886 const char* conshdlrname;
3894 const char* varname;
3895 const char** varnames;
3926 unsigned int maxnamelen;
3972 saggvars = nfixedvars;
3976 if( nfixedvars > 0 )
3981 varFixedHash =
NULL;
3988 indicatorSlackHash =
NULL;
4000 if( readerdata->linearizeands )
4004 if( andconshdlr !=
NULL )
4008 for(
c = nconss - 1;
c >= 0; --
c )
4015 if( strcmp(conshdlrname,
"and") == 0 )
4017 if( readerdata->aggrlinearizationands )
4039 SCIPinfoMessage(
scip, file,
"* Variables : %d (%d binary, %d integer, %d implicit integer, %d continuous)\n",
4058 for( v = 0; v <
nvars; ++v )
4072 assert( matrix->nentries < matrix->sentries );
4074 matrix->values[matrix->nentries] =
objscale * value;
4075 matrix->columns[matrix->nentries] =
var;
4076 matrix->rows[matrix->nentries] =
"Obj";
4083 for(
c = 0;
c < nconss; ++
c )
4104 if( strcmp(conshdlrname,
"linear") == 0 )
4130 else if( strcmp(conshdlrname,
"setppc") == 0 )
4151 else if( strcmp(conshdlrname,
"logicor") == 0 )
4161 else if( strcmp(conshdlrname,
"knapsack") == 0 )
4173 for(
i = 0;
i < nconsvars; ++
i )
4183 else if( strcmp(conshdlrname,
"varbound") == 0 )
4221 else if( strcmp(conshdlrname,
"indicator") == 0 )
4250 consIndicator[nConsIndicator++] = cons;
4253 else if( strcmp(conshdlrname,
"SOS1") == 0 )
4256 consSOS1[nConsSOS1++] = cons;
4268 else if( strcmp(conshdlrname,
"SOS2") == 0 )
4271 consSOS2[nConsSOS2++] = cons;
4282 else if( strcmp(conshdlrname,
"nonlinear") == 0 )
4307 consQuadratic[nConsQuadratic++] = cons;
4317 for( j = 0; j < nquadexprs; ++j )
4354 for( j = 0; j < nlinexprs; ++j )
4369 consvars = quadvars;
4370 nconsvars = nquadexprs;
4377 else if( strcmp(conshdlrname,
"and") == 0 )
4379 if( readerdata->linearizeands )
4402 if( !readerdata->aggrlinearizationands )
4404 rowvars[0] = resultant;
4410 n = (int) log10((
double)nrowvars) + 1 + l;
4417 maxnamelen =
MAX(maxnamelen, (
unsigned int) n);
4420 for( v = 0; v < nrowvars; ++v )
4426 n = (int) log10((
double)v) + 2;
4439 assert(k < nconss + naddrows);
4440 consnames[k] = rowname;
4443 rowvars[1] = operands[v];
4457 for( v = nrowvars - 1; v >= 0; --v )
4459 rowvars[v] = operands[v];
4463 rowvars[nrowvars] = resultant;
4466 if( readerdata->aggrlinearizationands )
4479 maxnamelen =
MAX(maxnamelen, (
unsigned int) n);
4484 assert(k < nconss + naddrows);
4485 consnames[k] = rowname;
4490 rowvals[nrowvars] = (
SCIP_Real) nrowvars;
4504 rowvals[nrowvars] = 1.0;
4509 rhss[
c] = -nrowvars + 1.0;
4537 SCIPwarningMessage(
scip,
"there are %d and-constraint-rownames which have to be cut down to %d characters; MPS file might be corrupted\n",
4542 if( varFixedHash !=
NULL )
4545 if( indicatorSlackHash !=
NULL && nConsIndicator == 0 )
4560 for(
c = 0;
c < naggvars; ++
c )
4571 maxnamelen =
MAX(maxnamelen, (
unsigned int) l);
4577 varnames[
nvars +
c] = namestr;
4586 l = strlen(namestr);
4587 maxnamelen =
MAX(maxnamelen, (
unsigned int) l);
4588 consnames[nconss + naddrows +
c] = namestr;
4589 rhss[nconss + naddrows +
c] = 0.0;
4596 matrix->values[matrix->nentries] = -1.0;
4597 matrix->columns[matrix->nentries] = aggvars[
c];
4598 matrix->rows[matrix->nentries] = namestr;
4605 if( nfixedvars > 0 )
4607 int startpos =
nvars + naggvars;
4616 for( v = nfixedvars - 1; v >= 0; --v )
4628 maxnamelen =
MAX(maxnamelen, (
unsigned int) l);
4633 varnames[startpos + nfixvars] = namestr;
4634 fixvars[nfixvars] =
var;
4643 matrix->values[matrix->nentries] = 0.0;
4644 matrix->columns[matrix->nentries] =
var;
4645 matrix->rows[matrix->nentries] =
"Obj";
4662 printBoundSection(
scip, file,
vars,
nvars, aggvars, naggvars, fixvars, nfixvars, transformed, varnames, indicatorSlackHash, maxnamelen);
4664 if( nfixedvars > 0 )
4670 if( nConsSOS1 > 0 || nConsSOS2 > 0 )
4680 for(
c = 0;
c < nConsSOS1; ++
c )
4691 for( v = 0; v < nconsvars; ++v )
4699 if( sosweights !=
NULL )
4709 for(
c = 0;
c < nConsSOS2; ++
c )
4720 for( v = 0; v < nconsvars; ++v )
4728 if( sosweights !=
NULL )
4742 if( nConsQuadratic > 0 )
4744 const char* varname2;
4747 SCIPdebugMsg(
scip,
"start printing QCMATRIX sections for quadratic constraints\n");
4750 for(
c = 0;
c < nConsQuadratic; ++
c )
4754 cons = consQuadratic[
c];
4764 for( v = 0; v < nconsvars; ++v )
4771 if( sqrcoef == 0.0 )
4792 for( v = 0; v < nbilin; ++v )
4837 if( nConsIndicator > 0 )
4845 for(
c = 0;
c < nConsIndicator; ++
c )
4851 cons = consIndicator[
c];
4898 if( indicatorSlackHash !=
NULL )
4914 for( v =
nvars + naggvars + nfixvars - 1; v >= 0; --v )
4918 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 SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(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 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_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