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

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

SCIP Doxygen Documentation: cons_logicor.c Source File

SCIP_ConshdlrData

nlastcliquesshorten;

nlastimplsshorten;

signature;

presolved:1;

impladded:1;

sorted:1;

changed:1;

merged:1;

existmultaggr:1;

validsignature:1;

assert(conshdlrdata !=

);

assert(eventhdlr !=

);

(*conshdlrdata)->nlastcliquesneg = 0;

(*conshdlrdata)->nlastimplsneg = 0;

(*conshdlrdata)->nlastcliquesshorten = 0;

(*conshdlrdata)->nlastimplsshorten = 0;

(*conshdlrdata)->eventhdlr = eventhdlr;

assert(conshdlrdata !=

);

assert(*conshdlrdata !=

);

assert(consdata !=

);

assert(consdata->nvars <= consdata->varssize);

( num > consdata->varssize )

consdata->varssize = newsize;

assert(num <= consdata->varssize);

assert(consdata !=

);

assert(nvars == 0 || vars !=

);

(*consdata)->row =

;

(*consdata)->nlrow =

;

(*consdata)->varssize = nvars;

(*consdata)->nvars = nvars;

(*consdata)->vars =

;

(*consdata)->varssize = 0;

(*consdata)->nvars = 0;

(*consdata)->watchedvar1 = -1;

(*consdata)->watchedvar2 = -1;

(*consdata)->filterpos1 = -1;

(*consdata)->filterpos2 = -1;

(*consdata)->presolved =

;

(*consdata)->impladded =

;

(*consdata)->changed =

;

(*consdata)->sorted = (nvars <= 1);

(*consdata)->merged = (nvars <= 1);

(*consdata)->existmultaggr =

;

(*consdata)->validsignature =

;

( v = 0; v < (*consdata)->nvars; v++ )

assert(var !=

);

( v = 0; v < (*consdata)->nvars; v++ )

assert((*consdata)->vars[v] !=

);

assert(consdata !=

);

assert(*consdata !=

);

( (*consdata)->row !=

)

( (*consdata)->nlrow !=

)

( v = 0; v < (*consdata)->nvars; v++ )

assert((*consdata)->vars[v] !=

);

assert(consdata !=

);

assert(consdata !=

);

assert(watchedvar1 == -1 || watchedvar1 != watchedvar2);

assert(watchedvar1 != -1 || watchedvar2 == -1);

assert(watchedvar1 == -1 || (0 <= watchedvar1 && watchedvar1 < consdata->nvars));

assert(watchedvar2 == -1 || (0 <= watchedvar2 && watchedvar2 < consdata->nvars));

( watchedvar1 == consdata->watchedvar2 || watchedvar2 == consdata->watchedvar1 )

tmp = consdata->watchedvar1;

consdata->watchedvar1 = consdata->watchedvar2;

consdata->watchedvar2 = tmp;

tmp = consdata->filterpos1;

consdata->filterpos1 = consdata->filterpos2;

consdata->filterpos2 = tmp;

assert(watchedvar1 == -1 || watchedvar1 != consdata->watchedvar2);

assert(watchedvar2 == -1 || watchedvar2 != consdata->watchedvar1);

( consdata->watchedvar1 != -1 && consdata->watchedvar1 != watchedvar1 )

assert(consdata->filterpos1 != -1);

consdata->filterpos1) );

( consdata->watchedvar2 != -1 && consdata->watchedvar2 != watchedvar2 )

assert(consdata->filterpos2 != -1);

consdata->filterpos2) );

( watchedvar1 != -1 && watchedvar1 != consdata->watchedvar1 )

&consdata->filterpos1) );

( watchedvar2 != -1 && watchedvar2 != consdata->watchedvar2 )

&consdata->filterpos2) );

consdata->watchedvar1 = watchedvar1;

consdata->watchedvar2 = watchedvar2;

assert(var !=

);

assert(consdata !=

);

consdata->existmultaggr =

;

consdata->presolved =

;

assert(var !=

);

consdata->vars[consdata->nvars] = var;

assert(conshdlr !=

);

assert(conshdlrdata !=

);

consdata->sorted = (consdata->nvars == 1);

consdata->changed =

;

consdata->validsignature =

;

( consdata->row !=

)

consdata->merged =

;

assert(eventhdlr !=

);

assert(consdata !=

);

assert(0 <= pos && pos < consdata->nvars);

( consdata->watchedvar1 == pos )

( consdata->watchedvar2 == pos )

assert(pos != consdata->watchedvar1);

assert(pos != consdata->watchedvar2);

( pos != consdata->nvars - 1 )

consdata->vars[pos] = consdata->vars[consdata->nvars-1];

consdata->sorted =

;

( consdata->watchedvar1 == consdata->nvars )

consdata->watchedvar1 = pos;

( consdata->watchedvar2 == consdata->nvars )

consdata->watchedvar2 = pos;

consdata->changed =

;

consdata->validsignature =

;

assert(cons !=

);

assert(eventhdlr !=

);

assert(nfixedvars !=

);

assert(ndelconss !=

);

assert(nchgcoefs !=

);

assert(result !=

);

assert(consdata !=

);

nvars = consdata->nvars;

vars = consdata->vars;

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

assert(var !=

);

( idx == consdata->nvars - 1 )

bestvar = consdata->vars[idx];

( idxnouplocks == consdata->nvars - 1 )

( indepidx == consdata->nvars - 1 )

assert(bestvar ==

|| bestvar == consdata->vars[v]);

bestobjvalnouplocks = objval;

nvars = consdata->nvars;

( nvars == 2 && indepidx >= 0 )

assert(0 <= idx2 && idx2 < 2);

( nfixables == 1 && idxnouplocks >= 0 )

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

assert(var !=

);

assert(idxnouplocks != v);

nvars = consdata->nvars;

assert(idx >= 0 && idx < nvars);

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

assert(var !=

);

assert(eventhdlr !=

);

assert(redundant !=

);

assert(consdata !=

);

