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

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

SCIP Doxygen Documentation: cons_sos2.c Source File

SCIP_ConshdlrData

*infeasible =

;

(

(

, &cons,

, 1, &var, &val, 0.0, 0.0,

,

,

,

,

,

*infeasible =

;

*tightened = *tightened || tighten;

*tightened = *tightened || tighten;

assert( cons !=

);

assert( var !=

);

assert( cons !=

);

assert( var !=

);

assert( consdata !=

);

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

( num > consdata->maxvars )

( reserveWeights )

consdata->maxvars = newsize;

assert( num <= consdata->maxvars );

assert( cons !=

);

assert( consdata !=

);

assert( var !=

);

assert( conshdlrdata !=

);

assert( conshdlrdata->eventhdlr !=

);

assert( consdata->nfixednonzeros >= 0 );

++consdata->nfixednonzeros;

( consdata->row !=

)

assert( var !=

);

assert( cons !=

);

assert( consdata !=

);

( consdata->weights ==

&& consdata->maxvars > 0 )

assert( var !=

);

assert( consdata->weights !=

);

assert( consdata->maxvars >= consdata->nvars+1 );

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

( consdata->weights[pos] > weight )

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

(j = consdata->nvars; j > pos; --j)

consdata->vars[j] = consdata->vars[j-1];

consdata->weights[j] = consdata->weights[j-1];

consdata->vars[pos] = var;

consdata->weights[pos] = weight;

assert( var !=

);

assert( cons !=

);

assert( consdata !=

);

assert( consdata->nvars >= 0 );

assert( var !=

);

( consdata->weights !=

)

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

( consdata->weights !=

)

( consdata->nvars > 0 )

consdata->weights[consdata->nvars] = consdata->weights[consdata->nvars-1] + 1.0;

consdata->weights[consdata->nvars] = 0.0;

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

(j = pos; j < consdata->nvars-1; ++j)

consdata->vars[j] = consdata->vars[j+1];

( consdata->weights !=

)

consdata->weights[j] = consdata->weights[j+1];

lastFixedNonzero;

localnremovedvars;

assert( cons !=

);

assert( consdata !=

);

assert( eventhdlr !=

);

assert( cutoff !=

);

assert( success !=

);

assert( ndelconss !=

);

assert( nfixedvars !=

);

assert( nremovedvars !=

);

( consdata->nvars <= 2 )

lastFixedNonzero = -1;

vars = consdata->vars;

lastzero = consdata->nvars;

localnremovedvars = 0;

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

assert(vars == consdata->vars);

( lastFixedNonzero != -1 && lastFixedNonzero != j + 1 )

(

,

);

( nfixednonzeros > 2 )

(

,

);

( lastFixedNonzero == -1)

lastFixedNonzero = j;

( j == consdata->nvars - 1 )

( lastzero > j + 1 )

lastzero = consdata->nvars;

assert(vars == consdata->vars);

( lastzero < consdata->nvars )

assert(lastzero >= 0);

( j = lastzero; j >= 0; --j )

localnremovedvars += (lastzero + 1);

assert(vars == consdata->vars);

*nremovedvars += localnremovedvars;

( lastFixedNonzero >= 0 )

lastFixedNonzero -= localnremovedvars;

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

( consdata->nvars <= 2 )

oldnfixedvars = *nfixedvars;

( nfixednonzeros == 1 )

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

( j = 0; j < lastFixedNonzero - 1; ++j )

( j = lastFixedNonzero + 2; j < consdata->nvars; ++j )

( *nfixedvars > oldnfixedvars )

( nfixednonzeros == 2 )

assert(0 < lastFixedNonzero && lastFixedNonzero < consdata->nvars);

( j = 0; j < lastFixedNonzero - 1; ++j )

( j = lastFixedNonzero + 1; j < consdata->nvars; ++j )

assert( cons !=

);

assert( consdata !=

);

assert( cutoff !=

);

assert( ngen !=

);

( consdata->nfixednonzeros > 2 )

(

,

);

( consdata->nfixednonzeros == 1 )

firstFixedNonzero;

firstFixedNonzero = -1;

nvars = consdata->nvars;

vars = consdata->vars;

assert( vars !=

);

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

firstFixedNonzero = j;

assert( firstFixedNonzero >= 0 );

(j = 0; j < firstFixedNonzero-1; ++j)

assert( ! infeasible );

(j = firstFixedNonzero+2; j < nvars; ++j)

(

,

,

( consdata->nfixednonzeros == 2 )

firstFixedNonzero;

firstFixedNonzero = -1;

nvars = consdata->nvars;

vars = consdata->vars;

assert( vars !=

);

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

firstFixedNonzero = j;

assert( 0 <= firstFixedNonzero && firstFixedNonzero < nvars-1 );

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

assert( ! infeasible );

allVarFixed = allVarFixed && success;

(j = firstFixedNonzero+2; j < nvars; ++j)

(

,

,

allVarFixed = allVarFixed && success;

( *ngen > ngenold )

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

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

assert( cons !=

);

assert( consdata !=

);

nvars = consdata->nvars;

vars = consdata->vars;

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

assert( 0 < lastNonzero && lastNonzero < nvars );

= weight1/weight2;

assert( 0 <= ind && ind < nvars-1 );

( cnt > maxNonzeros )

assert( consdata !=

);

nvars = consdata->nvars;

vars = consdata->vars;

assert( 0 < maxInd && maxInd < nvars-1 );

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

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

assert( ! infeasible );

(j = maxInd+1; j < nvars; ++j)

(j = maxInd+1; j < nvars; ++j)

assert( ! infeasible );

assert( conshdlr !=

);

assert( cons !=

);

assert( consdata !=

);

assert( consdata->row ==

);

nvars = consdata->nvars;

vars = consdata->vars;

assert( vars !=

);

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

lhs = minLb + minLb2;

rhs = maxUb + maxUb2;

consdata->row = row;

assert( conshdlr !=

);

assert( conshdlr !=

);

assert(conshdlrdata !=

);

assert( conshdlr !=

);

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

assert( conss !=

);

assert( conss[c] !=

);

assert( consdata !=

);

( consdata->row !=

)

assert( conshdlr !=

);

assert( cons !=

);

assert( consdata !=

);

assert( conshdlrdata !=

);

assert( conshdlrdata->eventhdlr !=

);

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

( (*consdata)->weights !=

)

( (*consdata)->row !=

)

assert( (*consdata)->row ==

);

assert( conshdlr !=

);

assert( sourcecons !=

);

assert( targetcons !=

);

assert( conshdlrdata !=

);

assert( conshdlrdata->eventhdlr !=

);

assert( sourcedata !=

);

assert( sourcedata->nvars > 0 );

assert( sourcedata->nvars <= sourcedata->maxvars );

consdata->nvars = sourcedata->nvars;

consdata->maxvars = sourcedata->nvars;

consdata->row =

;

consdata->nfixednonzeros = 0;

( sourcedata->weights !=

)

consdata->weights =

;

(j = 0; j < sourcedata->nvars; ++j)

assert( sourcedata->vars[j] != 0 );

++(consdata->nfixednonzeros);

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

( consdata->nfixednonzeros > 0 )

(

oldnfixedvars = *nfixedvars; )

(

oldndelconss = *ndelconss; )

assert( conshdlr !=

);

assert( result !=

);

( nrounds == 0 || nnewfixedvars > 0 || nnewaggrvars > 0 || nnewchgcoefs > 0 )

assert( eventhdlr !=

);

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

assert( conss !=

);

assert( conss[c] !=

);

assert( consdata !=

);

assert( consdata->nvars >= 0 );

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

(*nchgcoefs) += nremovedvars;

(

(

,

,

*nfixedvars - oldnfixedvars, nremovedvars, *ndelconss - oldndelconss); )

assert( conshdlr !=

);

*infeasible =

;

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

assert( conss !=

);

assert( conss[c] !=

);

assert( consdata !=

);

( consdata->row ==

)

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

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

assert( conss[c] !=

);

assert( consdata !=

);

( consdata->row ==

)

row = consdata->row;

( ngen > 0 )

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

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

assert( conss[c] !=

);

assert( consdata !=

);

row = consdata->row;

( ngen > 0 )

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

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

|| completely); ++c)

assert( conss[c] !=

);

assert( consdata !=

);

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

( firstNonzero < 0 )

( j > firstNonzero+1 )

assert( conshdlr !=

);

assert( conss !=

);

assert( result !=

);

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

assert( conss[c] !=

);

assert( consdata !=

);

assert( cons !=

);

assert( infervar !=

);

assert( bdchgidx !=

);

assert( result !=

);

assert( consdata !=

);

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

var = consdata->vars[inferinfo];

assert( var != infervar );

assert( conshdlr !=

);

assert( cons !=

);

assert( consdata !=

);

vars = consdata->vars;

nvars = consdata->nvars;

assert( vars !=

);

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

assert( conshdlr !=

);

assert( cons !=

);

assert( consdata !=

);

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

( consdata->weights ==

)

* consname;

assert( sourcescip !=

);

assert( sourcecons !=

);

assert( valid !=

);

assert( sourceconsdata !=

);

nvars = sourceconsdata->nvars;

assert( nvars >= 0 );

( sourceconsdata->weights !=

)

sourcevars = sourceconsdata->vars;

(v = 0; v < nvars && *valid; ++v)

assert( sourcevars !=

);

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

(

(

, cons, name, 0,

,

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

( *s !=

)

t = strchr(t,

);

(

, s);

weight = strtod(s, &t);

t = strchr(t,

);

(

, s);

assert(consdata !=

);

( varssize < consdata->nvars )

(*success) =

;

assert(vars !=

);

assert(consdata !=

);

(*nvars) = consdata->nvars;

assert(success !=

);

assert(consdata !=

);

nconsvars = consdata->nvars;

assert(consvars !=

);

( i = 0; i < nconsvars - 1; ++i )

( j = i; j < i + 2; ++j )

locvars[0] = consvars[j];

assert(success !=

);

assert(consdata !=

);

nconsvars = consdata->nvars;

assert(consvars !=

);

( i = 0; i < nconsvars - 1; ++i )

( j = i; j < i + 2; ++j )

locvars[0] = consvars[j];

allownegation =

;

( allownegation )

( k = 0; k < nlocvars; ++k )

assert( eventhdlr !=

);

assert( eventdata !=

);

assert( event !=

);

assert( cons !=

);

assert( consdata !=

);

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

( eventtype )

++(consdata->nfixednonzeros);

++(consdata->nfixednonzeros);

--(consdata->nfixednonzeros);

--(consdata->nfixednonzeros);

assert(var !=

);

assert(var !=

);

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

oldbound, newbound, consdata->nfixednonzeros);

conshdlrdata->eventhdlr =

;

eventExecSOS2,

) );

( conshdlrdata->eventhdlr ==

)

consEnfolpSOS2, consEnfopsSOS2, consCheckSOS2, consLockSOS2, conshdlrdata) );

