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

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

SCIP Doxygen Documentation: cons.c Source File

assert(conshdlr !=

);

assert(num <= conshdlr->consssize);

assert(conshdlr !=

);

assert(num <= conshdlr->initconsssize);

assert(conshdlr !=

);

assert(num <= conshdlr->sepaconsssize);

assert(conshdlr !=

);

assert(num <= conshdlr->enfoconsssize);

assert(conshdlr !=

);

assert(num <= conshdlr->checkconsssize);

assert(conshdlr !=

);

assert(num <= conshdlr->propconsssize);

assert(conshdlr !=

);

assert(num <= conshdlr->updateconsssize);

assert(conshdlr !=

);

( c = 0; c < conshdlr->

; ++c )

assert(conshdlr->

[c]->

== (c < conshdlr->nactiveconss));

( c = 0; c < conshdlr->

; ++c )

assert(c < conshdlr->ninitconsskept || conshdlr->

[c]->

);

( c = 0; c < conshdlr->

; ++c )

( c = 0; c < conshdlr->

; ++c )

( c = 0; c < conshdlr->

; ++c )

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(cons !=

);

&& ((

->cons_agelimit > 0 && cons->

>

->cons_agelimit)

assert(cons !=

);

&& ((

->cons_obsoleteage > 0 && cons->

>

->cons_obsoleteage)

assert(conshdlr !=

);

assert(cons !=

);

assert(conshdlr !=

);

assert(cons !=

);

assert(conshdlr !=

);

assert(cons !=

);

assert(conshdlr !=

);

assert(cons !=

);

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(cons->

==

->scip);

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

( delpos < conshdlr->ninitconsskept )

( delpos < conshdlr->ninitconss-1 )

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(cons->

==

->scip);

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(0 <= delpos && delpos < conshdlr->nusefulsepaconss);

( delpos < conshdlr->lastnusefulsepaconss )

assert(conshdlr->

<= delpos && delpos < conshdlr->nsepaconss);

( delpos < conshdlr->nsepaconss-1 )

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(cons->

==

->scip);

conshdlr->

[insertpos] = cons;

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(0 <= delpos && delpos < conshdlr->nusefulenfoconss);

( delpos < conshdlr->lastnusefulenfoconss )

assert(conshdlr->

<= delpos && delpos < conshdlr->nenfoconss);

( delpos < conshdlr->nenfoconss-1 )

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(cons->

);

assert(cons->

==

->scip);

assert(0 <= insertpos && insertpos <= conshdlr->ncheckconss);

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(cons->

);

assert(0 <= delpos && delpos < conshdlr->nusefulcheckconss);

assert(conshdlr->

<= delpos && delpos < conshdlr->ncheckconss);

( delpos < conshdlr->ncheckconss-1 )

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(cons->

==

->scip);

conshdlr->

[insertpos] = cons;

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(0 <= delpos && delpos < conshdlr->nusefulpropconss);

( delpos < conshdlr->lastnusefulpropconss )

assert(conshdlr->

<= delpos && delpos < conshdlr->npropconss);

( delpos < conshdlr->npropconss-1 )

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(cons->

==

->scip);

(

,

, cons->

, conshdlr->

);

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

(

, cons->

, conshdlr->

);

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

assert(cons->

==

->scip);

(

,

, cons->

, conshdlr->

);

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

(

, cons->

, conshdlr->

);

assert(conshdlr !=

);

assert(stat !=

);

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons->

== conshdlr);

( conshdlr->consenable !=

)

( conshdlr->consenable(

->scip, conshdlr, cons) );

assert(conshdlr !=

);

assert(stat !=

);

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons->

== conshdlr);

( conshdlr->consdisable !=

)

( conshdlr->consdisable(

->scip, conshdlr, cons) );

assert(conshdlr !=

);

assert(stat !=

);

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons->

== conshdlr);

assert(depth >= -1);

(

,

,

cons->

, conshdlr->

, depth, focusnode);

( conshdlr->consactive !=

)

( conshdlr->consactive(

->scip, conshdlr, cons) );

assert(conshdlr !=

);

assert(stat !=

);

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons->

== conshdlr);

( conshdlr->consdeactive !=

)

( conshdlr->consdeactive(

->scip, conshdlr, cons) );

assert(conshdlr !=

);

(

,

,

assert(cons !=

);

assert(cons->

== conshdlr);

(

,

,

assert(cons->

== 1);

assert(conshdlr !=

);

(

,

assert(conshdlr !=

);

(

,

,

assert(conshdlr !=

);

assert(cons !=

);

assert(cons->

== conshdlr);

(

,

,

((

*)elem2)->conshdlr->checkpriority - ((

*)elem1)->conshdlr->checkpriority;

assert(conshdlr !=

);

assert(valid !=

);

( conshdlr->conshdlrcopy !=

)

( conshdlr->conshdlrcopy(

->scip, conshdlr, valid) );

assert(conshdlr !=

);

assert(name !=

);

assert(desc !=

);

assert(conssepalp !=

|| conssepasol !=

|| sepafreq == -1);

assert(consprop !=

|| propfreq == -1);

assert(eagerfreq >= -1);

assert(!needscons || ((conshdlrcopy ==

) == (conscopy ==

)));

(

, name);

assert((consgetvars !=

) == (consgetnvars !=

));

(*conshdlr)->sepapriority = sepapriority;

(*conshdlr)->enfopriority = enfopriority;

(*conshdlr)->checkpriority = checkpriority;

(*conshdlr)->sepafreq = sepafreq;

(*conshdlr)->propfreq = propfreq;

(*conshdlr)->eagerfreq = eagerfreq;

(*conshdlr)->maxprerounds = maxprerounds;

(*conshdlr)->conshdlrcopy = conshdlrcopy;

(*conshdlr)->consfree = consfree;

(*conshdlr)->consinit = consinit;

(*conshdlr)->consexit = consexit;

(*conshdlr)->consinitpre = consinitpre;

(*conshdlr)->consexitpre = consexitpre;

(*conshdlr)->consinitsol = consinitsol;

(*conshdlr)->consexitsol = consexitsol;

(*conshdlr)->consdelete = consdelete;

(*conshdlr)->constrans = constrans;

(*conshdlr)->consinitlp = consinitlp;

(*conshdlr)->conssepalp = conssepalp;

(*conshdlr)->conssepasol = conssepasol;

(*conshdlr)->consenfolp = consenfolp;

(*conshdlr)->consenforelax = consenforelax;

(*conshdlr)->consenfops = consenfops;

(*conshdlr)->conscheck = conscheck;

(*conshdlr)->consprop = consprop;

(*conshdlr)->conspresol = conspresol;

(*conshdlr)->consresprop = consresprop;

(*conshdlr)->conslock = conslock;

(*conshdlr)->consactive = consactive;

(*conshdlr)->consdeactive = consdeactive;

(*conshdlr)->consenable = consenable;

(*conshdlr)->consdisable = consdisable;

(*conshdlr)->consprint = consprint;

(*conshdlr)->consdelvars = consdelvars;

(*conshdlr)->conscopy = conscopy;

(*conshdlr)->consparse = consparse;

(*conshdlr)->consgetvars = consgetvars;

(*conshdlr)->consgetnvars = consgetnvars;

(*conshdlr)->conshdlrdata = conshdlrdata;

(*conshdlr)->consgetdivebdchgs = consgetdivebdchgs;

(*conshdlr)->consgetpermsymgraph = consgetpermsymgraph;

(*conshdlr)->consgetsignedpermsymgraph = consgetsignedpermsymgraph;

(*conshdlr)->conss =

;

(*conshdlr)->consssize = 0;

(*conshdlr)->nconss = 0;

(*conshdlr)->nactiveconss = 0;

(*conshdlr)->maxnactiveconss = 0;

(*conshdlr)->startnactiveconss = 0;

(*conshdlr)->initconss =

;

(*conshdlr)->initconsssize = 0;

(*conshdlr)->ninitconss = 0;

(*conshdlr)->ninitconsskept = 0;

(*conshdlr)->sepaconss =

;

(*conshdlr)->sepaconsssize = 0;

(*conshdlr)->nsepaconss = 0;

(*conshdlr)->nusefulsepaconss = 0;

(*conshdlr)->enfoconss =

;

(*conshdlr)->enfoconsssize = 0;

(*conshdlr)->nenfoconss = 0;

(*conshdlr)->nusefulenfoconss = 0;

(*conshdlr)->checkconss =

;

(*conshdlr)->checkconsssize = 0;

(*conshdlr)->ncheckconss = 0;

(*conshdlr)->nusefulcheckconss = 0;

(*conshdlr)->propconss =

;

(*conshdlr)->propconsssize = 0;

(*conshdlr)->npropconss = 0;

(*conshdlr)->nusefulpropconss = 0;

(*conshdlr)->nmarkedpropconss = 0;

(*conshdlr)->updateconss =

;

(*conshdlr)->updateconsssize = 0;

(*conshdlr)->nupdateconss = 0;

(*conshdlr)->nenabledconss = 0;

(*conshdlr)->lastnusefulpropconss = 0;

(*conshdlr)->lastnusefulsepaconss = 0;

(*conshdlr)->lastnusefulenfoconss = 0;

(*conshdlr)->storedpropconss =

;

(*conshdlr)->storedpropconsssize = 0;

(*conshdlr)->storednmarkedpropconss = 0;

(*conshdlr)->storedpropdomchgcount = 0;

(*conshdlr)->nsepacalls = 0;

(*conshdlr)->nenfolpcalls = 0;

(*conshdlr)->nenfopscalls = 0;

(*conshdlr)->nenforelaxcalls = 0;

(*conshdlr)->npropcalls = 0;

(*conshdlr)->ncheckcalls = 0;

(*conshdlr)->nrespropcalls = 0;

(*conshdlr)->ncutoffs = 0;

(*conshdlr)->ncutsfound = 0;

(*conshdlr)->ncutsapplied = 0;

(*conshdlr)->nconssfound = 0;

(*conshdlr)->ndomredsfound = 0;

(*conshdlr)->nchildren = 0;

(*conshdlr)->lastpropdomchgcount = -1;

(*conshdlr)->lastsepalpcount = -1;

(*conshdlr)->lastenfolplpcount = -1;

(*conshdlr)->lastenfolpdomchgcount = -1;

(*conshdlr)->lastenfopsdomchgcount = -1;

(*conshdlr)->lastenforelaxdomchgcount = -1;

(*conshdlr)->lastenforelaxrelaxcount = -1;

(*conshdlr)->lastenfolpnode = -1;

(*conshdlr)->lastenfopsnode = -1;

(*conshdlr)->lastnfixedvars = 0;

(*conshdlr)->lastnaggrvars = 0;

(*conshdlr)->lastnchgvartypes = 0;

(*conshdlr)->lastnchgbds = 0;

(*conshdlr)->lastnaddholes = 0;

(*conshdlr)->lastndelconss = 0;

(*conshdlr)->lastnaddconss = 0;

(*conshdlr)->lastnupgdconss = 0;

(*conshdlr)->lastnchgcoefs = 0;

(*conshdlr)->lastnchgsides = 0;

(*conshdlr)->nfixedvars = 0;

(*conshdlr)->naggrvars = 0;

(*conshdlr)->nchgvartypes = 0;

(*conshdlr)->nchgbds = 0;

(*conshdlr)->naddholes = 0;

(*conshdlr)->ndelconss = 0;

(*conshdlr)->naddconss = 0;

(*conshdlr)->nupgdconss = 0;

(*conshdlr)->nchgcoefs = 0;

(*conshdlr)->nchgsides = 0;

(*conshdlr)->npresolcalls = 0;

(*conshdlr)->delayupdatecount = 0;

(*conshdlr)->needscons = needscons;

(*conshdlr)->sepalpwasdelayed =

;

(*conshdlr)->sepasolwasdelayed =

;

(*conshdlr)->propwasdelayed =

;

(*conshdlr)->duringsepa =

;

(*conshdlr)->duringprop =

;

(*conshdlr)->initialized =

;

,

,

,

,

&(*conshdlr)->maxprerounds,

, maxprerounds, -1, INT_MAX,

,

) );

,

&(*conshdlr)->delaysepa,

, delaysepa,

,

) );

,

&(*conshdlr)->delayprop,

, delayprop,

,

) );