assert(consdata->nvars == 0 || consdata->vars !=

);

consdata->existmultaggr =

;

consdata->presolved =

;

( v < consdata->nvars )

var = consdata->vars[v];

( consdata->nvars == 0 )

nvars = consdata->nvars;

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

( requiredsize > nconsvars )

assert(requiredsize <= nconsvars);

( v2 = nconsvars - 1; v2 >= 0; --v2 )

( v2 = nconsvars - 1; v2 >= 0; --v2 )

size =

(nconsvars, 1) + nvars - 1;

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

consvars[k] = vars[k];

( requiredsize > nconsvars )

assert(requiredsize <= nconsvars);

lhs = 1.0 - constant;

( ndelconss !=

&& naddconss !=

)

assert( naddconss !=

);

( var != consdata->vars[v] )

( var != consdata->vars[v] )

consdata->presolved =

;

assert(consdata !=

);

( v = 0; v < consdata->nvars; ++v )

** entries,

assert(cons !=

);

assert(eventhdlr !=

);

assert(*entries !=

);

assert(nentries !=

);

assert(redundant !=

);

assert(nchgcoefs !=

);

assert(consdata !=

);

nvars = consdata->nvars;

*redundant =

;

( consdata->merged )

( consdata->nvars <= 1 )

consdata->merged =

;

assert(consdata->vars !=

&& nvars > 0);

assert(*nentries >= nbinvars + nintvars + nimplvars);

assert(consdata->presolved);

vars = consdata->vars;

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

