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

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

SCIP Doxygen Documentation: reader_opb.c Source File

assert(opbinput !=

);

(

, opbinput->linenumber, msg, opbinput->token);

( opbinput->linebuf[opbinput->linebufsize - 1] ==

)

opbinput->haserror =

;

assert(opbinput !=

);

opbinput->haserror;

assert(hasdot !=

);

assert(exptype !=

);

( isdigit((

)c) )

( (*exptype ==

) && !(*hasdot) && (c ==

) )

( !firstchar && (*exptype ==

) && (c ==

|| c ==

) )

( nextc ==

|| nextc ==

)

( isdigit((

)nextc) )

( (*exptype ==

) && (c ==

|| c ==

) )

assert(opbinput !=

);

opbinput->linepos = 0;

opbinput->linebuf[opbinput->linebufsize - 2] =

;

(

(opbinput->linebuf, opbinput->linebufsize, opbinput->file) ==

)

opbinput->linenumber++;

( opbinput->linebuf[opbinput->linebufsize - 2] !=

)

opbinput->linebuf[newsize-2] =

;

(

(opbinput->linebuf + opbinput->linebufsize - 1, newsize - opbinput->linebufsize + 1, opbinput->file) ==

)

opbinput->linebufsize = newsize;

opbinput->linebuf[opbinput->linebufsize - 1] =

;

commentstart = strchr(opbinput->linebuf,

[i]);

( commentstart !=

)

*commentstart =

;

*(commentstart+1) =

;

*pointer1 = *pointer2;

assert(opbinput !=

);

assert(opbinput->linepos < opbinput->linebufsize);

( opbinput->npushedtokens > 0 )

(&opbinput->token, &opbinput->pushedtokens[opbinput->npushedtokens-1]);

opbinput->npushedtokens--;

(

,

, opbinput->linenumber, opbinput->token);

buf = opbinput->linebuf;

( buf[opbinput->linepos] ==

)

assert(opbinput->linepos == 0);

buf = opbinput->linebuf;

assert(opbinput->linepos < opbinput->linebufsize);

(

(buf[opbinput->linepos], buf[opbinput->linepos+1],

, &hasdot, &exptype) )

opbinput->token[tokenlen] = buf[opbinput->linepos];

(

(buf[opbinput->linepos], buf[opbinput->linepos+1],

, &hasdot, &exptype) );

opbinput->token[tokenlen] = buf[opbinput->linepos];

( tokenlen == 1 &&

(opbinput->token[0]) )

&& (opbinput->token[tokenlen-1] ==

|| opbinput->token[tokenlen-1] ==

|| opbinput->token[tokenlen-1] ==

)

&& buf[opbinput->linepos] ==

)

( opbinput->token[tokenlen-1] ==

&& (buf[opbinput->linepos] ==

|| buf[opbinput->linepos] ==

) )

opbinput->token[tokenlen-1] = buf[opbinput->linepos];

opbinput->token[tokenlen] =

;

(

,

, opbinput->linenumber, opbinput->token);

assert(opbinput !=

);

(&opbinput->pushedtokens[opbinput->npushedtokens], &opbinput->token);

opbinput->npushedtokens++;

assert(opbinput !=

);

(&opbinput->pushedtokens[opbinput->npushedtokens], &opbinput->tokenbuf);

opbinput->npushedtokens++;

assert(opbinput !=

);

assert(opbinput !=

);

( *(opbinput->token) ==

)

assert(opbinput !=

);

assert(sign !=

);

assert(*sign == +1 || *sign == -1);

( strlen(opbinput->token) == 1 )

assert(opbinput->token[1] ==

);

( *opbinput->token ==

)

( *opbinput->token ==

)

assert(opbinput !=

);

assert(value !=

);

val = strtod(opbinput->token, &endptr);

( endptr != opbinput->token && *endptr ==

)

( strlen(opbinput->token) > 18 )

opbinput->nproblemcoeffs++;

assert(opbinput !=

);

( strcmp(opbinput->token,

) == 0 )

( strcmp(opbinput->token,

) == 0 )

( strcmp(opbinput->token,

) == 0 )

assert(opbinput !=

);

( strcmp(opbinput->token,

) == 0 )

assert(opbinput !=

);

( strcmp(opbinput->token,

) == 0 )

initial = !dynamiccols;

removable = dynamiccols;

assert(opbinput !=

);

assert(vars !=

);

assert(nvars !=

);

assert(varssize !=

);

assert(*varssize >= 0);

name = opbinput->token;

assert(name !=

);

(!isdigit((

) *name ) && !

(*name) && !opbinput->haserror )

( *nvars == *varssize )

(*vars)[*nvars] = var;

opbinput->haserror =

;

name = opbinput->token;

*

nlincoefs,

*

ntermcoefs,

assert(opbinput !=

);

assert(name !=

);

assert(linvars !=

);

assert(lincoefs !=

);

