Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://scip.zib.de/doc/html/reader__mps_8c_source.php below:

SCIP Doxygen Documentation: reader_mps.c Source File

assert(mpsi !=

);

(*mpsi)->haserror =

;

(*mpsi)->isinteger =

;

(*mpsi)->isnewformat =

;

(*mpsi)->buf [0] =

;

(*mpsi)->probname[0] =

;

(*mpsi)->objname [0] =

;

assert(mpsi !=

);

mpsi->section;

assert(mpsi !=

);

assert(mpsi !=

);

assert(mpsi !=

);

assert(mpsi !=

);

assert(mpsi !=

);

assert(mpsi !=

);

assert(mpsi !=

);

mpsi->objname;

assert(mpsi !=

);

mpsi->objsense;

assert(mpsi !=

);

mpsi->haserror;

assert(mpsi !=

);

mpsi->isinteger;

assert(mpsi !=

);

mpsi->section = section;

* probname

assert(mpsi !=

);

assert(probname !=

);

assert(strlen(probname) <

(mpsi->probname));

assert(mpsi !=

);

assert(objname !=

);

assert(strlen(objname) <

(mpsi->objname));

assert(mpsi !=

);

mpsi->objsense = sense;

assert(mpsi !=

);

mpsi->haserror =

;

* what_name,

* entity_name,

assert(mpsi !=

);

assert(what !=

);

assert(what_name !=

);

assert(entity !=

);

assert(entity_name !=

);

, mpsi->lineno, what, what_name, entity, entity_name);

(i = pos; i < 80; i++)

( (beg <= end) && (buf[end] ==

) )

( (beg <= end) && (buf[beg] ==

) )

( i = beg; i <= end; i++ )

( buf[i] ==

)

mpsi->f0 = mpsi->f1 = mpsi->f2 = mpsi->f3 = mpsi->f4 = mpsi->f5 = 0;

(

==

(mpsi->buf, (

)

(mpsi->buf), mpsi->fp) )

( *mpsi->buf ==

);

len = (

int) strlen(mpsi->buf);

( i = 0; i < len; i++ )

( (mpsi->buf[i] ==

) || (mpsi->buf[i] ==

) || (mpsi->buf[i] ==

) )

mpsi->buf[i] =

;

( len > 0 && mpsi->buf[len-1] ==

)

assert(strlen(mpsi->buf) >= 80);

( *mpsi->buf !=

)

mpsi->f0 =

(&mpsi->buf[0],

, &nexttok);

assert(mpsi->f0 != 0);

( !mpsi->isnewformat )

( (mpsi->buf[14] ==

) && (mpsi->buf[13] ==

) )

( (mpsi->buf[39] ==

) && (mpsi->buf[38] ==

) )

space = mpsi->buf[12] | mpsi->buf[13]

| mpsi->buf[22] | mpsi->buf[23]

| mpsi->buf[36] | mpsi->buf[37] | mpsi->buf[38]

| mpsi->buf[47] | mpsi->buf[48]

| mpsi->buf[61] | mpsi->buf[62] | mpsi->buf[63];

( space ==

)

= isdigit((

)mpsi->buf[24]) || isdigit((

)mpsi->buf[25])

|| isdigit((

)mpsi->buf[26]) || isdigit((

)mpsi->buf[27])

|| isdigit((

)mpsi->buf[28]) || isdigit((

)mpsi->buf[29])

|| isdigit((

)mpsi->buf[30]) || isdigit((

)mpsi->buf[31])

|| isdigit((

)mpsi->buf[32]) || isdigit((

)mpsi->buf[33])

|| isdigit((

)mpsi->buf[34]) || isdigit((

)mpsi->buf[35]);

mpsi->isnewformat =

;

mpsi->isnewformat =

;

( (

== (mpsi->f2 =

(

,

, &nexttok))) || (*mpsi->f2 ==

) )

( !strcmp(mpsi->f2,

) )

( (

== (mpsi->f3 =

(

,

, &nexttok))) || (*mpsi->f3 ==

) )

