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

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

SCIP Doxygen Documentation: scip_prob.c Source File

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

probdelorig, probtrans, probdeltrans, probinitsol, probexitsol, probcopy, probdata,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

* filename,

* extension

* fileextension;

assert(filename !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( !usevartable || !useconstable )

(

);

fileextension =

;

( extension ==

)

extension !=

? extension : fileextension, &result);

,

->origprob->nvars,

->origprob->nbinvars,

->origprob->nintvars,

->origprob->nimplvars,

->origprob->ncontvars,

->origprob->nconss);

( c =

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

(

=

->set->nconshdlrs - 1;

>= 0; --

)

(

->origprob->conss[c]->conshdlr ==

->set->conshdlrs[

] )

(

= 0;

<

->set->nconshdlrs; ++

)

( nconss[

] > 0 )

(

->set->random_permutationseed > 0 )

permuteconss =

->set->random_permuteconss;

permutevars =

->set->random_permutevars;

permutationseed =

->set->random_permutationseed;

(

(

, (

)permutationseed, permuteconss, permutevars, permutevars, permutevars, permutevars) );

, readingtime);

(

->set->time_reading )

assert(i < scip->

->nreaders);

(

,

* filename,

* extension,

* fileextension;

fileextension =

;

( filename !=

&& filename[0] !=

)

file = fopen(filename,

);

( compression !=

)

( extension ==

&& fileextension ==

)

(

->messagehdlr,

, filename);

success = fclose(file);

(

, filename);

* filename,

* extension,

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

* filename,

* extension,

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

transsolorig =

->set->misc_transsolsorig;

->set->misc_transsolsorig = transsolorig;

(

->set->nconcsolvers > 0 )

( i =

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

assert(

->set->nactivepricers == 0);

( i =

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

assert(

->set->nactivebenders == 0);

( i = 0; i <

->set->nreaders; ++i )

randseed,

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(nvars == 0 || vars !=

);

assert(nconshdlrs == 0 || conshdlrs !=

);

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

assert(nconss == 0 || conss !=

);

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

conss[j]->consspos = j;

nconss =

->origprob->nconss;

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

assert(conss[j]->consspos == -1);

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

vars[j]->probindex = j;

( j = nbinvars; j < nbinvars+nintvars; ++j )

vars[j]->probindex = j;

( j = nbinvars+nintvars; j < nbinvars+nintvars+nimplvars; ++j )

vars[j]->probindex = j;

( j = nbinvars+nintvars+nimplvars; j < nvars; ++j )

vars[j]->probindex = j;

, randseed);

, randseed);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(nvars == 0 || vars !=

);

assert(nvars == 0 || coefs !=

);

origvars =

->origprob->vars;

norigvars =

->origprob->nvars;

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

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

( i = 0; i <

->transprob->nvars; i++ )

->origprob->objscale = 1.0;

->origprob->objsense = objsense;

->origprob->objoffset = 0.0;

->origprob->objisintegral =

;

->transprob->objscale = 1.0;

->transprob->objsense = objsense;

->transprob->objoffset = 0.0;

->transprob->objisintegral =

;

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

(

,

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

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->objsense;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->objoffset += addval;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->objoffset;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->objscale;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->transprob->objoffset;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->transprob->objscale;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

, oldobjlimit, objlimit);

(

, oldobjlimit, objlimit);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

->set->nactivepricers != 0 )

(v = 0; v <

->origprob->nvars; ++v)

( v ==

->origprob->nvars )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->lp->objsqrnormunreliable )

assert(!

->lp->objsqrnormunreliable);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

);

->eventfilter,

->eventqueue, var) );

(

);

(

);

->branchcand,

->eventfilter,

->eventqueue, var) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

);

(

);

->branchcand,

->eventfilter,

->eventqueue, var) );

assert(var !=

);

assert(deleted !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

);

(

);