assert(lincoefssize !=

);

assert(nlincoefs !=

);

assert(terms !=

);

assert(termcoefs !=

);

assert(ntermvars !=

);

assert(termcoefssize !=

);

assert(ntermcoefs !=

);

assert(newsection !=

);

*newsection =

;

*isNonlinear =

;

*issoftcons =

;

( strcmp(opbinput->token,

) == 0 )

(

,

, opbinput->linenumber, name);

(

, opbinput,

);

(

,

, opbinput->linenumber);

assert(

( opbinput->file ) );

opbinput->eof =

;

haveweightstart =

;

haveweightend =

;

(

(opbinput, &coefsign) )

(

,

, opbinput->linenumber, coefsign);

( (*nlincoefs > 0 || *ntermcoefs > 0 || ntmpcoefs > 0) && !havesign )

(

,

, opbinput->linenumber, coef, coefsign);

( strcmp(name,

) == 0 )

assert(ntmpcoefs == 0);

tmpcoefs[ntmpcoefs] = coefsign * coef;

( *nlincoefs == 0 && *ntermcoefs == 0 && ntmpcoefs == 0 && !havesign && !havevalue && strcmp(name,

) != 0 &&

(

, opbinput) )

( !opbinput->wbo )

(

,

, opbinput->linenumber);

haveweightstart =

;

*weight = coefsign * coef;

(

,

, opbinput->linenumber, *weight);

haveweightend =

;

( haveweightstart != haveweightend )

( strcmp(name,

) == 0 )

*isNonlinear =

;

(

,

, opbinput->linenumber, coefsign * coef);

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

assert(*ntermcoefs <= *termcoefssize);

( *ntermcoefs >= *termcoefssize )

*termcoefssize = newsize;

assert(*ntermcoefs < *termcoefssize);

(*ntermvars)[*ntermcoefs] = ntmpvars;

( --ntmpvars; ntmpvars >= 0; --ntmpvars )

(*terms)[*ntermcoefs][ntmpvars] = tmpvars[ntmpvars];

(*termcoefs)[*ntermcoefs] = coefsign * coef;

(

,

, (*termcoefs)[*ntermcoefs], opbinput->linenumber);

assert(ntmpvars == 1);

assert(*nlincoefs <= *lincoefssize);

( *nlincoefs >= *lincoefssize )

*lincoefssize = newsize;

assert(*nlincoefs < *lincoefssize);

(*linvars)[*nlincoefs] = tmpvars[0];

(*lincoefs)[*nlincoefs] = coefsign * coef;

(

,

, (*lincoefs)[*nlincoefs], opbinput->linenumber);

( !opbinput->haserror )

assert(ntmpvars == 0);

( ntmpcoefs > 0 )

assert(ntmpcoefs == 1);

assert(*nlincoefs == 0 && *ntermcoefs == 0);

(*lincoefs)[*nlincoefs] = tmpcoefs[0];

*

ntermvars,

ntermcoefs

assert(opbinput !=

);

assert(ncoefs == 0 || (linvars !=

&& coefs !=

));

assert(ntermcoefs == 0 || (terms !=

&& ntermvars !=

&& termcoefs !=

));

( strcmp(sense,

) == 0 )

( ntermcoefs > 0 )

( t = 0; t < ntermcoefs; ++t )

assert(terms !=

);

assert(ntermvars !=

);

assert(termcoefs !=

);

nvars = ntermvars[t];

assert(vars !=

);

( SCIPdebugIsMainscip(

) )

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

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

( termcoefs[v] < 0 )

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

( SCIPdebugIsMainscip(

) )

( t = 0; t < ntermcoefs; ++t )

nvars = ntermvars[t];

assert(vars !=

);

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

artval += (((val < 0.5) ? 0.0 : 1.0) * termcoefs[t]);

ntermvars, termcoefs,

, 0.0,

, var, 0.0, 0.0,

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

assert(linvars !=

);

assert(coefs !=

);

* nNonlinearConss

assert(opbinput !=

);

assert(nNonlinearConss !=

);

(

(

, opbinput, name, &linvars, &lincoefs, &nlincoefs, &lincoefssize, &terms, &termcoefs, &ntermvars, &termcoefssize,

&ntermcoefs, &newsection, &isNonlinear, &issoftcons, &weight) );

(

(opbinput) || opbinput->eof )

( strcmp(name,

) == 0 || strcmp(name,

) == 0 )

( opbinput->wbo )

(

, opbinput,

);

(

(

, opbinput, name, objscale, linvars, lincoefs, nlincoefs, terms, termcoefs, ntermvars, ntermcoefs) );

( strcmp(name,

) == 0 )

opbinput->wbo =

;

( nlincoefs == 0 )

assert(nlincoefs == 1);

assert(lincoefs !=

);

opbinput->topcost = lincoefs[0];

(

,

, opbinput->topcost);

( nlincoefs > 0 )

