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

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

SCIP Doxygen Documentation: cons_components.c Source File

SCIP_ConshdlrData

assert(elem1 !=

);

assert(elem2 !=

);

( comp1->

== 0 )

( comp2->

== 0 )

( comp2->

== 0 )

assert(conshdlrdata !=

);

minsize =

(minsize, conshdlrdata->minsize);

assert(problem !=

);

assert(problem->ncomponents < problem->componentssize);

= problem->scip;

component = &problem->components[problem->ncomponents];

component->

= 0;

component->

= problem->ncomponents;

++problem->ncomponents;

assert(component !=

);

problem = component->

;

assert(problem !=

);

= problem->scip;

assert(component !=

);

subscip = component->

;

assert(subscip !=

);

problem = component->

;

assert(problem !=

);

= problem->scip;

nvars = component->

;

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

component->

[idx] = sourcevars[v];

(

,

,

problem = component->

;

assert(problem !=

);

= problem->scip;

( i = 0; i < component->

; ++i )

( i = 0; i < component->

; ++i )

assert(conshdlrdata !=

);

,

,

,

,

,

,

,

,

,

,

,

, &success) );

,

,

,

,

,

,

,

,

,

,

,

, &success) );

assert(newconshdlr !=

);

assert(newconshdlrdata !=

);

newconshdlrdata->subscipdepth = conshdlrdata->subscipdepth +

(

);

assert(subscip !=

);

assert(vars !=

);

assert(subvars !=

);

assert(conss !=

);

assert(varmap !=

);

assert(consmap !=

);

assert(success !=

);

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

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

assert(component !=

);

assert(consmap !=

);

assert(conss !=

);

assert(success !=

);

assert(component->

> 0);

problem = component->

;

assert(problem !=

);

= problem->scip;

conss, varmap, consmap, component->

, nconss, success) );

assert(subscip !=

);

( avoidmemout && memorylimit <= 0.0 )

( timelimit <= 0.0 )

( softtimelimit > -0.5 )

softtimelimit =

(softtimelimit, 0.0);

* ntightenedbounds,

assert(conshdlrdata !=

);

assert(subscip !=

);

assert(vars !=

);

assert(conss !=

);

assert(ndeletedconss !=

);

assert(nfixedvars !=

);

assert(ntightenedbounds !=

);

assert(result !=

);

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

( subvar !=

)

(

,

,

(

,

,

fixvals[i] =

(fixvals[i], gub);

fixvals[i] =

(fixvals[i], glb);

(

,

);

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

( subvars[i] !=

)

(

,

, feasible ?

:

);

(

,

,

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

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

(

,

,

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

( subvars[i] ==

)

&infeasible, &tightened) );

&infeasible, &tightened) );

assert(!infeasible);

*ntightenedbounds += ntightened;

(

,

, ntightened);

assert(component !=

);

problem = component->

;

assert(problem !=

);

= problem->scip;

subscip = component->

;

assert(subscip !=

);