(

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

*vars =

->origprob->vars;

( nvars !=

)

*nvars =

->origprob->nvars;

( nbinvars !=

)

*nbinvars =

->origprob->nbinvars;

( nintvars !=

)

*nintvars =

->origprob->nintvars;

( nimplvars !=

)

*nimplvars =

->origprob->nimplvars;

( ncontvars !=

)

*ncontvars =

->origprob->ncontvars;

*vars =

->transprob->vars;

( nvars !=

)

*nvars =

->transprob->nvars;

( nbinvars !=

)

*nbinvars =

->transprob->nbinvars;

( nintvars !=

)

*nintvars =

->transprob->nintvars;

( nimplvars !=

)

*nimplvars =

->transprob->nimplvars;

( ncontvars !=

)

*ncontvars =

->transprob->ncontvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->origprob->vars;

->transprob->vars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->origprob->nvars;

->transprob->nvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->origprob->nbinvars;

->transprob->nbinvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->origprob->nintvars;

->transprob->nintvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->origprob->nimplvars;

->transprob->nimplvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->origprob->ncontvars;

->transprob->ncontvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->transprob->fixedvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->transprob->nfixedvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*vars =

->origprob->vars;

( nvars !=

)

*nvars =

->origprob->nvars;

( nbinvars !=

)

*nbinvars =

->origprob->nbinvars;

( nintvars !=

)

*nintvars =

->origprob->nintvars;

( nimplvars !=

)

*nimplvars =

->origprob->nimplvars;

( ncontvars !=

)

*ncontvars =

->origprob->ncontvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->vars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->nvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->nbinvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->nintvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->nimplvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->ncontvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->stat->nvaridx;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*vars =

->origprob->vars;

( nvars !=

)

*nvars =

->origprob->nvars;

( nbinvars !=

)

*nbinvars =

->origprob->nbinvars;

( nintvars !=

)

*nintvars =

->origprob->nintvars;

( nimplvars !=

)

*nimplvars =

->origprob->nimplvars;

( ncontvars !=

)

*ncontvars =

->origprob->ncontvars;

*vars =

->transprob->vars;

( nvars !=

)

*nvars =

->transprob->nvars;

( nbinvars !=

)

*nbinvars =

->transprob->nbinvars;

( nintvars !=

)

*nintvars =

->transprob->nintvars;

( nimplvars !=

)

*nimplvars =

->transprob->nimplvars;

( ncontvars !=

)

*ncontvars =

->transprob->ncontvars;

assert(name !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->nactivepricers == 0);

assert(cons !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

->set->reopt_enable )

->tree, cons) );

