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

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

SCIP Doxygen Documentation: scip_solvingstats.c Source File

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nruns;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nreoptruns;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nnodes;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->ntotalnodes;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nfeasleaves;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->ninfeasleaves;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nobjleaves;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nrootboundchgs;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nrootboundchgsrun;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->ndelayedcutoffs;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nlps;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nlpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nnz;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nrootlpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nrootfirstlpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nprimallps;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nprimallpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nduallps;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nduallpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nbarrierlps;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nbarrierlpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nprimalresolvelps +

->stat->ndualresolvelps;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nprimalresolvelpiterations +

->stat->ndualresolvelpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nprimalresolvelps;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nprimalresolvelpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->ndualresolvelps;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->ndualresolvelpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nnodelps;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nnodezeroitlps;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nnodelpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->ninitlps;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->ninitlpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->ndivinglps;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->ndivinglpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nstrongbranchs;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nsblpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nrootstrongbranchs;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nrootsblpiterations;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->npricerounds;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nseparounds;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->maxdepth;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->maxtotaldepth;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nbacktracks;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nactiveconss;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nenabledconss;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->transprob->dualbound;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( treelowerbound < scip->primal->upperbound)

treelowerbound;

->primal->upperbound;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->rootlowerbound;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->firstlpdualbound;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->firstprimalbound;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->primal->upperbound;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->primal->cutoffbound;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->primal->nsolsfound;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->primal->nlimsolsfound;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->primal->nbestsolsfound;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

/

(

->transprob->nbinvars +

->transprob->nintvars, 1);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

/

(

->transprob->nbinvars +

->transprob->nintvars, 1);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

history = (onlycurrentrun ?

->stat->glbhistorycrun :

->stat->glbhistory);

assert(history !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

history = (onlycurrentrun ?

->stat->glbhistorycrun :

->stat->glbhistory);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

scale =

->transprob->nvars *

->stat->vsidsweight;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

scale =

->transprob->nvars *

->stat->vsidsweight;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

1e-6 *

->stat->nnz * (

0.00328285264101 *

->stat->nprimalresolvelpiterations +

0.00531625104146 *

->stat->ndualresolvelpiterations +

0.000738719124051 *

->stat->nprobboundchgs +

0.0011123144764 *

->stat->nisstoppedcalls );

* extension,

assert(prob !=

);

( extension !=

)

retcode =

(

->set->readers[i], prob,

->set,

->messagehdlr, file, extension, genericnames, &result);

assert(i < scip->

->nreaders);

(

,

* extension,

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

* extension,

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(

->transprob !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->messagehdlr, file,

);

( i = 0; i <

->set->npresols; ++i )

presol =

->set->presols[i];

( i = 0; i <

->set->nprops; ++i )

prop =

->set->props[i];

( i = 0; i <

->set->nconshdlrs; ++i )

maxnactiveconss;

conshdlr =

->set->conshdlrs[i];

->stat->nrootintfixings,

->stat->nrootboundchgs);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->messagehdlr, file,

);

( i = 0; i <

->set->nconshdlrs; ++i )

startnactiveconss;

maxnactiveconss;

conshdlr =

->set->conshdlrs[i];

maxnactiveconss > startnactiveconss ?

:

,

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->messagehdlr, file,

);

( i = 0; i <

->set->nconshdlrs; ++i )

maxnactiveconss;

conshdlr =

->set->conshdlrs[i];

(

->messagehdlr, file,

,

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( i = 0; i <

->set->nprops; ++i )

prop =

->set->props[i];

(

->messagehdlr, file,

);

( i = 0; i <

->set->nprops; ++i )

prop =

->set->props[i];

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->conf_maxstoresize == 0 )

( maxsize == -1 )

assert(initsize >= 0);

assert(maxsize >= 0);

(

->messagehdlr, file,

, initstoresize, maxstoresize);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->messagehdlr, file,

);

( i = 0; i <

->set->nsepas; ++i )

sepa =

->set->sepas[i];

( k = 0; k <

->set->nsepas; ++k )

( parentsepa != sepa )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->messagehdlr, file,

);

( i = 0; i <

->set->ncutsels; ++i )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( i = 0; i <

->set->nactivepricers; ++i )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->messagehdlr, file,

);

( i = 0; i <

->set->nbranchrules; ++i )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nlpsolsfound,

->stat->nlpbestsolsfound);

->stat->nrelaxsolsfound,

->stat->nrelaxbestsolsfound);

->stat->npssolsfound,

->stat->npsbestsolsfound);

->stat->nsbsolsfound,

->stat->nsbbestsolsfound);

( i = 0; i <

->set->nheurs; ++i )

->stat->nexternalsolsfound);

( ndivesets > 0 &&

->set->misc_showdivingstats )

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

,

);

,

( i = 0; i <

->set->nheurs; ++i )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( !

->set->reopt_enable )

( i = 0; i <

->set->ncomprs; ++i )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->messagehdlr, file,

);

->stat->nprimallps +

->stat->nprimalzeroitlps,

->stat->nprimallpiterations,

->stat->primalzeroittime,

->stat->nprimalzeroitlps);

->stat->nduallps +

->stat->ndualzeroitlps,

->stat->nduallpiterations,

->stat->dualzeroittime,

->stat->ndualzeroitlps);

->stat->nlexduallps,

->stat->nlexduallpiterations,

->stat->nbarrierlps,

->stat->nbarrierlpiterations,

->stat->barrierzeroittime,

->stat->nbarrierzeroitlps);

->stat->nresolveinstablelps,

->stat->nresolveinstablelpiters,

->stat->ndivinglps,

->stat->ndivinglpiterations,

->stat->nstrongbranchs,

->stat->nsblpiterations,

->stat->nrootstrongbranchs,

->stat->nrootsblpiterations,

->stat->nrootstrongbranchs > 0

->stat->nconflictlps,

->stat->nconflictlpiterations,

nnlrowconvexineq;

nnlrownonconvexineq;