(

,

,

nvars = component->

;

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

( subvars[v] !=

)

( v = 0; v < component->

; ++v )

(

,

,

( problem->nlowerboundinf == 0 || (problem->nlowerboundinf == 1

assert(problem->nlowerboundinf > 0 ||

(

, newcutoffbound, problem->lowerbound));

newcutoffbound = newcutoffbound - problem->lowerbound + component->

;

( problem->nlowerboundinf == 0 )

(

,

,

( component->

== 0 )

nodelimit = 2 * lastnnodes;

nodelimit =

(nodelimit, 10LL);

( mainnodelimit != -1 )

assert(mainnodelimit >= lastnnodes);

nodelimit =

(nodelimit, mainnodelimit - lastnnodes);

( lastcomponent )

(

,

,

--problem->nlowerboundinf;

problem->lowerbound += newdualbound;

problem->lowerbound += (newdualbound - component->

);

( problem->nlowerboundinf == 0 )

(

,

,

problem->nfeascomps == problem->ncomponents ?

problem->nfeascomps == problem->ncomponents ?

++(problem->nfeascomps);

( v = 0; v < component->

; ++v )

var = component->

[v];

subvar = component->

[v];

assert(var !=

);

( subvar ==

)

( problem->nfeascomps == problem->ncomponents )

(

,

,

problem->nfeascomps == problem->ncomponents ?

problem->nfeascomps == problem->ncomponents ?

++(problem->nsolvedcomps);

assert(problem !=

);

assert(*problem !=

);

(*problem)->scip =

;

(*problem)->lowerbound = fixedvarsobjsum;

(*problem)->fixedvarsobjsum = fixedvarsobjsum;

(*problem)->ncomponents = 0;

(*problem)->componentssize = ncomponents;

(*problem)->nlowerboundinf = ncomponents;

(*problem)->nfeascomps = 0;

(*problem)->nsolvedcomps = 0;

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

assert(problem !=

);

assert(*problem !=

);

= (*problem)->scip;

( (*problem)->bestsol !=

)

( c = (*problem)->ncomponents - 1; c >= 0; --c )

( (*problem)->components !=

)

( conshdlr ==

)

* conscomponent,

* firstvaridxpercons,

* ncompsminsize,

assert(conshdlrdata !=

);

assert(digraph !=

);

assert(conss !=

);

assert(vars !=

);

assert(firstvaridxpercons !=

);

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

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

ncontvars = ncvars - nintvars - nbinvars;

ndiscvars = (int)(nbinvars + conshdlrdata->intfactor * nintvars);

compsize[c] = nbinvars + conshdlrdata->intfactor * nintvars + conshdlrdata->contfactor * ncontvars;

( ndiscvars <= conshdlrdata->maxintvars && compsize[c] <= conshdlrdata->maxcompweight )

( ncvars >= minsize )

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

conscomponent[permu[c]] = c;

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

varcomponent[c] = conscomponent[varcomponent[c]];

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

conscomponent[c] = (firstvaridxpercons[c] == -1 ? -1 : varcomponent[firstvaridxpercons[c]]);

* compstartsvars,

* compstartsconss,

assert((*problem)->components !=

);

( comp = 0; comp < ncomponents; comp++ )

assert((*problem)->ncomponents == comp+1);

component = &(*problem)->components[comp];

compvars = &(sortedvars[compstartsvars[comp]]);

component->

= compstartsvars[comp + 1 ] - compstartsvars[comp];

compconss = &(sortedconss[compstartsconss[comp]]);

ncompconss = compstartsconss[comp + 1] - compstartsconss[comp];

( component->

> 1 && ncompconss > 1 )

( i = 0; i < component->

; ++i )

(

,

,

component->

, nbinvars, nintvars, ncontvars, ncompconss);

assert(ncompconss > 0 || component->

== 1);

(

,

,

component->

, (*problem)->name, component->

, ncompconss);

( i = 0; i < component->

; ++i )

assert(problem !=

);

*result = subscipresult;

( !component->

)

* unfixedvarpos,

* firstvaridxpercons,

assert(digraph !=

);

assert(conss !=

);

assert(firstvaridxpercons !=

);

assert(success !=

);

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

( nconsvars > nvars )

( nconsvars == nvars )

assert(nconsvars < nvars);

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

assert(consvars[v] !=

);

( nconsvars < nvars )

assert(consvars[nconsvars] ==

);

assert(requiredsize <= nvars);

firstvaridxpercons[c] = -1;

( nconsvars > 0 )

( idx1 == -1 && v < nconsvars )

idx1 = unfixedvarpos[idx1];

assert(idx1 < nunfixedvars);

firstvaridxpercons[c] = idx1;

(; v < nconsvars; ++v )

idx2 = unfixedvarpos[idx2];

assert(idx2 < nunfixedvars);

* compstartsvars,

* compstartsconss,

* ncompsminsize,

assert(conshdlrdata !=

);

assert(sortedvars !=

);

assert(sortedconss !=

);

assert(compstartsvars !=

);

assert(compstartsconss !=

);

assert(nsortedvars !=

);

assert(nsortedconss !=

);

assert(ncomponents !=

);

assert(ncompsminsize !=

);

assert(ncompsmaxsize !=

);

( fixedvarsobjsum !=

)

*fixedvarsobjsum = 0.0;

(*nsortedconss) = 0;

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

sortedconss[(*nsortedconss)] = tmpconss[c];

( nvars > 1 && *nsortedconss > 1 )

* unfixedvarpos;

* firstvaridxpercons;

nunfixedvars = 0;

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

assert(nunfixedvars <= v);

sortedvars[nunfixedvars] = vars[v];

unfixedvarpos[v] = nunfixedvars;

unfixedvarpos[v] = -1;

*nsortedvars = nunfixedvars;

( nunfixedvars > 0 )

(

(

, digraph, sortedconss, *nsortedconss, unfixedvarpos, nunfixedvars, firstvaridxpercons, &success) );

* conscomponent;

( *ncomponents > 1 )

nconss = *nsortedconss;

nvars = *nsortedvars;

,

(

(

, conshdlrdata, digraph, sortedconss, sortedvars, varcomponent, conscomponent, nconss, *nsortedvars,

firstvaridxpercons, ncompsminsize, ncompsmaxsize) );

( i < nconss && conscomponent[i] == -1 )

( c = 0; c < *ncomponents + 1; ++c )

assert(i == nconss || conscomponent[i] >= c);

compstartsconss[c] = i;

( i < nconss && conscomponent[i] == c )

( c = 0, i = 0; c < *ncomponents + 1; ++c )

assert(i == nvars || varcomponent[i] >= c);

compstartsvars[c] = i;

( i < nvars && varcomponent[i] == c )

( c = 0; c < *ncomponents; ++c )

( i = compstartsconss[c]; i < compstartsconss[c+1]; ++i )

assert(conscomponent[i] == c);

( i = compstartsvars[c]; i < compstartsvars[c+1]; ++i )

assert(varcomponent[i] == c);

assert(conshdlr !=

);

assert(conshdlrdata !=

);

assert(conshdlr !=

);

assert(result !=

);

assert(conshdlrdata !=

);

(

(

) + conshdlrdata->subscipdepth > conshdlrdata->maxdepth

* compstartsvars;

* compstartsconss;

compstartsconss, &nsortedvars, &nsortedconss, &ncomponents, &ncompsminsize, &ncompsmaxsize) );

( ncompsminsize > 1 )

(

,

,

( ncomponents > ncompsminsize )

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

size = compstartsvars[c+1] - compstartsvars[c];

( size >= minsize )

compstartsvars[m] = compstartsvars[c+1];

compstartsconss[m] = compstartsconss[c+1];

( c == ncomponents - 1 )

assert(m == ncompsminsize);

compstartsvars[m] = compstartsvars[c+1];

compstartsconss[m] = compstartsconss[c+1];

assert(m == ncompsminsize);

assert(compstartsvars[m] == nsortedvars);

assert(compstartsconss[m] == nsortedconss);

compstartsconss, ncomponents, &problem) );

( problem !=

)

( nodelimit == -1 )

( problem !=

)

* compstartsvars;

* compstartsconss;

assert(conshdlr !=

);

assert(result !=

);

assert(conshdlrdata !=

);

compstartsconss, &nsortedvars, &nsortedconss, &ncomponents, &ncompsminsize, &ncompsmaxsize) );

( ncompsmaxsize > 0 )

(

,

,

( subscip ==

)

compvars = &(sortedvars[compstartsvars[comp]]);

ncompvars = compstartsvars[comp + 1 ] - compstartsvars[comp];

compconss = &(sortedconss[compstartsconss[comp]]);

ncompconss = compstartsconss[comp + 1] - compstartsconss[comp];

( ncompconss == 0 )

assert(ncompvars == 1);

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

(

,

,

comp, ncompvars, nbinvars, nintvars, ncontvars, ncompconss);

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

compconss, varmap, consmap, ncompvars, ncompconss, &success) );

( debugsol !=

)

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

( subvars[i] !=

)

ncompvars, ncompconss, ndelconss, nfixedvars, nchgbds, result, &solved) );

( nsolved == ncomponents - 1 )

assert(conshdlr !=

);

assert(consdata !=

);

assert(*consdata !=

);

assert(result !=

);

assert(nconss == 0);

conshdlrdata->subscipdepth = 0;

assert(conshdlr !=

);

,

,

,

,

,

,

,

,

,

static SCIP_RETCODE copyToSubscip(SCIP *scip, SCIP *subscip, const char *name, SCIP_VAR **vars, SCIP_VAR **subvars, SCIP_CONS **conss, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, int nvars, int nconss, SCIP_Bool *success)

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_CHECKPRIORITY

#define DEFAULT_CONTFACTOR

#define DEFAULT_MINRELSIZE

static SCIP_RETCODE createConsComponents(SCIP *scip, SCIP_CONS **cons, const char *name, PROBLEM *problem)

static SCIP_RETCODE createAndSplitProblem(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_Real fixedvarsobjsum, SCIP_VAR **sortedvars, SCIP_CONS **sortedconss, int *compstartsvars, int *compstartsconss, int ncomponents, PROBLEM **problem)

static SCIP_RETCODE initComponent(PROBLEM *problem)

static SCIP_RETCODE fillDigraph(SCIP *scip, SCIP_DIGRAPH *digraph, SCIP_CONS **conss, int nconss, int *unfixedvarpos, int nunfixedvars, int *firstvaridxpercons, SCIP_Bool *success)

static int getMinsize(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)

#define CONSHDLR_PROP_TIMING

#define DEFAULT_FEASTOLFACTOR

#define consEnfolpComponents

static SCIP_DECL_CONSDELETE(consDeleteComponents)

#define CONSHDLR_MAXPREROUNDS

#define consEnfopsComponents

#define DEFAULT_MAXINTVARS

static SCIP_RETCODE componentSetupWorkingSol(COMPONENT *component, SCIP_HASHMAP *varmap)

static SCIP_DECL_SORTPTRCOMP(componentSort)

static SCIP_RETCODE freeProblem(PROBLEM **problem)

static SCIP_DECL_CONSENFORELAX(consEnforelaxComponents)

static SCIP_RETCODE componentCreateSubscip(COMPONENT *component, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_CONS **conss, int nconss, SCIP_Bool *success)

static SCIP_RETCODE createSubscip(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP **subscip)

#define DEFAULT_INTFACTOR

#define DEFAULT_NODELIMIT

static SCIP_DECL_CONSFREE(conshdlrFreeComponents)

static SCIP_RETCODE sortComponents(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *digraph, SCIP_CONS **conss, SCIP_VAR **vars, int *varcomponent, int *conscomponent, int nconss, int nvars, int *firstvaridxpercons, int *ncompsminsize, int *ncompsmaxsize)

#define DEFAULT_MAXCOMPWEIGHT

#define consCheckComponents

static SCIP_RETCODE solveProblem(PROBLEM *problem, SCIP_RESULT *result)

static SCIP_DECL_CONSPROP(consPropComponents)

#define CONSHDLR_PROPFREQ

static SCIP_RETCODE solveSubscip(SCIP *scip, SCIP *subscip, SCIP_Longint nodelimit, SCIP_Real gaplimit)

static SCIP_RETCODE solveComponent(COMPONENT *component, SCIP_Bool lastcomponent, SCIP_RESULT *result)

#define CONSHDLR_PRESOLTIMING

static SCIP_DECL_CONSINITSOL(consInitsolComponents)

static SCIP_RETCODE freeComponent(COMPONENT *component)

static SCIP_DECL_CONSLOCK(consLockComponents)

#define CONSHDLR_EAGERFREQ

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopyComponents)

