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

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

SCIP Doxygen Documentation: reader_pip.c Source File

assert(pipinput !=

);

(

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

( pipinput->linebuf[strlen(pipinput->linebuf)-1] ==

)

(void)

(formatstr, 256,

, pipinput->linepos);

pipinput->haserror =

;

assert(pipinput !=

);

pipinput->haserror;

assert(hasdot !=

);

assert(exptype !=

);

( isdigit((

)c) )

( (*exptype ==

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

) && isdigit((

)nextc) )

( !firstchar && (*exptype ==

) && (c ==

|| c ==

) )

( nextc ==

|| nextc ==

)

( isdigit((

)nextc) )

( (*exptype ==

) && (c ==

|| c ==

) )

assert(pipinput !=

);

pipinput->linepos = 0;

(

(pipinput->linebuf, (

)

(pipinput->linebuf), pipinput->file) ==

)

pipinput->linenumber++;

pipinput->haserror =

;

commentstart = strchr(pipinput->linebuf,

[i]);

( commentstart !=

)

*commentstart =

;

*(commentstart+1) =

;

*pointer1 = *pointer2;

assert(pipinput !=

);

( pipinput->npushedtokens > 0 )

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

pipinput->npushedtokens--;

(

,

, pipinput->linenumber, pipinput->token);

buf = pipinput->linebuf;

( buf[pipinput->linepos] ==

)

assert(pipinput->linepos == 0);

(

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

, &hasdot, &exptype) )

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

(

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

, &hasdot, &exptype) );

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

( tokenlen == 1 &&

(pipinput->token[0]) )

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

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

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

)

&& buf[pipinput->linepos] ==

)

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

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

|| buf[pipinput->linepos] ==

) )

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

pipinput->token[tokenlen] =

;

(

,

, pipinput->linenumber, pipinput->token);

assert(pipinput !=

);

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

pipinput->npushedtokens++;

assert(pipinput !=

);

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

pipinput->npushedtokens++;

assert(pipinput !=

);

assert(pipinput !=

);

iscolon = (strcmp(pipinput->token,

) == 0);

(

,

, pipinput->linenumber);

(

,

, pipinput->linenumber);

(

,

, pipinput->linenumber);

(

,

, pipinput->linenumber);

(

,

, pipinput->linenumber);

(

,

, pipinput->linenumber);

(

,

, pipinput->linenumber);

(

,

, pipinput->linenumber);

(

,

, pipinput->linenumber);

assert(pipinput !=

);

assert(sign !=

);

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

( pipinput->token[1] ==

)

( *pipinput->token ==

)

( *pipinput->token ==

)

assert(pipinput !=

);

assert(value !=

);

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

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

)

assert(pipinput !=

);

( strcmp(pipinput->token,

) == 0 )

( strcmp(pipinput->token,

) == 0 )

( strcmp(pipinput->token,

) == 0 )

assert(name !=

);

assert(var !=

);

( created !=

)

( created !=

)

assert(pipinput !=

);

assert(monomials !=

);

assert(monomialscoef !=

);

assert(monomialssize !=

);

assert(*monomials !=

|| *monomialssize == 0);

( minnmonomials <= *monomialssize )

( *monomials !=

)

( *monomialscoef !=

)

*monomialssize = newsize;

assert(vars !=

);

assert(exponents !=

);

assert(factorssize !=

);

assert(*exponents !=

|| *factorssize == 0);

assert(*vars !=

|| *factorssize == 0);

( minnfactors <= *factorssize )

( *exponents !=

)

*factorssize = newsize;

assert(pipinput !=

);

assert(name !=

);

assert(expr !=

);

assert(islinear !=

);

assert(newsection !=

);

*newsection =

;

( strcmp(pipinput->token,

) == 0 )

(

,

, pipinput->linenumber, name);

((nfactors > 0 || havevalue) && (issign =

(pipinput, &nextcoefsign))) )

( coefsign * coef != 0.0 )

monomialscoef[nmonomials] = coefsign * coef;

( havevalue )

constant += coefsign * coef;

( monomialdegree > 1 )

coefsign = nextcoefsign;

(

,

, pipinput->linenumber, coefsign);

(

(pipinput, &coefsign) )

(

,

, pipinput->linenumber, coefsign);

( nfactors > 0 || havevalue )

(

, pipinput,

);

TERMINATE_READPOLYNOMIAL;

( strcmp(pipinput->token,

) == 0 )

(

, pipinput,

);

TERMINATE_READPOLYNOMIAL;

( nmonomials > 0 && !havesign )

(

, pipinput,

);

TERMINATE_READPOLYNOMIAL;

