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

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

SCIP Doxygen Documentation: cons_indicator.c Source File

linconsactive:1;

implicationadded:1;

slacktypechecked:1;

SCIP_ConshdlrData

maxroundingrounds;

maxsepanonviolated;

SCIP_ConflicthdlrData

, __FILE__, __LINE__, _restat_); \

assert(cons !=

);

assert(graph !=

);

assert(success !=

);

assert(consdata !=

);

lincons = consdata->lincons;

assert(lincons !=

);

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

vars[i] = linvars[i];

vals[i] = linvals[i];

nlocvars = nvarslincons;

vars[0] = consdata->binvar;

( nlocvars == 1 )

vars[0] = consdata->slackvar;

( nlocvars == 1 )

assert( eventhdlr !=

);

assert( eventdata !=

);

assert( event !=

);

assert( cons !=

);

assert( consdata !=

);

assert( 0 <= consdata->nfixednonzero && consdata->nfixednonzero <= 2 );

assert( consdata->linconsactive );

assert( conshdlr !=

);

assert( conshdlrdata !=

);

++(consdata->nfixednonzero);

(

,

,

++(consdata->nfixednonzero);

(

,

,

--(consdata->nfixednonzero);

(

,

,

--(consdata->nfixednonzero);

(

,

,

assert( 0 <= consdata->nfixednonzero && consdata->nfixednonzero <= 2 );

conshdlrdata->boundhaschanged =

;

assert( eventhdlr !=

);

assert( eventdata !=

);

assert( event !=

);

(

,

,

assert( conshdlrdata !=

);

conshdlrdata->linconsboundschanged =

;

assert( eventhdlr !=

);

assert( eventdata !=

);

assert( event !=

);

assert( conshdlrdata !=

);

assert( conshdlrdata->forcerestart );

( conshdlrdata->performedrestart )

++(conshdlrdata->nbinvarszero);

(

,

,

( conshdlrdata->nbinvarszero > (

) ((

) conshdlrdata->ninitconss * conshdlrdata->restartfrac) )

, conshdlrdata->nbinvarszero, conshdlrdata->ninitconss);

( conshdlrdata->objindicatoronly )

conshdlrdata->performedrestart =

;

assert(

(

, conshdlrdata->minabsobj, 1.0 ) );

( ! conshdlrdata->objindicatoronly )

conshdlrdata->performedrestart =

;

assert( conflicthdlr !=

);

assert( conflicthdlr !=

);

assert( bdchginfos !=

|| nbdchginfos == 0 );

assert( result !=

);

assert( conflicthdlrdata !=

);

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

assert( bdchginfos !=

);

assert( bdchginfos[i] !=

);

( haveslack && i == nbdchginfos )

(

,

);

assert( conflicthdlrdata->conshdlr !=

);

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

assert( bdchginfos !=

);

assert( bdchginfos[i] !=

);

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

assert( conss[j] !=

);

assert( slackvar !=

);

( slackvar == var )

( i == nbdchginfos )

assert( param !=

);

assert( name !=

);

assert( value !=

);

( *value == newvalue )

assert( param !=

);

assert( conshdlr !=

);

assert( conshdlrdata !=

);

assert( vector !=

);

assert( conshdlr !=

);

assert( conshdlrdata !=

);

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

assert( consdata !=

);

lincons = consdata->lincons;

assert( lincons !=

);

slackvar = consdata->slackvar;

assert( slackvar !=

);

linvals[0] = scalar;

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

assert( var !=

);

( var == slackvar )

newvars[nnewvars++] = var;

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

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

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

assert( var !=

);

( var == slackvar )

matval[cnt] = sign * linvals[v];

assert( slackvar !=

);

( conshdlrdata->useotherconss )

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

assert( cons !=

);

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

assert( var !=

);

newvars[nnewvars++] = var;

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

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

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

assert( var !=

);

matval[cnt] = linvals[v];

(

);

assert( conshdlr !=

);

assert( conshdlrdata !=

);

assert( conshdlrdata->naddlincons <= conshdlrdata->maxaddlincons );

( num > conshdlrdata->maxaddlincons )

conshdlrdata->maxaddlincons = newsize;

assert( num <= conshdlrdata->maxaddlincons );

assert( conshdlrdata !=

);

assert( conshdlrdata->altlp ==

);

assert( conshdlrdata->varhash ==

);

assert( conshdlrdata->lbhash ==

);

assert( conshdlrdata->ubhash ==

);

assert( conshdlrdata->slackhash !=

);

conshdlrdata->nrows = 1;

assert( lp !=

);

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

covered[j] =

;

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

assert( conss[j] !=

);

assert( consdata !=

);

ind = consdata->colindex;

assert( ind < nCols );

covered[ind] =

;

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

* indices =

;

assert( lp !=

);

assert( conss !=

);

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

assert( conss[j] !=

);

assert( consdata !=

);

( consdata->colindex >= 0 )

obj[cnt] = 1.0 - val;

indices[cnt++] = consdata->colindex;

* indices =

;

assert( lp !=

);

assert( conss !=

);

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

assert( conss[j] !=

);

assert( consdata !=

);

( consdata->colindex >= 0 )

indices[cnt++] = consdata->colindex;

* indices =

;

assert( lp !=

);

assert( conss !=

);

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

assert( conss[j] !=

);

assert( consdata !=

);

( consdata->colindex >= 0 )

indices[cnt] = consdata->colindex;

* indices =

;

assert( lp !=

);

assert( conss !=

);

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

assert( conss[j] !=

);

assert( consdata !=

);

( consdata->colindex >= 0 )

indices[cnt] = consdata->colindex;

assert( conshdlrdata !=

);

altlp = conshdlrdata->altlp;

lbhash = conshdlrdata->lbhash;

ubhash = conshdlrdata->ubhash;

assert( lbhash !=

&& ubhash !=

);

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

conshdlrdata->scaled =

;

(

,

, cnt);

assert( conshdlrdata !=

);

altlp = conshdlrdata->altlp;

lbhash = conshdlrdata->lbhash;

ubhash = conshdlrdata->ubhash;

assert( lbhash !=

&& ubhash !=

);

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

(

,

, cnt);

assert( conshdlrdata !=

);

assert( vector !=

);

assert( isLocal !=

);

lbhash = conshdlrdata->lbhash;

ubhash = conshdlrdata->ubhash;

assert( lbhash !=

&& ubhash !=

);

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

assert( 0 <= col && col < nCols );

assert( 0 <= col && col < nCols );

assert( conshdlrdata !=

);

( ! conshdlrdata->scaled )

altlp = conshdlrdata->altlp;

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

sum = -

(sum) / ((double) cnt);

conshdlrdata->scaled =

;

assert( conshdlrdata !=

);

assert( vars !=

|| nvars == 0 );

assert( vals !=

|| nvars == 0 );

assert( colindex !=

);

( conshdlrdata->altlp ==

)

assert( conshdlrdata->altlp !=

);

assert( conshdlrdata->varhash !=

);

assert( conshdlrdata->lbhash !=

);

assert( conshdlrdata->ubhash !=

);

assert( conshdlrdata->slackhash !=

);

assert( nrows == conshdlrdata->nrows );

matval[cnt++] = sign * rhscoef;

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

assert( var !=

);

( var != slackvar )

( ind < INT_MAX )

matind[cnt] = (conshdlrdata->nrows)++;

newrowsslack[nnewrows++] =

;

matval[cnt++] = sign * vals[v];

matind[cnt] = (conshdlrdata->nrows)++;

newrowsslack[nnewrows++] =

;

newvars[nnewvars++] = var;

matval[cnt++] = sign * vals[v];

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

( newrowsslack[i] )

assert( slackvar ==

);

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

assert( var !=

);

matbeg[nnewcols] = cnt;

matval[cnt++] = -val;

matval[cnt++] = -1.0;

obj[nnewcols] = 0.0;

++conshdlrdata->nlbbounds;

(

,

,

matbeg[nnewcols] = cnt;

matval[cnt++] = val;

matval[cnt++] = 1.0;

obj[nnewcols] = 0.0;

++conshdlrdata->nubbounds;

(

,

,

assert( cnt == ncols + nnewcols + 1 );

conshdlrdata->scaled =

;

assert( conshdlr !=

);

assert( lincons !=

);

assert( colindex !=

);

assert( conshdlrdata !=

);

(

,

, scalar, constant);

linvals[0] = scalar;

(

(

, conshdlr, conshdlrdata, slackvar, nlinvars, linvars, linvals, linrhs, objcoef, 1.0,

, colindex) );

(

(

, conshdlr, conshdlrdata, slackvar, nlinvars, linvars, linvals, linrhs, objcoef, 1.0,

, colindex) );

(

(

, conshdlr, conshdlrdata, slackvar, nlinvars, linvars, linvals, linlhs, objcoef, -1.0,

, colindex) );

assert( conshdlr !=

);

assert( row !=

);

assert( colindex !=

);

assert( conshdlrdata !=

);

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

assert( rowvars[j] !=

);

(

(

, conshdlr, conshdlrdata,

, nrowcols, rowvars, rowvals, rowrhs, objcoef, 1.0,

, colindex) );

(

(

, conshdlr, conshdlrdata,

, nrowcols, rowvars, rowvals, rowrhs, objcoef, 1.0,

, colindex) );

(

(

, conshdlr, conshdlrdata,

, nrowcols, rowvars, rowvals, rowlhs, objcoef, -1.0,

, colindex) );

assert( conshdlr !=

);

assert( conshdlrdata !=

);

( conshdlrdata->objcutindex >= 0 )

( ! conshdlrdata->objothervarsonly )

(

,

, conshdlrdata->objupperbound);

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

assert( var !=

);

objvars[nobjvars] = var;

objvals[nobjvars++] = objval;

(

(

, conshdlr, conshdlrdata,

, nobjvars, objvars, objvals, conshdlrdata->objupperbound, 0.0, 1.0,

, &conshdlrdata->objcutindex) );

assert( conshdlrdata->objcutindex >= 0 );

conshdlrdata->objaltlpbound = conshdlrdata->objupperbound;

assert( conshdlr !=

);

assert( cons !=

);

assert( conshdlrdata !=

);

( conshdlrdata->altlp !=

)

assert( consdata !=

);

( consdata->colindex >= 0 )

consdata->colindex = -1;

conshdlrdata->scaled =

;

assert( conshdlrdata !=

);

( ! conshdlrdata->useobjectivecut )

( conshdlrdata->altlp ==

)

(

(

, objbnd, conshdlrdata->objupperbound) )

conshdlrdata->objupperbound = objbnd;

(

(

, conshdlrdata->objupperbound, conshdlrdata->objaltlpbound) )

(

,

, conshdlrdata->objupperbound);

( conshdlrdata->objcutindex < 0 )

assert(

(

, oldbnd, conshdlrdata->objaltlpbound) );

(

(conshdlrdata->altlp, 0, conshdlrdata->objcutindex, conshdlrdata->objupperbound) );

conshdlrdata->objaltlpbound = conshdlrdata->objupperbound;

assert( lp !=

);

assert( infeasible !=

);

assert( error !=

);

( maxcondition > 0.0 )

( condition !=

&& condition > maxcondition )

(

,

, condition, maxcondition);

(

,

, condition, maxcondition);

(

,

);

*infeasible =

;

*infeasible =

;

nnonviolated = 0;

assert( lp !=

);

assert( conss !=

);

assert( S !=

);

assert( size !=

);

assert( value !=

);

assert( error !=

);

assert( cutoff !=

);

assert( nGen !=

);

assert( nconss <= nCols );

(

,

, *size, *value);

( conshdlrdata->trysolfromcover )

( heurindicator ==

)

(

,

);

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

assert( consdata !=

);

ind = consdata->colindex;

assert( ind < nCols );

( val < candval )

( candidate < 0 )

assert( candidate >= 0 );

assert( ! S[candidate] );

assert( sizeIIS > 0 );

( conshdlrdata->normtype )

(

, conshdlrdata->normtype);

(

,

,

*size, candidate, candobj, primsol[

(conss[candidate])->colindex], sizeIIS, (sum - (

) (sizeIIS - 1))/norm);

S[candidate] =

;

( conshdlrdata->updatebounds )

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

ind = consdata->colindex;

assert( ind < nCols );

assert( consdata->binvar !=

);

assert( cnt == sizeIIS );

(

(

, &cons, name, cnt, vars,

,

,

,

,

, isLocal,

,

, removable,

) );

(

(

, &cons,

, cnt, vars,

,

,

,

,

, isLocal,

,

, removable,

) );

( enfosepatype )

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

ind = consdata->colindex;

assert( ind < nCols );

assert( consdata->binvar !=

);

( nnonviolated > conshdlrdata->maxsepanonviolated )

(

,

, nnonviolated);

(step < nconss);

* consname,

assert( conshdlr !=

);

assert( conshdlrdata !=

);

assert( consdata !=

);

assert( slackvar !=

);

assert( eventhdlrrestart !=

);

( activeone || binvar ==

)

binvarinternal = binvar;

(*consdata)->nfixednonzero = 0;

(*consdata)->colindex = -1;

(*consdata)->linconsactive = linconsactive;

(*consdata)->binvar = binvarinternal;

(*consdata)->slackvar = slackvar;

(*consdata)->activeone = activeone;

(*consdata)->lessthanineq = lessthanineq;

(*consdata)->lincons = lincons;

(*consdata)->implicationadded =

;

(*consdata)->slacktypechecked =

;

(*consdata)->varswithevents =

;

(*consdata)->eventtypes =

;

(*consdata)->nevents = 0;

( binvarinternal !=

)

assert( var !=

);

(*consdata)->binvar = var;

( conshdlrdata->forcerestart )

++((*consdata)->nfixednonzero);

assert( var !=

);

(*consdata)->slackvar = var;

( linconsactive )

++((*consdata)->nfixednonzero);

assert( lincons !=

);

assert( consname !=

);

(

,

, consname, (*consdata)->colindex);

( (*consdata)->nfixednonzero > 0 )

(

,

, consname, (*consdata)->nfixednonzero);

name[50] =

;

assert( conshdlrdata !=

);

assert( ngen !=

);

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

assert( consdata !=

);

( ub <= conshdlrdata->maxcouplingvalue )

!conshdlrdata->removeindicators, !conshdlrdata->removeindicators,

) );

( conshdlrdata->removeindicators )

assert( cons !=

);

assert( consdata !=

);

assert( cutoff !=

);

assert( success !=

);

assert( ndelconss !=

);

assert( nfixedvars !=

);

assert( consdata->binvar !=

);

assert( consdata->slackvar !=

);

(

,

);

(

,

);

assert( ! infeasible );

(

,

);

(

,

);

assert( ! infeasible );

( dualreductions )

binvar = consdata->binvar;

assert( ! infeasible );

assert( ! infeasible );

var = consdata->binvar;

( var != consdata->binvar && ! negated )

assert( conshdlrdata->eventhdlrbound !=

);

( conshdlrdata->forcerestart )

assert( conshdlrdata->eventhdlrrestart !=

);

conshdlrdata->eventhdlrrestart, (

*) conshdlrdata, -1) );

consdata->binvar = var;

assert( var !=

);

( var == consdata->slackvar )

var = consdata->slackvar;

assert( var != consdata->slackvar );

assert( conshdlrdata->eventhdlrbound !=

);

consdata->slackvar = var;

( var == consdata->binvar )

(

,

,

(

,

,

assert( ! infeasible );

assert( cons !=

);

assert( consdata !=

);

assert( cutoff !=

);

assert( nGen !=

);

( ! consdata->linconsactive )

assert( consdata->slackvar !=

);

assert( consdata->binvar !=

);

( consdata->nfixednonzero > 1 )

(

,

);

( consdata->nfixednonzero == 1 )

(

,

,

assert( ! infeasible );

(

,

,

assert( ! infeasible );

( addopposite && consdata->linconsactive )

assert( consdata->lincons !=

);

slackvar = consdata->slackvar;

assert( slackvar !=

);

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

( linvars[j] != slackvar )

allintegral =

;

vars[nvars] = linvars[j];

vals[nvars++] = linvals[j];

assert( nlinvars == nvars + 1 );

( dualreductions )

binvar = consdata->binvar;

assert( ! infeasible );

assert( ! infeasible );

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

val = linconsvals[j];

var = linconsvars[j];

assert( var !=

);

( var == consdata->slackvar )

maxactivity += val *

;

newub = (maxactivity - rhs) / (-1.0 * coeffslack);

(

,

,

assert( !infeasible );

assert( conshdlr !=

);

assert( conss !=

);

assert( cutoff !=

);

assert( nGen !=

);

assert( conshdlrdata !=

);

lp = conshdlrdata->altlp;

assert( lp !=

);

( conshdlrdata->updatebounds )

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

assert( conss[j] !=

);

assert( consdata !=

);

(

(

, conshdlr, conshdlrdata, lp, sol, enfosepatype, conshdlrdata->removable, genlogicor, nconss, conss, S, &size, &value, &error, cutoff, &nCuts) );

( nCuts == 0 && error )

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

assert( conshdlrdata !=

);

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

assert( conss[c] !=

);

assert( consdata !=

);

assert( consdata->lincons !=

);

( ! consdata->linconsactive )

someLinconsNotActive =

;

(

(

, conss[c], consdata, conshdlrdata, dualreductions, conshdlrdata->addopposite, &cutoff, &cnt) );

binvar = consdata->binvar;

( valSlack > maxSlack )

maxSlack = valSlack;

( (someLinconsNotActive || conshdlrdata->enforcecuts) && conshdlrdata->sepaalternativelp )

conshdlrdata->niiscutsgen += ngen;

conshdlrdata->niiscutsgen += ngen;

( ! conshdlrdata->branchindicators )

assert( consdata !=

);

binvar = consdata->binvar;

slackvar = consdata->slackvar;

assert( conshdlr !=

);

assert( conss !=

);

assert( cutoff !=

);

assert( nGen !=

);

( *nGen >= maxsepacuts )

assert( conshdlrdata !=

);

lp = conshdlrdata->altlp;

assert( lp !=

);

( conshdlrdata->updatebounds )

(threshold = conshdlrdata->roundingmaxthres;

rounds < conshdlrdata->maxroundingrounds && threshold >= conshdlrdata->roundingminthres && *nGen < maxsepacuts && ! (*cutoff);

threshold -= conshdlrdata->roundingoffset )

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

assert( conss[j] !=

);

assert( consdata !=

);

assert( binvarneg !=

);

assert( conshdlrdata->binvarhash !=

);

( binvarval > binvarnegval )

( size == nconss )

( size == oldsize )

(

,

);

(

,

, nvarsone, nvarszero, nvarsfrac);

(

(

, conshdlr, conshdlrdata, lp, sol, enfosepatype, conshdlrdata->removable, conshdlrdata->genlogicor,

nconss, conss, S, &size, &value, &error, cutoff, &nCuts) );

assert( conshdlr !=

);

assert( conss !=

);

assert( nGen !=

);

( *nGen >= maxsepacuts )

assert( conshdlrdata !=

);

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

assert( conss[c] !=

);

assert( consdata !=

);

slackvar = consdata->slackvar;

lincons = consdata->lincons;

assert( lincons !=

);

binvar = consdata->binvar;

assert( binvar !=

);

cutval = binval * ypart;

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

( linvars[j] == slackvar )

( conshdlrdata->sepapersplocal )

finitebound =

;

linval = signfactor * linvals[j];

dout += linval * lb;

dout += linval * ub;

xpart = linval * xval;

(

(

, binval * din, binval * dout + xpart) )

cutval += binval * din;

cutval += binval * dout + xpart;

cutvars[cnt] = linvars[j];

cutvals[cnt++] = linval;

( ! finitebound )

cutvars[cnt] = binvar;

cutvals[cnt] = ypart;

(

,

, cutval, cutrhs);

(void)

(name, 50,

, conshdlrdata->nperspcutsgen + *nGen);

assert( ! infeasible );

( *nGen >= maxsepacuts )

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

assert( conshdlrdata !=

);

maxsepacuts = conshdlrdata->maxsepacutsroot;

maxsepacuts = conshdlrdata->maxsepacuts;

( conshdlrdata->sepacouplingcuts )

(c = 0; c < nusefulconss && ncuts < maxsepacuts; ++c)

assert( conss !=

);

assert( conss[c] !=

);

assert( consdata !=

);

assert( consdata->slackvar !=

);

assert( consdata->binvar !=

);

( conshdlrdata->sepacouplinglocal )

( ub <= conshdlrdata->sepacouplingvalue )

assert( ! infeasible );

(

,

, ncuts);

(

,

);

(

,

, ncuts - noldcuts);

( ncuts > noldcuts )

conshdlrdata->niiscutsgen += ncuts;

( conshdlrdata->genlogicor )

(

,

);

(

,

, ncuts - noldcuts);

( ncuts > noldcuts )

conshdlrdata->nperspcutsgen += ncuts;

assert( conshdlrdata !=

);

conshdlrdata->linconsevents =

;

conshdlrdata->linconsboundschanged =

;

conshdlrdata->boundhaschanged =

;

conshdlrdata->removable =

;

conshdlrdata->scaled =

;

conshdlrdata->altlp =

;

conshdlrdata->nrows = 0;

conshdlrdata->varhash =

;

conshdlrdata->slackhash =

;

conshdlrdata->lbhash =

;

conshdlrdata->ubhash =

;

conshdlrdata->nlbbounds = 0;

conshdlrdata->nubbounds = 0;

conshdlrdata->nslackvars = 0;

conshdlrdata->objcutindex = -1;

conshdlrdata->roundingminthres = 0.1;

conshdlrdata->roundingmaxthres = 0.6;

conshdlrdata->roundingoffset = 0.1;

conshdlrdata->addedcouplingcons =

;

conshdlrdata->ninitconss = 0;

conshdlrdata->nbinvarszero = 0;

conshdlrdata->performedrestart =

;

conshdlrdata->objindicatoronly =

;

conshdlrdata->objothervarsonly =

;

conshdlrdata->minabsobj = 0.0;

conshdlrdata->normtype =

;

conshdlrdata->niiscutsgen = 0;

conshdlrdata->nperspcutsgen = 0;

maxabsvalidx = -1;

assert( upgdcons !=

);

assert( conshdlr !=

);

assert( conshdlrdata !=

);

( ! conshdlrdata->upgradelinear )

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

assert( var !=

);

secabsval = maxabsval;

minactivity += val * lb;

maxactivity += val * ub;

assert( maxabsval >= 0.0 );

assert( 0 <= maxabsvalidx && maxabsvalidx < nvars );

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

( upgdlhs || upgdrhs )

assert( ! upgdlhs || ! upgdrhs );

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

( vars[l] == indvar )

indconsvars[cnt] = vars[l];

indconsvals[cnt] = -vals[l];

indconsvals[cnt] = vals[l];

( indneglhs || indnegrhs )

assert( conshdlr !=

);

assert( valid !=

);

assert( conshdlr !=

);

assert( conshdlrdata !=

);

( conshdlrdata->trysolutions && conshdlrdata->heurtrysol ==

)

assert( conshdlr !=

);

( conshdlrdata->binvarhash !=

)

( conshdlrdata->binslackvarhash !=

)

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

assert( consdata !=

);

( consdata->varswithevents !=

)

assert( consdata->eventtypes !=

);

assert( consdata->lincons !=

);

(j = 0; j < consdata->nevents; ++j)

consdata->nevents = 0;

assert( consdata->varswithevents ==

);

assert( consdata->eventtypes ==

);

conshdlrdata->maxaddlincons = 0;

conshdlrdata->naddlincons = 0;

conshdlrdata->nrows = 0;

assert( conshdlr !=

);

assert( conshdlrdata !=

);

assert( conshdlrdata->altlp ==

);

assert( conshdlrdata->varhash ==

);

assert( conshdlrdata->lbhash ==

);

assert( conshdlrdata->ubhash ==

);

assert( conshdlrdata->slackhash ==

);

( conshdlrdata->maxaddlincons > 0 )

assert( conshdlrdata->addlincons ==

);

conshdlrdata->naddlincons = 0;

conshdlrdata->maxaddlincons = 0;

assert( conshdlr !=

);

assert( conshdlrdata !=

);

assert( conshdlrdata->slackhash ==

);

conshdlrdata->boundhaschanged =

;

( conshdlrdata->sepaalternativelp )

assert( conshdlrdata->slackhash !=

);

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

assert( conss !=

);

assert( conss[c] !=

);

assert( consdata !=

);

assert( consdata->slackvar !=

);

++conshdlrdata->nslackvars;

( conshdlrdata->genlogicor )

logicorsepafreq;

( logicorconshdlr ==

)

(

);

( (sepafreq != -1 || conshdlrdata->enforcecuts) && logicorsepafreq != 1 )

(

,

);

conshdlrdata->objothervarsonly =

;

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

assert( conss !=

);

assert( conss[c] !=

);

assert( consdata !=

);

assert( consdata->binvar !=

);

assert( consdata->slackvar !=

);

conshdlrdata->objothervarsonly =

;

( ! consdata->linconsactive )

( conshdlrdata->sepaalternativelp && consdata->colindex < 0 )

(

(

, &nlrow,

(conss[c]), 0.0, 0,

,

, quadexpr, 0.0, 0.0,

) );

( conshdlrdata->sepaalternativelp )

( conshdlrdata->naddlincons > 0 )

(c = 0; c < conshdlrdata->naddlincons; ++c)

cons = conshdlrdata->addlincons[c];

(

,

, cnt);

( conshdlrdata->useotherconss )

* conshdlrname;

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

assert( cons !=

);

(

,

, cnt);

( conshdlrdata->forcerestart )

assert( conshdlrdata->eventhdlrrestart !=

);

conshdlrdata->nbinvarszero = 0;

conshdlrdata->objindicatoronly =

;

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

covered[j] =

;

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

assert( conss !=

);

assert( conss[c] !=

);

assert( consdata !=

);

assert( consdata->binvar !=

);

( probindex < 0 )

assert( 0 <= probindex && probindex < nvars );

covered[probindex] =

;

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

(

(obj) < conshdlrdata->minabsobj )

conshdlrdata->minabsobj =

(obj);

assert(

(

, conshdlrdata->minabsobj, 1.0) );

conshdlrdata->objindicatoronly =

;

assert( conshdlrdata->eventhdlrrestart !=

);

assert( conshdlr !=

);

assert( conshdlrdata !=

);

( conshdlrdata->sepaalternativelp )

( conshdlrdata->slackhash !=

)

( conshdlrdata->altlp !=

)

assert( conshdlrdata->varhash !=

);

assert( conshdlrdata->lbhash !=

);

assert( conshdlrdata->ubhash !=

);

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

assert( conss !=

);

assert( conss[c] !=

);

assert( consdata !=

);

consdata->colindex = -1;

assert( conshdlrdata->slackhash ==

);

assert( conshdlrdata->varhash ==

);

assert( conshdlrdata->lbhash ==

);

assert( conshdlrdata->ubhash ==

);

assert( conshdlr !=

);

assert( cons !=

);

assert( consdata !=

);

assert( conshdlrdata !=

);

( conshdlrdata->binslackvarhash !=

)

assert( conshdlrdata !=

);

( conshdlrdata->sepaalternativelp )

assert( (*consdata)->slackvar !=

);

assert( (*consdata)->binvar !=

);

( (*consdata)->linconsactive )

assert( conshdlrdata->eventhdlrbound !=

);

( conshdlrdata->forcerestart )

assert( conshdlrdata->eventhdlrrestart !=

);

( conshdlrdata->linconsevents && (*consdata)->linconsactive && (*consdata)->varswithevents !=

)

assert( cons !=

);

assert( (*consdata)->eventtypes !=

);

assert( (*consdata)->lincons !=

);

(j = 0; j < (*consdata)->nevents; ++j)

(*consdata)->nevents = 0;

assert( (*consdata)->varswithevents ==

);

assert( (*consdata)->eventtypes ==

);

assert( (*consdata)->lincons !=

);

assert( conshdlr !=

);

assert( sourcecons !=

);

assert( targetcons !=

);

assert( conshdlrdata !=

);

assert( conshdlrdata->eventhdlrbound !=

);

assert( sourcedata !=

);

assert( sourcedata->binvar !=

);

( sourcedata->slackvar ==

)

( sourcedata->lincons ==

)

assert( sourcedata->lincons !=

);

assert( sourcedata->slackvar !=

);

sourcedata->binvar,

, sourcedata->lessthanineq, sourcedata->slackvar, sourcedata->lincons, sourcedata->linconsactive) );

consdata->activeone = sourcedata->activeone;

assert( consdata !=

);

( sourcedata->linconsactive )

( conshdlrdata->sepaalternativelp )

( conshdlrdata->binvarhash ==

)

assert( conshdlrdata->binvarhash !=

);

( !

(conshdlrdata->binvarhash, (

*) consdata->binvar) )

assert( conshdlr !=

);

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

assert( conss !=

);

assert( conss[c] !=

);

assert( consdata !=

);

assert( consdata->lincons !=

);

assert( translincons !=

);

consdata->lincons = translincons;

assert( conshdlrdata !=

);

conshdlrdata->addedcouplingcons =

;

(

oldnfixedvars = *nfixedvars; )

(

oldndelconss = *ndelconss; )

assert( conshdlr !=

);

assert( result !=

);

assert( conshdlrdata !=

);

( nrounds == 0 || nnewfixedvars > 0 || nnewchgbds > 0 || nnewaggrvars > 0 )

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

assert( conss !=

);

assert( conss[c] !=

);

assert( consdata !=

);

assert( consdata->binvar !=

);

( ! consdata->linconsactive )

assert( consdata->lincons !=

);

assert( consdata->slackvar !=

);

( ! consdata->implicationadded )

consdata->implicationadded =

;

( ! consdata->slacktypechecked )

consdata->slacktypechecked =

;

assert( consdata->lincons !=

);

slackvar = consdata->slackvar;

assert( slackvar !=

);

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

( vars[j] == slackvar )

foundslackvar =

;

( j == nvars && foundslackvar )

(

,

,

noReductions = nnewfixedvars == 0 && nnewaggrvars == 0 && nnewchgvartypes == 0 && nnewchgbds == 0

&& nnewdelconss == 0 && nnewchgcoefs == 0 && nnewchgsides == 0;

( noReductions && *result !=

&& conshdlrdata->addcouplingcons && ! conshdlrdata->addedcouplingcons )

*nupgdconss += ngen;

( conshdlrdata->removeindicators )

conshdlrdata->addedcouplingcons =

;

(

(

,

,

nconss, *nfixedvars - oldnfixedvars, *ndelconss - oldndelconss); )

assert( conshdlr !=

);

assert( conshdlrdata !=

);

*infeasible =

;

( ! conshdlrdata->addcoupling )

( conshdlrdata->addcouplingcons && conshdlrdata->addedcouplingcons )

(

,

, nconss);

(c = 0; c < nconss && !(*infeasible); ++c)

assert( conss !=

);

assert( conss[c] !=

);

assert( consdata !=

);

( ! consdata->linconsactive )

( ub <= conshdlrdata->maxcouplingvalue )

( conshdlrdata->addcouplingcons )

assert( ! conshdlrdata->addedcouplingcons );

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

( solinfeasible )

assert( conshdlrdata !=

);

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

( solinfeasible )

assert( conshdlrdata !=

);

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

( solinfeasible )

( objinfeasible )

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

assert( conshdlrdata !=

);

assert( trysol !=

);

changedSol =

;

someLinconsNotActive =

;

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

assert( conss[c] !=

);

assert( consdata !=

);

assert( consdata->binvar !=

);

( ! consdata->linconsactive )

someLinconsNotActive =

;

assert( consdata->slackvar !=

);

( trysol !=

)

changedSol = changedSol || changed;

( trysol !=

)

changedSol = changedSol || changed;

( someLinconsNotActive )

lp = conshdlrdata->altlp;

assert( conshdlrdata->sepaalternativelp );

( conshdlrdata->updatebounds )

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

assert( conss[c] !=

);

assert( consdata !=

);

( trysol !=

&& changedSol )

assert( conshdlrdata->heurtrysol !=

);

( trysol !=

)

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

assert( conshdlrdata !=

);

( ! conshdlrdata->boundhaschanged && !

(

) && ! conshdlrdata->linconsboundschanged )

( !conshdlrdata->linconsevents )

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

assert( conss[c] !=

);

assert( consdata !=

);

( ! consdata->linconsactive )

assert( consdata->lincons !=

);

assert( consdata->slackvar !=

);

assert( nvars != 0 );

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

( vars[j] == consdata->slackvar )

( vals[j] > 0.0 )

consdata->varswithevents[consdata->nevents] = vars[j];

consdata->nevents++;

consdata->varswithevents[consdata->nevents] = vars[j];

consdata->nevents++;

assert( consdata->nevents == nvars - 1 );

conshdlrdata->linconsevents =

;

conshdlrdata->boundhaschanged =

;

conshdlrdata->linconsboundschanged =

;

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

assert( conss[c] !=

);

assert( consdata !=

);

(

(

, cons, consdata, conshdlrdata, dualreductions, conshdlrdata->addopposite, &cutoff, &cnt) );

assert( cons !=

);

assert( infervar !=

);

assert( bdchgidx !=

);

assert( result !=

);

assert( consdata !=

);

assert( inferinfo == 0 || inferinfo == 1 || inferinfo == 2 || inferinfo == 3 );

assert( consdata->linconsactive );

( inferinfo == 0 )

assert( infervar != consdata->binvar );

( inferinfo == 1 )

assert( infervar != consdata->slackvar );

( inferinfo == 2 )

assert( inferinfo == 3 );

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

( linconsvals[j] > 0.0 )

assert( conshdlr !=

);

assert( cons !=

);

assert( consdata !=

);

assert( consdata->binvar !=

);

( consdata->linconsactive )

assert( consdata->slackvar !=

);

assert( consdata->lincons !=

);

assert( consdata->slackvar ==

);

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

assert( conshdlr !=

);

assert( cons !=

);

assert( consdata !=

);

assert( consdata->binvar !=

);

binvar = consdata->binvar;

assert( consdata->slackvar !=

);

assert( consdata->lincons !=

);

* consname;

assert( sourcescip !=

);

assert( sourcecons !=

);

(

,

, consname);

assert( sourceconsdata !=

);

sourcelincons = sourceconsdata->lincons;

assert( sourcelincons !=

);

assert( conshdlrlinear !=

);

assert( translincons !=

);

sourceconsdata->lincons = translincons;

sourcelincons = translincons;

sourcebinvar = sourceconsdata->binvar;

assert( sourcebinvar !=

);

sourceslackvar = sourceconsdata->slackvar;

assert( sourceslackvar !=

);

assert( targetlincons !=

);

assert( targetbinvar !=

);

assert( targetslackvar !=

);

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

( targetlincons !=

)

binvarname[1024];

slackvarname[1024];

linconsname[1024];

nargs = sscanf(str,

, binvarname, &zeroone, slackvarname, linconsname);

( nargs != 3 && nargs != 4 )

( zeroone != 0 && zeroone != 1 )

( binvar ==

)

( slackvar ==

)

( lincons ==

)

* posstr;

assert( nargs == 3 );

posstr = strstr(slackvarname,

);

( posstr ==

)

(void)

(binvarname, 1023,

, posstr+8);

( lincons ==

)

(void)

(binvarname, 1023,

, posstr+9);

( lincons ==

)

(void)

(binvarname, 1023,

, posstr+16);

( lincons ==

)

name, posstr+8, posstr+9, posstr+16);

assert( lincons !=

);

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

assert( conshdlr !=

);

assert( cons !=

);

assert( conshdlrdata !=

);

assert( consdata !=

);

( conshdlrdata->altlp !=

)

assert( conshdlrdata->sepaalternativelp );

( consdata->colindex >= 0 )

assert( conshdlr !=

);

assert( cons !=

);

assert( conshdlrdata !=

);

( conshdlrdata->altlp !=

)

assert( consdata !=

);

assert( conshdlrdata->sepaalternativelp );

( consdata->colindex >= 0 )

assert( cons !=

);

assert( vars !=

);

assert( success !=

);

assert( varssize >= 0 );

assert( consdata !=

);

assert( consdata->lincons !=

);

( consdata->binvar !=

)

assert( varssize > 0 );

vars[nvars++] = consdata->binvar;

( consdata->slackvar !=

)

assert( varssize > nvars );

vars[nvars++] = consdata->slackvar;

assert( cons !=

);

assert( nvars !=

);

assert( success !=

);

assert( consdata !=

);

assert( consdata->lincons !=

);

( consdata->binvar !=

)

( consdata->slackvar !=

)

assert( nlinvars >= 0 );

assert(conshdlr !=

);

assert(diveset !=

);

assert(success !=

);

assert(infeasible !=

);

*infeasible =

;

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

&score, &roundup) );

( score > bestscore )

bestvarroundup = roundup;

assert(! *success || bestvar !=

);

conshdlrdata->eventhdlrbound =

;

eventExecIndicatorBound,

) );

assert(conshdlrdata->eventhdlrbound !=

);

conshdlrdata->eventhdlrlinconsbound =

;

eventExecIndicatorLinconsBound,

) );