nnlrownonlineareq;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nnlps);

(

->messagehdlr, file,

,

(nnlrownonconvexineq == 0 && nnlrownonlineareq == 0) ?

:

,

nnlrowlinear, nnlrowconvexineq, nnlrownonconvexineq, nnlrownonlineareq);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->nrelaxs == 0 )

(

->messagehdlr, file,

);

( i = 0; i <

->set->nrelaxs; ++i )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nnodes,

->stat->ninternalnodes,

->stat->nnodes -

->stat->ninternalnodes );

->stat->ntotalnodes,

->stat->ntotalinternalnodes,

->stat->ntotalnodes -

->stat->ntotalinternalnodes);

->stat->nreprops,

->stat->nrepropboundchgs,

->stat->nrepropcutoffs);

->stat->nnodes > 0

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

objlimitreached =

;

objlimitreached =

;

(

->primal->nsolsfound !=

->primal->nlimsolsfound )

limsolstring[0] =

;

->primal->nsolsfound,

->primal->nbestsolsfound, limsolstring);

(

->primal->nlimsolsfound == 0 )

assert(!objlimitreached);

( objlimitreached )

assert(!objlimitreached);

(

->primal->nlimsolsfound == 0 )

(

->primal->nsolsfound > 0 )

firstprimalbound =

->stat->firstprimalbound;

->stat->nrunsbeforefirst,

->stat->nnodesbeforefirst,

->stat->firstprimaltime,

->stat->firstprimaldepth,

(

->stat->firstprimalheur !=

)

: ((

->stat->nrunsbeforefirst == 0 ) ?

:

));

(

->set->misc_calcintegral )

* names[] = {

( s = 0; s < 3; ++s )

names[s],

,

);

( s = 0; s < 3; ++s )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( nconcsolvers > 0 )

(

->messagehdlr, file,

);

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

winner == i ?

:

,

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->messagehdlr, file,

);

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

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

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( firstlptime > 0.0 )

firstlpspeed = (

)

->stat->nrootfirstlpiterations/firstlptime;

( firstlpspeed > 0.0 )

->stat->nrootfirstlpiterations,

(

)

->stat->nrootfirstlpiterations/firstlptime);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->time_reading )

totaltime = solvingtime;

totaltime = solvingtime + readingtime;

(

->messagehdlr, file,

, readingtime,

->set->time_reading ?

:

);

(

->stat->ncopies > 0 )

(

->messagehdlr, file,

,

copytime,

->stat->ncopies,

->stat->mincopytime,

->stat->maxcopytime, copytime /

->stat->ncopies);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( i = 0; i <

->set->nexprhdlrs; ++i )

assert(exprhdlr !=

);

( !headerprinted )

,

,

,

,

,

,

,

,

,

,

,

,

);

headerprinted =

;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( i = 0; i <

->set->nnlpis; ++i )

nlpi =

->set->nlpis[i];

assert(nlpi !=

);

( !printedheader )

,

,

,

,

,

->set->time_nlpieval ?

:

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

printedheader =

;

(

->set->time_nlpieval )

(

->set->time_nlpieval )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( !

->set->tablessorted )

((

**)tables, tablePosComp, ntables);

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

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( !

->set->reopt_enable )

(

->stat->nreoptruns > 0 )

(

->stat->nreoptruns > 0 )

totalnstrongbranchs;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

( v = 0; v <

->transprob->nvars; ++v )

var =

->transprob->vars[v];

vars[i] = vars[i-1];

(

->messagehdlr, file,

);

(

->messagehdlr, file,

);

totalnstrongbranchs = 0;

( v = 0; v <

->transprob->nvars; ++v )

totalnstrongbranchs += nstrongbranchs;

totalnstrongbranchs,

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->nimplications;

* filename

(

,

);

(

->primal->nsols == 1 )

->stat->firstsolgap =

->stat->lastsolgap;

(

->set->misc_calcintegral )

( upperbound < scip->stat->lastupperbound )

SCIP_Real SCIPbranchGetScore(SCIP_SET *set, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)

internal methods for branching rules and branching candidate storage

SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)

internal methods for clocks and timing issues

SCIP_Longint SCIPconcsolverGetNNodes(SCIP_CONCSOLVER *concsolver)

SCIP_Longint SCIPconcsolverGetNSolsRecvd(SCIP_CONCSOLVER *concsolver)

SCIP_Real SCIPconcsolverGetSyncTime(SCIP_CONCSOLVER *concsolver)

SCIP_Longint SCIPconcsolverGetNTighterIntBnds(SCIP_CONCSOLVER *concsolver)

SCIP_Real SCIPconcsolverGetSolvingTime(SCIP_CONCSOLVER *concsolver)

SCIP_Longint SCIPconcsolverGetNTighterBnds(SCIP_CONCSOLVER *concsolver)

SCIP_Longint SCIPconcsolverGetNLPIterations(SCIP_CONCSOLVER *concsolver)

char * SCIPconcsolverGetName(SCIP_CONCSOLVER *concsolver)

SCIP_Longint SCIPconcsolverGetNSolsShared(SCIP_CONCSOLVER *concsolver)

datastructures for concurrent solvers

SCIP_CONCSOLVER ** SCIPgetConcurrentSolvers(SCIP *scip)

int SCIPgetNConcurrentSolvers(SCIP *scip)

helper functions for concurrent scip solvers

internal methods for conflict analysis