(void)

(paramdesc,

,

,

assert(conshdlr !=

);

assert(name !=

);

assert(desc !=

);

assert(conssepalp !=

|| conssepasol !=

|| sepafreq == -1);

assert(consprop !=

|| propfreq == -1);

assert(eagerfreq >= -1);

assert(!needscons || ((conshdlrcopy ==

) == (conscopy ==

)));

checkpriority, sepafreq, propfreq, eagerfreq, maxprerounds, delaysepa, delayprop, needscons, proptiming,

presoltiming, conshdlrcopy, consfree, consinit, consexit, consinitpre, consexitpre, consinitsol, consexitsol,

consdelete, constrans, consinitlp, conssepalp, conssepasol, consenfolp, consenforelax, consenfops, conscheck,

consprop, conspresol, consresprop, conslock, consactive, consdeactive, consenable, consdisable, consdelvars,

consprint, conscopy, consparse, consgetvars, consgetnvars, consgetdivebdchgs, consgetpermsymgraph,

consgetsignedpermsymgraph, conshdlrdata),

assert(conshdlr !=

);

( *conshdlr ==

)

assert(!(*conshdlr)->initialized);

assert((*conshdlr)->nconss == 0);

( (*conshdlr)->consfree !=

)

( (*conshdlr)->consfree(

->scip, *conshdlr) );

assert(conshdlr !=

);

(

->misc_resetstat )

( conshdlr->consinit !=

)

assert(conshdlr !=

);

( conshdlr->consexit !=

)

assert(conshdlr !=

);

( conshdlr->consinitpre !=

)

( stat->

>= 2 )

( c = 0; c < conshdlr->

; ++c )

assert(conshdlr !=

);

( conshdlr->consexitpre !=

)

assert(conshdlr !=

);

assert(stat !=

);

( conshdlr->consinitsol !=

)

assert(conshdlr !=

);

( conshdlr->consexitsol !=

)

assert(conshdlr !=

);

assert(cutoff !=

);

( conshdlr->consinitlp !=

)