( !strcmp(mpsi->f3,

) )

mpsi->isinteger =

;

( !strcmp(mpsi->f3,

) )

mpsi->isinteger =

;

( !strcmp(mpsi->f3,

) )

( (

== (mpsi->f4 =

(

,

, &nexttok))) || (*mpsi->f4 ==

) )

( !strcmp(mpsi->f4,

) )

mpsi->isinteger =

;

( !strcmp(mpsi->f4,

) )

mpsi->isinteger =

;

( (

== (mpsi->f5 =

(

,

, &nexttok))) || (*mpsi->f5 ==

) )

is_empty = (mpsi->f0 ==

&& mpsi->f1 ==

);

( is_marker || is_empty );

assert(mpsi !=

);

assert(str !=

);

assert(mpsi !=

);

assert(name !=

);

*** varnames,

( varnames !=

)

*** consnames,

( consnames !=

)

assert(mpsi !=

);

assert(mpsi !=

);

assert(mpsi !=

);

*** consnames,

dynamic = mpsi->dynamicconss;

initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable,

) );

initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable,

) );

initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable,

) );

*** varnames,

assert(var ==

);

assert(var ==

);

(

,

colname, mpsi->lineno);

assert(var !=

);

(

,

( *rhsname ==

)

( *rngname ==

)

READBOUNDS_FINISH;

( l = (

) strlen(

(mpsi)) - 1; l >= 0; --l )

( *bndname ==

)

assert(var !=

);

assert(!infeasible);

(

,

,

(var), val);

(

,

,

(var), val);

(

,

,

(var), val);

(

,

,

(var), val);

( semicontsize <= nsemicont )

( semicont ==

)

assert(semicont !=

);

semicont[nsemicont] = var;

assert(*bndname !=

);

( nsemicont > 0 )

assert(semicont !=

);

( i = 0; i < nsemicont; ++i )

assert(oldlb >= 0.0);

initial = mpsi->initialconss;

dynamic = mpsi->dynamicconss;

removable = mpsi->dynamicrows;

assert( type == 1 || type == 2 );

(

(

, &cons, name, 0,

,

, initial, separate, enforce, check, propagate,

local, dynamic, removable,

) );

assert( type == 2 );

(

(

, &cons, name, 0,

,

, initial, separate, enforce, check, propagate,

local, dynamic, removable,

) );

(

,

, name, type);

( consType != 1 && consType != 2 )

assert( consType == 1 || consType == 2 );

(

,

, isQuadObj ?

:

);

( k = 1; k <= 2; ++k )

(

== field )

coef = strtod(field, &endptr);

( endptr == field || *endptr !=

)

assert(newsize > size);

quadvars1[cnt] = var1;

quadvars2[cnt] = var2;

quadcoefs[cnt] = coef;

( var1 == var2 || !isQuadObj )

quadcoefs[cnt] /= 2.0;

initial, separate, enforce, check, propagate;

local, modifiable, dynamic, removable;

modifiable =

;

retcode =

(

, &cons,

, 1, &qmatrixvar, &minusone, cnt, quadvars1, quadvars2, quadcoefs, lhs, rhs,

initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable);

( lincons ==

)

assert(newsize > size);

quadvars1[cnt] = var1;

quadvars2[cnt] = var2;

quadcoefs[cnt] = coef;

initial = mpsi->initialconss;

dynamic = mpsi->dynamicconss;

removable = mpsi->dynamicrows;

stickingatnode =

;

(

);

( lincons ==

)

( binvar ==

)

assert( binvar !=

);

( i = 0; i < nlinvars; ++i )

vars[i] = linvars[i];

vals[i] = -linvals[i];

initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode);

initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode) );

* filename,

*** varnames,

*** consnames,

* consnamessize,

assert(filename !=

);

( retcode,

(

, mpsi->probname,

,

,

,

,

,

,

), TERMINATE );

assert(consnamefreq !=

);

(

*)consnamefreq->

;

* string1 = (

*)key1;