assert(cons !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

assert(name !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

assert(name !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->stat->npresolupgdconss;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->origprob->nconss;

->transprob->nconss;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->origprob->conss;

->transprob->conss;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->nconss;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->origprob->conss;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(conshdlrs !=

);

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

assert(conshdlrs[c] !=

);

assert(cons !=

);

assert(

->conflictstore !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( iscutoffinvolved )

->transprob,

->reopt, cons, conftype, iscutoffinvolved, primalbound) );

assert(event !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->transprob,

->reopt,

->primal->cutoffbound) );

assert(cons !=

);

assert(node !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( validnode !=

)

(

,

(

,

assert(cons !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(cons !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(cons !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

void SCIPclockSetTime(SCIP_CLOCK *clck, SCIP_Real sec)

internal methods for clocks and timing issues

SCIP_RETCODE SCIPfreeConcurrent(SCIP *scip)

helper functions for concurrent scip solvers

SCIP_RETCODE SCIPconflictstoreCleanNewIncumbent(SCIP_CONFLICTSTORE *conflictstore, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_PROB *transprob, SCIP_REOPT *reopt, SCIP_Real cutoffbound)

SCIP_RETCODE SCIPconflictstoreFree(SCIP_CONFLICTSTORE **conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_REOPT *reopt)

SCIP_RETCODE SCIPconflictstoreCreate(SCIP_CONFLICTSTORE **conflictstore, SCIP_SET *set)

SCIP_RETCODE SCIPconflictstoreAddConflict(SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_REOPT *reopt, SCIP_CONS *cons, SCIP_CONFTYPE conftype, SCIP_Bool cutoffinvolved, SCIP_Real primalbound)

internal methods for storing conflicts

void SCIPconsMarkConflict(SCIP_CONS *cons)

void SCIPconsSetLocal(SCIP_CONS *cons, SCIP_Bool local)

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

internal methods for constraints and constraint handlers

SCIP_RETCODE SCIPdecompstoreCreate(SCIP_DECOMPSTORE **decompstore, BMS_BLKMEM *blkmem, int nslots)

void SCIPdecompstoreFree(SCIP_DECOMPSTORE **decompstore, BMS_BLKMEM *blkmem)

internal methods for decompositions and the decomposition store

#define SCIP_DECOMPSTORE_CAPA

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 SCIPdebugFreeDebugData(set)

#define SCIP_CALL_ABORT(x)

void SCIPsplitFilename(char *filename, char **path, char **name, char **extension, char **compression)

SCIP_Bool SCIPisTransformed(SCIP *scip)

int SCIPgetNObjVars(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPpermuteProb(SCIP *scip, unsigned int randseed, SCIP_Bool permuteconss, SCIP_Bool permutebinvars, SCIP_Bool permuteintvars, SCIP_Bool permuteimplvars, SCIP_Bool permutecontvars)

SCIP_RETCODE SCIPgetSolVarsData(SCIP *scip, SCIP_SOL *sol, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)

int SCIPgetNIntVars(SCIP *scip)

SCIP_RETCODE SCIPsetObjIntegral(SCIP *scip)

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

int SCIPgetNImplVars(SCIP *scip)

const char * SCIPgetProbName(SCIP *scip)

int SCIPgetNContVars(SCIP *scip)

int SCIPgetNCheckConss(SCIP *scip)

SCIP_RETCODE SCIPaddPricedVar(SCIP *scip, SCIP_VAR *var, SCIP_Real score)

SCIP_Real SCIPgetOrigObjscale(SCIP *scip)

SCIP_RETCODE SCIPwriteOrigProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)

SCIP_RETCODE SCIPsetProbName(SCIP *scip, const char *name)

SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)

SCIP_RETCODE SCIPsetProbDeltrans(SCIP *scip, SCIP_DECL_PROBDELTRANS((*probdeltrans)))

SCIP_Real SCIPgetTransObjoffset(SCIP *scip)

int SCIPgetNOrigBinVars(SCIP *scip)

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

int SCIPgetNOrigConss(SCIP *scip)

SCIP_Real SCIPgetOrigObjoffset(SCIP *scip)

SCIP_VAR ** SCIPgetOrigVars(SCIP *scip)

int SCIPgetNOrigContVars(SCIP *scip)

SCIP_RETCODE SCIPsetProbExitsol(SCIP *scip, SCIP_DECL_PROBEXITSOL((*probexitsol)))

int SCIPgetNOrigIntVars(SCIP *scip)

SCIP_CONS ** SCIPgetConss(SCIP *scip)

SCIP_RETCODE SCIPsetProbTrans(SCIP *scip, SCIP_DECL_PROBTRANS((*probtrans)))

SCIP_RETCODE SCIPsetProbDelorig(SCIP *scip, SCIP_DECL_PROBDELORIG((*probdelorig)))

int SCIPgetNOrigImplVars(SCIP *scip)

SCIP_Real SCIPgetObjlimit(SCIP *scip)

SCIP_RETCODE SCIPaddObjoffset(SCIP *scip, SCIP_Real addval)

int SCIPgetNUpgrConss(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPchgReoptObjective(SCIP *scip, SCIP_OBJSENSE objsense, SCIP_VAR **vars, SCIP_Real *coefs, int nvars)

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

SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNConss(SCIP *scip)

SCIP_RETCODE SCIPfreeProb(SCIP *scip)

SCIP_PROBDATA * SCIPgetProbData(SCIP *scip)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

SCIP_Real SCIPgetObjNorm(SCIP *scip)

SCIP_Bool SCIPallVarsInProb(SCIP *scip)

int SCIPgetNOrigVars(SCIP *scip)

SCIP_RETCODE SCIPsetProbInitsol(SCIP *scip, SCIP_DECL_PROBINITSOL((*probinitsol)))

SCIP_RETCODE SCIPdelVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool *deleted)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

SCIP_RETCODE SCIPaddOrigObjoffset(SCIP *scip, SCIP_Real addval)

SCIP_RETCODE SCIPcreateProbBasic(SCIP *scip, const char *name)

SCIP_CONS ** SCIPgetOrigConss(SCIP *scip)

SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)

SCIP_RETCODE SCIPwriteTransProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)

int SCIPgetNFixedVars(SCIP *scip)

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

SCIP_RETCODE SCIPsetProbData(SCIP *scip, SCIP_PROBDATA *probdata)

int SCIPgetNBinVars(SCIP *scip)

SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)

int SCIPgetNTotalVars(SCIP *scip)

SCIP_Real SCIPgetTransObjscale(SCIP *scip)

SCIP_RETCODE SCIPsetProbCopy(SCIP *scip, SCIP_DECL_PROBCOPY((*probcopy)))

SCIP_Bool SCIPisObjIntegral(SCIP *scip)

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

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

SCIP_RETCODE SCIPreadProb(SCIP *scip, const char *filename, const char *extension)

SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)

SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)

SCIP_Real SCIPgetNodeDualbound(SCIP *scip, SCIP_NODE *node)

SCIP_RETCODE SCIPdelConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons)