(

, opbinput,

);

( !

(opbinput, &sense) )

(

, opbinput,

);

(

(opbinput, &sidesign) )

sidevalue *= sidesign;

initial = initialconss;

modifiable =

;

removable = dynamicrows;

++(opbinput->nindvars);

( ntermcoefs > 0 || issoftcons )

++(opbinput->consnumber);

ntermvars, termcoefs, indvar, weight, issoftcons,

, lhs, rhs,

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

);

++(opbinput->consnumber);

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

);

(

,

, opbinput->linenumber);

++(*nNonlinearConss);

( t = ntermcoefs - 1; t >= 0; --t )

assert(terms !=

);

* commentstart;

assert(opbinput !=

);

assert(objoffset !=

);

commentstart =

;

opbinput->linebuf[opbinput->linebufsize - 2] =

;

(

(opbinput->linebuf, opbinput->linebufsize, opbinput->file) ==

)

assert(

(opbinput->file) );

( opbinput->linebuf[opbinput->linebufsize - 2] !=

)

opbinput->linebuf[newsize-2] =

;

(

(opbinput->linebuf + opbinput->linebufsize - 1, newsize - opbinput->linebufsize + 1, opbinput->file) ==

)

opbinput->linebufsize = newsize;

opbinput->linebuf[opbinput->linebufsize - 1] =

;

commentstart = strchr(opbinput->linebuf,

[i]);

( commentstart !=

)

nproducts = strstr(opbinput->linebuf,

);

( nproducts !=

)

nproducts += strlen(

);

(

,

, atoi(pos));

( pos !=

&& strcmp(pos,

) == 0 )

str = strstr(opbinput->linebuf,

);

str += strlen(

);

*objscale = atof(str);

str = strstr(opbinput->linebuf,

);

str += strlen(

);

*objoffset = atof(str);

*commentstart =

;

(commentstart !=

&& !stop);

* filename

nNonlinearConss;

assert(opbinput !=

);

opbinput->file =

(filename,

);

( opbinput->file ==

)

( objscale < 0.0 )

opbinput->objsense = (

)(-1 * (

)(opbinput->objsense));

nNonlinearConss = 0;

( opbinput->wbo )

assert(nvars > 0 || vars !=

);

( i = nvars - 1; i >= 0; --i )

topcostvars[ntopcostvars] = vars[i];

topcostrhs =

(

, opbinput->topcost - 1.0);

-

(

), topcostrhs,

,

,

,

,

,

,

,

,

,

) );

assert( vars !=

);

assert( nvars > 0 );

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

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

( vars[v] ==

)

(

,

);

(

,

, scalar, constant);

assert(vars !=

);

assert(nvars !=

);

assert(constant !=

);

( requiredsize > *nvars )

assert( requiredsize <= *nvars );

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

( vars[v] ==

)

assert(resvars !=

);

assert(nresvars !=

);

assert(andvars !=

);

assert(nandvars !=

);

assert(existandconshdlr !=

);

assert(existands !=

);

( conshdlr !=

)

* shouldnotbeinand;

*existandconshdlr =

;

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

assert( conshdlr !=

);

andconss[nandconss] = origconss[c];

assert(andconss !=

|| nandconss == 0);

*nresvars = nandconss;

( nandconss > 0 )

assert(andconss !=

);

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

assert(andconss[c] !=

);

assert((*andvars)[c] !=

&& (*nandvars)[c] > 0);

assert((*resvars)[c] !=

);

((

**)(*resvars), (

**)(*andvars), (*nandvars), SCIPvarComp, (*nresvars));

*existands =

;

assert(*nandvars !=

|| *nresvars == 0);

(

= *nresvars - 1;

>= 0; --

)

shouldnotbeinand[ncontainedands] =

;

assert(*nandvars !=

);

( v < (*nandvars)[

] )

assert(*andvars !=

);

assert(*resvars !=

);

(

((

**)(*resvars), SCIPvarComp, (*andvars)[

][v], *nresvars, &pos) )

(

= ncontainedands - 1;

>= 0; --

)

( shouldnotbeinand[

] == pos )

(

,

);

shouldnotbeinand[ncontainedands] = pos;

(*nandvars)[

] = (*nandvars)[

] + (*nandvars)[pos] - 1;

(

= (*nandvars)[pos] - 1;

>= 0; --

)

(*andvars)[

][(*nandvars)[

] -

- 1] = (*andvars)[pos][

];

*existands =

;

*existandconshdlr =

;

assert( linebuffer !=

);

assert( linecnt !=

);

linebuffer[0] =

;

assert( linebuffer !=

);

assert( linecnt !=

);

( (*linecnt) > 0 )

linebuffer[(*linecnt)] =

;

* extension

assert(linebuffer !=

);

assert(linecnt !=

);

assert(extension !=

);

(void) strncat(linebuffer, extension,

- (

)(*linecnt));