#define CONSHDLR_ENFOPRIORITY

static SCIP_DECL_CONSPRESOL(consPresolComponents)

static SCIP_RETCODE solveAndEvalSubscip(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP *subscip, SCIP_VAR **vars, SCIP_VAR **subvars, SCIP_CONS **conss, int nvars, int nconss, int *ndeletedconss, int *nfixedvars, int *ntightenedbounds, SCIP_RESULT *result, SCIP_Bool *solved)

static SCIP_RETCODE findComponents(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_Real *fixedvarsobjsum, SCIP_VAR **sortedvars, SCIP_CONS **sortedconss, int *compstartsvars, int *compstartsconss, int *nsortedvars, int *nsortedconss, int *ncomponents, int *ncompsminsize, int *ncompsmaxsize)

static SCIP_RETCODE initProblem(SCIP *scip, PROBLEM **problem, SCIP_Real fixedvarsobjsum, int ncomponents)

struct Component COMPONENT

#define CONSHDLR_DELAYPROP

constraint handler for handling independent components

#define SCIPdebugGetSolVal(scip, var, val)

#define SCIPdebugSolEnable(scip)

#define SCIPdebugAddSolVal(scip, var, val)

#define SCIPdebugSolIsEnabled(scip)

#define SCIPdebugSolIsValidInSubtree(scip, isvalidinsubtree)