assert(conshdlrdata->eventhdlrlinconsbound !=

);

conshdlrdata->eventhdlrrestart =

;

eventExecIndicatorRestart,

) );

assert( conshdlrdata->eventhdlrrestart !=

);

conshdlrdata->heurtrysol =

;

conshdlrdata->binvarhash =

;

conshdlrdata->binslackvarhash =

;

conshdlrdata->addlincons =

;

conshdlrdata->naddlincons = 0;

conshdlrdata->maxaddlincons = 0;

consEnfolpIndicator, consEnfopsIndicator, consCheckIndicator, consLockIndicator,

assert( conshdlr !=

);

conflicthdlrdata->conshdlrdata = conshdlrdata;

conflicthdlrdata->conshdlr = conshdlr;

assert( conflicthdlrdata->conshdlr !=

);

conflictExecIndicator, conflicthdlrdata) );

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

(

, cons, name, binvar, nvars, vars, vals, rhs,

,

, initial,

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

(

, name);

( conshdlr ==

)

assert( conshdlrdata !=

);

( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )

(

,

);

( conshdlrdata->nolinconscont && conshdlrdata->generatebilinear )

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

valscopy[j] = -vals[j];

assert( nvars == 0 || valscopy !=

);

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

( conshdlrdata->scaleslackvar )

absvalsum +=

(valscopy[j]);

( ! conshdlrdata->scaleslackvar )

( activeone || binvar ==

)

binvarinternal = binvar;

( binvarinternal !=

)

( conshdlrdata->usesameslackvar && conshdlrdata->binslackvarhash ==

)

( conshdlrdata->binslackvarhash !=

&&

(conshdlrdata->binslackvarhash, (

*) binvarinternal) )

assert( ! infeasible );

( conshdlrdata->binslackvarhash !=

)

assert( slackvar !=

);

( conshdlrdata->nolinconscont )

assert( ! conshdlrdata->generatebilinear );

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

linconsactive =

;

( linconsactive )

( ! lessthanineq )

( conshdlrdata->scaleslackvar && nvars > 0 )

absvalsum = absvalsum/((

) nvars);

( conshdlrdata->generatebilinear )

(

(

, cons, name, 0,

,

, 1, &binvarinternal, &slackvar, &val, 0.0, 0.0,

binvar, activeone, lessthanineq, slackvar, lincons, linconsactive) );

assert( consdata !=

);

(

(

, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate,

local, modifiable, dynamic, removable, stickingatnode) );

( linconsactive )

( conshdlrdata->sepaalternativelp )

( conshdlrdata->binvarhash ==

)

assert( conshdlrdata->binvarhash !=

);

assert( lincons !=

);

assert( binvar !=

);

assert( slackvar !=

);

( conshdlr ==

)

assert( conshdlrdata !=

);

( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )

(

,

);

( conshdlrdata->nolinconscont )

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

linconsactive =

;

( conshdlrdata->generatebilinear )

binvarinternal = binvar;

(

(

, cons, name, 0,

,

, 1, &binvarinternal, &slackvar, &val, 0.0, 0.0,

binvar, activeone,

, slackvar, lincons, linconsactive) );

assert( consdata !=

);

(

(

, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate,

local, modifiable, dynamic, removable, stickingatnode) );

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

assert( lincons !=

);

assert( binvar !=

);

( conshdlr ==

)

assert( conshdlrdata !=

);

( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )

(

,

);

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

binvarinternal = binvar;

( conshdlrdata->usesameslackvar && conshdlrdata->binslackvarhash ==

)

( conshdlrdata->binslackvarhash !=

&&

(conshdlrdata->binslackvarhash, (

*) binvarinternal) )

assert( ! infeasible );

( conshdlrdata->binslackvarhash !=

)

assert( slackvar !=

);

( conshdlrdata->nolinconscont )

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

linconsactive =

;

( conshdlrdata->generatebilinear )

(

(

, cons, name, 0,

,

, 1, &binvarinternal, &slackvar, &val, 0.0, 0.0,

binvar, activeone,

, slackvar, lincons, linconsactive) );

assert( consdata !=

);

(

(

, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate,

local, modifiable, dynamic, removable, stickingatnode) );

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

assert( cons !=

);

assert( consdata !=

);

( !consdata->lessthanineq )

assert( ! infeasible );

assert( cons !=

);

assert( consdata !=

);

consdata->lincons;

assert( cons !=

);

assert( conshdlrdata !=

);

assert( consdata !=

);

assert( consdata->lincons !=

);

assert( lincons !=

);

consdata->lincons = lincons;

consdata->linconsactive =

;

( conshdlrdata->nolinconscont )

assert( vars !=

);

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

consdata->linconsactive =

;

assert( cons !=

);

assert( consdata !=

);

consdata->activeone;

assert( cons !=

);

assert( consdata !=

);

consdata->binvar;

assert(cons !=

);

assert(consdata !=

);

binvar = consdata->binvar;

( ! consdata->activeone )

assert(binvar !=

);

assert( cons !=

);

assert( binvar !=

);

assert( consdata !=

);

( consdata->binvar !=

)

assert( var !=

);

( ! consdata->activeone )

consdata->binvar = var;

assert( conshdlr !=

);

assert( conshdlrdata !=

);

assert( conshdlrdata->eventhdlrbound !=

);

assert( conshdlrdata->eventhdlrrestart !=

);

( consdata->linconsactive )

( conshdlrdata->forcerestart )

++(consdata->nfixednonzero);

( ! consdata->activeone )

consdata->binvar = binvar;

assert( cons !=

);

assert( consdata !=

);

consdata->slackvar;

assert( cons !=

);

assert( consdata !=

);

assert( consdata->slackvar !=

);

assert( cons !=

);

assert( consdata !=

);

( consdata->linconsactive )

assert( consdata->slackvar !=

);

assert( consdata->binvar !=

);

assert( cons !=

);

assert( sol !=

);

assert( changed !=

);

assert( cons !=

);

assert( consdata !=

);

( ! consdata->linconsactive )

lincons = consdata->lincons;

assert( lincons !=

);

slackvar = consdata->slackvar;

binvar = consdata->binvar;

assert( slackvar !=

);

assert( binvar !=

);

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

( var != slackvar )

slackcoef = linvals[v];

assert( slackcoef != 0.0 );

val = (val - sum)/slackcoef;

( slackcoef < 0 )

assert( conshdlr !=

);

assert( sol !=

);

assert( changed !=

);

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

assert( conss[c] !=

);

assert( consdata !=

);

( ! consdata->linconsactive )

*changed = *changed || chg;

assert( lincons !=

);

assert( conshdlrdata !=

);

assert( conshdlrdata->naddlincons+1 <= conshdlrdata->maxaddlincons );

conshdlrdata->addlincons[conshdlrdata->naddlincons++] = lincons;

assert( row !=

);

assert( conshdlrdata !=

);

( ! conshdlrdata->sepaalternativelp )

static SCIP_RETCODE branchCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)