(*linecnt) += (int) strlen(extension);

*

nandvars,

*

multisymbol,

assert(file !=

);

assert(vars !=

|| nvars == 0);

assert(resvars !=

|| nresvars == 0);

assert(andvars !=

|| nandvars ==

);

assert(multisymbol !=

);

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

( topcostcons !=

)

assert(conshdlr !=

);

( conshdlr !=

)

assert(conss !=

|| nconss == 0);

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

assert(cons !=

);

assert(linvars !=

|| nlinvars == 0);

topcostfound =

;

(

= 0;

< nlinvars; ++

)

topcostfound =

;

assert(!topcostfound);

topcostfound =

;

( conshdlr !=

)

assert(conss !=

|| nconss == 0);

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

assert(cons !=

);

assert(topvars !=

|| ntopvars == 0);

topcostfound =

;

(

= 0;

< ntopvars; ++

)

topcostfound =

;

assert(!topcostfound);

topcostfound =

;

( conshdlr !=

)

assert(conss !=

|| nconss == 0);

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

assert(cons !=

);

assert(topvars !=

|| ntopvars == 0);

topcostfound =

;

(

= 0;

< ntopvars; ++

)

topcostfound =

;

assert(!topcostfound);

topcostfound =

;

assert(mult * 10 > mult);

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

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

assert(var !=

);

assert( linecnt != 0 );

assert(andvars !=

);

assert(nandvars !=

);

assert(pos >= 0 && nandvars[pos] > 0 && andvars[pos] !=

);

assert(andvars[pos][nandvars[pos] - 1] !=

);

(

= nandvars[pos] - 2;

>= 0; --

)

*

type,

*

nandvars,

*

multisymbol

assert(strcmp(type,

) == 0 || strcmp(type,

) == 0);

assert(mult !=

);

assert(resvars !=

);

assert(nresvars > 0);

assert(andvars !=

&& nandvars !=

);

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

(

(*mult) >

(*mult * 10) )

(

(*mult) >

(*mult * 10) )

(

(*mult) != 1 )

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

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

assert( var !=

);

assert(andvars !=

);

assert(nandvars !=

);

assert(pos >= 0 && nandvars[pos] > 0 && andvars[pos] !=

);

assert(andvars[pos][nandvars[pos] - 1] !=

);

(

= nandvars[pos] - 2;

>= 0; --

)

*

nandvars,

*

multisymbol

assert(vars !=

|| nvars == 0);

assert(resvars !=

);

assert(nresvars > 0);

assert(andvars !=

&& nandvars !=

);

nactivevars = nvars;

activeconstant = 0.0;

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

activevals[v] = 1.0;

( activevars !=

)

retcode =

(

, file,

, activevars, activevals, nactivevars, rhs - activeconstant, resvars,

nresvars, andvars, nandvars, weight, &mult, multisymbol);

retcode =

(

, file,

, activevars, activevals, nactivevars, lhs - activeconstant, resvars,

nresvars, andvars, nandvars, weight, &mult, multisymbol);

retcode =

(

, file,

, activevars, activevals, nactivevars, rhs - activeconstant, resvars,

nresvars, andvars, nandvars, weight, &mult, multisymbol);

* multisymbol

assert(strcmp(type,

) == 0 || strcmp(type,

) == 0);

assert(mult !=

);

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

(

(*mult) >

(*mult * 10) )

(

(*mult) >

(*mult * 10) )

(

(*mult) != 1 )

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

assert( var !=

);

* multisymbol

assert( vars !=

|| nvars == 0 );

nactivevars = nvars;

activeconstant = 0.0;

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

activevals[v] = 1.0;

( activevars !=

)

retcode =

(

, file,

, activevars, activevals, nactivevars, rhs - activeconstant, weight, &mult,

retcode =

(

, file,

, activevars, activevals, nactivevars, lhs - activeconstant, weight, &mult,

retcode =

(

, file,

, activevars, activevals, nactivevars, rhs - activeconstant, weight, &mult,

* nindicatorconss

* conshdlrname;

assert(conss !=

|| nconss == 0);

assert(nlinearconss !=

);

assert(nindicatorconss !=

);

*nindicatorconss = 0;

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

assert(cons !=

);

assert(conshdlr !=

);

( strcmp(conshdlrname,

) == 0 )

( strcmp(conshdlrname,

) == 0 )

++(*nindicatorconss);

( strcmp(conshdlrname,

) == 0 )

++(*nindicatorconss);

*

nandvars,

*

multisymbol,

* conshdlrname;

assert(file !=

);

assert(conss !=

|| nconss == 0);

assert(vars !=

|| nvars == 0);

assert(resvars !=

|| nresvars == 0);

assert(andvars !=

|| nandvars == 0);

assert(multisymbol !=

);

( conshdlr !=

)

assert(indconss !=

|| nindconss == 0);

( nindconss > 0 )

assert(indconss !=

);

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

assert(indconss[c] !=

);

assert(lincons !=

);

( conshdlr !=

)

assert(pbconss !=

|| npbconss == 0);

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

assert(pbconss[c] !=

);

assert(lincons !=

);

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

assert(conshdlr !=

);

( strcmp(conshdlrname,

) == 0 )

( !pbhashmapcreated )

pbhashmapcreated =

;

assert(lincons !=

);

( strcmp(conshdlrname,

) == 0 )

( !indhashmapcreated )

indhashmapcreated =

;

assert(lincons !=

);

( c = 0; c < nconss && retcode ==

; ++c )

assert(cons !=

);

assert(conshdlr !=

);

( linconssofindicatorsmap !=

)

( artcons !=

)

( linconssofpbsmap !=

)

( artcons !=

)

( indvar !=

)

(

,

,

(artcons));

topcostfound =

;

( strcmp(conshdlrname,

) == 0 )

weight, transformed, multisymbol);

( strcmp(conshdlrname,

) == 0 )

andvars, nandvars, weight, transformed, multisymbol);

consvars,

, nconsvars, 1.0, 1.0, weight, transformed, multisymbol);