* string2 = (

*)key2;

width =

(8u, width);

maxnamelen

fieldwidth;

assert( col1 !=

);

assert( col2 !=

);

assert( maxnamelen > 0 );

fieldwidth;

assert( col1 !=

);

assert( col2 !=

);

assert( strlen(col1) <= 2 );

assert( maxnamelen == -1 || maxnamelen > 0 );

( maxnamelen < 0 )

(void)

(format, 32,

, fieldwidth);

* varname,

maxnamelen

assert( recordcnt !=

);

assert( *recordcnt >= 0 && *recordcnt < 2 );

( *recordcnt == 0 )

( *recordcnt == 2 )

assert( name !=

);

(*matrix)->nentries = 0;

(*matrix)->sentries = slots;

( matrix->nentries + capacity >= matrix->sentries )

matrix->sentries = matrix->sentries * 2 + capacity;

assert( nvars == 0 || vars !=

);

assert( matrix !=

);

nactivevars = nvars;

( v = 0; v < nactivevars; ++v )

activevals[v] = 1.0;

( requiredsize > nactivevars )

assert( requiredsize <= nactivevars );

( v = 0; v < nactivevars; ++v )

activeconstant += activevals[v];

activevals[v] *= -1.0;

assert( matrix->nentries + nactivevars < matrix->sentries );

( v = 0; v < nactivevars; ++v )

matrix->values[matrix->nentries] = activevals[v];

matrix->columns[matrix->nentries] = activevars[v];

matrix->rows[matrix->nentries] =

;

(*rhs) -= activeconstant;

assert( aggvars !=

);

assert( naggvars !=

);

assert( saggvars !=

);

( v = 0; v < nvars; ++v )

assert( varAggregated !=

);

( *saggvars <= *naggvars )

assert( newsize > *saggvars );

*saggvars = newsize;

(*aggvars)[*naggvars] = var;

assert( *naggvars <= *saggvars );

* maxnamelen,

*** varnames,

assert( vars !=

);

assert( maxnamelen !=

);

( v = 0; v < nvars; ++v )

assert( var !=

);

(*maxnamelen) =

(*maxnamelen, (

) l);

(*varnames)[v] = varname;

(

,

,

* maxnamelen,

*** consnames,

assert(maxnamelen !=

);

hashGetKeyNamefreq, hashKeyEqString, SCIPhashKeyValString,

) );

( i = 0; i < nconss; ++i )

assert( cons !=

);

(

,

);

consnamefreqs[i].

= 0;

consnamefreq->

+= 1;

consnamefreqs[i] = *consnamefreq;

(

,

);

(*maxnamelen) =

(*maxnamelen, (

) l);

( ; i >= 0; --i)

maxnamelen

* varname;

((

**) matrix->columns, (

**) matrix->rows, matrix->values, SCIPvarComp, matrix->nentries);

intSection =

;

( v = 0; v < matrix->nentries; )

var = matrix->columns[v];

assert( var !=

);

intSection =

;

value = matrix->values[v];

(

, file, varname, matrix->rows[v], value, &recordcnt, maxnamelen);

( v < matrix->nentries && var == matrix->columns[v] );

( recordcnt == 1 )

** consnames,

maxnamelen,

assert( rhss !=

);

( c = 0; c < nconss; ++c )

assert(consnames[c] !=

);

(

, file,

, consnames[c], rhss[c], &recordcnt, maxnamelen);

(

, file,

,

, -objoffset, &recordcnt, maxnamelen);

( recordcnt == 1 )

** consnames,

maxnamelen

* conshdlrname;

( c = 0; c < nconss; ++c )

assert( cons !=

);

assert( consnames[c] !=

);

assert( conshdlr !=

);

( strcmp(conshdlrname,

) == 0 )

( strcmp(conshdlrname,

) == 0 )

(

, file,

, consnames[c], rhs - lhs, &recordcnt, maxnamelen);

(recordcnt == 1 )

** varnames,

maxnamelen

* varname;

assert(vars !=

);