#define DEFAULT_FORCERESTART

static SCIP_DECL_CONSCHECK(consCheckIndicator)

#define DEFAULT_TRYSOLUTIONS

#define EVENTHDLR_RESTART_NAME

static SCIP_RETCODE addAltLPRow(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_ROW *row, SCIP_Real objcoef, int *colindex)

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_SEPAFREQ

#define CONFLICTHDLR_PRIORITY

#define SCIP_CALL_PARAM(x)

static SCIP_DECL_CONSCOPY(consCopyIndicator)

static SCIP_DECL_CONSSEPALP(consSepalpIndicator)

static SCIP_DECL_CONSPARSE(consParseIndicator)

#define CONFLICTHDLR_NAME

static SCIP_DECL_CONSENFOPS(consEnfopsIndicator)

#define CONSHDLR_CHECKPRIORITY

#define DEFAULT_ADDCOUPLINGCONS

#define MAXROUNDINGROUNDS

#define DEFAULT_ADDOPPOSITE

static SCIP_RETCODE checkLPBoundsClean(SCIP *scip, SCIP_LPI *lp, int nconss, SCIP_CONS **conss)

static SCIP_DECL_CONSPRINT(consPrintIndicator)

static SCIP_RETCODE propIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_Bool dualreductions, SCIP_Bool addopposite, SCIP_Bool *cutoff, int *nGen)