consvars,

, nconsvars, -

(

), 1.0, resvars, nresvars, andvars, nandvars,

weight, transformed, multisymbol);

weight, transformed, multisymbol);

( strcmp(conshdlrname,

) == 0 )

resvars, nresvars, andvars, nandvars, weight, transformed, multisymbol);

( strcmp(conshdlrname,

) == 0 )

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

weight, transformed, multisymbol);

( strcmp(conshdlrname,

) == 0 )

(

, cons), resvars, nresvars, andvars, nandvars, weight, transformed, multisymbol);

( strcmp(conshdlrname,

) == 0 )

assert(indvar !=

);

assert(indvar !=

);

assert(slackvar !=

);

assert(lincons !=

);

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

( consvars[v] == slackvar )

assert(nonbinarypos == -1);

( nonbinarypos == -1 )

assert(0 <= nonbinarypos && nonbinarypos < nconsvars);

consvars[nonbinarypos] = consvars[nconsvars];

consvals[nonbinarypos] = consvals[nconsvars];

resvars, nresvars, andvars, nandvars,

weight, transformed, multisymbol);

weight, transformed, multisymbol);

(

,

,

(cons) );

( strcmp(conshdlrname,

) == 0 )

assert(existandconshdlr);

( strcmp(conshdlrname,

) == 0 )

assert(cons !=

);

(

,

( linconssofpbsmap !=

)

( linconssofindicatorsmap !=

)

*

multisymbol,

assert(file !=

);

assert(vars !=

|| nvars == 0);

assert(printedfixing !=

);

assert(multisymbol !=

);

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

assert( vars !=

);

assert(lb > -0.5 && ub < 1.5);

( lb > 0.5 || ub < 0.5 )

( transformed ) {

*

nandvars,

*

multisymbol,

assert(file !=

);

assert(resvars !=

|| nresvars == 0);

assert(nandvars !=

|| nresvars == 0);

assert(andvars !=

|| nandvars ==

);

assert(multisymbol !=

);

(

= nresvars - 1;

>= 0; --

)

assert( resvars !=

);

resvar = resvars[

];

( lb > 0.5 || ub < 0.5 )

assert( andvars !=

&& nandvars !=

);

assert( andvars[

] !=

|| nandvars[

] == 0 );

( v = nandvars[

] - 1; v >= 0; --v )

assert( andvars[

] !=

);

assert( andvars[

][v] !=

);

( lb > 0.5 || ub < 0.5 )

(

= nresvars - 1;

>= 0; --

)

assert( resvars !=

);

resvar = resvars[

];

assert( andvars !=

&& nandvars !=

);

assert( andvars[

] !=

|| nandvars[

] == 0 );

( v = nandvars[

] - 1; v >= 0; --v )

assert( andvars[

] !=

);

assert( andvars[

][v] !=

);

( rhslhs == 1 )

assert( andvars !=

&& nandvars !=

);

assert( andvars[

] !=

|| nandvars[

] == 0 );

( v = nandvars[

] - 1; v >= 0; --v )

assert( andvars[

] !=

);

assert( andvars[

][v] !=

);

firstprinted =

;

assert( andvars !=

&& nandvars !=

);

assert( andvars[

] !=

|| nandvars[

] == 0 );

( v = nandvars[

] - 1; v >= 0; --v )

assert( andvars[

] !=

);

assert( andvars[

][v] !=

);

firstprinted =

;

assert(transformed);

assert(andvars !=

);

assert(nandvars !=

);

assert(pos >= 0 && nandvars[pos] > 0 && andvars[pos] !=

);

assert(andvars[pos][nandvars[pos] - 1] !=

);

(

= nandvars[pos] - 2;

>= 0; --

)

*

nandvars,

nindicatorconss;

assert( vars !=

|| nvars == 0 );

assert( conss !=

|| nconss == 0 );

assert( result !=

);

(

, file,

, nvars - nresvars - nindicatorconss);

SCIPvarGetHashkey, SCIPvarIsHashkeyEq, SCIPvarGetHashkeyVal,

) );