(pos >= nbinvars + nintvars && pos < nbinvars + nintvars + nimplvars &&

(*entries)[pos] = 0;

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

( (*entries)[pos] == 0 )

(*entries)[pos] = negarray[v] ? 2 : 1;

( (*entries)[pos] == 1 )

(

,

,

(

,

,

consdata->merged =

;

assert(cons !=

);

assert(cutoff !=

);

assert(reduceddom !=

);

assert(addcut !=

);

assert(mustcheck !=

);

assert(consdata !=

);

assert(consdata->watchedvar1 == -1 || consdata->watchedvar1 != consdata->watchedvar2);

*mustcheck =

;

vars = consdata->vars;

nvars = consdata->nvars;

assert(nvars == 0 || vars !=

);

( consdata->watchedvar1 >= 0 &&

(vars[consdata->watchedvar1]) > 0.5 )

( consdata->watchedvar2 >= 0 &&

(vars[consdata->watchedvar2]) > 0.5 )

( consdata->watchedvar1 >= 0 &&

(vars[consdata->watchedvar1]) > 0.5 )

watchedvar1 = consdata->watchedvar1;

( consdata->watchedvar2 >= 0 &&

(vars[consdata->watchedvar2]) > 0.5 )

( watchedvar1 == -1 )

watchedvar1 = consdata->watchedvar2;

watchedvar2 = consdata->watchedvar2;

assert(watchedvar1 >= 0 || watchedvar2 == -1);

assert(nbranchings1 <= nbranchings2);

( watchedvar2 == -1 )

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

( v == consdata->watchedvar1 || v == consdata->watchedvar2 )

assert(v != consdata->watchedvar1);

assert(v != consdata->watchedvar2);

(

,

,

( consdata->watchedvar1 != -1 )

assert(nbranchings >= 0);

( nbranchings < nbranchings2 )

( nbranchings < nbranchings1 )

watchedvar2 = watchedvar1;

nbranchings2 = nbranchings1;

nbranchings1 = nbranchings;

nbranchings2 = nbranchings;

assert(nbranchings1 <= nbranchings2);

assert(watchedvar1 >= 0 || watchedvar2 == -1);

( watchedvar1 == -1 )

assert(watchedvar2 == -1);

( watchedvar2 == -1 )

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

(

,

,

( watchedvar1 != consdata->watchedvar1 )

*reduceddom =

;

(

,

,

assert(consdata !=

);

vars = consdata->vars;

nvars = consdata->nvars;

( v = 0; v < nvars && sum < 1.0; ++v )

assert(consdata !=

);

assert(consdata->row ==

);

assert(consdata !=

);

( consdata->nlrow ==

)

( i = 0; i < consdata->nvars; ++i )

assert(consdata->nlrow !=

);

assert( cutoff !=

);

assert(consdata !=

);

( consdata->row ==

)

assert(consdata->row !=

);

assert(cons !=

);

assert(cutoff !=

);

assert(separated !=

);

assert(reduceddom !=

);

assert(consdata !=

);

( sol ==

&& consdata->row !=

)

assert(cons !=

);

assert(cutoff !=

);

assert(infeasible !=

);

assert(reduceddom !=

);

assert(solvelp !=

);

*infeasible =

;

assert(consdata !=

);

( !consdata->sorted )

( consdata->nvars <= 1 )

consdata->sorted =

;

( consdata->watchedvar1 != -1 )

var1 = consdata->vars[consdata->watchedvar1];

assert(var1 !=

);

consdata->watchedvar1 = -1;

( consdata->watchedvar2 != -1 )

var2 = consdata->vars[consdata->watchedvar2];

assert(var2 !=

);

consdata->watchedvar2 = -1;

assert(consdata->watchedvar1 == -1);

assert(consdata->watchedvar2 == -1);

assert(var1 !=

|| var2 ==

);

((

**)consdata->vars, SCIPvarComp, consdata->nvars);

consdata->sorted =

;

found =

((

**)consdata->vars, SCIPvarComp, (

*)var1, consdata->nvars, &pos);

(void)

((

**)consdata->vars, SCIPvarComp, (

*)var1, consdata->nvars, &pos);

assert(pos >= 0 && pos < consdata->nvars);

consdata->watchedvar1 = pos;

found =

((

**)consdata->vars, SCIPvarComp, (

*)var2, consdata->nvars, &pos);

(void)

((

**)consdata->vars, SCIPvarComp, (

*)var2, consdata->nvars, &pos);

assert(pos >= 0 && pos < consdata->nvars);

consdata->watchedvar2 = pos;

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

assert(

(consdata->vars[v], consdata->vars[v - 1]) >= 0);

( consdata1->nvars != consdata2->nvars )

assert(consdata1->sorted);

assert(consdata2->sorted);

( i = 0; i < consdata1->nvars ; ++i )

( consdata1->vars[i] != consdata2->vars[i] )

assert(

(consdata1->vars[i], consdata2->vars[i]) == 1 ||

coefsequal =

;

assert(

(consdata1->vars[i], consdata2->vars[i]) == 0);

assert(consdata !=

);

assert(consdata->sorted);

assert(consdata->nvars > 0);

assert(minidx >= 0 && minidx <= maxidx);

(consdata->nvars, minidx, mididx, maxidx);

assert(conss !=

);

assert(ndelconss !=

);

hashtablesize = nconss;

hashGetKeyLogicorcons, hashKeyEqLogicorcons, hashKeyValLogicorcons, (

*)

) );

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

assert(consdata0->sorted);

( cons1 !=

)

assert(consdata1 !=

);

assert(consdata0->nvars >= 1 && consdata0->nvars == consdata1->nvars);

assert(consdata0->sorted && consdata1->sorted);

assert(consdata0->vars[0] == consdata1->vars[0]);

( consdata0->changed &&

(cons1) < *firstchange )

assert(ndelconss !=

);

(

,

,

signature = 0;

assert(vars !=

);

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

signature |= ((

int)1 << ((

)

(vars[v]) % (

(

int) * 8)));

( consdata->validsignature )

consdata->signature =

(consdata->vars, consdata->nvars);

consdata->validsignature =

;

* noccurlistentries,

assert(cons !=

);

assert(varstopos !=

);

assert(occurlist !=

);

assert(noccurlistentries !=

);

assert(consdata !=

);

nvars = consdata->nvars;

vars = consdata->vars;

assert(vars !=

);

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

assert(0 < pos && pos <= occurlistlength);

( l = noccurlistentries[pos] - 1; l >= 0; --l )

( occurlist[pos][l] == cons )

--noccurlistentries[pos];

assert(noccurlistentries[pos] >= 0);

occurlist[pos][l] = occurlist[pos][noccurlistentries[pos]];

* noccurlistentries,

occurlistlength,

assert(varstopos !=

);

assert(occurlist !=

);

assert(noccurlistentries !=

);

assert(nentries !=

);

assert(shortestlist !=

);

*nentries = INT_MAX;

*shortestlist =

;

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

assert(var !=

);

assert(0 < pos && pos <= occurlistlength);

( noccurlistentries[pos] < *nentries )

*nentries = noccurlistentries[pos];

*shortestlist = occurlist[pos];

* noccurlistentries,

occurlistlength,

assert(cons !=

);

assert(varstopos !=

);

assert(occurlist !=

);

assert(noccurlistentries !=

);

assert(ndelconss !=

);

assert(consdata !=

);

assert(consdata->nvars > 1);

assert(consdata->validsignature);

assert(consdata->sorted);

vars = consdata->vars;

assert(vars !=

);

(vars, consdata->nvars, varstopos, occurlist, noccurlistentries, occurlistlength, &nentries, &shortestlist);

( nentries == 0 )

assert(shortestlist !=

);

assert(0 < nentries);

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

cons1 = shortestlist[c];

assert(cons1 !=

);

( cons != cons1 )

assert(consdata1 !=

);

assert(consdata1->nvars >= consdata->nvars);

( consdata1->nvars == consdata->nvars )

assert(consdata->validsignature);

assert(consdata->sorted);

assert(consdata1->validsignature);

assert(consdata1->sorted);

( (consdata->signature & (~consdata1->signature)) == 0 )

( v < consdata->nvars && v1 < consdata1->nvars )

var1 = consdata1->vars[v1];

( comp > 0 )

( v == consdata->nvars )

assert(elem1 !=

);

assert(elem2 !=

);

assert(consdata1 !=

);

assert(consdata2 !=

);

consdata1->nvars - consdata2->nvars;

* noccurlistentries,

* occurlistsizes,

* occurlistlength,

assert(cons !=

);

assert(varstopos !=

);

assert(occurlist !=

);

assert(noccurlistentries !=

);

assert(occurlistsizes !=

);

assert(occurlistlength !=

);

assert(*occurlistlength <= occurlistsize);

assert(consdata !=

);

assert(consdata->nvars > 1);

vars = consdata->vars;

assert(vars !=

);

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

assert(var !=

);

pos = *occurlistlength;

assert(pos <= occurlistsize);

assert(occurlist[pos] ==

);

assert(noccurlistentries[pos] == 0);

assert(occurlistsizes[pos] == 0);

occurlist[pos][noccurlistentries[pos]] = cons;

++(noccurlistentries[pos]);

++(*occurlistlength);

assert(0 < pos && pos <= *occurlistlength);

assert(occurlist[pos] !=

);

assert(occurlistsizes[pos] > 0);

( noccurlistentries[pos] == occurlistsizes[pos] )

assert(occurlistsizes[pos] > noccurlistentries[pos] && occurlistsizes[pos] < INT_MAX);

assert(noccurlistentries[pos] < occurlistsizes[pos]);

occurlist[pos][noccurlistentries[pos]] = cons;

++(noccurlistentries[pos]);

* noccurlistentries,

occurlistlength,

signature;

assert(cons !=

);

assert(artvar !=

);

assert(varstopos !=

);

assert(occurlist !=

);

assert(noccurlistentries !=

);

assert(nchgcoefs !=

);

assert(deleted !=

);

assert(consdata !=

);

assert(consdata->sorted);

nvars = consdata->nvars;

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

vars = consdata->vars;

assert(vars !=

);

oldvar = vars[artpos];

vars[artpos] = artvar;

(vars, nvars, varstopos, occurlist, noccurlistentries, occurlistlength, &nentries, &shortestlist);

vars[artpos] = oldvar;

( nentries == 0 )

assert(shortestlist !=

);

assert(0 < nentries);

oldvar = vars[artpos];

vars[artpos] = artvar;

vars[artpos] = oldvar;

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

cons1 = shortestlist[c];

assert(cons1 !=

);

( cons != cons1 )

assert(consdata1 !=

);

( consdata1->nvars < nvars )

assert(consdata->sorted);

assert(consdata->merged);

assert(consdata1->validsignature);

assert(consdata1->sorted);

assert(consdata1->merged);

( (signature & (~consdata1->signature)) == 0 )

( v < nvars && v1 < consdata1->nvars )

var1 = consdata1->vars[v1];

( artvar == var1 )

( comp > 0 )

( v1 < consdata1->nvars )

( artvar == consdata1->vars[v1] )

assert(pos < consdata1->nvars);

assert(artvar == consdata1->vars[pos]);

(

,

,

( consdata1->nvars > nvars )

assert(0 < pos && pos <= occurlistlength);

( l = noccurlistentries[pos] - 1; l >= 0; --l )

( occurlist[pos][l] == cons1 )

--noccurlistentries[pos];

assert(noccurlistentries[pos] >= 0);

occurlist[pos][l] = occurlist[pos][noccurlistentries[pos]];

assert(consdata1->nvars == nvars);

(

,

,

* noccurlistentries,

occurlistlength,

assert(conss !=

|| nconss == 0);

assert(varstopos !=

);

assert(occurlist !=

);

assert(noccurlistentries !=

);

assert(eventhdlr !=

);

assert(ndelconss !=

);

assert(nchgcoefs !=

);

assert(conss !=

);

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

assert(cons !=

);

assert(consdata !=

);

nvars = consdata->nvars;

vars = consdata->vars;

assert(vars !=

);

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

occurlistlength, eventhdlr, nchgcoefs, &deleted) );

** entries,

assert(cons !=

);

assert(eventhdlr !=

);

assert(*entries !=

);

assert(nentries !=

);

assert(redundant !=

);

assert(nfixedvars !=

);

assert(nchgcoefs !=

);

assert(ndelconss !=

);

assert(redundant !=

);

assert(consdata !=

);

assert(consdata->nvars > 0);

*redundant =

;

( !consdata->presolved )

( consdata->nvars == 0 )

( consdata->nvars == 1 )

(

,

);

assert(!infeasible);

consdata->presolved =

;

** entries,

* noccurlistentries;

* occurlistsizes;

occurlistlength;

assert(conss !=

|| nconss == 0);

assert(entries !=

);

assert(*entries !=

);

assert(nentries !=

);

assert(eventhdlr !=

);

assert(firstchange !=

);

assert(0 <= *firstchange);

assert(nfixedvars !=

);

assert(ndelconss !=

);

assert(nchgcoefs !=

);

( *firstchange > nconss || nconss < 2 )

(

,

);

lastnfixedvars = -1;

( *nfixedvars != lastnfixedvars )

lastnfixedvars = *nfixedvars;

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

assert(cons !=

);

myconss[c] = myconss[nmyconss - 1];

(

(

, cons, eventhdlr, entries, nentries, &redundant, nfixedvars, nchgcoefs, ndelconss, cutoff) );

myconss[c] = myconss[nmyconss - 1];

assert(consdata->nvars >= 2);

((

**)myconss, conssLogicorComp, nmyconss);

assert(myconss[0] !=

&& myconss[nmyconss - 1] !=

);

occurlistsize = 2 * nbinvars;

assert(cons !=

);

assert(consdata !=

);

nmaxvars = consdata->nvars;

occurlistlength = 0;

conschanged =

;

assert(consdata->validsignature);

conschanged = conschanged || consdata->changed;

consdata->changed =

;

assert(cons !=

);

assert(consdata !=

);

( consdata->nvars == nmaxvars );

assert(cons !=

);

assert(consdata !=

);

assert(consdata->validsignature);

( conschanged || consdata->changed )

consdata->changed =

;

conschanged =

;

(

(

, myconss, nmyconss, varstopos, occurlist, noccurlistentries, occurlistlength, eventhdlr, ndelconss, nchgcoefs) );

( --occurlistsize ; occurlistsize >= 0; --occurlistsize )

assert((occurlistsizes[occurlistsize] == 0) == (occurlist[occurlistsize] ==

));

** entries,

assert(eventhdlr !=

);

assert(conss !=

|| nconss == 0);

assert(entries !=

);

assert(*entries !=

);

assert(nentries !=

);

assert(nfixedvars !=

);

assert(ndelconss !=

);

assert(nchgcoefs !=

);

assert(conss !=

);

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

assert(cons !=

);

assert(consdata !=

);

consdata->presolved =

;

(

(

, cons, eventhdlr, entries, nentries, &redundant, nfixedvars, nchgcoefs, ndelconss, cutoff) );

assert(consdata->nvars >= 2);

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

var = consdata->vars[v];

assert(var !=

);

boundtypes[v] =

;

boundtypes[v] =

;

nfixedvars, &redundant, cutoff,

) );

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

( redundants[v] )

redundants[v] =

;

*nchgcoefs += nredvars;

( consdata->nvars == 1 )

(

,

);

assert(!infeasible);

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

assert(cons !=

);

assert(consdata !=

);

consdata->presolved =

;

** entries,

assert(conshdlr !=

);

assert(eventhdlr !=

);

assert(conss !=

|| nconss == 0);

assert(entries !=

);

assert(*entries !=

);

assert(nentries !=

);

assert(nfixedvars !=

);

assert(ndelconss !=

);

assert(nupgdconss !=

);

assert(nchgcoefs !=

);

assert(cutoff !=

);

assert(conshdlrdata !=

);

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

assert(conss !=

);

assert(cons !=

);

(

(

, cons, eventhdlr, entries, nentries, &redundant, nfixedvars, nchgcoefs, ndelconss, cutoff) );

assert(consdata !=

);

assert(consdata->nvars >= 2);

assert(consdata->nvars <= size);

assert(consdata->presolved);

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

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

comppercons += (v - 1);

(

= v - 1;

>= 0; --

)

var2 = repvars[

];

(

,

,

* lastvar = consdata->vars[consdata->nvars - 1];

(

,

,

( v < consdata->nvars )

assert(consdata->vars[v] == lastvar);

negated[v] = negated[consdata->nvars];

(

,

,

( comppercons > maxcomppercons )

assert(cons !=

);

assert(eventhdlr !=

);

assert(nfixedvars !=

);

assert(nchgbds !=

);

assert(nchgcoefs !=

);

assert(ndelconss !=

);

assert(naddconss !=

);

assert(nupgdconss !=

);

assert(cutoff !=

);

assert(consdata !=

);

( consdata->nvars == 2 )

( !consdata->impladded )

*nchgbds += nimplbdchgs;

( implinfeasible )

( nimplbdchgs > 0 )

consdata->impladded =

;

( consdata->nvars == 2 && conshdlrsetppc !=

)

( consdata->nvars == 0 )

( consdata->nvars == 1 )

(

,

,

assert(consdata->vars !=

);

assert(consdata->vars[0] !=

);

( conshdlrlinear !=

)

(

,

,

assert(nvars == 0 || vars !=

);

assert(nvars == 0 || vals !=

);

assert(mult == +1 || mult == -1);

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

( mult * vals[v] > 0.0 )

transvars[v] = vars[v];

assert(transvars[v] !=

);

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

assert(upgdcons !=

);

( nvars > 2 && nposbin + nnegbin + nposimplbin + nnegimplbin == nvars && ncoeffspone + ncoeffsnone == nvars

assert(conshdlr !=

);

assert(nconss == 0 || conss !=

);

assert(result !=

);

(

,

, nconss, sol ==

?

:

);

assert(conshdlrdata !=

);

reduceddom =

;

( c = 0; c < nusefulconss && !cutoff && !reduceddom; ++c )

( c = nusefulconss; c < nconss && !cutoff && !separated && !reduceddom; ++c )

( separated )

( reduceddom )

assert(cons !=

);

assert(graph !=

);

assert(success !=

);

assert(consdata !=

);

( i = 0; i < consdata->nvars; ++i )

vars[i] = logicorvars[i];

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlrdata !=

);

assert(conshdlr !=

);

assert(conshdlrdata !=

);

conshdlrdata->nlastcliquesneg = 0;

conshdlrdata->nlastimplsneg = 0;

conshdlrdata->nlastcliquesshorten = 0;

conshdlrdata->nlastimplsshorten = 0;

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

assert(consdata !=

);

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

assert(conshdlr !=

);

assert(conshdlrdata !=

);

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

assert(consdata !=

);

( v = 0; v < consdata->nvars; ++v )

consdata->presolved =

;

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

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

assert(consdata !=

);

( consdata->row !=

)

( consdata->nlrow !=

)

assert(conshdlr !=

);

assert(consdata !=

);

assert(*consdata !=

);

assert(conshdlrdata !=

);

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

assert(conshdlr !=

);

assert(sourcecons !=

);

assert(targetcons !=

);

assert(sourcedata !=

);

assert(sourcedata->row ==

);

*infeasible =

;

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

assert(conshdlr !=

);

assert(nconss == 0 || conss !=

);

assert(result !=

);

(

,

, nusefulconss, nconss);

assert(conshdlrdata !=

);

reduceddom =

;

( c = 0; c < nusefulconss && !cutoff; ++c )

( reduceddom )

( separated )

assert(conshdlr !=

);

assert(nconss == 0 || conss !=

);

assert(result !=

);

(

,

, nusefulconss, nconss);

assert(conshdlrdata !=

);

reduceddom =

;

( c = 0; c < nusefulconss && !cutoff; ++c )

( reduceddom )

( separated )

assert(conshdlr !=

);

assert(nconss == 0 || conss !=

);

assert(result !=

);

(

,

, nconss);

assert(conshdlrdata !=

);

infeasible =

;

reduceddom =

;

( c = 0; c < nconss && !cutoff && !reduceddom && !solvelp; ++c )

( reduceddom )

( infeasible )

assert(conshdlr !=

);

assert(nconss == 0 || conss !=

);

assert(result !=

);

( c = 0; c < nconss && (*result ==

|| completely); ++c )

assert(consdata !=

);

( v = 0; v < consdata->nvars; ++v )

assert( consdata->vars[v] !=

);

assert(conshdlr !=

);

assert(nconss == 0 || conss !=

);

assert(result !=

);

assert(conshdlrdata !=

);

reduceddom =

;

( c = 0; c < nusefulconss && !cutoff; ++c )

( reduceddom )

* entries;

assert(conshdlr !=

);

assert(result !=

);

assert(conshdlrdata !=

);

oldnfixedvars = *nfixedvars;

oldnchgbds = *nchgbds;

oldndelconss = *ndelconss;

oldnupgdconss = *nupgdconss;

oldnchgcoefs = *nchgcoefs;

firstchange = INT_MAX;

assert(cons !=

);

assert(consdata !=

);

( !consdata->presolved )

( consdata->nvars <= 2 )

conshdlrdata->conshdlrsetppc, nfixedvars, nchgbds, nchgcoefs, ndelconss, naddconss, nupgdconss, &cutoff) );

( *nfixedvars > oldnfixedvars || *nchgbds > oldnchgbds || *nchgcoefs > oldnchgcoefs

|| *ndelconss > oldndelconss || *nupgdconss > oldnupgdconss )

( consdata->nvars <= 2 )

conshdlrdata->conshdlrsetppc, nfixedvars, nchgbds, nchgcoefs, ndelconss, naddconss, nupgdconss, &cutoff) );

( *nfixedvars > oldnfixedvars || *nchgbds > oldnchgbds || *nchgcoefs > oldnchgcoefs

|| *ndelconss > oldndelconss || *nupgdconss > oldnupgdconss )

( firstchange == INT_MAX && consdata->changed )

( firstchange < nconss && conshdlrdata->presolusehashing )

conshdlrdata->usestrengthening, &firstchange, nfixedvars, ndelconss, nchgcoefs, &cutoff) );

&entries, &nentries, nfixedvars, ndelconss, nchgcoefs, &cutoff) );

conshdlrdata->eventhdlr, conss, nconss, &entries, &nentries, nfixedvars, ndelconss,

nupgdconss, nchgcoefs, &cutoff) );