#define SCIP_LONGINT_FORMAT

SCIP_RETCODE SCIPincludeConshdlrComponents(SCIP *scip)

SCIP_RETCODE SCIPcopyPlugins(SCIP *sourcescip, SCIP *targetscip, SCIP_Bool copyreaders, SCIP_Bool copypricers, SCIP_Bool copyconshdlrs, SCIP_Bool copyconflicthdlrs, SCIP_Bool copypresolvers, SCIP_Bool copyrelaxators, SCIP_Bool copyseparators, SCIP_Bool copycutselectors, SCIP_Bool copypropagators, SCIP_Bool copyheuristics, SCIP_Bool copyeventhdlrs, SCIP_Bool copynodeselectors, SCIP_Bool copybranchrules, SCIP_Bool copydisplays, SCIP_Bool copydialogs, SCIP_Bool copytables, SCIP_Bool copyexprhdlrs, SCIP_Bool copynlpis, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)

SCIP_RETCODE SCIPgetConsCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_CONS *sourcecons, SCIP_CONS **targetcons, SCIP_CONSHDLR *sourceconshdlr, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)

SCIP_RETCODE SCIPcopyProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, const char *name)

SCIP_RETCODE SCIPcopyParamSettings(SCIP *sourcescip, SCIP *targetscip)