assert(conshdlr !=

);

modifiable =

;

( conshdlr ==

)

consdata->vars =

;

consdata->nvars = nvars;

consdata->maxvars = nvars;

consdata->row =

;

consdata->nfixednonzeros = -1;

consdata->weights =

;

( weights !=

)

assert( weights ==

);

(

(

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

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

(

(

, cons, name, nvars, vars, weights,

,

,

,

,

,

,

,

,

) );

assert( var !=

);

assert( cons !=

);

assert( var !=

);

assert( cons !=

);

assert( cons !=

);

assert( consdata !=

);

consdata->nvars;

assert( cons !=

);

assert( consdata !=

);

consdata->vars;

assert( cons !=

);

assert( consdata !=

);

consdata->weights;

static SCIP_RETCODE branchCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)

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

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_SEPAFREQ

static SCIP_DECL_CONSGETNVARS(consGetNVarsSOS2)

static SCIP_RETCODE propSOS2(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_Bool *cutoff, int *ngen)

#define CONSHDLR_CHECKPRIORITY

static SCIP_DECL_CONSSEPASOL(consSepasolSOS2)

#define CONSHDLR_PROP_TIMING

static SCIP_DECL_CONSEXITSOL(consExitsolSOS2)

static SCIP_DECL_CONSCOPY(consCopySOS2)

static SCIP_DECL_CONSRESPROP(consRespropSOS2)

static SCIP_RETCODE handleNewVariableSOS2(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Bool transformed)

static SCIP_RETCODE deleteVarSOS2(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos)

#define CONSHDLR_MAXPREROUNDS

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopySOS2)