(

,

,

( initkeptconss )

assert(currentdepth >= 0);

assert(conshdlr !=

);

assert(stat !=

);

assert(result !=

);

( conshdlr->conssepalp !=

&& ((depth == 0 && conshdlr->

== 0)

( !conshdlr->

|| execdelayed )

nusefulconss = nconss;

assert(firstcons >= 0);

assert(firstcons + nconss <= conshdlr->nsepaconss);

assert(nusefulconss <= nconss);

oldnactiveconss;

lastnusefulsepaconss;

(

,

,

firstcons, firstcons + nconss - 1, conshdlr->

, conshdlr->

,

lastsepalpcount = stat->

;

conss = &(conshdlr->

[firstcons]);

nusefulconss = nconss;

( conshdlr->conssepalp(

->scip, conshdlr, conss, nconss, nusefulconss, result) );

(

,

conshdlr->

, *result);

(

,

, conshdlr->

);

assert(conshdlr !=

);

assert(stat !=

);

assert(result !=

);

( conshdlr->conssepasol !=

&& ((depth == 0 && conshdlr->

== 0)

( !conshdlr->

|| execdelayed )

assert(nusefulconss <= nconss);

( nconss > 0 || !conshdlr->

)

oldnactiveconss;

(

,

,

nconss, conshdlr->

, (

*)sol);

nusefulconss = nconss;

( conshdlr->conssepasol(

->scip, conshdlr, conss, nconss, nusefulconss, sol, result) );

(

,

conshdlr->

, *result);

(

,

, conshdlr->

);

assert(conshdlr !=

);

assert(stat !=

);

assert(tree !=

);

assert(relaxsol !=

);

assert(result !=

);

&& ( strcmp(conshdlr->

,

) != 0 )

lastinfeasible =

;

lastinfeasible =

;

nusefulconss = nconss;

relaxchanged =

;

relaxchanged =

;

lastinfeasible =

;

assert(firstcons >= 0);

assert(firstcons + nconss <= conshdlr->nenfoconss);

assert(nusefulconss <= nconss);

( nconss > 0 || (!conshdlr->

&& relaxchanged) )

oldnactiveconss;

assert(conshdlr->consenforelax !=

);

(

,

firstcons, firstcons + nconss - 1, conshdlr->

, conshdlr->

, relaxchanged ?

:

);

conss = conshdlr->

+ firstcons;

nusefulconss = nconss;

( conshdlr->consenforelax(

->scip, relaxsol, conshdlr, conss, nconss, nusefulconss, solinfeasible, result) );

(

,

conshdlr->

, *result);

assert(conshdlr !=

);

assert(stat !=

);

assert(tree !=

);

assert(result !=

);

( conshdlr->consenfolp !=

)

lastinfeasible =

;

lastinfeasible =

;

nusefulconss = nconss;

lastinfeasible =

;

assert(firstcons >= 0);

assert(firstcons + nconss <= conshdlr->nenfoconss);

assert(nusefulconss <= nconss);

( nconss > 0 || (!conshdlr->

&& lpchanged) )

oldnactiveconss;

(

,

,

firstcons, firstcons + nconss - 1, conshdlr->

, conshdlr->

, lpchanged ?

:

);

conss = nconss > 0 ? conshdlr->

+ firstcons :

;

nusefulconss = nconss;

( conshdlr->consenfolp(

->scip, conshdlr, conss, nconss, nusefulconss, solinfeasible, result) );

(

,

conshdlr->

, *result);

assert(conshdlr !=

);

assert(diveset !=

);

assert(sol !=

);

assert(success !=

);

assert(infeasible !=

);

( conshdlr->consgetdivebdchgs !=

)

( conshdlr->consgetdivebdchgs(

->scip, conshdlr, diveset, sol, success, infeasible) );

assert(conshdlr !=

);

assert(stat !=

);

assert(tree !=

);

assert(result !=

);

( conshdlr->consenfops !=

)

lastinfeasible =

;

lastinfeasible =

;

nusefulconss = nconss;

lastinfeasible =

;

assert(firstcons >= 0);

assert(firstcons + nconss <= conshdlr->nenfoconss);

assert(nusefulconss <= nconss);

( nconss > 0 || (!conshdlr->

&& pschanged) )

(

,

,

firstcons, firstcons + nconss - 1, conshdlr->

, conshdlr->

, pschanged ?

:

, objinfeasible);

conss = conshdlr->

+ firstcons;

nusefulconss = nconss;

( conshdlr->consenfops(

->scip, conshdlr, conss, nconss, nusefulconss, solinfeasible, objinfeasible, result) );

( !objinfeasible )

(

,

(

,

conshdlr->

, *result);

( objinfeasible )

assert(conshdlr !=

);

assert(result !=

);

sol, checkintegrality, checklprows, printreason, completely, result) );

(

, conshdlr->

, *result);

assert(conshdlr !=

);

assert(stat !=

);

assert(result !=

);

( conshdlr->consprop !=

&& ((depth == 0 && conshdlr->

== 0)

( !conshdlr->

|| execdelayed )

nmarkedpropconss;

nusefulconss = nconss;

assert(firstcons >= 0);

assert(firstcons + nconss <= conshdlr->npropconss);

assert(nusefulconss <= nconss);

( nconss > 0 || fullpropagation

lastnusefulpropconss;

(

,

,

firstcons, firstcons + nconss - 1, conshdlr->

, conshdlr->

,

conss = nconss > 0 ? (conshdlr->

+ firstcons) :

;

nusefulconss = nconss;

( instrongbranching )

assert(nusefulconss <= nconss);

assert(nmarkedpropconss <= nconss);

( conshdlr->consprop(

->scip, conshdlr, conss, nconss, nusefulconss, nmarkedpropconss, proptiming, result) );

( instrongbranching )

assert(lastpropdomchgcount == stat->

);

(

,

conshdlr->

, *result);

(

,

, conshdlr->

);

assert(conshdlr !=

);

assert(nfixedvars !=

);

assert(naggrvars !=

);

assert(nchgvartypes !=

);

assert(nchgbds !=

);

assert(naddholes !=

);

assert(ndelconss !=

);

assert(naddconss !=

);

assert(nupgdconss !=

);

assert(nchgcoefs !=

);

assert(nchgsides !=

);

assert(result !=

);

( conshdlr->conspresol !=

nnewchgvartypes;

nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes,

nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides,

nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes,

ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) );

(

,

conshdlr->

, *result);

assert(conshdlr !=

);

( conshdlr->consdelvars !=

)

assert(conshdlr !=

);

assert(conshdlr->conslock !=

);

assert(conshdlr !=

);

assert(conshdlr->conslock !=

);

assert(conshdlr !=

);

conshdlr->

;

assert(conshdlr !=

);

conshdlr->

;

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conssepalp !=

|| conssepasol !=

|| sepafreq == -1);

conshdlr->conssepalp = conssepalp;

conshdlr->conssepasol = conssepasol;

assert(conshdlr !=

);

assert(consprop !=

|| propfreq == -1);

conshdlr->consprop = consprop;

assert(conshdlr !=

);

conshdlr->consenforelax = consenforelax;

assert(conshdlr !=

);

assert(!conshdlr->

|| (conshdlrcopy ==

) == (conscopy ==

));

conshdlr->conshdlrcopy = conshdlrcopy;

conshdlr->conscopy = conscopy;

assert(conshdlr !=

);

conshdlr->consfree = consfree;

assert(conshdlr !=

);

conshdlr->consinit = consinit;

assert(conshdlr !=

);

conshdlr->consexit = consexit;

assert(conshdlr !=

);

conshdlr->consinitsol = consinitsol;

assert(conshdlr !=

);

conshdlr->consexitsol = consexitsol;

assert(conshdlr !=

);

conshdlr->consinitpre = consinitpre;

assert(conshdlr !=

);

conshdlr->consexitpre = consexitpre;

assert(conshdlr !=

);

conshdlr->conspresol = conspresol;

(

, conshdlr->

);

assert(conshdlr !=

);

conshdlr->consdelete = consdelete;

assert(conshdlr !=

);

conshdlr->constrans = constrans;

assert(conshdlr !=

);

conshdlr->consinitlp = consinitlp;

assert(conshdlr !=

);

conshdlr->consresprop = consresprop;

assert(conshdlr !=

);

conshdlr->consactive = consactive;

assert(conshdlr !=

);

conshdlr->consdeactive = consdeactive;

assert(conshdlr !=

);

conshdlr->consenable = consenable;

assert(conshdlr !=

);

conshdlr->consdisable = consdisable;

assert(conshdlr !=

);

conshdlr->consdelvars = consdelvars;

assert(conshdlr !=

);

conshdlr->consprint = consprint;

assert(conshdlr !=

);

conshdlr->consparse = consparse;

assert(conshdlr !=

);

conshdlr->consgetvars = consgetvars;

assert(conshdlr !=

);

conshdlr->consgetnvars = consgetnvars;

assert(conshdlr !=

);

conshdlr->consgetdivebdchgs = consgetdivebdchgs;

assert(conshdlr !=

);

conshdlr->consgetpermsymgraph = consgetpermsymgraph;

assert(conshdlr !=

);

conshdlr->consgetsignedpermsymgraph = consgetsignedpermsymgraph;

assert(conshdlr !=

);

conshdlr->

;

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

conshdlr->

;

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

(conshdlr->conspresol !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

(conshdlr->conshdlrcopy !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlr !=

);

conshdlr->consgetpermsymgraph !=

;

assert(conshdlr !=

);

conshdlr->consgetsignedpermsymgraph !=

;

assert(conssetchg !=

);

assert(blkmem !=

);

(*conssetchg)->addedconss =

;

(*conssetchg)->disabledconss =

;

(*conssetchg)->addedconsssize = 0;

(*conssetchg)->naddedconss = 0;

(*conssetchg)->disabledconsssize = 0;

(*conssetchg)->ndisabledconss = 0;

assert(conssetchg !=

);

assert(conssetchg !=

);

assert(blkmem !=

);

( *conssetchg !=

)

assert(conssetchg !=

);

assert(num <= conssetchg->addedconsssize);

assert(conssetchg !=

);

assert(num <= conssetchg->disabledconsssize);

assert(conssetchg !=

);

assert(cons !=

);

( *conssetchg ==

)

(*conssetchg)->addedconss[(*conssetchg)->naddedconss] = cons;

(*conssetchg)->naddedconss++;

cons->

= (*conssetchg)->naddedconss-1;

assert(conssetchg !=

);

assert(cons !=

);

( *conssetchg ==

)

(*conssetchg)->disabledconss[(*conssetchg)->ndisabledconss] = cons;

(*conssetchg)->ndisabledconss++;

assert(conssetchg !=

);

assert(0 <= arraypos && arraypos < conssetchg->naddedconss);

assert(cons !=

);

(

,

, cons->

, arraypos);

( ; arraypos < conssetchg->

-1; ++arraypos )

assert(conssetchg !=

);

assert(0 <= arraypos && arraypos < conssetchg->ndisabledconss);

(

,

,

assert(conssetchg !=

);

( conss !=

)

( nconss !=

)

( conssetchg ==

)

(

,

,

( i < conssetchg->naddedconss )

assert(cons !=

);

( i < conssetchg->ndisabledconss )

assert(cons !=

);

(

,

,

( conssetchg ==

)

(

,

,

assert(cons !=

);

(

,

,

( i = conssetchg->

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

assert(cons !=

);

assert(conssetchg !=

);

( *conssetchg ==

)

(

,

,

(

*)*conssetchg, (*conssetchg)->

, (*conssetchg)->ndisabledconss);

( i = (*conssetchg)->naddedconss-1; i >= 0; --i )

cons = (*conssetchg)->addedconss[i];

assert(cons !=

);

( i = (*conssetchg)->ndisabledconss-1; i >= 0; --i )

cons = (*conssetchg)->disabledconss[i];

assert(cons !=

);

( (*conssetchg)->naddedconss == 0 && (*conssetchg)->ndisabledconss == 0 )

assert(cons !=

);

assert(blkmem !=

);

assert(name !=

);

assert(conshdlr !=

);

assert(!original || deleteconsdata);

(*cons)->scip =

->scip;

(*cons)->conshdlr = conshdlr;

(*cons)->consdata = consdata;

(*cons)->transorigcons =

;

(*cons)->addconssetchg =

;

(*cons)->addarraypos = -1;

(*cons)->consspos = -1;

(*cons)->initconsspos = -1;

(*cons)->sepaconsspos = -1;

(*cons)->enfoconsspos = -1;

(*cons)->checkconsspos = -1;

(*cons)->propconsspos = -1;

(*cons)->activedepth = -2;

(*cons)->validdepth = (local ? -1 : 0);

(*cons)->nupgradelocks = 0;

(*cons)->initial = initial;

(*cons)->separate = separate;

(*cons)->enforce = enforce;

(*cons)->check = check;

(*cons)->propagate = propagate;

(*cons)->sepaenabled = separate;

(*cons)->propenabled = propagate;

(*cons)->local = local;

(*cons)->modifiable = modifiable;

(*cons)->dynamic = dynamic;

(*cons)->removable = removable;

(*cons)->stickingatnode = stickingatnode;

(*cons)->original = original;

(*cons)->deleteconsdata = deleteconsdata;

(*cons)->active =

;

(*cons)->conflict =

;

(*cons)->enabled =

;

(*cons)->obsolete =

;

(*cons)->markpropagate =

;

(*cons)->deleted =

;

(*cons)->update =

;

(*cons)->updateinsert =

;

(*cons)->updateactivate =

;

(*cons)->updatedeactivate =

;

(*cons)->updateenable =

;

(*cons)->updatedisable =

;

(*cons)->updatesepaenable =

;

(*cons)->updatesepadisable =

;

(*cons)->updatepropenable =

;

(*cons)->updatepropdisable =

;

(*cons)->updateobsolete =

;

(*cons)->updatemarkpropagate =

;

(*cons)->updateunmarkpropagate =

;

(*cons)->updatefree =

;

(*cons)->updateactfocus =

;

(*cons)->nlockspos[i] = 0;

(*cons)->nlocksneg[i] = 0;

(

,

, (*cons)->name);

(*cons)->updateinsert =

;

assert((*cons)->update);

assert((*cons)->nuses == 2);

assert(cons !=

);

assert(sourcescip !=

);

assert(sourceconshdlr !=

);

assert(sourcecons !=

);

assert(varmap !=

);

assert(consmap !=

);

assert(valid !=

);

( sourceconshdlr->conscopy !=

)

( sourceconshdlr->conscopy(

->scip, cons, name, sourcescip, sourceconshdlr, sourcecons, varmap, consmap,

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

assert(cons !=

);

(*success) =

;

assert(str !=

);

( endptr ==

|| endptr == str )

assert(endptr !=

);

( endptr ==

|| endptr == str )

assert(endptr !=

);

( conshdlr ==

)

(messagehdlr,

, conshdlrname);

assert( conshdlr !=

);

( conshdlr->consparse ==

)

(messagehdlr,

, conshdlrname);

( conshdlr->consparse(

->scip, conshdlr, cons, consname, str,

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

assert(cons !=

);

assert(cons !=

);

assert(*cons !=

);

assert((*cons)->conshdlr !=

);

assert((*cons)->nuses == 0);

assert(!(*cons)->active);

assert(!(*cons)->update);

assert(!(*cons)->original || (*cons)->transorigcons ==

);

assert(blkmem !=

);

assert((*cons)->scip ==

->scip);

(

,

,

(*cons)->name, (*cons)->consspos, (*cons)->conshdlr->name);

( (*cons)->conshdlr->consdelete !=

&& (*cons)->consdata !=

&& (*cons)->deleteconsdata )

( (*cons)->conshdlr->consdelete(

->scip, (*cons)->conshdlr, *cons, &(*cons)->

) );

( !(*cons)->deleteconsdata )

(*cons)->consdata =

;

assert((*cons)->consdata ==

);

( (*cons)->transorigcons !=

)

assert(!(*cons)->original);

assert((*cons)->transorigcons->original);

assert((*cons)->transorigcons->transorigcons == *cons);

(*cons)->transorigcons->transorigcons =

;

( !(*cons)->original )

assert((*cons)->consspos == -1);

assert(cons !=

);

assert(cons->

>= 0);

(

, cons->

, cons->

, (

*)cons);

assert(blkmem !=

);

assert(cons !=

);

assert(*cons !=

);

assert((*cons)->conshdlr !=

);

assert((*cons)->nuses >= 1);

assert((*cons)->scip ==

->scip);

(

,

, (*cons)->name, (*cons)->nuses, (

*)(*cons));

( (*cons)->nuses == 0 )

assert(!(*cons)->active || (*cons)->updatedeactivate);

(*cons)->updatefree =

;

assert((*cons)->update);

assert((*cons)->nuses == 1);

assert(cons !=

);

assert(cons->

==

->scip);

assert(conshdlr !=

);

( conshdlr->consprint !=

)

( conshdlr->consprint(

->scip, conshdlr, cons, file) );

(messagehdlr, file,

, conshdlr->

);

assert(cons !=

);

assert(cons->

==

->scip);

assert(conshdlr !=

);

( conshdlr->consgetvars !=

)

( conshdlr->consgetvars(

->scip, conshdlr, cons, vars, varssize, success) );

(*success) =

;

assert(cons !=

);

assert(cons->

==

->scip);

assert(conshdlr !=

);

( conshdlr->consgetnvars !=

)

( conshdlr->consgetnvars(

->scip, conshdlr, cons, nvars, success) );

(*success) =

;

assert(cons !=

);

assert(cons->

==

->scip);

assert(success !=

);

assert(conshdlr !=

);

( conshdlr->consgetpermsymgraph !=

)

( conshdlr->consgetpermsymgraph(

->scip, conshdlr, cons, graph, success) );

assert(cons !=

);

assert(cons->

==

->scip);

assert(success !=

);

assert(conshdlr !=

);

( conshdlr->consgetsignedpermsymgraph !=

)

( conshdlr->consgetsignedpermsymgraph(

->scip, conshdlr, cons, graph, success) );

assert(cons !=

);

assert(cons->

==

->scip);

assert(origcons !=

);

assert(origcons->

==

->scip);

assert(transcons !=

);

assert(*transcons !=

);

assert(cons !=

);

assert(cons->

==

->scip);

( cons->

!= initial )

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons !=

);

assert(cons->

==

->scip);

( cons->

!= enforce )

assert(cons !=

);

assert(cons->

==

->scip);

( cons->

!= check )

cons->

= check;

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons !=

);

cons->

= local;

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert( cons !=

);

assert( name !=

);

cons->

= (

*)name;

assert(cons !=

);

assert(cons->

==

->scip);

(

,

,

assert(cons !=

);

assert(cons->

==

->scip);

(

,

,

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons !=

);

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons !=

);

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons !=

);

assert(cons->

==

->scip);

(

,

,

cons->

+= deltaage;

assert(cons !=

);

assert(cons->

==

->scip);

assert(cons !=

);

assert(result !=

);

assert(cons->

==

->scip);

assert(conshdlr !=

);

( conshdlr->consresprop !=

)

( conshdlr->consresprop(

->scip, conshdlr, cons, infervar, inferinfo, inferboundtype, bdchgidx,

relaxedbd, result) );

(

,

conshdlr->

, *result);

(

,

assert(cons !=

);

assert((

)locktype >= 0 && (

)locktype < (

)

);

assert(cons->

[locktype] >= 0);

assert(cons->

[locktype] >= 0);

assert(-2 <= nlockspos && nlockspos <= 2);

assert(-2 <= nlocksneg && nlocksneg <= 2);

assert(cons->

==

->scip);

oldnlockspos = cons->

[locktype];

oldnlocksneg = cons->

[locktype];

cons->

[locktype] += nlockspos;

cons->

[locktype] += nlocksneg;

assert(cons->

[locktype] >= 0);

assert(cons->

[locktype] >= 0);

updlockpos = (int)(cons->

[locktype] > 0) - (int)(oldnlockspos > 0);

updlockneg = (int)(cons->

[locktype] > 0) - (int)(oldnlocksneg > 0);

( updlockpos != 0 || updlockneg != 0 )

assert(cons !=

);

assert(cons->

==

->scip);

assert(result !=

);

assert(conshdlr !=

);

assert(conshdlr->conscheck !=

);

( conshdlr->conscheck(

->scip, conshdlr, &cons, 1, sol, checkintegrality, checklprows, printreason,

(

,

conshdlr->

, cons->

, *result);

assert(cons !=

);

assert(cons->

==

->scip);

assert(result !=

);

assert(conshdlr !=

);

assert(conshdlr->consenfops !=

);

( conshdlr->consenfops(

->scip, conshdlr, &cons, 1, 1, solinfeasible, objinfeasible, result) );

(

,

conshdlr->

, *result);

assert(cons !=

);

assert(cons->

==

->scip);

assert(result !=

);

assert(conshdlr !=

);

assert(conshdlr->consenfolp !=

);

( conshdlr->consenfolp(

->scip, conshdlr, &cons, 1, 1, solinfeasible, result) );

(

,

conshdlr->

, *result);

assert(cons !=

);

assert(cons->

==

->scip);

assert(sol !=

);

assert(result !=

);

assert(conshdlr !=

);

assert(conshdlr->consenfolp !=

);

( conshdlr->consenforelax(

->scip, sol, conshdlr, &cons, 1, 1, solinfeasible, result) );

(

,

conshdlr->

, *result);

assert(cons !=

);

assert(infeasible !=

);

assert(cons->

==

->scip);

assert(conshdlr !=

);

( conshdlr->consinitlp !=

)

( conshdlr->consinitlp(

->scip, conshdlr, &cons, 1, infeasible) );

assert(cons !=

);

assert(cons->

==

->scip);

assert(result !=

);

assert(conshdlr !=

);

( conshdlr->conssepalp !=

)

( conshdlr->conssepalp(

->scip, conshdlr, &cons, 1, 1, result) );

(

, conshdlr->

,

assert(cons !=

);

assert(cons->

==

->scip);

assert(sol !=

);

assert(result !=

);

assert(conshdlr !=

);

( conshdlr->conssepasol !=

)

( conshdlr->conssepasol(

->scip, conshdlr, &cons, 1, 1, sol, result) );

(

,

conshdlr->

, *result);

assert(cons !=

);

assert(cons->

==

->scip);

assert(result !=

);

assert(conshdlr !=

);

( conshdlr->consprop !=

)

( conshdlr->consprop(

->scip, conshdlr, &cons, 1, 1, 1, proptiming, result) );

(

,

conshdlr->

, *result);

assert(cons !=

);

assert(cons->

==

->scip);

assert(result !=

);

assert(infervar !=

);

assert(bdchgidx !=

);

assert(conshdlr !=

);

( conshdlr->consresprop !=

)

( conshdlr->consresprop(

->scip, conshdlr, cons, infervar, inferinfo, boundtype, bdchgidx, relaxedbd, result) );

(

,

conshdlr->

, *result);

nnewchgvartypes,

assert(cons !=

);

assert(cons->

==

->scip);

assert(nfixedvars !=

);

assert(naggrvars !=

);

assert(nchgvartypes !=

);

assert(nchgbds !=

);

assert(naddholes !=

);

assert(ndelconss !=

);

assert(naddconss !=

);

assert(nupgdconss !=

);

assert(nchgcoefs !=

);

assert(nchgsides !=

);

assert(result !=

);

assert(conshdlr !=

);

( conshdlr->conspresol !=

)

( conshdlr->conspresol(

->scip, conshdlr, &cons, 1, nrounds, timing,

nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss,

nnewupgdconss, nnewchgcoefs, nnewchgsides, nfixedvars, naggrvars, nchgvartypes,

nchgbds, naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) );

(

,

conshdlr->

, *result);

assert(cons !=

);

assert(cons->

==

->scip);

assert(conshdlr !=

);

( conshdlr->consactive !=

)

( conshdlr->consactive(

->scip, conshdlr, cons) );

assert(cons !=

);

assert(cons->

==

->scip);

assert(conshdlr !=

);

( conshdlr->consdeactive !=

)

( conshdlr->consdeactive(

->scip, conshdlr, cons) );

assert(cons !=

);

cons->

;

assert(conshdlr !=

);

assert(num <= conshdlr->storedpropconsssize);

assert(conshdlrs !=

|| nconshdlrs == 0);

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

conshdlr = conshdlrs[c];

assert(conshdlr !=

);

assert(blkmem !=

);

assert(conshdlrs !=

|| nconshdlrs == 0);

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

conshdlr = conshdlrs[c];

assert(conshdlr !=

);

assert(cons !=

);

assert(linconsstats !=

);

assert(linconsstats !=

);

assert(*linconsstats !=

);

linconsstats->

= 0;

assert(linconsstats !=

);

linconsstats->

[(int)linconstype];

assert(linconsstats !=

);

linconsstats->

;

assert(linconsstats !=

);

assert(increment >= 1);

linconsstats->

[(int)linconstype] += increment;

linconsstats->

+= increment;

assert(linconsstats !=

);

assert(cons !=

);

cons->

;

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

cons->

;

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

(!cons->

? 0

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

cons->

;

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

!cons->

;

assert(cons !=

);

cons->

;

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

assert((

)locktype >= 0 && (

)locktype < (

)

);

(cons->

[locktype] > 0);

assert(cons !=

);

assert((

)locktype >= 0 && (

)locktype < (

)

);

(cons->

[locktype] > 0);

assert(cons !=

);

assert((

)locktype >= 0 && (

)locktype < (

)

);

assert(cons !=

);

assert((

)locktype >= 0 && (

)locktype < (

)

);

assert(cons !=

);

assert((

)locktype >= 0 && (

)locktype < (

)

);

assert(cons !=

);

assert(cons !=

);

assert(cons !=

);

SCIP_DECL_CONSENFOPS(ConshdlrSubtour::scip_enfops)

SCIP_DECL_CONSSEPASOL(ConshdlrSubtour::scip_sepasol)

SCIP_DECL_CONSLOCK(ConshdlrSubtour::scip_lock)

SCIP_DECL_CONSDELETE(ConshdlrSubtour::scip_delete)

SCIP_DECL_CONSCOPY(ConshdlrSubtour::scip_copy)

SCIP_DECL_CONSSEPALP(ConshdlrSubtour::scip_sepalp)

SCIP_DECL_CONSTRANS(ConshdlrSubtour::scip_trans)

SCIP_DECL_CONSDELVARS(ConshdlrSubtour::scip_delvars)

SCIP_DECL_CONSPRINT(ConshdlrSubtour::scip_print)

SCIP_DECL_CONSCHECK(ConshdlrSubtour::scip_check)

SCIP_DECL_CONSPROP(ConshdlrSubtour::scip_prop)

SCIP_DECL_CONSENFOLP(ConshdlrSubtour::scip_enfolp)

static GRAPHNODE ** active

int SCIPbranchcandGetNPseudoCands(SCIP_BRANCHCAND *branchcand)

internal methods for branching rules and branching candidate storage

void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)

void SCIPclockEnableOrDisable(SCIP_CLOCK *clck, SCIP_Bool enable)

void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)

SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)

void SCIPclockReset(SCIP_CLOCK *clck)

void SCIPclockFree(SCIP_CLOCK **clck)

SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)

internal methods for clocks and timing issues

SCIP_RETCODE SCIPconshdlrsStorePropagationStatus(SCIP_SET *set, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)

static SCIP_RETCODE conshdlrAddInitcons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)

void SCIPconshdlrSetFree(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))

SCIP_RETCODE SCIPconsAddLocks(SCIP_CONS *cons, SCIP_SET *set, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)

SCIP_RETCODE SCIPconshdlrSeparateLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)

void SCIPconshdlrSetInitsol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))

SCIP_RETCODE SCIPconsParse(SCIP_CONS **cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *str, 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 *success)

SCIP_RETCODE SCIPconssetchgUndo(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPconsEnableSeparation(SCIP_CONS *cons, SCIP_SET *set)

static SCIP_RETCODE conssetchgEnsureAddedconssSize(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)

void SCIPconshdlrSetTrans(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))

SCIP_RETCODE SCIPconshdlrSetPresol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)

void SCIPconshdlrIncNCutsFound(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPconshdlrInit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

static SCIP_RETCODE conssetchgDelAddedCons(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int arraypos)

static SCIP_RETCODE conshdlrEnableCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)

void SCIPconsMarkConflict(SCIP_CONS *cons)

SCIP_RETCODE SCIPconsEnable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)

void SCIPconsCapture(SCIP_CONS *cons)

SCIP_RETCODE SCIPconsProp(SCIP_CONS *cons, SCIP_SET *set, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)

static SCIP_RETCODE conssetchgCreate(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPconsPrint(SCIP_CONS *cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)

SCIP_RETCODE SCIPconsCreate(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set, 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 original, SCIP_Bool deleteconsdata)

void SCIPconshdlrIncNAppliedCuts(SCIP_CONSHDLR *conshdlr)

static SCIP_RETCODE conshdlrEnsureCheckconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)

static void conshdlrDelPropcons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

static SCIP_Bool conshdlrAreUpdatesDelayed(SCIP_CONSHDLR *conshdlr)

void SCIPconsSetLocal(SCIP_CONS *cons, SCIP_Bool local)

SCIP_RETCODE SCIPconsMarkPropagate(SCIP_CONS *cons, SCIP_SET *set)

void SCIPconshdlrSetInit(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))

void SCIPconshdlrSetDelete(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))

SCIP_RETCODE SCIPconshdlrEnforceRelaxSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_SOL *relaxsol, SCIP_Bool solinfeasible, SCIP_RESULT *result)

static SCIP_RETCODE conshdlrDisableConsSeparation(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

static SCIP_Real conshdlrGetAgeresetavg(SCIP_CONSHDLR *conshdlr)

static SCIP_RETCODE conssetchgEnsureDisabledconssSize(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)

SCIP_RETCODE SCIPconsDeactivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)

void SCIPconshdlrSetParse(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))

static SCIP_RETCODE conshdlrEnsurePropconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)

SCIP_RETCODE SCIPconshdlrExitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool restart)

void SCIPconshdlrSetGetPermsymGraph(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)))

SCIP_RETCODE SCIPconshdlrSeparateSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)

void SCIPconshdlrSetGetNVars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))