assert(nfixvars == 0 || fixvars !=

);

sectionName =

;

( v = 0; v < nvars; ++v )

assert( var !=

);

varname = varnames[v];

sectionName =

;

sectionName =

;

sectionName =

;

sectionName =

;

sectionName =

;

sectionName =

;

sectionName =

;

( v = 0; v < naggvars; ++v )

sectionName =

;

assert( var !=

);

varname = varnames[nvars + v];

( v = 0; v < nfixvars; ++v )

assert(transformed);

assert(fixvars !=

&& fixvars[v] !=

);

assert(var !=

);

varname = varnames[nvars + naggvars + v];

sectionName =

;

assert(reader !=

);

assert(readerdata !=

);

assert(reader !=

);

assert(reader !=

);

nvars, nbinvars, nintvars, nimplvars, ncontvars, fixedvars, nfixedvars, conss, nconss, result) );

,

,

,

,

* filename,

*** varnames,

*** consnames,

* consnamessize,

assert(reader !=

);

assert(result !=

);

retcode =

(

, filename, varnames, consnames, varnamessize, consnamessize, nvarnames, nconsnames);

** consnames;

* conshdlrname;

* varname;

** varnames;

maxnamelen;

assert(reader !=

);

assert(result !=

);

needRANGES =

;

saggvars = nfixedvars;

( nfixedvars > 0 )

varFixedHash =

;

indicatorSlackHash =

;

assert( matrix->sentries >= nvars );

assert(readerdata !=

);

( readerdata->linearizeands )

( andconshdlr !=

)

( c = nconss - 1; c >= 0; --c )

assert(conshdlr !=

);

( strcmp(conshdlrname,

) == 0 )

( readerdata->aggrlinearizationands )

assert(naddrows >= 0);

(

, file,

,

nvars, nbinvars, nintvars, nimplvars, ncontvars);

( v = 0; v < nvars; ++v )

assert( matrix->nentries < matrix->sentries );

matrix->values[matrix->nentries] = objscale * value;

matrix->columns[matrix->nentries] = var;

matrix->rows[matrix->nentries] =

;

( c = 0; c < nconss; ++c )

assert( cons !=

);

assert( conshdlr !=

);

( strcmp(conshdlrname,

) == 0 )

( strcmp(conshdlrname,

) == 0 )

( strcmp(conshdlrname,

) == 0 )

( strcmp(conshdlrname,

) == 0 )

( i = 0; i < nconsvars; ++i )

( strcmp(conshdlrname,

) == 0 )

( strcmp(conshdlrname,

) == 0 )

assert( slackvar !=

);

assert( indicatorSlackHash !=

);

assert( binvar !=

);

consIndicator[nConsIndicator++] = cons;

( strcmp(conshdlrname,

) == 0 )

consSOS1[nConsSOS1++] = cons;

( strcmp(conshdlrname,

) == 0 )

consSOS2[nConsSOS2++] = cons;

( strcmp(conshdlrname,

) == 0 )

consQuadratic[nConsQuadratic++] = cons;

( j = 0; j < nquadexprs; ++j )

( j = 0; j < nlinexprs; ++j )

consvars = quadvars;

nconsvars = nquadexprs;

( strcmp(conshdlrname,

) == 0 )

( readerdata->linearizeands )

( !readerdata->aggrlinearizationands )

rowvars[0] = resultant;

n = (int) log10((

)nrowvars) + 1 + l;

maxnamelen =

(maxnamelen, (

) n);

( v = 0; v < nrowvars; ++v )

n = (int) log10((

)v) + 2;

assert(k < nconss + naddrows);

consnames[k] = rowname;

rowvars[1] = operands[v];

( v = nrowvars - 1; v >= 0; --v )

rowvars[v] = operands[v];

rowvars[nrowvars] = resultant;

( readerdata->aggrlinearizationands )

maxnamelen =

(maxnamelen, (

) n);

assert(k < nconss + naddrows);

consnames[k] = rowname;

rowvals[nrowvars] = (

) nrowvars;