static SCIP_RETCODE updateFirstRowGlobal(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)

static SCIP_DECL_CONSEXIT(consExitIndicator)

static SCIP_RETCODE fixAltLPVariables(SCIP *scip, SCIP_LPI *lp, int nconss, SCIP_CONS **conss, SCIP_Bool *S)

static SCIP_RETCODE createVarUbs(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS **conss, int nconss, int *ngen)

static SCIP_DECL_CONSEXITSOL(consExitsolIndicator)

#define CONSHDLR_PROP_TIMING

#define DEFAULT_USEOBJECTIVECUT

static SCIP_RETCODE addAltLPConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *lincons, SCIP_VAR *slackvar, SCIP_Real objcoef, int *colindex)

static SCIP_RETCODE extendToCover(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_LPI *lp, SCIP_SOL *sol, SCIP_ENFOSEPATYPE enfosepatype, SCIP_Bool removable, SCIP_Bool genlogicor, int nconss, SCIP_CONS **conss, SCIP_Bool *S, int *size, SCIP_Real *value, SCIP_Bool *error, SCIP_Bool *cutoff, int *nGen)

#define CONFLICTHDLR_DESC

static SCIP_RETCODE scaleFirstRow(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)

static SCIP_RETCODE separateIISRounding(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, SCIP_ENFOSEPATYPE enfosepatype, int nconss, SCIP_CONS **conss, int maxsepacuts, SCIP_Bool *cutoff, int *nGen)