SCIP_RETCODE SCIPconsDisable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPconsDeactive(SCIP_CONS *cons, SCIP_SET *set)

static SCIP_RETCODE conshdlrMarkConsObsolete(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

SCIP_RETCODE SCIPconshdlrLockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)

void SCIPconshdlrSetActive(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))

SCIP_RETCODE SCIPconshdlrEnforceLPSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_Bool solinfeasible, SCIP_RESULT *result)

SCIP_RETCODE SCIPconsGetPermsymGraph(SCIP_CONS *cons, SCIP_SET *set, SYM_GRAPH *graph, SCIP_Bool *success)

SCIP_RETCODE SCIPconsGetNVars(SCIP_CONS *cons, SCIP_SET *set, int *nvars, SCIP_Bool *success)

static SCIP_RETCODE conshdlrEnsureUpdateconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)

void SCIPconshdlrSetInitpre(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))

void SCIPconsSetStickingAtNode(SCIP_CONS *cons, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPconsSetSeparated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool separate)

#define checkConssArrays(conshdlr)

SCIP_RETCODE SCIPconsSepalp(SCIP_CONS *cons, SCIP_SET *set, SCIP_RESULT *result)

static SCIP_RETCODE conssetchgRelease(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set)

static SCIP_RETCODE conshdlrProcessUpdates(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPconsEnfops(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)

SCIP_RETCODE SCIPconsActive(SCIP_CONS *cons, SCIP_SET *set)

#define AGERESETAVG_AGELIMIT

SCIP_RETCODE SCIPconsResetAge(SCIP_CONS *cons, SCIP_SET *set)

static SCIP_RETCODE conshdlrEnsureInitconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)