#define CONSHDLR_SEPAPRIORITY

static SCIP_DECL_CONSPARSE(consParseSOS2)

static SCIP_DECL_CONSINITLP(consInitlpSOS2)

static SCIP_DECL_CONSENFORELAX(consEnforelaxSOS2)

static SCIP_DECL_EVENTEXEC(eventExecSOS2)

static SCIP_DECL_CONSENFOLP(consEnfolpSOS2)

static SCIP_RETCODE presolRoundSOS2(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, SCIP_Bool *success, int *ndelconss, int *nfixedvars, int *nremovedvars)

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

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

static SCIP_DECL_CONSCHECK(consCheckSOS2)

static SCIP_RETCODE fixVariableZeroNode(SCIP *scip, SCIP_VAR *var, SCIP_NODE *node, SCIP_Bool *infeasible)

static SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(consGetSignedPermsymGraphSOS2)

static SCIP_RETCODE inferVariableZero(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened, SCIP_Bool *success)

static SCIP_DECL_CONSPRESOL(consPresolSOS2)

static SCIP_DECL_CONSDELETE(consDeleteSOS2)

static SCIP_DECL_CONSENFOPS(consEnfopsSOS2)

static SCIP_DECL_CONSFREE(consFreeSOS2)

static SCIP_DECL_CONSGETVARS(consGetVarsSOS2)