( strcmp(pipinput->token,

) == 0 )

TERMINATE_READPOLYNOMIAL;

( nfactors == 0 )

(

, pipinput,

);

TERMINATE_READPOLYNOMIAL;

exponents[nfactors-1] = exponent;

monomialdegree += (int)exponent - 1;

(

,

, pipinput->linenumber, exponent,

(

,

, pipinput->linenumber, coef, coefsign);

TERMINATE_READPOLYNOMIAL;

(

, pipinput,

);

TERMINATE_READPOLYNOMIAL;

vars[nfactors] = var;

exponents[nfactors] = 1.0;

(

, pipinput,

);

TERMINATE_READPOLYNOMIAL;

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

assert(monomials[i] !=

);

TERMINATE_READPOLYNOMIAL:

assert(pipinput !=

);

modifiable =

;

( constant != 0.0 )

assert(child !=

);

assert(var !=

);

(

(

, &nonlinobjcons,

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

assert(pipinput !=

);

(

, pipinput,

);

( !

(pipinput, &sense) )

(

, pipinput,

);

(

(pipinput, &sidesign) )

sidevalue *= sidesign;

initial = pipinput->initialconss;

modifiable =

;

dynamic = pipinput->dynamicconss;

removable = pipinput->dynamicrows;

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

assert(child !=

);

assert(vars[i] !=

);

(

(

, &cons, name, nchildren, vars, coefs, lhs, rhs, initial, separate, enforce,

check, propagate, local, modifiable, dynamic, removable,

) );

(

(

, &cons, name, expr, lhs, rhs, initial, separate, enforce, check, propagate,

local, modifiable, dynamic, removable) );

assert(cons !=

);

(

,

, pipinput->linenumber);

assert(pipinput !=

);

hassign =

(pipinput, &sign);

(

, pipinput,

);

( leftsense )

(

(pipinput, &rightsense) )

hassign =

(pipinput, &sign);

( rightsense )

(

, pipinput,

);

assert(pipinput !=

);

(

, pipinput,

);

assert(pipinput !=

);

(

, pipinput,

);

* filename

assert(pipinput !=

);

pipinput->file =

(filename,

);

( pipinput->file ==

)

( pipinput->section )

assert(vars !=

);

assert(nvars !=

);

assert(*vars !=

|| *nvars == 0);

assert(constant !=

);

( requiredsize > *nvars )

assert( requiredsize <= *nvars );

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

*constant += (*scalars)[v];

(*scalars)[v] *= -1.0;

assert(expr !=

);

assert(expr !=

);

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,

- strlen(linebuffer));

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

(

,

, linebuffer, (

)strlen(linebuffer));

* rowname,

* rownameextension,

assert( strcmp(type,

) == 0 || strcmp(type,

) == 0 || strcmp(type,

) == 0 );

assert( nlinvars == 0 || (linvars !=

&& linvals !=

) );

( strlen(rowname) > 0 || strlen(rownameextension) > 0 )

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

assert(linvars !=

);

assert(linvals !=

);

assert( var !=

);

( quadexpr !=

)

nbilinexprterms;

nactivevars = nlinexprs;

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

assert(linexprs !=

&& linexprs[v] !=

);

assert(activevars[v] !=

);

constant += activeconstant;

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

assert(activevars !=

);

assert(activevals !=

);

var = activevars[v];

assert( var !=

);

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

assert(expr !=

);

assert(var !=

);

( lincoef == 0.0 )

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

assert(expr !=

);

assert(var !=

);

( sqrcoef == 0.0 )

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

assert(expr1 !=

);

assert(expr2 !=

);

assert(var1 !=

);

assert(var2 !=

);

( coef == 1.0 && needsign )

( coef == -1.0 )

* rowname,

* rownameextension,

assert(strcmp(type,

) == 0 || strcmp(type,

) == 0 || strcmp(type,

) == 0);

assert(expr !=

);

( strlen(rowname) > 0 || strlen(rownameextension) > 0 )

* rowname,

assert(rowname !=

);

assert(cons !=

);

( strlen(rowname) > 0 )

* rowname,

assert( rowname !=

);

assert( nlinvars == 0 || linvars !=

);

assert( quadexpr ==

|| nlinvars == 0);

assert( lhs <= rhs );

nactivevars = nlinvars;

( linvals !=

)

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

activevals[v] = 1.0;

(

(

, file, rowname,

,

, activevars, activevals, nactivevars, quadexpr,

rhs - activeconstant, transformed) );

activevals, nactivevars, quadexpr, lhs - activeconstant, transformed) );