SCIP_Real SCIPgetLocalOrigEstimate(SCIP *scip)

SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)

SCIP_RETCODE SCIPclearConflictStore(SCIP *scip, SCIP_EVENT *event)

SCIP_Real SCIPgetLocalLowerbound(SCIP *scip)

SCIP_RETCODE SCIPupdateLocalDualbound(SCIP *scip, SCIP_Real newbound)

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

SCIP_RETCODE SCIPchgChildPrio(SCIP *scip, SCIP_NODE *child, SCIP_Real priority)

SCIP_RETCODE SCIPupdateNodeDualbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)

SCIP_Real SCIPgetLocalDualbound(SCIP *scip)

SCIP_RETCODE SCIPaddConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_NODE *validnode)

SCIP_Real SCIPgetNodeLowerbound(SCIP *scip, SCIP_NODE *node)

SCIP_Real SCIPgetLocalTransEstimate(SCIP *scip)

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

void SCIPrandomPermuteArray(SCIP_RANDNUMGEN *randnumgen, void **array, int begin, int end)

int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)

int SCIPgetNConshdlrs(SCIP *scip)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)

SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)

SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)

SCIP_Bool SCIPconsIsGlobal(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsAdded(SCIP_CONS *cons)

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

SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)

SCIP_SOL * SCIPeventGetSol(SCIP_EVENT *event)

#define SCIPallocClearBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

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

SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)

SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)

SCIP_Real SCIPnodeGetEstimate(SCIP_NODE *node)

int SCIPnodeGetDepth(SCIP_NODE *node)

const char * SCIPreaderGetName(SCIP_READER *reader)

SCIP_RETCODE SCIPenableReoptimization(SCIP *scip, SCIP_Bool enable)

SCIP_Real SCIPtransformObj(SCIP *scip, SCIP_Real obj)

SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)

SCIP_RETCODE SCIPfreeTransform(SCIP *scip)

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

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

SCIP_Real SCIPgetCutoffbound(SCIP *scip)

SCIP_Real SCIPgetReadingTime(SCIP *scip)

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

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

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)

SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)

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

SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)

void SCIPfreeRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen)

SCIP_RETCODE SCIPcreateRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen, unsigned int initialseed, SCIP_Bool useglobalseed)

void SCIPprintSysError(const char *message)

void SCIPlpRecalculateObjSqrNorm(SCIP_SET *set, SCIP_LP *lp)

SCIP_Real SCIPlpGetObjNorm(SCIP_LP *lp)

internal methods for LP management

memory allocation routines

#define BMSduplicateMemoryArray(ptr, source, num)

#define BMSfreeMemoryArray(ptr)

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

void SCIPmessagePrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, const char *formatstr,...)

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

SCIP_RETCODE SCIPpricerDeactivate(SCIP_PRICER *pricer, SCIP_SET *set)

internal methods for variable pricers

SCIP_RETCODE SCIPpricestoreAddVar(SCIP_PRICESTORE *pricestore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_VAR *var, SCIP_Real score, SCIP_Bool root)

internal methods for storing priced variables

void SCIPprimalAddOrigObjoffset(SCIP_PRIMAL *primal, SCIP_SET *set, SCIP_Real addval)

SCIP_RETCODE SCIPprimalFree(SCIP_PRIMAL **primal, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPprimalCreate(SCIP_PRIMAL **primal)

SCIP_RETCODE SCIPprimalUpdateObjoffset(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_RETCODE SCIPprimalUpdateObjlimit(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)

internal methods for collecting primal CIP solutions and primal informations

SCIP_Bool SCIPprobIsPermuted(SCIP_PROB *prob)

void SCIPprobSetTrans(SCIP_PROB *prob, SCIP_DECL_PROBTRANS((*probtrans)))

void SCIPprobSetInitsol(SCIP_PROB *prob, SCIP_DECL_PROBINITSOL((*probinitsol)))

void SCIPprobSetObjIntegral(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobAddVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var)

const char * SCIPprobGetName(SCIP_PROB *prob)

int SCIPprobGetNObjVars(SCIP_PROB *prob, SCIP_SET *set)

SCIP_RETCODE SCIPprobPerformVarDeletions(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand)

void SCIPprobSetExitsol(SCIP_PROB *prob, SCIP_DECL_PROBEXITSOL((*probexitsol)))

SCIP_Real SCIPprobGetObjlim(SCIP_PROB *prob, SCIP_SET *set)

void SCIPprobUpdateDualbound(SCIP_PROB *prob, SCIP_Real newbound)

SCIP_RETCODE SCIPprobSetName(SCIP_PROB *prob, const char *name)

void SCIPprobSetDeltrans(SCIP_PROB *prob, SCIP_DECL_PROBDELTRANS((*probdeltrans)))

void SCIPprobSetData(SCIP_PROB *prob, SCIP_PROBDATA *probdata)

void SCIPprobAddObjoffset(SCIP_PROB *prob, SCIP_Real addval)

void SCIPprobSetCopy(SCIP_PROB *prob, SCIP_DECL_PROBCOPY((*probcopy)))

SCIP_VAR * SCIPprobFindVar(SCIP_PROB *prob, const char *name)

SCIP_RETCODE SCIPprobCreate(SCIP_PROB **prob, BMS_BLKMEM *blkmem, SCIP_SET *set, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata, SCIP_Bool transformed)

void SCIPprobSetObjlim(SCIP_PROB *prob, SCIP_Real objlim)

SCIP_RETCODE SCIPprobDelVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var, SCIP_Bool *deleted)

SCIP_Bool SCIPprobIsObjIntegral(SCIP_PROB *prob)

SCIP_CONS * SCIPprobFindCons(SCIP_PROB *prob, const char *name)

void SCIPprobMarkPermuted(SCIP_PROB *prob)

SCIP_PROBDATA * SCIPprobGetData(SCIP_PROB *prob)

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

SCIP_RETCODE SCIPprobFree(SCIP_PROB **prob, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)

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

void SCIPprobSetDelorig(SCIP_PROB *prob, SCIP_DECL_PROBDELORIG((*probdelorig)))

void SCIPprobSetObjsense(SCIP_PROB *prob, SCIP_OBJSENSE objsense)

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 managing constraints

public methods for managing events

public methods for message output

public data structures and miscellaneous methods

public methods for input file readers

public methods for primal CIP solutions

public methods for branch and bound tree

public methods for problem variables

SCIP_RETCODE SCIPreaderRead(SCIP_READER *reader, SCIP_SET *set, const char *filename, const char *extension, SCIP_RESULT *result)

SCIP_RETCODE SCIPreaderResetReadingTime(SCIP_READER *reader)

internal methods for input file readers

SCIP_RETCODE SCIPreoptAddCons(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONS *cons)

SCIP_RETCODE SCIPreoptFree(SCIP_REOPT **reopt, SCIP_SET *set, SCIP_PRIMAL *origprimal, BMS_BLKMEM *blkmem)

data structures and methods for collecting reoptimization information

public methods for constraint handler plugins and constraints

public methods for memory management

public methods for message handling

public methods for numerical tolerances

public methods for SCIP parameter handling

static SCIP_RETCODE writeProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool transformed, SCIP_Bool genericnames)