static SCIP_RETCODE conshdlrAddCheckcons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)

static SCIP_RETCODE ensurePropagationStorage(SCIP_SET *set, SCIP_CONSHDLR *conshdlr, int num)

SCIP_RETCODE SCIPconsResprop(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)

void SCIPconsSetRemovable(SCIP_CONS *cons, SCIP_Bool removable)

SCIP_RETCODE SCIPconshdlrCreate(SCIP_CONSHDLR **conshdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int sepapriority, int enfopriority, int checkpriority, int sepafreq, int propfreq, int eagerfreq, int maxprerounds, SCIP_Bool delaysepa, SCIP_Bool delayprop, SCIP_Bool needscons, SCIP_PROPTIMING proptiming, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSFREE((*consfree)), SCIP_DECL_CONSINIT((*consinit)), SCIP_DECL_CONSEXIT((*consexit)), SCIP_DECL_CONSINITPRE((*consinitpre)), SCIP_DECL_CONSEXITPRE((*consexitpre)), SCIP_DECL_CONSINITSOL((*consinitsol)), SCIP_DECL_CONSEXITSOL((*consexitsol)), SCIP_DECL_CONSDELETE((*consdelete)), SCIP_DECL_CONSTRANS((*constrans)), SCIP_DECL_CONSINITLP((*consinitlp)), SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFORELAX((*consenforelax)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSPROP((*consprop)), SCIP_DECL_CONSPRESOL((*conspresol)), SCIP_DECL_CONSRESPROP((*consresprop)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_DECL_CONSACTIVE((*consactive)), SCIP_DECL_CONSDEACTIVE((*consdeactive)), SCIP_DECL_CONSENABLE((*consenable)), SCIP_DECL_CONSDISABLE((*consdisable)), SCIP_DECL_CONSDELVARS((*consdelvars)), SCIP_DECL_CONSPRINT((*consprint)), SCIP_DECL_CONSCOPY((*conscopy)), SCIP_DECL_CONSPARSE((*consparse)), SCIP_DECL_CONSGETVARS((*consgetvars)), SCIP_DECL_CONSGETNVARS((*consgetnvars)), SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)), SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)), SCIP_CONSHDLRDATA *conshdlrdata)