objsense, objscale, objoffset, multisymbol, existands, transformed) );

retcode =

(

, file, conss, nconss, vars, nvars, resvars, nresvars, andvars, nandvars,

multisymbol, existandconshdlr, existands, transformed);

( existands && (retcode ==

) )

* filename,

assert(reader !=

);

opbinput.file =

;

opbinput.linebuf[0] =

;

opbinput.token[0] =

;

opbinput.tokenbuf[0] =

;

opbinput.npushedtokens = 0;

opbinput.linenumber = 1;

opbinput.linepos = 0;

opbinput.eof =

;

opbinput.haserror =

;

opbinput.nproblemcoeffs = 0;

opbinput.wbo =

;

opbinput.nindvars = 0;

opbinput.consnumber = 0;

( opbinput.nproblemcoeffs > 0 )

(

,

, opbinput.nproblemcoeffs);

( opbinput.haserror )

( nintvars > 0 || ncontvars + nimplvars > nindicatorconss + nresvars )

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

retcode =

(

, file, name, transformed, objsense, objscale, objoffset, vars,

nvars, conss, nconss, resvars, nresvars, andvars, nandvars, existandconshdlr, existands, result);

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

( !existands || !

((

**)resvars, SCIPvarComp, vars[v], nresvars, &pos) )

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

( !existands || !

((

**)resvars, SCIPvarComp, vars[v], nresvars, &pos) )

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

retcode =

(

, file, name, transformed, objsense, objscale, objoffset, vars,

nvars, conss, nconss, resvars, nresvars, andvars, nandvars, existandconshdlr, existands, result);

assert(resvars !=

);

assert(andvars !=

);

assert(nandvars !=

);

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

assert(andvars[v] !=

);

assert(reader !=

);

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

,

,

,

,

Constraint handler for AND 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 pseudoboolean constraints

#define ARTIFICIALVARNAMEPREFIX

Constraint handler for the set partitioning / packing / covering constraints .

Constraint handler for variable bound constraints .

#define SCIPdebugGetSolVal(scip, var, val)

#define SCIPdebugAddSolVal(scip, var, val)

#define SCIP_CALL_ABORT(x)

#define SCIP_LONGINT_FORMAT

SCIP_FILE * SCIPfopen(const char *path, const char *mode)

int SCIPfeof(SCIP_FILE *stream)

int SCIPfclose(SCIP_FILE *fp)

char * SCIPfgets(char *s, int size, SCIP_FILE *stream)

int SCIPgetNVarsKnapsack(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetVbdcoefVarbound(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNVarsLogicor(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR ** SCIPgetVarsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsAnd(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, int nvars, SCIP_VAR **vars, 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_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNVarsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR * SCIPgetResultantAnd(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNVarsAnd(SCIP *scip, SCIP_CONS *cons)

SCIP_Real * SCIPgetValsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR * SCIPgetVbdvarVarbound(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNVarsSetppc(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR * SCIPgetIndVarPseudoboolean(SCIP *const scip, SCIP_CONS *const cons)

SCIP_VAR ** SCIPgetVarsSetppc(SCIP *scip, 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 SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_VAR ** SCIPgetVarsLogicor(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetRhsVarbound(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR ** SCIPgetVarsAnd(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR ** SCIPgetVarsKnapsack(SCIP *scip, SCIP_CONS *cons)

SCIP_CONS * SCIPgetLinearConsPseudoboolean(SCIP *const scip, SCIP_CONS *const cons)

SCIP_RETCODE SCIPcreateConsPseudoboolean(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR **linvars, int nlinvars, SCIP_Real *linvals, SCIP_VAR ***terms, int nterms, int *ntermvars, SCIP_Real *termvals, SCIP_VAR *indvar, SCIP_Real weight, SCIP_Bool issoftcons, SCIP_VAR *intvar, 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_SETPPCTYPE_PARTITIONING

@ SCIP_SETPPCTYPE_COVERING

@ SCIP_SETPPCTYPE_PACKING

SCIP_RETCODE SCIPwriteOpb(SCIP *scip, FILE *file, const char *name, SCIP_Bool transformed, SCIP_OBJSENSE objsense, SCIP_Real objscale, SCIP_Real objoffset, SCIP_VAR **vars, int nvars, int nbinvars, int nintvars, int nimplvars, int ncontvars, SCIP_VAR **fixedvars, int nfixedvars, SCIP_CONS **conss, int nconss, SCIP_Bool genericnames, SCIP_RESULT *result)

SCIP_RETCODE SCIPreadOpb(SCIP *scip, SCIP_READER *reader, const char *filename, SCIP_RESULT *result)

SCIP_RETCODE SCIPincludeReaderOpb(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

int SCIPgetNOrigConss(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNConss(SCIP *scip)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

SCIP_RETCODE SCIPaddOrigObjoffset(SCIP *scip, SCIP_Real addval)

SCIP_CONS ** SCIPgetOrigConss(SCIP *scip)

SCIP_RETCODE SCIPcreateProb(SCIP *scip, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata)

SCIP_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)

void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)

SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)

SCIP_RETCODE SCIPhashtableCreate(SCIP_HASHTABLE **hashtable, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)

SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)

void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)

#define SCIPdebugMsgPrint

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)

int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)

SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)

SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

#define SCIPreallocMemoryArray(scip, ptr, newnum)

#define SCIPallocMemoryArray(scip, ptr, num)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPduplicateMemoryArray(scip, ptr, source, num)

#define SCIPfreeMemoryArray(scip, ptr)

#define SCIPduplicateBufferArray(scip, ptr, source, num)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, 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)))

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_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)

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_Real SCIPround(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)

SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

int SCIPvarGetIndex(SCIP_VAR *var)

SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)

SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)

SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetNegationVar(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_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)

SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)

SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)

SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)

SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)

void SCIPsortPtrPtrInt(void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

int SCIPstrcasecmp(const char *s1, const char *s2)

int SCIPsnprintf(char *t, int len, const char *s,...)

void SCIPprintSysError(const char *message)

int SCIPmemccpy(char *dest, const char *src, char stop, unsigned int cnt)

static const SCIP_Real scalars[]

memory allocation routines

SCIP_Real SCIPconsGetLhs(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)

SCIP_Real SCIPconsGetRhs(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)

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 const char delimchars[]

static SCIP_RETCODE writeOpbRelevantAnds(SCIP *const scip, FILE *const file, SCIP_VAR **const resvars, int const nresvars, SCIP_VAR **const *const andvars, int const *const nandvars, SCIP_HASHTABLE *const printedfixing, char const *const multisymbol, SCIP_Bool const transformed)

static SCIP_RETCODE printNonLinearCons(SCIP *const scip, FILE *const file, SCIP_VAR **const vars, SCIP_Real *const vals, int const nvars, SCIP_Real const lhs, SCIP_Real const rhs, SCIP_VAR **const resvars, int const nresvars, SCIP_VAR **const *const andvars, int const *const nandvars, SCIP_Longint weight, SCIP_Bool const transformed, char const *const multisymbol)

static SCIP_RETCODE setObjective(SCIP *const scip, OPBINPUT *const opbinput, const char *sense, SCIP_Real const scale, SCIP_VAR **const linvars, SCIP_Real *const coefs, int const ncoefs, SCIP_VAR ***const terms, SCIP_Real *const termcoefs, int *const ntermvars, int const ntermcoefs)

static SCIP_RETCODE printRow(SCIP *scip, FILE *file, const char *type, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real lhs, SCIP_Longint weight, SCIP_Longint *mult, const char *multisymbol)

static void clearBuffer(char *linebuffer, int *linecnt)

static SCIP_Bool isSign(OPBINPUT *opbinput, int *sign)

static SCIP_DECL_READERREAD(readerReadOpb)

static SCIP_RETCODE getBinVarsRepresentatives(SCIP *const scip, SCIP_VAR **const vars, int const nvars, SCIP_Bool const transformed)

static SCIP_Bool getNextToken(SCIP *scip, OPBINPUT *opbinput)

static SCIP_Bool isValueChar(char c, char nextc, SCIP_Bool firstchar, SCIP_Bool *hasdot, OPBEXPTYPE *exptype)

static SCIP_RETCODE getVariableOrTerm(SCIP *scip, OPBINPUT *opbinput, SCIP_VAR ***vars, int *nvars, int *varssize)

static SCIP_RETCODE writeOpbFixedVars(SCIP *const scip, FILE *const file, SCIP_VAR **vars, int nvars, SCIP_HASHTABLE *const printedfixing, char const *const multisymbol, SCIP_Bool const transformed)

static void swapTokenBuffer(OPBINPUT *opbinput)

static SCIP_RETCODE printLinearCons(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real lhs, SCIP_Real rhs, SCIP_Longint weight, SCIP_Bool transformed, const char *multisymbol)

static const char commentchars[]

static SCIP_DECL_READERWRITE(readerWriteOpb)

static SCIP_RETCODE writeOpbObjective(SCIP *const scip, FILE *const file, SCIP_VAR **const vars, int const nvars, SCIP_VAR **const resvars, int const nresvars, SCIP_VAR **const *const andvars, int const *const nandvars, SCIP_OBJSENSE const objsense, SCIP_Real const objscale, SCIP_Real const objoffset, char const *const multisymbol, SCIP_Bool const existands, SCIP_Bool const transformed)

static SCIP_RETCODE printNLRow(SCIP *const scip, FILE *const file, char const *const type, SCIP_VAR **const vars, SCIP_Real const *const vals, int const nvars, SCIP_Real lhs, SCIP_VAR **const resvars, int const nresvars, SCIP_VAR **const *const andvars, int const *const nandvars, SCIP_Longint weight, SCIP_Longint *const mult, char const *const multisymbol)

static void writeBuffer(SCIP *scip, FILE *file, char *linebuffer, int *linecnt)

static void pushToken(OPBINPUT *opbinput)

static SCIP_RETCODE computeAndConstraintInfos(SCIP *const scip, SCIP_Bool const transformed, SCIP_VAR ***resvars, int *nresvars, SCIP_VAR ****andvars, int **nandvars, SCIP_Bool *const existandconshdlr, SCIP_Bool *const existands)

static SCIP_RETCODE getActiveVariables(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)

static SCIP_RETCODE writeOpbConstraints(SCIP *const scip, FILE *const file, SCIP_CONS **const conss, int const nconss, SCIP_VAR **const vars, int const nvars, SCIP_VAR **const resvars, int const nresvars, SCIP_VAR **const *const andvars, int const *const nandvars, char const *const multisymbol, SCIP_Bool const existandconshdlr, SCIP_Bool const existands, SCIP_Bool const transformed)

static void determineTotalNumberLinearConss(SCIP *const scip, SCIP_CONS **const conss, int const nconss, int *nlinearconss, int *nindicatorconss)

static SCIP_Bool isStartingSoftConstraintWeight(SCIP *scip, OPBINPUT *opbinput)

#define OPB_MAX_PUSHEDTOKENS

static void appendBuffer(SCIP *scip, FILE *file, char *linebuffer, int *linecnt, const char *extension)

static SCIP_Bool getNextLine(SCIP *scip, OPBINPUT *opbinput)

static SCIP_Bool isEndLine(OPBINPUT *opbinput)

#define OPB_INIT_COEFSSIZE

static SCIP_RETCODE writeOpb(SCIP *scip, FILE *file, const char *name, SCIP_Bool transformed, SCIP_OBJSENSE objsense, SCIP_Real objscale, SCIP_Real objoffset, SCIP_VAR **vars, int nvars, SCIP_CONS **conss, int nconss, SCIP_VAR **const resvars, int const nresvars, SCIP_VAR **const *const andvars, int const *const nandvars, SCIP_Bool const existandconshdlr, SCIP_Bool const existands, SCIP_RESULT *result)

static SCIP_RETCODE getMaxAndConsDim(SCIP *scip, OPBINPUT *opbinput, SCIP_Real *objscale, SCIP_Real *objoffset)

static SCIP_RETCODE createVariable(SCIP *scip, SCIP_VAR **var, char *name)

static void syntaxError(SCIP *scip, OPBINPUT *opbinput, const char *msg)

static SCIP_RETCODE readOPBFile(SCIP *scip, OPBINPUT *opbinput, const char *filename)

static SCIP_DECL_READERCOPY(readerCopyOpb)

static SCIP_RETCODE readConstraints(SCIP *scip, OPBINPUT *opbinput, SCIP_Real objscale, int *nNonlinearConss)

static SCIP_Bool isValue(SCIP *scip, OPBINPUT *opbinput, SCIP_Real *value)

static SCIP_Bool isDelimChar(char c)

static void swapPointers(char **pointer1, char **pointer2)

static SCIP_Bool hasError(OPBINPUT *opbinput)

static void pushBufferToken(OPBINPUT *opbinput)

static SCIP_Bool isSense(OPBINPUT *opbinput, OPBSENSE *sense)

enum OpbExpType OPBEXPTYPE

static SCIP_RETCODE readCoefficients(SCIP *const scip, OPBINPUT *const opbinput, char *const name, SCIP_VAR ***linvars, SCIP_Real **lincoefs, int *const nlincoefs, int *lincoefssize, SCIP_VAR ****terms, SCIP_Real **termcoefs, int **ntermvars, int *termcoefssize, int *const ntermcoefs, SCIP_Bool *const newsection, SCIP_Bool *const isNonlinear, SCIP_Bool *const issoftcons, SCIP_Real *const weight)

#define INDICATORSLACKVARNAME

static SCIP_Bool isEndingSoftConstraintWeight(SCIP *scip, OPBINPUT *opbinput)

static SCIP_Bool isTokenChar(char c)

pseudo-Boolean file reader (opb format)

public methods for constraint handler plugins and constraints

public methods for memory management

public methods for message handling

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for global and local (sub)problems

public methods for reader plugins

public methods for querying solving statistics

public methods for SCIP variables

enum SCIP_Objsense SCIP_OBJSENSE

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_VARSTATUS_ORIGINAL

@ SCIP_VARSTATUS_MULTAGGR

@ SCIP_VARSTATUS_AGGREGATED

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