rowvals[nrowvars] = 1.0;

rhss[c] = -nrowvars + 1.0;

(

,

,

( varFixedHash !=

)

( indicatorSlackHash !=

&& nConsIndicator == 0 )

assert( indicatorSlackHash ==

);

( c = 0; c < naggvars; ++c )

maxnamelen =

(maxnamelen, (

) l);

varnames[nvars + c] = namestr;

l = strlen(namestr);

maxnamelen =

(maxnamelen, (

) l);

consnames[nconss + naddrows + c] = namestr;

rhss[nconss + naddrows + c] = 0.0;

matrix->values[matrix->nentries] = -1.0;

matrix->columns[matrix->nentries] = aggvars[c];

matrix->rows[matrix->nentries] = namestr;

( nfixedvars > 0 )

startpos = nvars + naggvars;

( v = nfixedvars - 1; v >= 0; --v )

maxnamelen =

(maxnamelen, (

) l);

varnames[startpos + nfixvars] = namestr;

fixvars[nfixvars] = var;

matrix->values[matrix->nentries] = 0.0;

matrix->columns[matrix->nentries] = var;

matrix->rows[matrix->nentries] =

;

(

, file, nconss + naddrows +naggvars, consnames, rhss, maxnamelen, objscale * objoffset);

(

, file, vars, nvars, aggvars, naggvars, fixvars, nfixvars, transformed, varnames, indicatorSlackHash, maxnamelen);

( nfixedvars > 0 )

( nConsSOS1 > 0 || nConsSOS2 > 0 )

( c = 0; c < nConsSOS1; ++c )

( v = 0; v < nconsvars; ++v )

( sosweights !=

)

( c = 0; c < nConsSOS2; ++c )

( v = 0; v < nconsvars; ++v )

( sosweights !=

)

( nConsQuadratic > 0 )

* varname2;

(

,

);

( c = 0; c < nConsQuadratic; ++c )

cons = consQuadratic[c];

( v = 0; v < nconsvars; ++v )

( sqrcoef == 0.0 )

( v = 0; v < nbilin; ++v )

( nConsIndicator > 0 )

( c = 0; c < nConsIndicator; ++c )

cons = consIndicator[c];

( indicatorSlackHash !=

)

( v = nvars + naggvars + nfixvars - 1; v >= 0; --v )

( 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 SCIPincludeReaderBasic(SCIP *scip, SCIP_READER **readerptr, const char *name, const char *desc, const char *extension, SCIP_READERDATA *readerdata)

SCIP_RETCODE SCIPsetReaderCopy(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERCOPY((*readercopy)))

SCIP_READERDATA * SCIPreaderGetData(SCIP_READER *reader)

SCIP_RETCODE SCIPsetReaderFree(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERFREE((*readerfree)))

const char * SCIPreaderGetName(SCIP_READER *reader)

SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERREAD((*readerread)))

SCIP_RETCODE SCIPsetReaderWrite(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERWRITE((*readerwrite)))

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)

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

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)

static SCIP_DECL_READERWRITE(readerWriteMps)

struct SparseMatrix SPARSEMATRIX

static const char * mpsinputField1(const MPSINPUT *mpsi)

static SCIP_DECL_HASHKEYEQ(hashKeyEqString)

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_DECL_READERFREE(readerFreeMps)

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 SCIP_DECL_HASHGETKEY(hashGetKeyNamefreq)

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_DECL_READERCOPY(readerCopyMps)

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 SCIP_DECL_READERREAD(readerReadMps)

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)

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 SCIP_DECL_HASHKEYVAL(hashKeyValVar)

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)

#define DEFAULT_AGGRLINEARIZATION_ANDS

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)

#define DEFAULT_LINEARIZE_ANDS

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

enum SCIP_BoundType SCIP_BOUNDTYPE

enum SCIP_VerbLevel SCIP_VERBLEVEL

enum SCIP_Objsense SCIP_OBJSENSE

struct SCIP_ReaderData SCIP_READERDATA

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4