activevals, nactivevars, quadexpr, rhs - activeconstant, transformed) );

* rowname,

assert(rowname !=

);

assert(expr !=

);

* nAggregatedVars,

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

(*aggregatedVars)[(*nAggregatedVars)++] = var;

nAggregatedVars,

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

activevars[0] = aggregatedVars[j];

activevals[0] = 1.0;

activeconstant = 0.0;

activevals[nactivevars] = -1.0;

activevars[nactivevars] = aggregatedVars[j];

(

(

, file, consname,

,

, activevars, activevals, nactivevars,

, - activeconstant,

assert(name !=

);

( isdigit(name[0]) )

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

( isalnum(name[i]) )

assert(vars !=

|| nvars == 0);

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

* conshdlrname;

assert( conss !=

|| nconss == 0 );

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

assert(conss !=

);

assert(cons !=

);

assert( conshdlr !=

);

( strcmp(conshdlrname,

) == 0 )

* conshdlrname;

nAggregatedVars;

nAggregatedVars = 0;

(

, file,

,

nvars, nbinvars, nintvars, nimplvars, ncontvars);

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

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

assert( cons !=

);

assert( conshdlr !=

);

( strcmp(conshdlrname,

) == 0 )

( strcmp(conshdlrname,

) == 0 )

consvars,

, nconsvars,

, 1.0, 1.0, transformed) );

( strcmp(conshdlrname,

) == 0 )

( strcmp(conshdlrname,

) == 0 )

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

( strcmp(conshdlrname,

) == 0 )

( strcmp(conshdlrname,

) == 0 )

( !ispolynomial )

( !ispolynomial )

consNonlinear[nConsNonlinear++] = cons;

( simplifiedexpr !=

)

( strcmp(conshdlrname,

) == 0 )

consAnd[nConsAnd++] = cons;

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

( ntmpvars > tmpvarssize )

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

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

assert( var !=

);

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

var = aggregatedVars[v];

assert( var !=

);

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

assert( var !=

);

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

assert( var !=

);

assert(reader !=

);

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

* filename,

assert(reader !=

);

pipinput.file =

;

pipinput.linebuf[0] =

;

pipinput.probname[0] =

;

pipinput.objname[0] =

;

pipinput.token[0] =

;

pipinput.tokenbuf[0] =

;

pipinput.npushedtokens = 0;

pipinput.linenumber = 0;

pipinput.linepos = 0;

pipinput.haserror =

;

( pipinput.haserror )

Constraint handler for AND constraints, .

Constraint handler for knapsack constraints of the form , x binary and .

Constraint handler for linear constraints in their most general form, .

Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...

constraint handler for nonlinear constraints specified by algebraic expressions

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

Constraint handler for variable bound constraints .

variable expression handler

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

int SCIPfclose(SCIP_FILE *fp)

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

int SCIPgetNVarsKnapsack(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetVbdcoefVarbound(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNVarsLogicor(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)

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

SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNVarsLinear(SCIP *scip, SCIP_CONS *cons)

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

int SCIPgetNVarsAnd(SCIP *scip, SCIP_CONS *cons)

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

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

int SCIPgetNVarsSetppc(SCIP *scip, SCIP_CONS *cons)

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

SCIP_EXPR * SCIPgetExprNonlinear(SCIP_CONS *cons)

SCIP_Real SCIPgetRhsNonlinear(SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable)

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

SCIP_Longint * SCIPgetWeightsKnapsack(SCIP *scip, SCIP_CONS *cons)

SCIP_Longint SCIPgetCapacityKnapsack(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetLhsVarbound(SCIP *scip, SCIP_CONS *cons)

SCIP_SETPPCTYPE SCIPgetTypeSetppc(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

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

SCIP_Real SCIPgetRhsVarbound(SCIP *scip, SCIP_CONS *cons)

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

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

SCIP_Real SCIPgetLhsNonlinear(SCIP_CONS *cons)

@ SCIP_SETPPCTYPE_PARTITIONING

@ SCIP_SETPPCTYPE_COVERING

@ SCIP_SETPPCTYPE_PACKING

SCIP_RETCODE SCIPcreateExprVar(SCIP *scip, SCIP_EXPR **expr, SCIP_VAR *var, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

void SCIPsetConstantExprSum(SCIP_EXPR *expr, SCIP_Real constant)

SCIP_RETCODE SCIPappendExprSumExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *child, SCIP_Real childcoef)

SCIP_RETCODE SCIPcreateExprSum(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real *coefficients, SCIP_Real constant, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

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

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

SCIP_RETCODE SCIPincludeReaderPip(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

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

int SCIPgetNTotalVars(SCIP *scip)

SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)

void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)

SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)

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

SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)

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

void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)

void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)

SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)

SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)

SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

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

SCIP_RETCODE SCIPcreateExprMonomial(SCIP *scip, SCIP_EXPR **expr, int nfactors, SCIP_VAR **vars, SCIP_Real *exponents, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

int SCIPexprGetNChildren(SCIP_EXPR *expr)

void SCIPexprGetQuadraticBilinTerm(SCIP_EXPR *expr, int termidx, SCIP_EXPR **expr1, SCIP_EXPR **expr2, SCIP_Real *coef, int *pos2, SCIP_EXPR **prodexpr)

SCIP_Real SCIPgetExponentExprPow(SCIP_EXPR *expr)

SCIP_Bool SCIPisExprProduct(SCIP *scip, SCIP_EXPR *expr)

SCIP_Bool SCIPisExprSum(SCIP *scip, SCIP_EXPR *expr)

SCIP_Bool SCIPexprAreQuadraticExprsVariables(SCIP_EXPR *expr)

void SCIPexprGetQuadraticData(SCIP_EXPR *expr, SCIP_Real *constant, int *nlinexprs, SCIP_EXPR ***linexprs, SCIP_Real **lincoefs, int *nquadexprs, int *nbilinexprs, SCIP_Real **eigenvalues, SCIP_Real **eigenvectors)

SCIP_Real * SCIPgetCoefsExprSum(SCIP_EXPR *expr)

SCIP_Bool SCIPisExprValue(SCIP *scip, SCIP_EXPR *expr)

SCIP_Real SCIPgetCoefExprProduct(SCIP_EXPR *expr)

SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)

SCIP_Bool SCIPisExprVar(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPprintExpr(SCIP *scip, SCIP_EXPR *expr, FILE *file)

SCIP_Real SCIPgetValueExprValue(SCIP_EXPR *expr)

SCIP_Bool SCIPisExprPower(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPcheckExprQuadratic(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool *isquadratic)

SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)

SCIP_Real SCIPgetConstantExprSum(SCIP_EXPR *expr)

SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)

void SCIPexprGetQuadraticQuadTerm(SCIP_EXPR *quadexpr, int termidx, SCIP_EXPR **expr, SCIP_Real *lincoef, SCIP_Real *sqrcoef, int *nadjbilin, int **adjbilin, SCIP_EXPR **sqrexpr)

SCIP_RETCODE SCIPduplicateExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR **copyexpr, SCIP_DECL_EXPR_MAPEXPR((*mapexpr)), void *mapexprdata, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPsimplifyExpr(SCIP *scip, SCIP_EXPR *rootexpr, SCIP_EXPR **simplified, SCIP_Bool *changed, SCIP_Bool *infeasible, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

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

#define SCIPallocBlockMemoryArray(scip, ptr, num)

SCIP_RETCODE 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_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

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

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

SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)

SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)

SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

int SCIPvarGetIndex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)

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

SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)

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

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

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

void SCIPprintSysError(const char *message)

int SCIPstrncpy(char *t, const char *s, int size)

static const SCIP_Real scalars[]

memory allocation routines

#define BMSclearMemoryArray(ptr, num)

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

public methods for managing constraints

public functions to work with algebraic expressions

wrapper functions to map file i/o to standard or zlib file i/o

struct SCIP_File SCIP_FILE

public methods for message output

#define SCIPdebugPrintCons(x, y, z)

public data structures and miscellaneous methods

public methods for NLP management

public methods for input file readers

public methods for problem variables

static SCIP_Bool isExprSignomial(SCIP *scip, SCIP_EXPR *expr)

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

static SCIP_RETCODE readPolynomial(SCIP *scip, PIPINPUT *pipinput, char *name, SCIP_EXPR **expr, SCIP_Bool *islinear, SCIP_Bool *newsection)

#define PIP_MAX_PUSHEDTOKENS

static SCIP_RETCODE getVariable(SCIP *scip, char *name, SCIP_Bool dynamiccols, SCIP_VAR **var, SCIP_Bool *created)

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

static SCIP_Bool hasError(PIPINPUT *pipinput)

static SCIP_Bool isNewSection(SCIP *scip, PIPINPUT *pipinput)

static SCIP_Bool getNextToken(SCIP *scip, PIPINPUT *pipinput)

static SCIP_RETCODE readGenerals(SCIP *scip, PIPINPUT *pipinput)

static SCIP_RETCODE readStart(SCIP *scip, PIPINPUT *pipinput)

static SCIP_DECL_HASHGETKEY(hashGetKeyVar)