SCIP_RETCODE SCIPcopyLimits(SCIP *sourcescip, SCIP *targetscip)

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

SCIP_RETCODE SCIPdigraphComputeUndirectedComponents(SCIP_DIGRAPH *digraph, int minsize, int *components, int *ncomponents)

void SCIPdigraphGetComponent(SCIP_DIGRAPH *digraph, int compidx, int **nodes, int *nnodes)

SCIP_RETCODE SCIPdigraphAddArc(SCIP_DIGRAPH *digraph, int startnode, int endnode, void *data)

SCIP_RETCODE SCIPdigraphSetSizes(SCIP_DIGRAPH *digraph, int *sizes)

void SCIPdigraphFree(SCIP_DIGRAPH **digraph)

int SCIPdigraphGetNComponents(SCIP_DIGRAPH *digraph)

SCIP_RETCODE SCIPcreateDigraph(SCIP *scip, SCIP_DIGRAPH **digraph, int nnodes)

SCIP_Bool SCIPisPresolveFinished(SCIP *scip)

SCIP_Bool SCIPisStopped(SCIP *scip)

SCIP_RETCODE SCIPfree(SCIP **scip)

SCIP_RETCODE SCIPcreate(SCIP **scip)

SCIP_STATUS SCIPgetStatus(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

int SCIPgetNIntVars(SCIP *scip)

int SCIPgetNImplVars(SCIP *scip)

const char * SCIPgetProbName(SCIP *scip)

int SCIPgetNContVars(SCIP *scip)

SCIP_CONS ** SCIPgetConss(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNConss(SCIP *scip)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

int SCIPgetNOrigVars(SCIP *scip)

int SCIPgetNBinVars(SCIP *scip)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)

SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)

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

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

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

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

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

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

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

SCIP_PARAM * SCIPgetParam(SCIP *scip, const char *name)

SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)

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

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

SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)

SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)

SCIP_RETCODE SCIPgetLongintParam(SCIP *scip, const char *name, SCIP_Longint *value)

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

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

SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)

void SCIPpqueueFree(SCIP_PQUEUE **pqueue)

SCIP_RETCODE SCIPpqueueInsert(SCIP_PQUEUE *pqueue, void *elem)

int SCIPpqueueNElems(SCIP_PQUEUE *pqueue)

SCIP_RETCODE SCIPpqueueCreate(SCIP_PQUEUE **pqueue, int initsize, SCIP_Real sizefac, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_DECL_PQUEUEELEMCHGPOS((*elemchgpos)))