assert(conshdlr !=

);

assert(cons !=

);

assert(infervar !=

);

assert(result !=

);

assert(consdata !=

);

(

,

);

infervarfound =

;

( v = 0; v < consdata->nvars; ++v )

( consdata->vars[v] != infervar )

assert(!infervarfound);

infervarfound =

;

assert(infervarfound);

assert(consdata !=

);

( i = 0; i < consdata->nvars; ++i )

assert(conshdlr !=

);

assert(cons !=

);

assert(conshdlrdata !=

);

assert(consdata !=

);

assert(consdata->watchedvar1 == -1 || consdata->watchedvar1 != consdata->watchedvar2);

( consdata->watchedvar1 != -1 )

&consdata->filterpos1) );

( consdata->watchedvar2 != -1 )

&consdata->filterpos2) );

assert(conshdlr !=

);

assert(cons !=

);

assert(conshdlrdata !=

);

assert(consdata !=

);

assert(consdata->watchedvar1 == -1 || consdata->watchedvar1 != consdata->watchedvar2);

( consdata->watchedvar1 != -1 )

assert(consdata->filterpos1 != -1);

consdata->filterpos1) );

consdata->watchedvar1 = -1;

consdata->filterpos1 = -1;

( consdata->watchedvar2 != -1 )

assert(consdata->filterpos2 != -1);