public methods for global and local (sub)problems

public methods for random numbers

public methods for solutions

public methods for querying solving statistics

public methods for timing

public methods for SCIP variables

SCIP_RETCODE SCIPsetFreeConcsolvers(SCIP_SET *set)

internal methods for global SCIP settings

SCIP_RETCODE SCIPbendersDeactivate(SCIP_BENDERS *benders, SCIP_SET *set)

internal methods for Benders' decomposition

SCIP_RETCODE SCIPstatFree(SCIP_STAT **stat, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPstatCreate(SCIP_STAT **stat, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_MESSAGEHDLR *messagehdlr)

internal methods for problem statistics

SCIP_CONSSETCHG * addconssetchg

datastructures for constraints and constraint handlers

data structures for LP management

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

datastructures for problem variables

SCIP_RETCODE SCIPsyncstoreExit(SCIP_SYNCSTORE *syncstore)

SCIP_Bool SCIPsyncstoreIsInitialized(SCIP_SYNCSTORE *syncstore)

the function declarations for the synchronization store

void SCIPnodeUpdateLowerbound(SCIP_NODE *node, SCIP_STAT *stat, SCIP_SET *set, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real newbound)

SCIP_RETCODE SCIPnodeCutoff(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_REOPT *reopt, SCIP_LP *lp, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPnodeDelCons(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_CONS *cons)

SCIP_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)

int SCIPtreeGetEffectiveRootDepth(SCIP_TREE *tree)

SCIP_RETCODE SCIPnodeAddCons(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_CONS *cons)

void SCIPchildChgNodeselPrio(SCIP_TREE *tree, SCIP_NODE *child, SCIP_Real priority)

int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)

internal methods for branch and bound tree

@ SCIP_CONFTYPE_BNDEXCEEDING

enum SCIP_ConflictType SCIP_CONFTYPE

#define SCIP_EVENTTYPE_BESTSOLFOUND

#define SCIP_DECL_PROBCOPY(x)

#define SCIP_DECL_PROBDELTRANS(x)

#define SCIP_DECL_PROBEXITSOL(x)

struct SCIP_ProbData SCIP_PROBDATA

#define SCIP_DECL_PROBDELORIG(x)

#define SCIP_DECL_PROBTRANS(x)

#define SCIP_DECL_PROBINITSOL(x)

enum SCIP_Objsense SCIP_OBJSENSE

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STAGE_INITPRESOLVE

@ SCIP_STAGE_EXITPRESOLVE

@ SCIP_STAGE_TRANSFORMING

@ SCIP_NODETYPE_PROBINGNODE

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_VARSTATUS_ORIGINAL

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