void * SCIPpqueueRemove(SCIP_PQUEUE *pqueue)

void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)

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

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

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

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

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

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

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

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

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

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

SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)

SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)

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

SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

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

const char * SCIPheurGetName(SCIP_HEUR *heur)

SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

SCIP_Longint SCIPgetMemUsed(SCIP *scip)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

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

#define SCIPfreeMemoryArray(scip, ptr)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

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

SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)

int SCIPgetNActivePricers(SCIP *scip)

SCIP_Bool SCIPinProbing(SCIP *scip)

SCIP_RETCODE SCIPcheckSolOrig(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)

SCIP_SOL * SCIPgetBestSol(SCIP *scip)

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

SCIP_Real SCIPsolGetOrigObj(SCIP_SOL *sol)

SCIP_RETCODE SCIPprintBestSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)

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

int SCIPgetNSols(SCIP *scip)

SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)

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

SCIP_RETCODE SCIPaddSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *stored)

int SCIPsolGetIndex(SCIP_SOL *sol)

SCIP_RETCODE SCIPcheckSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *feasible)

SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)

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

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

SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)

SCIP_Real SCIPretransformObj(SCIP *scip, SCIP_Real obj)

void SCIPsolSetHeur(SCIP_SOL *sol, SCIP_HEUR *heur)

SCIP_RETCODE SCIPtransformProb(SCIP *scip)

SCIP_RETCODE SCIPfreeTransform(SCIP *scip)

SCIP_RETCODE SCIPinterruptSolve(SCIP *scip)

SCIP_RETCODE SCIPsolve(SCIP *scip)

void SCIPaddNNodes(SCIP *scip, SCIP_Longint nnodes)

SCIP_Real SCIPgetPrimalbound(SCIP *scip)

SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)

SCIP_Real SCIPgetGap(SCIP *scip)

SCIP_Longint SCIPgetNNodes(SCIP *scip)

SCIP_Real SCIPgetDualbound(SCIP *scip)

SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)

SCIP_Real SCIPgetCutoffbound(SCIP *scip)

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

SCIP_Real SCIPgetSolvingTime(SCIP *scip)

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

SCIP_Real SCIPinfinity(SCIP *scip)

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

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

SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

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

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

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

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

SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)

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

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

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPinRepropagation(SCIP *scip)

int SCIPgetDepth(SCIP *scip)

SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)

SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

int SCIPvarGetIndex(SCIP_VAR *var)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

void SCIPvarMarkDeleteGlobalStructures(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

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

SCIP_RETCODE SCIPgetActiveVars(SCIP *scip, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)

int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_Bool SCIPallowWeakDualReds(SCIP *scip)

SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)

void SCIPsortIntPtr(int *intarray, void **ptrarray, int len)

void SCIPsortRealInt(SCIP_Real *realarray, int *intarray, int len)

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

memory allocation routines

#define BMSclearMemoryArray(ptr, num)

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

public methods for managing constraints

public methods for primal heuristics

public methods for message output

public data structures and miscellaneous methods

methods for sorting joint arrays of various types

public methods for primal CIP solutions

public methods for branch and bound tree

public methods for problem variables

public methods for constraint handler plugins and constraints

public methods for problem copies

public methods for data structures

public methods for primal heuristic plugins and divesets

public methods for memory management

public methods for message handling

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for variable pricer plugins

public methods for global and local (sub)problems

public methods for the probing mode

public methods for solutions

public methods for querying solving statistics

public methods for timing

public methods for the branch-and-bound tree

public methods for SCIP variables

SCIP_Real fixedvarsobjsum

SCIP_Real lastprimalbound

struct SCIP_ConshdlrData SCIP_CONSHDLRDATA

struct SCIP_ConsData SCIP_CONSDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STATUS_TOTALNODELIMIT

@ SCIP_STATUS_BESTSOLLIMIT

@ SCIP_STATUS_PRIMALLIMIT

@ SCIP_STATUS_USERINTERRUPT

@ SCIP_STATUS_STALLNODELIMIT

@ SCIP_STATUS_RESTARTLIMIT

enum SCIP_Status SCIP_STATUS

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