consdata->filterpos2) );

consdata->watchedvar2 = -1;

consdata->filterpos2 = -1;

assert( conshdlr !=

);

assert( cons !=

);

* consname;

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

assert(cons !=

);

startptr = strchr((

*)str,

);

( startptr ==

)

endptr = strrchr(startptr,

);

( endptr ==

)

assert(endptr >= startptr);

( endptr > startptr )

strcopy[endptr-startptr] =

;

( varssize < requiredsize )

varssize = requiredsize;

assert(varssize >= requiredsize);

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

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

assert(consdata !=

);

( varssize < consdata->nvars )

(*success) =

;

assert(vars !=

);

assert(consdata !=

);

(*nvars) = consdata->nvars;

assert(eventhdlr !=

);

assert(eventdata !=

);

assert(event !=

);

(

,

);

assert(cons !=

);

assert(consdata !=

);

assert(var !=

);

consdata->presolved =

;

consdata->merged =

;

( !consdata->existmultaggr )

consdata->existmultaggr =

;

assert(conflicthdlr !=

);

assert(bdchginfos !=

|| nbdchginfos == 0);

assert(result !=

);

( nbdchginfos == 2 )

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

assert(bdchginfos !=

);

assert(bdchginfos[i] !=

);

( i == nbdchginfos )