void SCIPconshdlrEnableOrDisableClocks(SCIP_CONSHDLR *conshdlr, SCIP_Bool enable)

static SCIP_RETCODE conssetchgDelDisabledCons(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int arraypos)

SCIP_RETCODE SCIPconsTransform(SCIP_CONS *origcons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS **transcons)

static SCIP_Bool consExceedsAgelimit(SCIP_CONS *cons, SCIP_SET *set)

static SCIP_RETCODE conshdlrAddSepacons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)

SCIP_RETCODE SCIPconsCheck(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)

#define AGERESETAVG_OBSOLETEAGE

static void conshdlrDelEnfocons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

SCIP_RETCODE SCIPconssetchgAddAddedCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons, int depth, SCIP_Bool focusnode, SCIP_Bool active)

SCIP_RETCODE SCIPconshdlrInitLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Bool initkeptconss, SCIP_Bool *cutoff)

static SCIP_RETCODE conshdlrDisableConsPropagation(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

static SCIP_RETCODE conshdlrEnsureConssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)

void SCIPconshdlrSetDisable(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))

static void conshdlrUnmarkConsPropagate(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

static void conshdlrMarkConsPropagate(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

SCIP_RETCODE SCIPconsAddAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_Real deltaage, SCIP_REOPT *reopt)

void SCIPconshdlrSetGetSignedPermsymGraph(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)))

SCIP_RETCODE SCIPconsEnablePropagation(SCIP_CONS *cons, SCIP_SET *set)

static void conshdlrDelCheckcons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

static void conshdlrDelayUpdates(SCIP_CONSHDLR *conshdlr)

SCIP_DECL_HASHGETKEY(SCIPhashGetKeyCons)

static void conshdlrDelInitcons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

static SCIP_RETCODE conshdlrForceUpdates(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPconsEnfolp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_RESULT *result)

static SCIP_RETCODE conshdlrAddCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)

SCIP_RETCODE SCIPconsSetInitial(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool initial)

SCIP_RETCODE SCIPconssetchgFree(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set)

static SCIP_RETCODE conshdlrEnsureEnfoconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)

SCIP_RETCODE SCIPconsChgName(SCIP_CONS *cons, BMS_BLKMEM *blkmem, const char *name)

static SCIP_RETCODE conshdlrDisableCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)

SCIP_RETCODE SCIPconsIncAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)

void SCIPconshdlrSetExitsol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))

static SCIP_Bool consExceedsObsoleteage(SCIP_CONS *cons, SCIP_SET *set)

SCIP_RETCODE SCIPconshdlrInitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

void SCIPconsSetDynamic(SCIP_CONS *cons, SCIP_Bool dynamic)

SCIP_RETCODE SCIPconsSepasol(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_RESULT *result)

SCIP_RETCODE SCIPconsFree(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)

static SCIP_RETCODE conshdlrMarkConsUseful(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

static SCIP_RETCODE conshdlrEnableConsPropagation(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)

SCIP_RETCODE SCIPconssetchgAddDisabledCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS *cons)

SCIP_RETCODE SCIPconsDelete(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)

SCIP_RETCODE SCIPconsPresol(SCIP_CONS *cons, SCIP_SET *set, int nrounds, SCIP_PRESOLTIMING timing, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)

SCIP_RETCODE SCIPconsDisablePropagation(SCIP_CONS *cons, SCIP_SET *set)

void SCIPconshdlrSetResprop(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))

SCIP_RETCODE SCIPconsCopy(SCIP_CONS **cons, SCIP_SET *set, const char *name, SCIP *sourcescip, SCIP_CONSHDLR *sourceconshdlr, SCIP_CONS *sourcecons, 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)

static void conshdlrDelCons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)

void SCIPconshdlrSetInitlp(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))

SCIP_RETCODE SCIPconsResolvePropagation(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE inferboundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)

SCIP_RETCODE SCIPconsSetPropagated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool propagate)

SCIP_RETCODE SCIPconsDisableSeparation(SCIP_CONS *cons, SCIP_SET *set)