static SCIP_DECL_CONSTRANS(consTransSOS2)

#define CONSHDLR_PROPFREQ

static SCIP_DECL_CONSGETPERMSYMGRAPH(consGetPermsymGraphSOS2)

#define CONSHDLR_PRESOLTIMING

#define CONSHDLR_EAGERFREQ

#define EVENTHDLR_EVENT_TYPE

#define CONSHDLR_ENFOPRIORITY

#define CONSHDLR_DELAYSEPA

static SCIP_RETCODE generateRowSOS2(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_Bool local)

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

static SCIP_RETCODE addVarSOS2(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real weight)

static SCIP_RETCODE consdataEnsurevarsSizeSOS2(SCIP *scip, SCIP_CONSDATA *consdata, int num, SCIP_Bool reserveWeights)

static SCIP_DECL_CONSPRINT(consPrintSOS2)

static SCIP_DECL_CONSLOCK(consLockSOS2)

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

static SCIP_DECL_CONSPROP(consPropSOS2)

static SCIP_DECL_CONSSEPALP(consSepalpSOS2)

#define CONSHDLR_DELAYPROP

constraint handler for SOS type 2 constraints

SCIP_Real * SCIPgetWeightsSOS2(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR ** SCIPgetVarsSOS2(SCIP *scip, SCIP_CONS *cons)

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

int SCIPgetNVarsSOS2(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsSOS2(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPaddVarSOS2(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real weight)

SCIP_RETCODE SCIPcreateConsBasicSOS2(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights)

SCIP_RETCODE SCIPincludeConshdlrSOS2(SCIP *scip)

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_Bool SCIPisTransformed(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)

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

SCIP_Real SCIPgetLocalTransEstimate(SCIP *scip)

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

SCIP_Real SCIPcalcNodeselPriority(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdir, SCIP_Real targetvalue)

SCIP_Real SCIPcalcChildEstimateIncrease(SCIP *scip, SCIP_VAR *var, SCIP_Real varsol, SCIP_Real targetvalue)

SCIP_RETCODE SCIPcreateChild(SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)

SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)

SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)

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

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

SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))

SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)

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

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

SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)))

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

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

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

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

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

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

SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)))

SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))

SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))

SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))

SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))

SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))

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

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_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)

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)

SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)

SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)

SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)

const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)

SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)

SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)

SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)

SCIP_Real SCIPeventGetOldbound(SCIP_EVENT *event)

SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)

SCIP_Real SCIPeventGetNewbound(SCIP_EVENT *event)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

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

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBufferArrayNull(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

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

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

SCIP_RETCODE SCIPchgRowLhs(SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)

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

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)

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

SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)

SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)

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

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

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)

SCIP_Bool 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 SCIPisFeasPositive(SCIP *scip, SCIP_Real val)

SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)

SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)

SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)

SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)

SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)

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

const char * SCIPvarGetName(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 SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

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

SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)

SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)

SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)

void SCIPsortRealPtr(SCIP_Real *realarray, void **ptrarray, int len)

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

SCIP_RETCODE SCIPskipSpace(char **s)

SCIP_RETCODE SCIPaddSymgraphEdge(SCIP *scip, SYM_GRAPH *graph, int first, int second, SCIP_Bool hasval, SCIP_Real val)

SCIP_RETCODE SCIPaddSymgraphOpnode(SCIP *scip, SYM_GRAPH *graph, int op, int *nodeidx)

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

SCIP_RETCODE SCIPaddSymgraphValnode(SCIP *scip, SYM_GRAPH *graph, SCIP_Real val, int *nodeidx)

int SCIPgetSymgraphVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)

SCIP_RETCODE SCIPaddSymgraphConsnode(SCIP *scip, SYM_GRAPH *graph, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, int *nodeidx)

SCIP_RETCODE SCIPaddSymgraphVarAggregation(SCIP *scip, SYM_GRAPH *graph, int rootidx, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real constant)

int SCIPgetSymgraphNegatedVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)

memory allocation routines

#define BMScopyMemoryArray(ptr, source, num)

public methods for managing constraints

public methods for managing events

public methods for LP management

public methods for message output

public data structures and miscellaneous methods

methods for sorting joint arrays of various types

public methods for problem variables

public methods for branching rule plugins and branching

public methods for conflict handler plugins and conflict analysis

public methods for constraint handler plugins and constraints

public methods for problem copies

public methods for cuts and aggregation rows

public methods for event handler plugins and event handlers

public methods for the LP relaxation, rows and columns

public methods for memory management

public methods for message handling

public methods for numerical tolerances

public methods for global and local (sub)problems

public methods for solutions

public methods for SCIP variables

structs for symmetry computations

methods for dealing with symmetry detection graphs

struct SCIP_ConshdlrData SCIP_CONSHDLRDATA

struct SCIP_ConsData SCIP_CONSDATA

#define SCIP_EVENTTYPE_GUBCHANGED

struct SCIP_EventData SCIP_EVENTDATA

#define SCIP_EVENTTYPE_UBTIGHTENED

#define SCIP_EVENTTYPE_LBRELAXED

#define SCIP_EVENTTYPE_GLBCHANGED

#define SCIP_EVENTTYPE_LBTIGHTENED

#define SCIP_EVENTTYPE_UBRELAXED

@ SCIP_BRANCHDIR_DOWNWARDS

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SYM_CONSOPTYPE_SOS2_TUPLE

@ SCIP_VARSTATUS_MULTAGGR

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4