eventExecLogicor,

) );

conflictExecLogicor,

) );

consEnfolpLogicor, consEnfopsLogicor, consCheckLogicor, consLockLogicor,

assert(conshdlr !=

);

( conshdlrdata->conshdlrlinear !=

)

,

,

,

,

,

,

,

,

,

,

,

,

( conshdlr ==

)

assert(vars !=

|| nvars == 0);

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

(

(

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

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

assert(conshdlrdata !=

);

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

assert(var !=

);

assert(consdata !=

);

consdata->nvars;

assert(consdata !=

);

consdata->vars;

assert(consdata !=

);

( consdata->row !=

)

assert(consdata !=

);

( consdata->row !=

)

assert(consdata !=

);

consdata->row;

* entries;

( conshdlr ==

)

assert(naddconss !=

);

assert(ndelconss !=

);

assert(nchgcoefs !=

);

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

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

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopyLogicor)

static SCIP_Bool isConsViolated(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)

static SCIP_RETCODE addCoef(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)

static SCIP_DECL_HASHKEYVAL(hashKeyValLogicorcons)

#define DEFAULT_DUALPRESOLVING

static SCIP_DECL_CONSENFOLP(consEnfolpLogicor)

#define DEFAULT_IMPLICATIONS

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_SEPAFREQ

#define CONFLICTHDLR_PRIORITY

static void consdataCalcSignature(SCIP_CONSDATA *consdata)

#define CONFLICTHDLR_NAME

static SCIP_DECL_CONSEXITSOL(consExitsolLogicor)

static SCIP_RETCODE addCut(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff)

static SCIP_RETCODE delCoefPos(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)

#define CONSHDLR_CHECKPRIORITY

static SCIP_RETCODE createRow(SCIP *scip, SCIP_CONS *cons)

static SCIP_RETCODE processWatchedVars(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, SCIP_Bool *reduceddom, SCIP_Bool *addcut, SCIP_Bool *mustcheck)

static SCIP_RETCODE analyzeConflict(SCIP *scip, SCIP_CONS *cons)

static SCIP_DECL_CONSRESPROP(consRespropLogicor)

static SCIP_DECL_CONSLOCK(consLockLogicor)

#define CONSHDLR_PROP_TIMING

static SCIP_RETCODE addConsToOccurList(SCIP *scip, SCIP_CONS *cons, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int *occurlistsizes, int *occurlistlength, int occurlistsize)

#define CONFLICTHDLR_DESC

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

static SCIP_RETCODE removeConstraintsDueToNegCliques(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLR *conshdlrsetppc, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS **conss, int nconss, unsigned char **entries, int *nentries, int *nfixedvars, int *ndelconss, int *nupgdconss, int *nchgcoefs, SCIP_Bool *cutoff)

static SCIP_RETCODE unlockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)

#define DEFAULT_STRENGTHEN

static SCIP_DECL_CONSPRESOL(consPresolLogicor)