void SCIPconshdlrSetGetDiveBdChgs(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))

static SCIP_RETCODE conshdlrEnsureSepaconssMem(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, int num)

SCIP_RETCODE SCIPconsGetSignedPermsymGraph(SCIP_CONS *cons, SCIP_SET *set, SYM_GRAPH *graph, SCIP_Bool *success)

SCIP_RETCODE SCIPconshdlrUnlockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)

SCIP_RETCODE SCIPconsSetChecked(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool check)

SCIP_RETCODE SCIPconsInitlp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool *infeasible)

SCIP_RETCODE SCIPconsEnforelax(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)

static SCIP_RETCODE conshdlrAddUpdateCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)

static SCIP_RETCODE doConshdlrCreate(SCIP_CONSHDLR **conshdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int sepapriority, int enfopriority, int checkpriority, int sepafreq, int propfreq, int eagerfreq, int maxprerounds, SCIP_Bool delaysepa, SCIP_Bool delayprop, SCIP_Bool needscons, SCIP_PROPTIMING proptiming, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSFREE((*consfree)), SCIP_DECL_CONSINIT((*consinit)), SCIP_DECL_CONSEXIT((*consexit)), SCIP_DECL_CONSINITPRE((*consinitpre)), SCIP_DECL_CONSEXITPRE((*consexitpre)), SCIP_DECL_CONSINITSOL((*consinitsol)), SCIP_DECL_CONSEXITSOL((*consexitsol)), SCIP_DECL_CONSDELETE((*consdelete)), SCIP_DECL_CONSTRANS((*constrans)), SCIP_DECL_CONSINITLP((*consinitlp)), SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFORELAX((*consenforelax)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSPROP((*consprop)), SCIP_DECL_CONSPRESOL((*conspresol)), SCIP_DECL_CONSRESPROP((*consresprop)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_DECL_CONSACTIVE((*consactive)), SCIP_DECL_CONSDEACTIVE((*consdeactive)), SCIP_DECL_CONSENABLE((*consenable)), SCIP_DECL_CONSDISABLE((*consdisable)), SCIP_DECL_CONSDELVARS((*consdelvars)), SCIP_DECL_CONSPRINT((*consprint)), SCIP_DECL_CONSCOPY((*conscopy)), SCIP_DECL_CONSPARSE((*consparse)), SCIP_DECL_CONSGETVARS((*consgetvars)), SCIP_DECL_CONSGETNVARS((*consgetnvars)), SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)), SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)), SCIP_CONSHDLRDATA *conshdlrdata)

SCIP_RETCODE SCIPconshdlrsResetPropagationStatus(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)

void SCIPconshdlrSetExit(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))

SCIP_RETCODE SCIPconshdlrCopyInclude(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_Bool *valid)

SCIP_RETCODE SCIPconsActivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)

static SCIP_RETCODE conshdlrAddEnfocons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)

static SCIP_RETCODE conshdlrEnableConsSeparation(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)

void SCIPconshdlrSetCopy(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))

void SCIPconshdlrSetDelvars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))

static void conshdlrDelSepacons(SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

void SCIPconshdlrSetEnable(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))

SCIP_CONS * SCIPconsGetTransformed(SCIP_CONS *cons)

#define AGERESETAVG_DECAY

void SCIPconshdlrSetPrint(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))

SCIP_RETCODE SCIPconshdlrPropagate(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool fullpropagation, SCIP_Bool execdelayed, SCIP_Bool instrongbranching, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)

SCIP_RETCODE SCIPconsUnmarkPropagate(SCIP_CONS *cons, SCIP_SET *set)

SCIP_RETCODE SCIPconshdlrGetDiveBoundChanges(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)

static void conshdlrUpdateAgeresetavg(SCIP_CONSHDLR *conshdlr, SCIP_Real age)

void SCIPconshdlrSetDeactive(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))

static SCIP_RETCODE conshdlrAddPropcons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_CONS *cons)

SCIP_RETCODE SCIPconshdlrPresolve(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRESOLTIMING timing, int nrounds, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)

SCIP_RETCODE SCIPconsGetVars(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR **vars, int varssize, SCIP_Bool *success)

void SCIPconsSetNamePointer(SCIP_CONS *cons, const char *name)

SCIP_RETCODE SCIPconshdlrEnforcePseudoSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_BRANCHCAND *branchcand, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_Bool forced, SCIP_RESULT *result)

SCIP_RETCODE SCIPconssetchgApply(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)

SCIP_RETCODE SCIPconshdlrDelVars(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPconsSetEnforced(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool enforce)

void SCIPconsSetModifiable(SCIP_CONS *cons, SCIP_Bool modifiable)

void SCIPconshdlrSetGetVars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))

static SCIP_RETCODE conshdlrDeactivateCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)

void SCIPconshdlrSetExitpre(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))

SCIP_RETCODE SCIPconshdlrExitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPconshdlrInitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPconssetchgMakeGlobal(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)

SCIP_RETCODE SCIPconshdlrCheck(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT *result)

SCIP_RETCODE SCIPconshdlrExit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

static SCIP_RETCODE conshdlrActivateCons(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons, int depth, SCIP_Bool focusnode)

SCIP_RETCODE SCIPconshdlrFree(SCIP_CONSHDLR **conshdlr, SCIP_SET *set)

internal methods for constraints and constraint handlers

common defines and data types used in all packages of SCIP

#define SCIP_MAXTREEDEPTH

#define SCIP_CALL_FINALLY(x, y)

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

int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)

void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)