static SCIP_Bool isExprPolynomial(SCIP *scip, SCIP_EXPR *expr)

static const char tokenchars[]

static SCIP_Bool isSign(PIPINPUT *pipinput, int *sign)

static SCIP_Bool getNextLine(SCIP *scip, PIPINPUT *pipinput)

static const char commentchars[]

static void checkVarnames(SCIP *scip, SCIP_VAR **vars, int nvars)

static SCIP_RETCODE ensureMonomialsSize(SCIP *scip, SCIP_EXPR ***monomials, SCIP_Real **monomialscoef, int *monomialssize, int minnmonomials)

static void printSignomial(SCIP *scip, FILE *file, char *linebuffer, int *linecnt, SCIP_EXPR *expr, SCIP_Real coef, SCIP_Bool needsign)

static const char namechars[]

static SCIP_RETCODE printAggregatedCons(SCIP *scip, FILE *file, SCIP_Bool transformed, int nvars, int nAggregatedVars, SCIP_VAR **aggregatedVars)

static SCIP_Bool isNameValid(const char *name)

static void swapTokenBuffer(PIPINPUT *pipinput)

static SCIP_DECL_READERREAD(readerReadPip)

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

static SCIP_RETCODE printNonlinearCons(SCIP *scip, FILE *file, const char *rowname, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs)

static SCIP_RETCODE collectAggregatedVars(int nvars, SCIP_VAR **vars, int *nAggregatedVars, SCIP_VAR ***aggregatedVars, SCIP_HASHTABLE **varAggregated)

static SCIP_RETCODE printQuadraticCons(SCIP *scip, FILE *file, const char *rowname, SCIP_VAR **linvars, SCIP_Real *linvals, int nlinvars, SCIP_EXPR *quadexpr, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool transformed)

static SCIP_RETCODE readBinaries(SCIP *scip, PIPINPUT *pipinput)

enum PipSection PIPSECTION

#define PIP_INIT_MONOMIALSSIZE

static SCIP_Bool isSense(PIPINPUT *pipinput, PIPSENSE *sense)

static void pushBufferToken(PIPINPUT *pipinput)

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

static void pushToken(PIPINPUT *pipinput)

static SCIP_DECL_READERCOPY(readerCopyPip)

static void syntaxError(SCIP *scip, PIPINPUT *pipinput, const char *msg)

static void printRowAnd(SCIP *scip, FILE *file, const char *rowname, SCIP_CONS *cons)

#define PIP_INIT_FACTORSSIZE

static SCIP_Bool isDelimChar(char c)

static SCIP_RETCODE readConstraints(SCIP *scip, PIPINPUT *pipinput)

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

static SCIP_DECL_HASHKEYEQ(hashKeyEqVar)

static void printRowNl(SCIP *scip, FILE *file, const char *rowname, const char *rownameextension, const char *type, SCIP_EXPR *expr, SCIP_Real rhs)

static SCIP_DECL_HASHKEYVAL(hashKeyValVar)

enum PipExpType PIPEXPTYPE

static SCIP_RETCODE printRow(SCIP *scip, FILE *file, const char *rowname, const char *rownameextension, const char *type, SCIP_VAR **linvars, SCIP_Real *linvals, int nlinvars, SCIP_EXPR *quadexpr, SCIP_Real rhs, SCIP_Bool transformed)

static SCIP_RETCODE readObjective(SCIP *scip, PIPINPUT *pipinput)

static SCIP_RETCODE ensureFactorsSize(SCIP *scip, SCIP_VAR ***vars, SCIP_Real **exponents, int *factorssize, int minnfactors)

static SCIP_DECL_READERWRITE(readerWritePip)

static SCIP_Bool isValue(SCIP *scip, PIPINPUT *pipinput, SCIP_Real *value)

static void checkConsnames(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool transformed)

static SCIP_RETCODE readPIPFile(SCIP *scip, PIPINPUT *pipinput, const char *filename)

static const char delimchars[]

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

static SCIP_RETCODE readBounds(SCIP *scip, PIPINPUT *pipinput)

static SCIP_Bool isTokenChar(char c)

file reader for polynomial mixed-integer programs in PIP format

public methods for constraint handler plugins and constraints

public methods for memory management

public methods for message handling

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for global and local (sub)problems

public methods for reader plugins

public methods for SCIP variables

enum SCIP_Objsense SCIP_OBJSENSE

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_VARSTATUS_ORIGINAL

@ SCIP_VARSTATUS_MULTAGGR

@ SCIP_VARSTATUS_AGGREGATED

enum SCIP_Varstatus SCIP_VARSTATUS

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