static SCIP_DECL_CONSFREE(consFreeIndicator)

static SCIP_DECL_CONSGETNVARS(consGetNVarsIndicator)

static SCIP_Real varGetObjDelta(SCIP_VAR *var)

#define CONSHDLR_MAXPREROUNDS

static SCIP_RETCODE addAltLPColumn(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR *slackvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhscoef, SCIP_Real objcoef, SCIP_Real sign, SCIP_Bool colfree, int *colindex)

#define DEFAULT_MAXCONDITIONALTLP

static SCIP_RETCODE presolRoundIndicator(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_Bool dualreductions, SCIP_Bool *cutoff, SCIP_Bool *success, int *ndelconss, int *nfixedvars)

#define DEFAULT_SCALESLACKVAR

static SCIP_RETCODE checkAltLPInfeasible(SCIP *scip, SCIP_LPI *lp, SCIP_Real maxcondition, SCIP_Bool primal, SCIP_Bool *infeasible, SCIP_Bool *error)

static SCIP_DECL_CONSDISABLE(consDisableIndicator)

#define CONSHDLR_SEPAPRIORITY

static SCIP_RETCODE setAltLPObj(SCIP *scip, SCIP_LPI *lp, SCIP_SOL *sol, int nconss, SCIP_CONS **conss)