int SCIPconshdlrGetMaxNActiveConss(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetCheckTime(SCIP_CONSHDLR *conshdlr)

SCIP_PROPTIMING SCIPconshdlrGetPropTiming(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrWasSolSeparationDelayed(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNCheckCalls(SCIP_CONSHDLR *conshdlr)

SCIP_CONS ** SCIPconshdlrGetCheckConss(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNChgSides(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetPresolTime(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetEagerFreq(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrDoesPresolve(SCIP_CONSHDLR *conshdlr)

void SCIPconshdlrSetProp(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING timingmask)

int SCIPconshdlrGetNFixedVars(SCIP_CONSHDLR *conshdlr)

SCIP_PRESOLTIMING SCIPconshdlrGetPresolTiming(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetEnfoLPTime(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNPresolCalls(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNDomredsFound(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNCutsApplied(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNChgCoefs(SCIP_CONSHDLR *conshdlr)

void SCIPconshdlrSetPresolTiming(SCIP_CONSHDLR *conshdlr, SCIP_PRESOLTIMING presoltiming)

int SCIPconshdlrGetNUpdateConss(SCIP_CONSHDLR *conshdlr)

SCIP_CONS ** SCIPconshdlrGetEnfoConss(SCIP_CONSHDLR *conshdlr)

void SCIPconshdlrSetSepa(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)

SCIP_Real SCIPconshdlrGetStrongBranchPropTime(SCIP_CONSHDLR *conshdlr)

void SCIPconshdlrSetEnforelax(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))

SCIP_Longint SCIPconshdlrGetNCutsFound(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrSupportsSignedPermsymDetection(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrIsPropagationDelayed(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetPropTime(SCIP_CONSHDLR *conshdlr)

void SCIPconssetchgGetAddedConsData(SCIP_CONSSETCHG *conssetchg, SCIP_CONS ***conss, int *nconss)

SCIP_Real SCIPconshdlrGetEnfoPSTime(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetPropFreq(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNCutoffs(SCIP_CONSHDLR *conshdlr)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNEnabledConss(SCIP_CONSHDLR *conshdlr)

SCIP_CONS ** SCIPconshdlrGetUpdateConss(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrIsSeparationDelayed(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNSepaCalls(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNDelConss(SCIP_CONSHDLR *conshdlr)

SCIP_DECL_SORTPTRCOMP(SCIPconshdlrCompSepa)

SCIP_Bool SCIPconshdlrWasLPSeparationDelayed(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNChildren(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetEnfoRelaxTime(SCIP_CONSHDLR *conshdlr)

void SCIPconshdlrSetPropTiming(SCIP_CONSHDLR *conshdlr, SCIP_PROPTIMING proptiming)

SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNAggrVars(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNEnfoPSCalls(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNAddHoles(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNEnfoConss(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrIsInitialized(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNUpgdConss(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetStartNActiveConss(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrWasPropagationDelayed(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNAddConss(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrSupportsPermsymDetection(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNChgBds(SCIP_CONSHDLR *conshdlr)

const char * SCIPconshdlrGetDesc(SCIP_CONSHDLR *conshdlr)

SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNConssFound(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetCheckPriority(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetSepaFreq(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNPropCalls(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNEnfoLPCalls(SCIP_CONSHDLR *conshdlr)

SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetEnfoPriority(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetSetupTime(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNRespropCalls(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetSepaTime(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrIsClonable(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNChgVarTypes(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetRespropTime(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNEnfoRelaxCalls(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconsIsLockedNeg(SCIP_CONS *cons)

SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)

void SCIPconsAddUpgradeLocks(SCIP_CONS *cons, int nlocks)

int SCIPconsGetPos(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsConflict(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_Real SCIPconsGetAge(SCIP_CONS *cons)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

int SCIPconsGetActiveDepth(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLockedPos(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsPropagationEnabled(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

int SCIPconsGetNUpgradeLocks(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)

int SCIPconsGetNLocksTypeNeg(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)

int SCIPconsGetValidDepth(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsOriginal(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsUpdatedeactivate(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)

int SCIPconsGetNLocksPos(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLockedType(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)

SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInProb(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsGlobal(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)

int SCIPconsGetNLocksNeg(SCIP_CONS *cons)

int SCIPconsGetNUses(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLockedTypePos(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)

SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLocked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsSeparationEnabled(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLockedTypeNeg(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)

SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsAdded(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsObsolete(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)

int SCIPconsGetNLocksTypePos(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)

SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

int SCIPlinConsStatsGetSum(SCIP_LINCONSSTATS *linconsstats)

void SCIPlinConsStatsIncTypeCount(SCIP_LINCONSSTATS *linconsstats, SCIP_LINCONSTYPE linconstype, int increment)

int SCIPlinConsStatsGetTypeCount(SCIP_LINCONSSTATS *linconsstats, SCIP_LINCONSTYPE linconstype)

void SCIPlinConsStatsFree(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)

void SCIPlinConsStatsReset(SCIP_LINCONSSTATS *linconsstats)

void SCIPprintLinConsStats(SCIP *scip, FILE *file, SCIP_LINCONSSTATS *linconsstats)

SCIP_RETCODE SCIPlinConsStatsCreate(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

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

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

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

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

void SCIPstrCopySection(const char *str, char startchar, char endchar, char *token, int size, char **endptr)

SCIP_RETCODE SCIPskipSpace(char **s)

static const char * paramname[]

#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)

#define BMSfreeMemory(ptr)

#define BMSfreeBlockMemory(mem, ptr)

#define BMSallocBlockMemory(mem, ptr)

#define BMSreallocMemoryArray(ptr, num)

#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)

#define BMSduplicateMemoryArray(ptr, source, num)

#define BMSclearMemory(ptr)

#define BMScopyMemoryArray(ptr, source, num)

#define BMSfreeBlockMemoryArray(mem, ptr, num)

#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)

#define BMSclearMemoryArray(ptr, num)

struct BMS_BlkMem BMS_BLKMEM

#define BMSfreeMemoryArrayNull(ptr)

#define BMSallocMemory(ptr)

void SCIPmessagePrintError(const char *formatstr,...)

void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)

void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)

SCIP_RETCODE SCIPprobDelCons(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)

SCIP_RETCODE SCIPprobAddCons(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)

internal methods for storing and manipulating the main problem

public data structures and miscellaneous methods

SCIP_Bool SCIPreoptConsCanBeDeleted(SCIP_REOPT *reopt, SCIP_CONS *cons)

data structures and methods for collecting reoptimization information

int SCIPsepastoreGetNCuts(SCIP_SEPASTORE *sepastore)

internal methods for storing separated cuts

SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, 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 SCIPsetAddBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

SCIP_CONSHDLR * SCIPsetFindConshdlr(SCIP_SET *set, const char *name)

SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)

int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)

internal methods for global SCIP settings

internal methods for problem statistics

SCIP_CONS ** disabledconss

unsigned int nupgradelocks

int nlocksneg[NLOCKTYPES]

unsigned int updatesepaenable

unsigned int updateobsolete

unsigned int updatesepadisable

SCIP_CONSSETCHG * addconssetchg

unsigned int updateenable

unsigned int updateactfocus

unsigned int updateunmarkpropagate

unsigned int updateactivate

SCIP_CONS * transorigcons

unsigned int updatedisable

unsigned int updatedeactivate

unsigned int updatepropenable

unsigned int stickingatnode

int nlockspos[NLOCKTYPES]

unsigned int markpropagate

unsigned int updatemarkpropagate

unsigned int updatepropdisable

unsigned int updateinsert

SCIP_RESULT lastenfolpresult

SCIP_Longint ndomredsfound

SCIP_PRESOLTIMING presoltiming

SCIP_Longint lastenfolpdomchgcount

SCIP_CLOCK * enforelaxtime

int storednmarkedpropconss

SCIP_Longint nenfolpcalls

SCIP_RESULT lastenfopsresult

SCIP_Longint nenforelaxcalls

SCIP_Longint lastsepalpcount

SCIP_Longint lastenfolplpcount

SCIP_Bool sepasolwasdelayed

SCIP_Bool sepalpwasdelayed

SCIP_Longint ncutsapplied

SCIP_RESULT lastenforelaxresult

SCIP_Longint nenfopscalls

SCIP_Longint lastenforelaxrelaxcount

SCIP_Longint storedpropdomchgcount

SCIP_Longint lastenfolpnode

SCIP_PROPTIMING proptiming

SCIP_Longint lastenforelaxnode

SCIP_CONS ** storedpropconss

SCIP_Longint lastpropdomchgcount

SCIP_Longint lastenfopsnode

SCIP_Longint lastenforelaxdomchgcount

SCIP_Longint nrespropcalls

SCIP_CONSHDLRDATA * conshdlrdata

SCIP_Longint lastenfopsdomchgcount

int counter[SCIP_NLINCONSTYPES]

SCIP_Longint nprobholechgs

SCIP_Longint ninitconssadded

SCIP_Longint nprobboundchgs

datastructures for constraints and constraint handlers

SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)

int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)

internal methods for branch and bound tree

#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)

#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)

#define SCIP_DECL_CONSINITPRE(x)

#define SCIP_DECL_CONSEXIT(x)

#define SCIP_DECL_CONSGETVARS(x)

#define SCIP_DECL_CONSINITSOL(x)

struct SCIP_ConshdlrData SCIP_CONSHDLRDATA

#define SCIP_DECL_CONSDISABLE(x)

#define SCIP_DECL_CONSENFORELAX(x)

#define SCIP_DECL_CONSGETDIVEBDCHGS(x)

#define SCIP_DECL_CONSGETNVARS(x)

#define SCIP_DECL_CONSRESPROP(x)

@ SCIP_LINCONSTYPE_BINPACKING

@ SCIP_LINCONSTYPE_VARBOUND

@ SCIP_LINCONSTYPE_INVKNAPSACK

@ SCIP_LINCONSTYPE_PRECEDENCE

@ SCIP_LINCONSTYPE_AGGREGATION

@ SCIP_LINCONSTYPE_MIXEDBINARY

@ SCIP_LINCONSTYPE_SINGLETON

@ SCIP_LINCONSTYPE_SETCOVERING

@ SCIP_LINCONSTYPE_EQKNAPSACK

@ SCIP_LINCONSTYPE_KNAPSACK

@ SCIP_LINCONSTYPE_SETPARTITION

@ SCIP_LINCONSTYPE_INTKNAPSACK

@ SCIP_LINCONSTYPE_SETPACKING

@ SCIP_LINCONSTYPE_GENERAL

@ SCIP_LINCONSTYPE_CARDINALITY

#define SCIP_DECL_CONSACTIVE(x)

#define SCIP_DECL_CONSPARSE(x)

#define SCIP_DECL_CONSDEACTIVE(x)

#define SCIP_DECL_CONSPRESOL(x)

#define SCIP_DECL_CONSENABLE(x)

#define SCIP_DECL_CONSINITLP(x)

#define SCIP_DECL_CONSEXITPRE(x)

#define SCIP_DECL_CONSINIT(x)

struct SCIP_ConsData SCIP_CONSDATA

#define SCIP_DECL_CONSHDLRCOPY(x)

#define SCIP_DECL_CONSEXITSOL(x)

#define SCIP_NLINCONSTYPES

#define SCIP_DECL_CONSFREE(x)

enum SCIP_LinConstype SCIP_LINCONSTYPE

enum SCIP_BoundType SCIP_BOUNDTYPE

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

#define SCIP_PRESOLTIMING_MAX

#define SCIP_PRESOLTIMING_FINAL

unsigned int SCIP_PROPTIMING

#define SCIP_PRESOLTIMING_MEDIUM

unsigned int SCIP_PRESOLTIMING

#define SCIP_PROPTIMING_AFTERLPLOOP

#define SCIP_PRESOLTIMING_FAST

#define SCIP_PRESOLTIMING_EXHAUSTIVE

#define SCIP_PROPTIMING_BEFORELP

#define SCIP_PROPTIMING_ALWAYS

#define SCIP_PROPTIMING_DURINGLPLOOP

enum SCIP_LockType SCIP_LOCKTYPE

internal methods for problem variables

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