static SCIP_DECL_CONSENFOPS(consEnfopsLogicor)

static SCIP_DECL_CONSCHECK(consCheckLogicor)

static SCIP_RETCODE removeRedundantConss(SCIP *scip, SCIP_CONS *cons, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int occurlistlength, int *ndelconss)

#define CONSHDLR_MAXPREROUNDS

static void findShortestOccurlist(SCIP_VAR **vars, int nvars, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int occurlistlength, int *nentries, SCIP_CONS ***shortestlist)

static SCIP_RETCODE removeRedundantConssAndNonzeros(SCIP *scip, SCIP_CONS **conss, int nconss, unsigned char **entries, int *nentries, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool usestrengthening, int *firstchange, int *nfixedvars, int *ndelconss, int *nchgcoefs, SCIP_Bool *cutoff)

static SCIP_RETCODE prepareCons(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, unsigned char **entries, int *nentries, SCIP_Bool *redundant, int *nfixedvars, int *nchgcoefs, int *ndelconss, SCIP_Bool *cutoff)

#define DEFAULT_PRESOLPAIRWISE

#define CONSHDLR_SEPAPRIORITY

static SCIP_DECL_CONSPARSE(consParseLogicor)

static SCIP_RETCODE enforcePseudo(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, SCIP_Bool *infeasible, SCIP_Bool *reduceddom, SCIP_Bool *solvelp)

#define DEFAULT_NEGATEDCLIQUE

static SCIP_DECL_CONSSEPALP(consSepalpLogicor)

static SCIP_RETCODE createNormalizedLogicor(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, int mult, 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)

static SCIP_DECL_CONSGETVARS(consGetVarsLogicor)

static SCIP_RETCODE dualPresolving(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int *nfixedvars, int *ndelconss, int *nchgcoefs, int *naggrvars, SCIP_RESULT *result)

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

static SCIP_RETCODE lockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)

static SCIP_RETCODE shortenConss(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS **conss, int nconss, unsigned char **entries, int *nentries, int *nfixedvars, int *ndelconss, int *nchgcoefs, SCIP_Bool *cutoff)

static SCIP_DECL_CONSEXITPRE(consExitpreLogicor)

static SCIP_RETCODE consdataEnsureVarsSize(SCIP *scip, SCIP_CONSDATA *consdata, int num)

static SCIP_DECL_CONSDEACTIVE(consDeactiveLogicor)

static SCIP_DECL_CONSCOPY(consCopyLogicor)

static SCIP_DECL_CONSDELETE(consDeleteLogicor)

#define DEFAULT_PRESOLUSEHASHING

static SCIP_DECL_CONSINITLP(consInitlpLogicor)

static SCIP_RETCODE switchWatchedvars(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int watchedvar1, int watchedvar2)

static SCIP_DECL_EVENTEXEC(eventExecLogicor)

static SCIP_RETCODE fixDeleteOrUpgradeCons(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_CONSHDLR *conshdlrlinear, SCIP_CONSHDLR *conshdlrsetppc, int *nfixedvars, int *nchgbds, int *nchgcoefs, int *ndelconss, int *naddconss, int *nupgdconss, SCIP_Bool *cutoff)

static SCIP_DECL_CONSINITPRE(consInitpreLogicor)

#define HASHSIZE_LOGICORCONS

static unsigned int calcSignature(SCIP_VAR **vars, int nvars)

static SCIP_DECL_CONSSEPASOL(consSepasolLogicor)

static SCIP_DECL_HASHKEYEQ(hashKeyEqLogicorcons)

#define CONSHDLR_PROPFREQ

static SCIP_DECL_CONSPRINT(consPrintLogicor)

static SCIP_RETCODE detectRedundantConstraints(SCIP *scip, BMS_BLKMEM *blkmem, SCIP_CONS **conss, int nconss, int *firstchange, int *ndelconss)

static SCIP_DECL_CONSPROP(consPropLogicor)

static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, SCIP_Bool *separated, SCIP_Bool *reduceddom)

#define CONSHDLR_PRESOLTIMING

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

static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)

static SCIP_DECL_CONSGETPERMSYMGRAPH(consGetPermsymGraphLogicor)

static SCIP_DECL_CONSGETNVARS(consGetNVarsLogicor)

static SCIP_DECL_CONSENFORELAX(consEnforelaxLogicor)

static void consdataSort(SCIP_CONSDATA *consdata)

static SCIP_DECL_CONFLICTEXEC(conflictExecLogicor)

static SCIP_RETCODE addNlrow(SCIP *scip, SCIP_CONS *cons)

static SCIP_RETCODE strengthenConss(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int occurlistlength, SCIP_EVENTHDLR *eventhdlr, int *ndelconss, int *nchgcoefs)

#define CONSHDLR_EAGERFREQ

static SCIP_DECL_LINCONSUPGD(linconsUpgdLogicor)

static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)

static SCIP_RETCODE mergeMultiples(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, unsigned char **entries, int *nentries, SCIP_Bool *redundant, int *nchgcoefs)

#define CONSHDLR_ENFOPRIORITY

#define LINCONSUPGD_PRIORITY

#define CONSHDLR_DELAYSEPA

static void removeConsFromOccurList(SCIP_CONS *cons, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int occurlistlength)

static SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(consGetSignedPermsymGraphLogicor)

static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, int nvars, SCIP_VAR **vars)

static SCIP_RETCODE applyFixings(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *redundant, int *nchgcoefs, int *naddconss, int *ndelconss)

static SCIP_RETCODE disableCons(SCIP *scip, SCIP_CONS *cons)

static SCIP_DECL_SORTPTRCOMP(conssLogicorComp)

static SCIP_DECL_CONSACTIVE(consActiveLogicor)

static SCIP_RETCODE removeRedundantCons(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1, int *ndelconss)

static SCIP_DECL_CONSINITSOL(consInitsolLogicor)

static SCIP_DECL_CONSTRANS(consTransLogicor)

#define CONSHDLR_DELAYPROP