static SCIP_RETCODE checkIISlocal(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_Real *vector, SCIP_Bool *isLocal)

#define DEFAULT_USESAMESLACKVAR

static SCIP_DECL_CONSSEPASOL(consSepasolIndicator)

static SCIP_DECL_LINCONSUPGD(linconsUpgdIndicator)

#define DEFAULT_SEPAPERSPLOCAL

static SCIP_DECL_CONSDELETE(consDeleteIndicator)

static SCIP_DECL_CONFLICTFREE(conflictFreeIndicator)

static SCIP_RETCODE unfixAltLPVariables(SCIP *scip, SCIP_LPI *lp, int nconss, SCIP_CONS **conss, SCIP_Bool *S)

static SCIP_RETCODE separatePerspective(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, int nconss, SCIP_CONS **conss, int maxsepacuts, int *nGen)

#define DEFAULT_SEPAPERSPECTIVE

static SCIP_DECL_CONSGETVARS(consGetVarsIndicator)

static SCIP_RETCODE enforceCuts(SCIP *scip, SCIP_CONSHDLR *conshdlr, int nconss, SCIP_CONS **conss, SCIP_SOL *sol, SCIP_ENFOSEPATYPE enfosepatype, SCIP_Bool genlogicor, SCIP_Bool *cutoff, int *nGen)

#define DEFAULT_CONFLICTSUPGRADE

static SCIP_RETCODE initAlternativeLP(SCIP *scip, SCIP_CONSHDLR *conshdlr)

#define DEFAULT_MAXCOUPLINGVALUE

#define DEFAULT_SEPACOUPLINGVALUE

static SCIP_DECL_CONSINITSOL(consInitsolIndicator)

static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)

#define DEFAULT_REMOVEINDICATORS

#define DEFAULT_UPGRADELINEAR

static SCIP_DECL_CONSLOCK(consLockIndicator)

#define EVENTHDLR_LINCONSBOUND_DESC

#define DEFAULT_MAXSEPACUTSROOT

static SCIP_DECL_CONSINITPRE(consInitpreIndicator)

static SCIP_DECL_CONSTRANS(consTransIndicator)