int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNAppliedGlobalConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNDualproofsInfLocal(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNAppliedLocalLiterals(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPropCalls(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNDualproofsInfNonzeros(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNStrongbranchIterations(SCIP_CONFLICT *conflict)

SCIP_Real SCIPconflictGetInfeasibleLPTime(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNInfeasibleLPCalls(SCIP_CONFLICT *conflict)

SCIP_Real SCIPconflictGetGlobalApplTime(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNInfeasibleLPSuccess(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNGlobalChgBds(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPropConflictLiterals(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNAppliedConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNInfeasibleLPConflictConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNBoundexceedingLPSuccess(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNStrongbranchCalls(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceLiterals(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPropReconvergenceConss(SCIP_CONFLICT *conflict)

SCIP_Real SCIPconflictGetBoundexceedingLPTime(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceLiterals(SCIP_CONFLICT *conflict)

SCIP_Real SCIPconflictGetPseudoTime(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPseudoReconvergenceLiterals(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPropReconvergenceLiterals(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNAppliedLocalConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictLiterals(SCIP_CONFLICT *conflict)

SCIP_Real SCIPconflictGetStrongbranchTime(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPseudoSuccess(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNInfeasibleLPConflictLiterals(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPseudoConflictLiterals(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNLocalChgBds(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNDualproofsBndSuccess(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPropSuccess(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNDualproofsInfSuccess(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNBoundexceedingLPCalls(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPropConflictConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNStrongbranchSuccess(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNDualproofsBndGlobal(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPseudoReconvergenceConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNAppliedGlobalLiterals(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNDualproofsBndLocal(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPseudoCalls(SCIP_CONFLICT *conflict)

SCIP_Real SCIPconflictGetPropTime(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNBoundexceedingLPIterations(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNStrongbranchConflictLiterals(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPseudoConflictConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNDualproofsBndNonzeros(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNDualproofsInfGlobal(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceLiterals(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNStrongbranchConflictConss(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNInfeasibleLPIterations(SCIP_CONFLICT *conflict)

int SCIPconflictstoreGetMaxPoolSize(SCIP_CONFLICTSTORE *conflictstore)

int SCIPconflictstoreGetInitPoolSize(SCIP_CONFLICTSTORE *conflictstore)

internal methods for storing conflicts

SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)

#define SCIP_CALL_ABORT(x)

#define SCIP_LONGINT_FORMAT

SCIP_RETCODE SCIPdispPrintLine(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, FILE *file, SCIP_Bool forcedisplay, SCIP_Bool endline)

internal methods for displaying runtime statistics

SCIP_RETCODE SCIPprintStage(SCIP *scip, FILE *file)

SCIP_STATUS SCIPgetStatus(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

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

SCIP_Real SCIPcomputeGap(SCIP_Real eps, SCIP_Real inf, SCIP_Real primalbound, SCIP_Real dualbound)

int SCIPgetNActiveBenders(SCIP *scip)

SCIP_Real SCIPbendersGetSetupTime(SCIP_BENDERS *benders)

int SCIPbendersGetNTransferredCuts(SCIP_BENDERS *benders)

int SCIPbendersGetNStrengthenFails(SCIP_BENDERS *benders)

SCIP_BENDERS ** SCIPgetBenders(SCIP *scip)

int SCIPgetNBenders(SCIP *scip)

int SCIPbendersGetNStrengthenCalls(SCIP_BENDERS *benders)

int SCIPbendersGetNBenderscuts(SCIP_BENDERS *benders)

SCIP_Bool SCIPbendersIsActive(SCIP_BENDERS *benders)

const char * SCIPbendersGetName(SCIP_BENDERS *benders)

int SCIPbendersGetNStrengthenCutsFound(SCIP_BENDERS *benders)

int SCIPbendersGetNCalls(SCIP_BENDERS *benders)

int SCIPbendersGetNCutsFound(SCIP_BENDERS *benders)

SCIP_Real SCIPbendersGetTime(SCIP_BENDERS *benders)

SCIP_BENDERSCUT ** SCIPbendersGetBenderscuts(SCIP_BENDERS *benders)

const char * SCIPbenderscutGetName(SCIP_BENDERSCUT *benderscut)

SCIP_Longint SCIPbenderscutGetNCalls(SCIP_BENDERSCUT *benderscut)

SCIP_Real SCIPbenderscutGetTime(SCIP_BENDERSCUT *benderscut)

SCIP_Real SCIPbenderscutGetSetupTime(SCIP_BENDERSCUT *benderscut)

SCIP_Longint SCIPbenderscutGetNFound(SCIP_BENDERSCUT *benderscut)

SCIP_Longint SCIPbranchruleGetNDomredsFound(SCIP_BRANCHRULE *branchrule)

SCIP_Longint SCIPbranchruleGetNPseudoCalls(SCIP_BRANCHRULE *branchrule)

SCIP_Longint SCIPbranchruleGetNConssFound(SCIP_BRANCHRULE *branchrule)

SCIP_Longint SCIPbranchruleGetNLPCalls(SCIP_BRANCHRULE *branchrule)

const char * SCIPbranchruleGetName(SCIP_BRANCHRULE *branchrule)

SCIP_Longint SCIPbranchruleGetNChildren(SCIP_BRANCHRULE *branchrule)

SCIP_Real SCIPbranchruleGetTime(SCIP_BRANCHRULE *branchrule)

SCIP_Real SCIPbranchruleGetSetupTime(SCIP_BRANCHRULE *branchrule)

SCIP_Longint SCIPbranchruleGetNCutoffs(SCIP_BRANCHRULE *branchrule)

SCIP_Longint SCIPbranchruleGetNExternCalls(SCIP_BRANCHRULE *branchrule)

SCIP_Longint SCIPbranchruleGetNCutsFound(SCIP_BRANCHRULE *branchrule)

SCIP_Longint SCIPcomprGetNCalls(SCIP_COMPR *compr)

SCIP_Longint SCIPcomprGetNFound(SCIP_COMPR *compr)

SCIP_Real SCIPcomprGetSetupTime(SCIP_COMPR *compr)

SCIP_Real SCIPcomprGetTime(SCIP_COMPR *compr)

const char * SCIPcomprGetName(SCIP_COMPR *compr)

int SCIPconshdlrGetMaxNActiveConss(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetCheckTime(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNCheckCalls(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNChgSides(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetPresolTime(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrDoesPresolve(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNFixedVars(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetEnfoLPTime(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNPresolCalls(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNDomredsFound(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNCutsApplied(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNChgCoefs(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetStrongBranchPropTime(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNCutsFound(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetPropTime(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetEnfoPSTime(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNCutoffs(SCIP_CONSHDLR *conshdlr)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNSepaCalls(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNDelConss(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNChildren(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetEnfoRelaxTime(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNAggrVars(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNEnfoPSCalls(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNAddHoles(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNUpgdConss(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetStartNActiveConss(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNAddConss(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNChgBds(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNConssFound(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNPropCalls(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNEnfoLPCalls(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetSetupTime(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNRespropCalls(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetSepaTime(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNChgVarTypes(SCIP_CONSHDLR *conshdlr)

SCIP_Real SCIPconshdlrGetRespropTime(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPconshdlrGetNEnfoRelaxCalls(SCIP_CONSHDLR *conshdlr)

SCIP_Longint SCIPcutpoolGetNRootCalls(SCIP_CUTPOOL *cutpool)

SCIP_Longint SCIPcutpoolGetNCutsFound(SCIP_CUTPOOL *cutpool)

SCIP_Real SCIPcutpoolGetTime(SCIP_CUTPOOL *cutpool)

SCIP_Longint SCIPcutpoolGetMaxNCuts(SCIP_CUTPOOL *cutpool)

SCIP_Longint SCIPcutpoolGetNCalls(SCIP_CUTPOOL *cutpool)

SCIP_Longint SCIPcutpoolGetNCutsAdded(SCIP_CUTPOOL *cutpool)

SCIP_Longint SCIPcutselGetNLocalCuts(SCIP_CUTSEL *cutsel)

SCIP_Longint SCIPcutselGetNLocalCutsFiltered(SCIP_CUTSEL *cutsel)

SCIP_Longint SCIPcutselGetNRootCuts(SCIP_CUTSEL *cutsel)

SCIP_Longint SCIPcutselGetNRootForcedCuts(SCIP_CUTSEL *cutsel)

SCIP_Longint SCIPcutselGetNCalls(SCIP_CUTSEL *cutsel)

SCIP_Real SCIPcutselGetTime(SCIP_CUTSEL *cutsel)

const char * SCIPcutselGetName(SCIP_CUTSEL *cutsel)

SCIP_Longint SCIPcutselGetNRootCutsFiltered(SCIP_CUTSEL *cutsel)

SCIP_Real SCIPcutselGetSetupTime(SCIP_CUTSEL *cutsel)

SCIP_Longint SCIPcutselGetNLocalForcedCuts(SCIP_CUTSEL *cutsel)

SCIP_Longint SCIPcutselGetNRootCalls(SCIP_CUTSEL *cutsel)

SCIP_Longint SCIPdivesetGetNBacktracks(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

SCIP_Longint SCIPdivesetGetNSols(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

int SCIPdivesetGetMaxSolutionDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

SCIP_Longint SCIPdivesetGetNConflicts(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

SCIP_Real SCIPdivesetGetAvgSolutionDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

int SCIPdivesetGetMaxDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

int SCIPdivesetGetMinDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

SCIP_Real SCIPdivesetGetAvgDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

SCIP_Longint SCIPdivesetGetNLPIterations(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

int SCIPdivesetGetMinSolutionDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

const char * SCIPdivesetGetName(SCIP_DIVESET *diveset)

int SCIPdivesetGetNCalls(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

SCIP_Longint SCIPdivesetGetNProbingNodes(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

int SCIPdivesetGetNSolutionCalls(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)

const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)

SCIP_Real SCIPexprhdlrGetEstimateTime(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNDomainReductions(SCIP_EXPRHDLR *exprhdlr)

SCIP_Real SCIPexprhdlrGetReversepropTime(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNReversepropCalls(SCIP_EXPRHDLR *exprhdlr)

unsigned int SCIPexprhdlrGetNCreated(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNBranchings(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNSimplifyCalls(SCIP_EXPRHDLR *exprhdlr)

SCIP_Real SCIPexprhdlrGetIntevalTime(SCIP_EXPRHDLR *exprhdlr)

SCIP_Real SCIPexprhdlrGetSimplifyTime(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNIntevalCalls(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNSimplifications(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNCutoffs(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNEstimateCalls(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPheurGetNSolsFound(SCIP_HEUR *heur)

SCIP_Longint SCIPheurGetNBestSolsFound(SCIP_HEUR *heur)

SCIP_Longint SCIPheurGetNCalls(SCIP_HEUR *heur)

SCIP_Real SCIPheurGetSetupTime(SCIP_HEUR *heur)

int SCIPheurGetNDivesets(SCIP_HEUR *heur)

SCIP_Real SCIPheurGetTime(SCIP_HEUR *heur)

const char * SCIPheurGetName(SCIP_HEUR *heur)

SCIP_DIVESET ** SCIPheurGetDivesets(SCIP_HEUR *heur)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

int SCIPnlpiGetNSolves(SCIP_NLPI *nlpi)

SCIP_Real SCIPnlpiGetProblemTime(SCIP_NLPI *nlpi)

SCIP_Real SCIPnlpiGetSolveTime(SCIP_NLPI *nlpi)

int SCIPnlpiGetNTermStat(SCIP_NLPI *nlpi, SCIP_NLPTERMSTAT termstatus)

SCIP_Longint SCIPnlpiGetNIterations(SCIP_NLPI *nlpi)

int SCIPnlpiGetNProblems(SCIP_NLPI *nlpi)

int SCIPnlpiGetNSolStat(SCIP_NLPI *nlpi, SCIP_NLPSOLSTAT solstatus)

const char * SCIPnlpiGetName(SCIP_NLPI *nlpi)

SCIP_Real SCIPnlpiGetEvalTime(SCIP_NLPI *nlpi)

SCIP_RETCODE SCIPgetNLPNlRowsStat(SCIP *scip, int *nlinear, int *nconvexineq, int *nnonconvexineq, int *nnonlineareq)

SCIP_Real SCIPpresolGetSetupTime(SCIP_PRESOL *presol)

int SCIPpresolGetNAggrVars(SCIP_PRESOL *presol)

int SCIPpresolGetNCalls(SCIP_PRESOL *presol)

int SCIPpresolGetNDelConss(SCIP_PRESOL *presol)

int SCIPpresolGetNChgCoefs(SCIP_PRESOL *presol)

int SCIPpresolGetNAddHoles(SCIP_PRESOL *presol)

SCIP_Real SCIPpresolGetTime(SCIP_PRESOL *presol)

int SCIPpresolGetNChgVarTypes(SCIP_PRESOL *presol)

int SCIPpresolGetNChgSides(SCIP_PRESOL *presol)

int SCIPpresolGetNFixedVars(SCIP_PRESOL *presol)

int SCIPpresolGetNChgBds(SCIP_PRESOL *presol)

int SCIPpresolGetNAddConss(SCIP_PRESOL *presol)

const char * SCIPpresolGetName(SCIP_PRESOL *presol)

int SCIPpricerGetNVarsFound(SCIP_PRICER *pricer)

const char * SCIPpricerGetName(SCIP_PRICER *pricer)

SCIP_Real SCIPpricerGetSetupTime(SCIP_PRICER *pricer)

SCIP_Real SCIPpricerGetTime(SCIP_PRICER *pricer)

int SCIPpricerGetNCalls(SCIP_PRICER *pricer)

SCIP_Bool SCIPpropDoesPresolve(SCIP_PROP *prop)

SCIP_Real SCIPpropGetRespropTime(SCIP_PROP *prop)

SCIP_Real SCIPpropGetPresolTime(SCIP_PROP *prop)

SCIP_Longint SCIPpropGetNCutoffs(SCIP_PROP *prop)

SCIP_Real SCIPpropGetSetupTime(SCIP_PROP *prop)

int SCIPpropGetNAddHoles(SCIP_PROP *prop)

int SCIPpropGetNChgBds(SCIP_PROP *prop)

int SCIPpropGetNChgSides(SCIP_PROP *prop)

int SCIPpropGetNPresolCalls(SCIP_PROP *prop)

SCIP_Longint SCIPpropGetNRespropCalls(SCIP_PROP *prop)

SCIP_Real SCIPpropGetStrongBranchPropTime(SCIP_PROP *prop)

SCIP_Longint SCIPpropGetNDomredsFound(SCIP_PROP *prop)

int SCIPpropGetNChgCoefs(SCIP_PROP *prop)

int SCIPpropGetNAggrVars(SCIP_PROP *prop)

int SCIPpropGetNFixedVars(SCIP_PROP *prop)

const char * SCIPpropGetName(SCIP_PROP *prop)

int SCIPpropGetNAddConss(SCIP_PROP *prop)

SCIP_Real SCIPpropGetTime(SCIP_PROP *prop)

int SCIPpropGetNChgVarTypes(SCIP_PROP *prop)

SCIP_Longint SCIPpropGetNCalls(SCIP_PROP *prop)

int SCIPpropGetNDelConss(SCIP_PROP *prop)

const char * SCIPreaderGetName(SCIP_READER *reader)

SCIP_Longint SCIPrelaxGetNAddedConss(SCIP_RELAX *relax)

SCIP_Real SCIPrelaxGetTime(SCIP_RELAX *relax)

const char * SCIPrelaxGetName(SCIP_RELAX *relax)

SCIP_Longint SCIPrelaxGetNCutoffs(SCIP_RELAX *relax)

SCIP_Longint SCIPrelaxGetNSeparatedCuts(SCIP_RELAX *relax)

SCIP_Longint SCIPrelaxGetNReducedDomains(SCIP_RELAX *relax)

SCIP_Real SCIPrelaxGetImprovedLowerboundTime(SCIP_RELAX *relax)

SCIP_Longint SCIPrelaxGetNImprovedLowerbound(SCIP_RELAX *relax)

SCIP_Longint SCIPrelaxGetNCalls(SCIP_RELAX *relax)

SCIP_Longint SCIPsepaGetNCutsApplied(SCIP_SEPA *sepa)

SCIP_Longint SCIPsepaGetNCutoffs(SCIP_SEPA *sepa)

SCIP_Longint SCIPsepaGetNCutsAppliedViaPool(SCIP_SEPA *sepa)

SCIP_Longint SCIPsepaGetNCutsAppliedDirect(SCIP_SEPA *sepa)

const char * SCIPsepaGetName(SCIP_SEPA *sepa)

SCIP_Longint SCIPsepaGetNDomredsFound(SCIP_SEPA *sepa)

SCIP_Bool SCIPsepaIsParentsepa(SCIP_SEPA *sepa)

SCIP_Real SCIPsepaGetTime(SCIP_SEPA *sepa)

SCIP_SEPA * SCIPsepaGetParentsepa(SCIP_SEPA *sepa)

SCIP_Longint SCIPsepaGetNCutsAddedViaPool(SCIP_SEPA *sepa)

SCIP_Longint SCIPsepaGetNConssFound(SCIP_SEPA *sepa)

SCIP_Longint SCIPsepaGetNRootCalls(SCIP_SEPA *sepa)

SCIP_Longint SCIPsepaGetNCutsAddedDirect(SCIP_SEPA *sepa)

SCIP_Real SCIPsepaGetSetupTime(SCIP_SEPA *sepa)

SCIP_Longint SCIPsepaGetNCutsFound(SCIP_SEPA *sepa)

SCIP_Longint SCIPsepaGetNCalls(SCIP_SEPA *sepa)

SCIP_Real SCIPsolGetTime(SCIP_SOL *sol)

SCIP_Longint SCIPsolGetNodenum(SCIP_SOL *sol)

SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)

int SCIPsolGetDepth(SCIP_SOL *sol)

int SCIPsolGetRunnum(SCIP_SOL *sol)

SCIP_Real SCIPretransformObj(SCIP *scip, SCIP_Real obj)

void SCIPprintPropagatorStatistics(SCIP *scip, FILE *file)

void SCIPprintTreeStatistics(SCIP *scip, FILE *file)

void SCIPprintStatusStatistics(SCIP *scip, FILE *file)

SCIP_Real SCIPgetAvgConflictScoreCurrentRun(SCIP *scip)

void SCIPprintCompressionStatistics(SCIP *scip, FILE *file)

SCIP_Real SCIPgetAvgCutoffsCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)

void SCIPprintRootStatistics(SCIP *scip, FILE *file)

SCIP_Bool SCIPisPrimalboundSol(SCIP *scip)

SCIP_Longint SCIPgetNConflictDualproofsApplied(SCIP *scip)

int SCIPgetNImplications(SCIP *scip)

void SCIPprintConstraintTimingStatistics(SCIP *scip, FILE *file)

void SCIPaddNNodes(SCIP *scip, SCIP_Longint nnodes)

void SCIPincAvgGMIeff(SCIP *scip, SCIP_Real gmieff)

SCIP_Real SCIPgetDeterministicTime(SCIP *scip)

SCIP_Longint SCIPgetNSolsFound(SCIP *scip)

SCIP_Real SCIPgetPrimalbound(SCIP *scip)

int SCIPgetMaxDepth(SCIP *scip)

SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)

SCIP_Longint SCIPgetNBarrierLPIterations(SCIP *scip)

SCIP_Real SCIPgetAvgInferenceScore(SCIP *scip)

SCIP_Longint SCIPgetNDivingLPIterations(SCIP *scip)

SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(SCIP *scip)

SCIP_Real SCIPgetUpperbound(SCIP *scip)

SCIP_Real SCIPgetLowerboundRoot(SCIP *scip)

SCIP_Real SCIPgetAvgConflictlengthScore(SCIP *scip)

void SCIPprintSolutionStatistics(SCIP *scip, FILE *file)

SCIP_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)

SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)

void SCIPprintRelaxatorStatistics(SCIP *scip, FILE *file)

SCIP_Real SCIPgetGap(SCIP *scip)

SCIP_Longint SCIPgetNResolveLPIterations(SCIP *scip)

void SCIPprintOrigProblemStatistics(SCIP *scip, FILE *file)

SCIP_Longint SCIPgetNNodeZeroIterationLPs(SCIP *scip)

SCIP_Longint SCIPgetNNodes(SCIP *scip)

SCIP_Longint SCIPgetNFeasibleLeaves(SCIP *scip)

SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)

int SCIPgetMaxTotalDepth(SCIP *scip)

int SCIPgetNPricevars(SCIP *scip)

int SCIPgetNRootboundChgsRun(SCIP *scip)

SCIP_Real SCIPgetDualbound(SCIP *scip)

void SCIPprintLPStatistics(SCIP *scip, FILE *file)

SCIP_Longint SCIPgetNRootStrongbranchs(SCIP *scip)

int SCIPgetNEnabledConss(SCIP *scip)

int SCIPgetNSepaRounds(SCIP *scip)

int SCIPgetNCutsFoundRound(SCIP *scip)

void SCIPprintNLPStatistics(SCIP *scip, FILE *file)

int SCIPgetNRootboundChgs(SCIP *scip)

SCIP_Real SCIPgetFirstPrimalBound(SCIP *scip)

SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP *scip)

int SCIPgetNPricevarsApplied(SCIP *scip)

int SCIPgetNCutsApplied(SCIP *scip)

void SCIPprintPricerStatistics(SCIP *scip, FILE *file)

SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)

SCIP_Real SCIPgetLowerbound(SCIP *scip)

SCIP_Real SCIPgetAvgLowerbound(SCIP *scip)

SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)

SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)

void SCIPprintSeparatorStatistics(SCIP *scip, FILE *file)

void SCIPprintConcsolverStatistics(SCIP *scip, FILE *file)

SCIP_Longint SCIPgetNResolveLPs(SCIP *scip)

int SCIPgetNRuns(SCIP *scip)

void SCIPprintNLPIStatistics(SCIP *scip, FILE *file)

SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)

SCIP_Longint SCIPgetNDualLPIterations(SCIP *scip)

void SCIPprintBranchruleStatistics(SCIP *scip, FILE *file)

int SCIPgetNActiveConss(SCIP *scip)

void SCIPprintConflictStatistics(SCIP *scip, FILE *file)

SCIP_Real SCIPgetDualboundRoot(SCIP *scip)

SCIP_Longint SCIPgetNDualLPs(SCIP *scip)

SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(SCIP *scip)

SCIP_Real SCIPgetAvgGMIeff(SCIP *scip)

void SCIPprintExpressionHandlerStatistics(SCIP *scip, FILE *file)

int SCIPgetNPriceRounds(SCIP *scip)

SCIP_Longint SCIPgetNLPs(SCIP *scip)

int SCIPgetNReoptRuns(SCIP *scip)

SCIP_Real SCIPgetAvgDualbound(SCIP *scip)

void SCIPprintBendersStatistics(SCIP *scip, FILE *file)

void SCIPprintTimingStatistics(SCIP *scip, FILE *file)

SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)

SCIP_Longint SCIPgetNPrimalResolveLPIterations(SCIP *scip)

SCIP_Real SCIPgetAvgInferenceScoreCurrentRun(SCIP *scip)

void SCIPprintCutselectorStatistics(SCIP *scip, FILE *file)

SCIP_Real SCIPgetAvgConflictScore(SCIP *scip)

SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)

void SCIPstoreSolutionGap(SCIP *scip)

SCIP_Real SCIPgetAvgPseudocost(SCIP *scip, SCIP_Real solvaldelta)

void SCIPprintConstraintStatistics(SCIP *scip, FILE *file)

SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)

SCIP_Longint SCIPgetNBacktracks(SCIP *scip)

SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)

SCIP_Longint SCIPgetNBarrierLPs(SCIP *scip)

SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)

SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)

SCIP_Real SCIPgetTransGap(SCIP *scip)

SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)

SCIP_RETCODE SCIPwriteImplicationConflictGraph(SCIP *scip, const char *filename)

SCIP_Real SCIPgetAvgPseudocostScore(SCIP *scip)

SCIP_Real SCIPgetPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)

SCIP_Real SCIPgetCutoffbound(SCIP *scip)

SCIP_Real SCIPgetFirstLPLowerboundRoot(SCIP *scip)

SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)

SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)

SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)

int SCIPgetNCutsFound(SCIP *scip)

void SCIPprintPresolverStatistics(SCIP *scip, FILE *file)

void SCIPprintTransProblemStatistics(SCIP *scip, FILE *file)

SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)

SCIP_Longint SCIPgetNDivingLPs(SCIP *scip)

SCIP_Longint SCIPgetNNodeLPs(SCIP *scip)

SCIP_Real SCIPgetFirstLPDualboundRoot(SCIP *scip)

SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun(SCIP *scip)

SCIP_Longint SCIPgetNRootFirstLPIterations(SCIP *scip)

int SCIPgetNPricevarsFound(SCIP *scip)

SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)

SCIP_Longint SCIPgetNNZs(SCIP *scip)

SCIP_Longint SCIPgetNDelayedCutoffs(SCIP *scip)

SCIP_Longint SCIPgetNPrimalResolveLPs(SCIP *scip)

SCIP_Longint SCIPgetNConflictConssFound(SCIP *scip)

SCIP_Real SCIPgetAvgPseudocostCurrentRun(SCIP *scip, SCIP_Real solvaldelta)

SCIP_Real SCIPgetAvgInferences(SCIP *scip, SCIP_BRANCHDIR dir)

SCIP_Longint SCIPgetNPrimalLPIterations(SCIP *scip)

SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)

int SCIPgetNConflictConssFoundNode(SCIP *scip)

SCIP_Longint SCIPgetNLPIterations(SCIP *scip)

SCIP_Real SCIPgetAvgInferencesCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)

SCIP_Longint SCIPgetNDualResolveLPs(SCIP *scip)

void SCIPprintHeuristicStatistics(SCIP *scip, FILE *file)

SCIP_Real SCIPgetPseudocostVariance(SCIP *scip, SCIP_BRANCHDIR branchdir, SCIP_Bool onlycurrentrun)

SCIP_Real SCIPgetPrimalDualIntegral(SCIP *scip)

SCIP_Longint SCIPgetNPrimalLPs(SCIP *scip)

SCIP_Real SCIPgetAvgCutoffs(SCIP *scip, SCIP_BRANCHDIR dir)

SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)

SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)

int SCIPtableGetPosition(SCIP_TABLE *table)

SCIP_TABLE ** SCIPgetTables(SCIP *scip)

int SCIPgetNTables(SCIP *scip)

SCIP_STAGE SCIPtableGetEarliestStage(SCIP_TABLE *table)

SCIP_Bool SCIPtableIsActive(SCIP_TABLE *table)

SCIP_Real SCIPgetFirstLPTime(SCIP *scip)

SCIP_Real SCIPgetSolvingTime(SCIP *scip)

SCIP_Real SCIPgetReadingTime(SCIP *scip)

SCIP_Real SCIPinfinity(SCIP *scip)

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

SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPvarGetAvgBranchdepth(SCIP_VAR *var, SCIP_BRANCHDIR dir)

int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)

SCIP_Longint SCIPvarGetNBranchings(SCIP_VAR *var, SCIP_BRANCHDIR dir)

int SCIPvarGetBranchPriority(SCIP_VAR *var)

int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)

int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

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

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

SCIP_Real SCIPhistoryGetPseudocost(SCIP_HISTORY *history, SCIP_Real solvaldelta)

SCIP_Real SCIPhistoryGetAvgInferences(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)

SCIP_Longint SCIPhistoryGetNBranchings(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)

SCIP_Real SCIPhistoryGetAvgConflictlength(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)

SCIP_Real SCIPhistoryGetAvgCutoffs(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)

SCIP_Real SCIPhistoryGetCutoffSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)

SCIP_Real SCIPhistoryGetPseudocostCount(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)

SCIP_Real SCIPhistoryGetPseudocostVariance(SCIP_HISTORY *history, SCIP_BRANCHDIR direction)

SCIP_Real SCIPhistoryGetVSIDS(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)

SCIP_Real SCIPhistoryGetAvgGMIeff(SCIP_HISTORY *history)

SCIP_Real SCIPhistoryGetInferenceSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)

void SCIPhistoryIncGMIeffSum(SCIP_HISTORY *history, SCIP_Real gmieff)

internal methods for branching and inference history

SCIP_Longint SCIPcliquetableGetNEntries(SCIP_CLIQUETABLE *cliquetable)

methods for implications, variable bounds, and cliques

memory allocation routines

#define BMSclearMemoryArray(ptr, num)

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

int SCIPpricestoreGetNVars(SCIP_PRICESTORE *pricestore)

int SCIPpricestoreGetNVarsApplied(SCIP_PRICESTORE *pricestore)

SCIP_Real SCIPpricestoreGetProbPricingTime(SCIP_PRICESTORE *pricestore)

int SCIPpricestoreGetNVarsFound(SCIP_PRICESTORE *pricestore)

int SCIPpricestoreGetNProbvarsFound(SCIP_PRICESTORE *pricestore)

int SCIPpricestoreGetNProbPricings(SCIP_PRICESTORE *pricestore)

internal methods for storing priced variables

SCIP_Bool SCIPprimalUpperboundIsSol(SCIP_PRIMAL *primal, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)

SCIP_RETCODE SCIPprimalSetCutoffbound(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_Real cutoffbound, SCIP_Bool useforobjlimit)

internal methods for collecting primal CIP solutions and primal informations

void SCIPprobPrintStatistics(SCIP_PROB *prob, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)

SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)

SCIP_Real SCIPprobInternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)

internal methods for storing and manipulating the main problem

public methods for Benders' decomposition

public methods for Benders' decomposition cuts

public methods for branching rules

public methods for tree compressions

public methods for managing constraints

public methods for storing cuts in a cut pool

public methods for cut selectors

public functions to work with algebraic expressions

public methods for primal heuristics

public methods for branching and inference history structure

public methods for message output

public data structures and miscellaneous methods

methods for sorting joint arrays of various types

public methods for NLP solver interfaces

public methods for presolvers

public methods for variable pricers

public methods for propagators

public methods for input file readers

public methods for relaxation handlers

public methods for reoptimization

int SCIPreoptGetNTotalPrunedNodes(SCIP_REOPT *reopt)

int SCIPreoptGetNTotalFeasNodes(SCIP_REOPT *reopt)

int SCIPreoptGetFirstRestarts(SCIP_REOPT *reopt)

int SCIPreoptGetNTotalRestartsLocal(SCIP_REOPT *reopt)

int SCIPreoptGetLastRestarts(SCIP_REOPT *reopt)

int SCIPreoptGetNTotalCutoffReoptnodes(SCIP_REOPT *reopt)

int SCIPreoptGetNTotalInfNodes(SCIP_REOPT *reopt)

int SCIPreoptGetNRestartsGlobal(SCIP_REOPT *reopt)

public methods for separators

public methods for primal CIP solutions

public methods for displaying statistic tables

public methods for problem variables

SCIP_RETCODE SCIPreaderWrite(SCIP_READER *reader, SCIP_PROB *prob, SCIP_SET *set, SCIP_MESSAGEHDLR *msghdlr, FILE *file, const char *extension, SCIP_Bool genericnames, SCIP_RESULT *result)

internal methods for input file readers

SCIP_Real SCIPreoptGetSavingtime(SCIP_REOPT *reopt)

data structures and methods for collecting reoptimization information

public methods for Benders decomposition

public methods for memory management

public methods for message handling

public methods for nonlinear relaxation

public methods for numerical tolerances

public methods for solutions

static SCIP_RETCODE printProblem(SCIP *scip, SCIP_PROB *prob, FILE *file, const char *extension, SCIP_Bool genericnames)

static SCIP_DECL_SORTPTRCOMP(tablePosComp)

public methods for querying solving statistics

public methods for statistics table plugins

public methods for timing

public methods for SCIP variables

int SCIPsepastoreGetNCutsFoundRound(SCIP_SEPASTORE *sepastore)

int SCIPsepastoreGetNCutsApplied(SCIP_SEPASTORE *sepastore)

int SCIPsepastoreGetNCutsAdded(SCIP_SEPASTORE *sepastore)

internal methods for storing separated cuts

void SCIPsetSortCutsels(SCIP_SET *set)

void SCIPsetSortBranchrulesName(SCIP_SET *set)

void SCIPsetSortPresolsName(SCIP_SET *set)

void SCIPsetSortRelaxsName(SCIP_SET *set)

void SCIPsetSortPropsName(SCIP_SET *set)

SCIP_Real SCIPsetEpsilon(SCIP_SET *set)

void SCIPsetSortComprsName(SCIP_SET *set)

void SCIPsetSortPricersName(SCIP_SET *set)

SCIP_Real SCIPsetInfinity(SCIP_SET *set)

SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)

void SCIPsetSortHeursName(SCIP_SET *set)

void SCIPsetSortSepasName(SCIP_SET *set)

internal methods for global SCIP settings

SCIP_Real SCIPsolGetObj(SCIP_SOL *sol, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)

internal methods for storing primal CIP solutions

void SCIPstatUpdatePrimalDualIntegrals(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real upperbound, SCIP_Real lowerbound)

SCIP_Real SCIPstatGetPrimalReferenceIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Bool update)

SCIP_Real SCIPstatGetDualReferenceIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Bool update)

SCIP_Real SCIPstatGetPrimalDualIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Bool update)

internal methods for problem statistics

datastructures for block memory pools and memory buffers

datastructures for collecting primal CIP solutions and primal informations

datastructures for storing and manipulating the main problem

SCIP main data structure.

datastructures for global SCIP settings

datastructures for problem statistics

int SCIPsyncstoreGetWinner(SCIP_SYNCSTORE *syncstore)

SCIP_Bool SCIPsyncstoreIsInitialized(SCIP_SYNCSTORE *syncstore)

the function declarations for the synchronization store

SCIP_RETCODE SCIPtableOutput(SCIP_TABLE *table, SCIP_SET *set, FILE *file)

internal methods for displaying statistics tables

SCIP_Real SCIPtreeGetAvgLowerbound(SCIP_TREE *tree, SCIP_Real cutoffbound)

SCIP_Real SCIPtreeGetLowerbound(SCIP_TREE *tree, SCIP_SET *set)

int SCIPtreeGetNNodes(SCIP_TREE *tree)

internal methods for branch and bound tree

enum SCIP_DiveContext SCIP_DIVECONTEXT

@ SCIP_DIVECONTEXT_SINGLE

@ SCIP_DIVECONTEXT_ADAPTIVE

@ SCIP_DIVECONTEXT_SCHEDULER

@ SCIP_BRANCHDIR_DOWNWARDS

enum SCIP_BranchDir SCIP_BRANCHDIR

enum SCIP_VerbLevel SCIP_VERBLEVEL

enum SCIP_NlpSolStat SCIP_NLPSOLSTAT

@ SCIP_NLPSOLSTAT_GLOBOPT

@ SCIP_NLPSOLSTAT_UNKNOWN

enum SCIP_NlpTermStat SCIP_NLPTERMSTAT

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STAGE_INITPRESOLVE

@ SCIP_STAGE_EXITPRESOLVE

SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)

SCIP_Real SCIPvarGetPseudocostCount(SCIP_VAR *var, SCIP_BRANCHDIR dir)

SCIP_Real SCIPvarGetPseudocostVariance(SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)

SCIP_Real SCIPvarGetAvgCutoffs(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)

SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)

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