static SCIP_DECL_CONSFREE(consFreeLogicor)

static SCIP_RETCODE removeRedundantNonZeros(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *artvar, int artpos, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int occurlistlength, SCIP_EVENTHDLR *eventhdlr, int *nchgcoefs, SCIP_Bool *deleted)

static SCIP_DECL_HASHGETKEY(hashGetKeyLogicorcons)

static SCIP_RETCODE consdataPrint(SCIP *scip, SCIP_CONSDATA *consdata, FILE *file, SCIP_Bool endline)

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

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

#define SCIP_LONGINT_FORMAT

SCIP_RETCODE SCIPincludeLinconsUpgrade(SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)

int SCIPgetNVarsLogicor(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetDualsolLogicor(SCIP *scip, SCIP_CONS *cons)

SCIP_ROW * SCIPgetRowLogicor(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsSetpack(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 SCIPcleanupConssLogicor(SCIP *scip, SCIP_Bool onlychecked, int *naddconss, int *ndelconss, int *nchgcoefs)

SCIP_RETCODE SCIPcopyConsLinear(SCIP *scip, SCIP_CONS **cons, SCIP *sourcescip, const char *name, int nvars, SCIP_VAR **sourcevars, SCIP_Real *sourcecoefs, SCIP_Real lhs, SCIP_Real rhs, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, 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 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_RETCODE SCIPcreateConsBasicLogicor(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars)

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_Real SCIPgetDualfarkasLogicor(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPaddCoefLogicor(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)

SCIP_RETCODE SCIPincludeConshdlrLogicor(SCIP *scip)

SCIP_Bool SCIPisTransformed(SCIP *scip)

SCIP_Bool SCIPisPresolveFinished(SCIP *scip)

SCIP_Bool SCIPisStopped(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

int SCIPgetNIntVars(SCIP *scip)

int SCIPgetNImplVars(SCIP *scip)

int SCIPgetNContVars(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNBinVars(SCIP *scip)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)

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)

void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)

#define SCIPhashFour(a, b, c, d)

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

void * SCIPhashtableRetrieve(SCIP_HASHTABLE *hashtable, void *key)

SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)

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 SCIPwarningMessage(SCIP *scip, const char *formatstr,...)

SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)

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 SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)

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)

int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)

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

void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)

SCIP_CONS ** SCIPconshdlrGetCheckConss(SCIP_CONSHDLR *conshdlr)

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

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 SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))

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

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))

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

SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))

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

SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)

int SCIPconsGetPos(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsPropagationEnabled(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

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

SCIP_RETCODE SCIPenableConsPropagation(SCIP *scip, SCIP_CONS *cons)

int SCIPconsGetValidDepth(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)

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_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_Bool SCIPconsIsAdded(SCIP_CONS *cons)

SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)

SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)

SCIP_RETCODE SCIPdisableConsPropagation(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPaddConsAge(SCIP *scip, SCIP_CONS *cons, SCIP_Real deltaage)

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

SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

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_VAR * SCIPeventGetVar(SCIP_EVENT *event)

SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)

#define SCIPfreeCleanBufferArray(scip, ptr)

#define SCIPallocCleanBufferArray(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 SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPfreeBufferArrayNull(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

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

SCIP_RETCODE SCIPdelNlRow(SCIP *scip, SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)

SCIP_Bool SCIPisNLPConstructed(SCIP *scip)

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

SCIP_Bool SCIPnlrowIsInNLP(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_Bool SCIPinProbing(SCIP *scip)

SCIP_RETCODE SCIPaddVarsToRowSameCoef(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real val)

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 SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)

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

SCIP_Real SCIProwGetDualfarkas(SCIP_ROW *row)

SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)

SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)

SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)

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

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

int SCIPgetNImplications(SCIP *scip)

int SCIPgetNRuns(SCIP *scip)

SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)

SCIP_RETCODE SCIPshrinkDisjunctiveVarSet(SCIP *scip, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_Bool *boundtypes, SCIP_Bool *redundants, int nvars, int *nredvars, int *nglobalred, SCIP_Bool *setredundant, SCIP_Bool *glbinfeas, SCIP_Bool fullshortening)

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

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

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

int SCIPgetDepth(SCIP *scip)

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 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_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)

SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)

int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_RETCODE SCIPvarGetAggregatedObj(SCIP_VAR *var, SCIP_Real *aggrobj)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)

SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)

SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)

SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

int SCIPvarGetIndex(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 SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)

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

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

int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)

int SCIPgetNCliques(SCIP *scip)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

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

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

int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)

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

SCIP_Longint SCIPvarGetNBranchingsCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)

SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)

SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)

SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)

int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

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_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)

void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

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

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

SCIP_RETCODE SCIPextendPermsymDetectionGraphLinear(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool *success)

memory allocation routines

#define BMScopyMemoryArray(ptr, source, num)

#define BMSclearMemoryArray(ptr, num)

struct BMS_BlkMem BMS_BLKMEM

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

methods commonly used for presolving

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

methods for sorting joint arrays of various types

public methods for problem variables

public methods for conflict handler plugins and conflict analysis

public methods for constraint handler plugins and constraints

public methods for cuts and aggregation rows

public methods for event handler plugins and event handlers

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_ConshdlrData SCIP_CONSHDLRDATA

struct SCIP_ConsData SCIP_CONSDATA

struct SCIP_EventData SCIP_EVENTDATA

#define SCIP_EVENTTYPE_UBTIGHTENED

#define SCIP_EVENTTYPE_VARFIXED

#define SCIP_EVENTTYPE_LBRELAXED

@ SCIP_BRANCHDIR_DOWNWARDS

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STAGE_INITPRESOLVE

@ SCIP_STAGE_TRANSFORMING

enum SYM_Symtype SYM_SYMTYPE

#define SCIP_PRESOLTIMING_MEDIUM

#define SCIP_PRESOLTIMING_EXHAUSTIVE

@ SCIP_VARSTATUS_MULTAGGR

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