static SCIP_RETCODE updateObjUpperbound(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)

static SCIP_RETCODE checkTransferBoolParam(SCIP *scip, SCIP_PARAM *param, const char *name, SCIP_Bool newvalue, SCIP_Bool *value)

#define EVENTHDLR_BOUND_DESC

static SCIP_RETCODE separateIndicators(SCIP *scip, SCIP_CONSHDLR *conshdlr, int nconss, int nusefulconss, SCIP_CONS **conss, SCIP_SOL *sol, SCIP_ENFOSEPATYPE enfosepatype, SCIP_RESULT *result)

static SCIP_RETCODE fixAltLPVariable(SCIP_LPI *lp, int ind)

enum SCIP_enfosepatype SCIP_ENFOSEPATYPE

#define DEFAULT_SEPACOUPLINGLOCAL

#define EVENTHDLR_LINCONSBOUND_NAME

#define DEFAULT_UPDATEBOUNDS

static SCIP_DECL_CONSINITLP(consInitlpIndicator)

#define DEFAULT_RESTARTFRAC

static SCIP_RETCODE enforceIndicators(SCIP *scip, SCIP_CONSHDLR *conshdlr, int nconss, SCIP_CONS **conss, SCIP_SOL *sol, SCIP_ENFOSEPATYPE enfosepatype, SCIP_Bool genlogicor, SCIP_RESULT *result)

#define CONSHDLR_PROPFREQ

#define DEFAULT_SEPAALTERNATIVELP

static void initConshdlrData(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)

#define DEFAULT_ENFORCECUTS

#define CONSHDLR_PRESOLTIMING

static SCIP_RETCODE unfixAltLPVariable(SCIP_LPI *lp, int ind)

static SCIP_RETCODE consdataEnsureAddLinConsSize(SCIP *scip, SCIP_CONSHDLR *conshdlr, int num)

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopyIndicator)

#define DEFAULT_MAXSEPACUTS

static SCIP_RETCODE setAltLPObjZero(SCIP *scip, SCIP_LPI *lp, int nconss, SCIP_CONS **conss)

#define EVENTHDLR_BOUND_NAME

#define DEFAULT_BRANCHINDICATORS

static SCIP_DECL_CONSGETPERMSYMGRAPH(consGetPermsymGraphIndicator)

#define CONSHDLR_EAGERFREQ

static SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(consGetSignedPermsymGraphIndicator)

static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, const char *consname, SCIP_CONSDATA **consdata, SCIP_EVENTHDLR *eventhdlrrestart, SCIP_VAR *binvar, SCIP_Bool activeone, SCIP_Bool lessthanineq, SCIP_VAR *slackvar, SCIP_CONS *lincons, SCIP_Bool linconsactive)

static SCIP_DECL_CONSRESPROP(consRespropIndicator)

static SCIP_DECL_CONSGETDIVEBDCHGS(consGetDiveBdChgsIndicator)

#define DEFAULT_USEOTHERCONSS

#define CONSHDLR_ENFOPRIORITY

#define DEFAULT_DUALREDUCTIONS

static SCIP_DECL_CONSENABLE(consEnableIndicator)

static SCIP_RETCODE deleteAltLPConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

#define LINCONSUPGD_PRIORITY

#define DEFAULT_GENERATEBILINEAR

#define CONSHDLR_DELAYSEPA

static SCIP_RETCODE addObjcut(SCIP *scip, SCIP_CONSHDLR *conshdlr)

#define DEFAULT_GENLOGICOR

#define DEFAULT_TRYSOLFROMCOVER

static SCIP_DECL_CONSENFOLP(consEnfolpIndicator)

static SCIP_DECL_CONSENFORELAX(consEnforelaxIndicator)

#define EVENTHDLR_RESTART_DESC

static SCIP_DECL_CONSPROP(consPropIndicator)

static SCIP_DECL_CONSPRESOL(consPresolIndicator)

static SCIP_DECL_EVENTEXEC(eventExecIndicatorBound)

#define DEFAULT_MAXSEPANONVIOLATED

#define DEFAULT_ADDCOUPLING

#define DEFAULT_SEPACOUPLINGCUTS

static SCIP_RETCODE updateFirstRow(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)

static SCIP_DECL_PARAMCHGD(paramChangedIndicator)

static SCIP_DECL_CONSINIT(consInitIndicator)

#define CONSHDLR_DELAYPROP

#define DEFAULT_NOLINCONSCONT

static SCIP_DECL_CONFLICTEXEC(conflictExecIndicator)

constraint handler for indicator constraints

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 variable bound constraints .

#define SCIP_LONGINT_FORMAT

product expression handler

variable expression handler

SCIP_RETCODE SCIPcreateConsIndicatorGenericLinConsPure(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_Bool activeone, 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 SCIPcreateConsIndicatorLinCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar, 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 SCIPincludeLinconsUpgrade(SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)

SCIP_RETCODE SCIPcreateConsBasicIndicator(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs)

SCIP_VAR * SCIPgetBinaryVarIndicatorGeneric(SCIP_CONS *cons)

SCIP_RETCODE SCIPsetSlackVarUb(SCIP *scip, SCIP_CONS *cons, SCIP_Real ub)

SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)

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

SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPaddRowIndicator(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_ROW *row)

SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsIndicatorGeneric(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs, SCIP_Bool activeone, SCIP_Bool lessthanineq, 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 SCIPgetNVarsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPaddLinearConsIndicator(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *lincons)

SCIP_RETCODE SCIPsetLinearConsIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_CONS *lincons)

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)

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

SCIP_RETCODE SCIPcreateConsIndicatorGenericLinCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar, SCIP_Bool activeone, 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 SCIPcreateConsBasicIndicatorLinCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar)

SCIP_RETCODE SCIPmakeIndicatorsFeasible(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, SCIP_Bool *changed)

SCIP_VAR * SCIPgetBinaryVarIndicator(SCIP_CONS *cons)

SCIP_VAR * SCIPgetSlackVarIndicator(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_RETCODE SCIPcreateConsLogicor(SCIP *scip, SCIP_CONS **cons, const char *name, 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_RETCODE SCIPsetBinaryVarIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *binvar)

SCIP_RETCODE SCIPmakeIndicatorFeasible(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *changed)

SCIP_RETCODE SCIPcreateConsVarbound(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, 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_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_Bool SCIPisViolatedIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)

SCIP_RETCODE SCIPaddVarIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)

SCIP_Bool SCIPgetActiveOnIndicator(SCIP_CONS *cons)

SCIP_RETCODE SCIPincludeConshdlrIndicator(SCIP *scip)

SCIP_RETCODE SCIPgetConsCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_CONS *sourcecons, SCIP_CONS **targetcons, SCIP_CONSHDLR *sourceconshdlr, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name, 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_Bool global, SCIP_Bool *valid)

SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)

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

SCIP_RETCODE SCIPcreateExprProduct(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real coefficient, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_Bool SCIPisTransformed(SCIP *scip)

SCIP_STATUS SCIPgetStatus(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

int SCIPgetNIntVars(SCIP *scip)

SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)

SCIP_CONS ** SCIPgetConss(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNConss(SCIP *scip)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

int SCIPgetNOrigVars(SCIP *scip)

int SCIPgetNBinVars(SCIP *scip)

SCIP_Bool SCIPisObjIntegral(SCIP *scip)

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

SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

void SCIPhashmapPrintStatistics(SCIP_HASHMAP *hashmap, SCIP_MESSAGEHDLR *messagehdlr)

int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)

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)

SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)

SCIP_RETCODE SCIPhashmapSetImageInt(SCIP_HASHMAP *hashmap, void *origin, int image)

SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)

SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)

SCIP_Bool SCIPlpiIsInfinity(SCIP_LPI *lpi, SCIP_Real val)

SCIP_Bool SCIPlpiExistsPrimalRay(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiAddRows(SCIP_LPI *lpi, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)

SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI *lpi, const char *fname)

SCIP_RETCODE SCIPlpiGetBounds(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lbs, SCIP_Real *ubs)

int SCIPlpiGetInternalStatus(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)

SCIP_Bool SCIPlpiIsPrimalUnbounded(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)

SCIP_RETCODE SCIPlpiGetCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real *val)

SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI *lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real *quality)

SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)

SCIP_RETCODE SCIPlpiGetRows(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhs, SCIP_Real *rhs, int *nnonz, int *beg, int *ind, SCIP_Real *val)

SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)

SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiAddCols(SCIP_LPI *lpi, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)

SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)

SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)

SCIP_Bool SCIPlpiIsStable(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)

SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)

SCIP_RETCODE SCIPlpiChgCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real newval)

SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPaddConflict(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)

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

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

SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)

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

SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)

SCIP_RETCODE SCIPheurPassSolTrySol(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL *sol)

SCIP_RETCODE SCIPheurPassIndicator(SCIP *scip, SCIP_HEUR *heur, int nindconss, SCIP_CONS **indconss, SCIP_Bool *solcand, SCIP_Real obj)

SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)

SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)

SCIP_RETCODE SCIPchgBoolParam(SCIP *scip, SCIP_PARAM *param, 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)

SCIP_RETCODE SCIPgetCharParam(SCIP *scip, const char *name, char *value)

SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)

SCIP_Real SCIPcalcChildEstimate(SCIP *scip, SCIP_VAR *var, SCIP_Real targetvalue)

SCIP_RETCODE SCIPcreateChild(SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)

SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)

SCIP_BOUNDTYPE SCIPboundtypeOpposite(SCIP_BOUNDTYPE boundtype)

SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)

SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)

SCIP_CONFLICTHDLRDATA * SCIPconflicthdlrGetData(SCIP_CONFLICTHDLR *conflicthdlr)

SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)

const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)

SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)

SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)

SCIP_RETCODE SCIPincludeConflicthdlrBasic(SCIP *scip, SCIP_CONFLICTHDLR **conflicthdlrptr, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)

SCIP_RETCODE SCIPsetConflicthdlrFree(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTFREE((*conflictfree)))

SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))

SCIP_RETCODE SCIPsetConshdlrEnable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))

SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)

SCIP_RETCODE SCIPsetConshdlrInit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))

SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))

SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))

SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)

SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)

SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)

SCIP_RETCODE SCIPsetConshdlrDisable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))

SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)))

SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))

SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))

SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))

int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrExit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))

SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))

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

SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)))

SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))

SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))

SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))

SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))

SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))

int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))

int SCIPconshdlrGetSepaFreq(SCIP_CONSHDLR *conshdlr)

SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))

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

SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)

SCIP_RETCODE SCIPenfopsCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)

void SCIPconsAddUpgradeLocks(SCIP_CONS *cons, int nlocks)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

SCIP_RETCODE SCIPenfolpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_RESULT *result)

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

int SCIPconsGetNUpgradeLocks(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)

SCIP_RETCODE SCIPsepalpCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)

SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, 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_Bool SCIPconsIsPropagated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)

SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)

SCIP_RETCODE SCIPgetTransformedCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)

SCIP_RETCODE SCIPenforelaxCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)

SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)

SCIP_RETCODE SCIPsepasolCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result)

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

SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)

SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)

SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)

SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)

const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)

SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)

SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)

SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)

SCIP_Real SCIPeventGetOldbound(SCIP_EVENT *event)

SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)

SCIP_Real SCIPeventGetNewbound(SCIP_EVENT *event)

SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)

SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)

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

SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

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

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPallocBlockMemory(scip, ptr)

SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)

SCIP_Bool SCIPisNLPConstructed(SCIP *scip)

SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)

SCIP_RETCODE SCIPcreateNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)

SCIP_RETCODE SCIPgetDivesetScore(SCIP *scip, SCIP_DIVESET *diveset, SCIP_DIVETYPE divetype, SCIP_VAR *divecand, SCIP_Real divecandsol, SCIP_Real divecandfrac, SCIP_Real *candscore, SCIP_Bool *roundup)

SCIP_Bool SCIPinProbing(SCIP *scip)

SCIP_RETCODE SCIPaddDiveBoundChange(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)

int SCIProwGetNNonz(SCIP_ROW *row)

SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)

SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)

SCIP_RETCODE SCIPcreateEmptyRowConshdlr(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)

const char * SCIProwGetName(SCIP_ROW *row)

SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)

SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)

SCIP_Real SCIProwGetConstant(SCIP_ROW *row)

SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)

SCIP_Real * SCIProwGetVals(SCIP_ROW *row)

SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)

SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)

void SCIPupdateSolConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)

SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)

SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)

SCIP_RETCODE SCIPrestartSolve(SCIP *scip)

SCIP_Real SCIPgetPrimalbound(SCIP *scip)

SCIP_Real SCIPgetUpperbound(SCIP *scip)

SCIP_Real SCIPgetDualbound(SCIP *scip)

int SCIPgetNRuns(SCIP *scip)

SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)

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

SCIP_Real SCIPinfinity(SCIP *scip)

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

SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisLE(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 SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

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 SCIPisNegative(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_Real SCIPcutoffbounddelta(SCIP *scip)

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPinRepropagation(SCIP *scip)

int SCIPgetDepth(SCIP *scip)

SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)

SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)

SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)

SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Bool SCIPdoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

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

SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_Real SCIPvarGetAggrScalar(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)

SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)

SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)

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

SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)

SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)

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

SCIP_Real SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)

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

SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)

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_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)

SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)

SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)

SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)

SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)

int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_Bool SCIPallowWeakDualReds(SCIP *scip)

SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)

SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)

SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)

SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)

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

SCIP_RETCODE SCIPaddSymgraphEdge(SCIP *scip, SYM_GRAPH *graph, int first, int second, SCIP_Bool hasval, SCIP_Real val)

SCIP_RETCODE SCIPaddSymgraphOpnode(SCIP *scip, SYM_GRAPH *graph, int op, int *nodeidx)

SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)

int SCIPgetSymgraphVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)

SCIP_RETCODE SCIPaddSymgraphConsnode(SCIP *scip, SYM_GRAPH *graph, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, int *nodeidx)

SCIP_RETCODE SCIPaddSymgraphVarAggregation(SCIP *scip, SYM_GRAPH *graph, int rootidx, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real constant)

int SCIPgetSymgraphNegatedVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)

handle partial solutions for linear problems with indicators and otherwise continuous variables

primal heuristic that tries a given solution

interface methods for specific LP solvers

static const char * paramname[]

memory allocation routines

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

const char * SCIPparamGetName(SCIP_PARAM *param)

SCIP_PARAMTYPE SCIPparamGetType(SCIP_PARAM *param)

public methods for conflict analysis handlers

public methods for managing constraints

public methods for managing events

public methods for LP management

public methods for message output

#define SCIPdebugPrintCons(x, y, z)

public data structures and miscellaneous methods

public methods for handling parameter settings

public methods for problem variables

public methods for branching rule plugins and branching

public methods for conflict handler plugins and conflict analysis

public methods for constraint handler plugins and constraints

public methods for problem copies

public methods for cuts and aggregation rows

public methods for event handler plugins and event handlers

public methods for primal heuristic plugins and divesets

public methods for the LP relaxation, rows and columns

public methods for memory management

public methods for message handling

public methods for nonlinear relaxation

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for global and local (sub)problems

public methods for the probing mode

public methods for solutions

public methods for querying solving statistics

public methods for the branch-and-bound tree

public methods for SCIP variables

structs for symmetry computations

methods for dealing with symmetry detection graphs

@ SCIP_CONFTYPE_PROPAGATION

struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA

struct SCIP_ConshdlrData SCIP_CONSHDLRDATA

struct SCIP_ConsData SCIP_CONSDATA

#define SCIP_EVENTTYPE_BOUNDCHANGED

#define SCIP_EVENTTYPE_GUBCHANGED

#define SCIP_EVENTTYPE_GBDCHANGED

struct SCIP_EventData SCIP_EVENTDATA

#define SCIP_EVENTTYPE_UBTIGHTENED

#define SCIP_EVENTTYPE_LBRELAXED

#define SCIP_EVENTTYPE_BESTSOLFOUND

#define SCIP_EVENTTYPE_GLBCHANGED

#define SCIP_EVENTTYPE_LBTIGHTENED

#define SCIP_EVENTTYPE_UBRELAXED

#define SCIP_DIVETYPE_INTEGRALITY

@ SCIP_BRANCHDIR_DOWNWARDS

enum SCIP_BoundType SCIP_BOUNDTYPE

type definitions for specific LP solvers interface

@ SCIP_LPSOLQUALITY_ESTIMCONDITION

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STAGE_INITPRESOLVE

@ SCIP_STAGE_TRANSFORMING

enum SYM_Symtype SYM_SYMTYPE

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_VARSTATUS_MULTAGGR

@ SCIP_VARSTATUS_AGGREGATED

enum SCIP_Vartype SCIP_VARTYPE

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