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

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

SCIP Doxygen Documentation: scip_copy.c Source File

assert(cut !=

);

(

, cutsel);

assert(sourcescip !=

);

assert(targetscip !=

);

assert(cuts !=

|| ncuts == 0);

assert(ncutsadded !=

);

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

assert( cuts[c] !=

);

( sourcescip == targetscip )

( i = 0; i < ncols && takecut; ++i )

( sourcescip != targetscip )

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

(sourcescip,

);

assert(sourcescip !=

);

assert(targetscip !=

);

assert(sourcescip->

!=

);

assert(targetscip->

!=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( passmessagehdlr )

copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copycutselectors, copypropagators,

copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copydisplays, copydialogs, copytables, copyexprhdlrs, copynlpis, valid) );

assert(sourcescip !=

);

assert(targetscip !=

);

assert(sourcescip != targetscip);

assert(sourcescip->

!=

);

assert(targetscip->

!=

);

assert(valid !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( p = sourcescip->

->

- 1; p >= 0; --p )

copybendersvalid =

;

threadsafe, &copybendersvalid) );

*valid = *valid && copybendersvalid;

assert(sourcescip !=

);

assert(targetscip !=

);

assert(!original || global);

uselocalvarmap = (varmap ==

);

uselocalconsmap = (consmap ==

);

( uselocalvarmap )

localvarmap = varmap;

( uselocalconsmap )

localconsmap = consmap;

sourceprob = sourcescip->

;

( uselocalvarmap )

( uselocalconsmap )

assert(sourcescip !=

);

assert(targetscip !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(sourcescip !=

);

assert(targetscip !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(sourcescip !=

);

assert(targetscip !=

);

assert(sourcevar !=

);

assert(targetvar !=

);

assert(sourcevar->

== sourcescip);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

uselocalvarmap = (varmap ==

);

uselocalconsmap = (consmap ==

);

( !uselocalvarmap )

( *targetvar !=

)

( uselocalvarmap )

localvarmap = varmap;

( uselocalconsmap )

localconsmap = consmap;

sourcescip, sourcevar, localvarmap, localconsmap, global) );

(

(sourcescip, targetscip, sourceaggrvar, &targetaggrvar, localvarmap, localconsmap, global, success) );

sourcescip, sourcevar, localvarmap, localconsmap, global) );

constant,

,

,

,

,

,

,

,

,

,

) );

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

(

(sourcescip, targetscip, sourceaggrvars[i], &targetaggrvars[i], localvarmap, localconsmap, global, success) );

sourcescip, sourcevar, localvarmap, localconsmap, global) );

-constant,

,

,

,

,

,

,

,

,

,

) );

assert(sourcenegatedvar !=

);

(

(sourcescip, targetscip, sourcenegatedvar, &targetnegatedvar, localvarmap, localconsmap, global, success) );

( uselocalvarmap )

( uselocalconsmap )

( uselocalvarmap )

( uselocalconsmap )

nrelaxonlybinvars = 0;

nrelaxonlyintvars = 0;

nrelaxonlyimplvars = 0;

nrelaxonlycontvars = 0;

assert(sourcescip !=

);

assert(targetscip !=

);

assert(nfixedvars == 0 || fixedvars !=

);

assert(nfixedvars == 0 || fixedvals !=

);

uselocalvarmap = (varmap ==

);

uselocalconsmap = (consmap ==

);

( uselocalvarmap )

localvarmap = varmap;

( uselocalconsmap )

localconsmap = consmap;

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

nrelaxonlybinvars++;

nrelaxonlyintvars++;

nrelaxonlyimplvars++;

nrelaxonlycontvars++;

(

(sourcescip, targetscip, sourcevars[i], &targetvar, localvarmap, localconsmap, global, &success) );

assert(targetvar !=

);

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

assert(targetvar !=

);

infeasible = fixed =

;

assert(!infeasible);

nsourcefixedvars;

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

assert(nsourcefixedvars == nfixedbinvars + nfixedintvars + nfixedimplvars + nfixedcontvars);

( uselocalvarmap )

( uselocalconsmap )

assert(sourcescip !=

);

assert(targetscip !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars,

, global) );

assert(sourcescip !=

);

assert(targetscip !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(nvars == 0 || (sourcevars !=

&& targetvars !=

));

assert(sourcescip != targetscip);

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

( sourcevars[i] ==

|| targetvars[i] ==

)

assert(sourcevars[i]->

== sourcescip);

assert(targetvars[i]->

== targetscip);

( sourcevarstatus )

assert(sourcescip != targetscip);

( i = 0; i < sourcescip->

->

; ++i )

sourcenlpi = sourcescip->

->

[i];

targetnlpi = targetscip->

->

[i];

( targetnlpi !=

)

assert(subscip !=

);

assert(subsol !=

);

assert(subvars !=

);

assert(solvals !=

);

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

( subvars[i] !=

)

assert(subscip !=

);

assert(subsol !=

);

assert(subvars !=

);

assert(newsol !=

);

assert(subscip !=

);

assert(heur !=

);

assert(subvars !=

);

assert(success !=

);

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

( newsol ==

)

( solindex !=

)

assert(newsol ==

);

( newsol !=

)

assert(targetcons !=

);

assert(sourceconshdlr !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

uselocalvarmap = (varmap ==

);

uselocalconsmap = (consmap ==

);

( uselocalvarmap )

localvarmap = varmap;

*targetcons =

;

( uselocalconsmap )

localconsmap = consmap;

( *targetcons !=

)

(

(targetcons, targetscip->

, name, sourcescip, sourceconshdlr, sourcecons, localvarmap, localconsmap,

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

assert(*targetcons ==

|| *valid);

( *targetcons !=

&& !uselocalconsmap )

( uselocalvarmap )

( uselocalconsmap )

nsourceconshdlrs;

assert(sourcescip !=

);

assert(targetscip !=

);

assert(valid !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

uselocalvarmap = (varmap ==

);

uselocalconsmap = (consmap ==

);

( uselocalvarmap )

localvarmap = varmap;

( uselocalconsmap )

localconsmap = consmap;

assert(nsourceconshdlrs == 0 || sourceconshdlrs !=

);

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

assert(sourceconshdlrs[i] !=

);

assert(nsourceconss == 0 || sourceconss !=

);

( nsourceconss > 0 )

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

assert(sourceconss[c] !=

);

(

(sourcescip, targetscip, sourceconss[c], &targetcons, sourceconshdlrs[i], localvarmap, localconsmap,

,

assert(targetcons ==

|| singlevalid);

( targetcons !=

)

( !enablepricing )

(sourcescip,

,

( uselocalvarmap )

( uselocalconsmap )

assert(sourcescip !=

);

assert(targetscip !=

);

assert(valid !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

uselocalvarmap = (varmap ==

);

uselocalconsmap = (consmap ==

);

( uselocalvarmap )

localvarmap = varmap;

( uselocalconsmap )

localconsmap = consmap;

(sourcescip,

, nsourceconss);

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

assert(sourceconss[c] !=

);

assert(targetcons !=

);

( !enablepricing )

( uselocalvarmap )

( uselocalconsmap )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

nlocalcutsadded;

assert(sourcescip !=

);

assert(targetscip !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( ncutsadded !=

)

nlocalcutsadded = 0;

(sourcescip,

);

(

(sourcescip, targetscip, cuts, ncuts, varmap, consmap, global, &nlocalcutsadded) );

(sourcescip,

, nlocalcutsadded);

(

(sourcescip, targetscip, cuts, ncuts, varmap, consmap, global, &nlocalcutsadded) );

( ncutsadded !=

)

*ncutsadded = nlocalcutsadded;

(sourcescip,

, nlocalcutsadded);

sourceconfssize;

assert(sourcescip !=

);

assert(targetscip !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

uselocalvarmap = (varmap ==

);

uselocalconsmap = (consmap ==

);

( uselocalvarmap )

localvarmap = varmap;

( uselocalconsmap )

localconsmap = consmap;

assert(nsourceconfs <= sourceconfssize);

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

assert(sourceconfs[c] !=

);

assert(targetcons !=

);

( !enablepricing )

( uselocalvarmap )

( uselocalconsmap )

assert( sourcescip !=

);

assert( targetscip !=

);

assert( sourcescip != targetscip );

assert( infeasible !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( ncopied !=

)

( nbdchgs !=

)

( nbinvars == 0 )

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

assert( cliques[c] !=

);

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

(

(sourcescip, targetscip, cliquevars[j], &targetclique[j], varmap, consmap, global, &success) );

infeasible, &nboundchg) );

( ncopied !=

)

( nbdchgs !=

)

*nbdchgs += nboundchg;

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

sourcevar = sourcevars[j];

(

(sourcescip, targetscip, sourcevar, &targetvar, varmap, consmap, global, &success) );

(d = 0; d <= 1; ++d)

(l = 0; l < nimpls; ++l)

(

(sourcescip, targetscip, implvars[l], &implvar, varmap, consmap, global, &success) );

( ncopied !=

)

( nbdchgs !=

)

*nbdchgs += nboundchg;

assert(sourcescip !=

);

assert(targetscip !=

);

assert(sourcescip->

!=

);

assert(targetscip->

!=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->subscipdepth;

assert( newdepth > 0 );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->stat->subscipdepth = newdepth;

* suffix,

assert(sourcescip !=

);

assert(targetscip !=

);

assert(suffix !=

);

assert(global || !original);

(

(sourcescip, targetscip,

, enablepricing,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

, passmessagehdlr, &localvalid) );

localvalid =

;

(sourcescip,

, localvalid ?

:

);

uselocalvarmap = (varmap ==

);

uselocalconsmap = (consmap ==

);

( uselocalvarmap )

localvarmap = varmap;

( uselocalconsmap )

localconsmap = consmap;

(

(sourcescip, targetscip, localvarmap, localconsmap, fixedvars, fixedvals, nfixedvars, original, global) );

( useconscompression && (nfixedvars > 0 || !global) )

(sourcescip,

,

nfixedvars, global);

localvalid =

;

(

(sourcescip, targetscip, localvarmap, localconsmap, global, enablepricing, &consscopyvalid) );

(sourcescip,

,

original ?

:

, consscopyvalid ?

:

);

localvalid = localvalid && consscopyvalid;

(sourcescip,

, benderscopyvalid ?

:

);

localvalid = localvalid && benderscopyvalid;

( uselocalvarmap )

( uselocalconsmap )

( copytime < sourcescip->stat->mincopytime )

( valid !=

)

*valid = localvalid;

* suffix,

assert(sourcescip !=

);

assert(targetscip !=

);

assert(suffix !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars,

useconscompression, global, original, enablepricing, threadsafe, passmessagehdlr, valid) );

* suffix,

assert(sourcescip !=

);

assert(targetscip !=

);

assert(suffix !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars,

useconscompression, global, original, enablepricing, threadsafe, passmessagehdlr, valid) );

* suffix,

assert(sourcescip !=

);

assert(targetscip !=

);

assert(suffix !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars,

useconscompression, global, original, enablepricing, threadsafe, passmessagehdlr, valid) );

* suffix,

assert(sourcescip !=

);

assert(targetscip !=

);

assert(suffix !=

);

(

(sourcescip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(targetscip,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars,

useconscompression, global, original, enablepricing, threadsafe, passmessagehdlr, valid) );

timelimit =

(0.0, timelimit);

*success = timelimit > 0.0;

( timelimit < 0.0 )

( memorylimit < 0.0 )

assert(sourcescip !=

);

assert(subscip !=

);

void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)

void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)

SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)

internal methods for clocks and timing issues

SCIP_RETCODE SCIPconflictstoreGetConflicts(SCIP_CONFLICTSTORE *conflictstore, SCIP_CONS **conflicts, int conflictsize, int *nconflicts)

int SCIPconflictstoreGetNConflictsInStore(SCIP_CONFLICTSTORE *conflictstore)

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

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

void SCIPconsSetModifiable(SCIP_CONS *cons, SCIP_Bool modifiable)

internal methods for constraints and constraint handlers

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

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

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 SCIPdebugSolDataCreate(debugsoldata)

#define SCIP_CALL_ABORT(x)

SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)

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 SCIPcopyImplicationsCliques(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *infeasible, int *nbdchgs, int *ncopied)

SCIP_RETCODE SCIPcopyOrig(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_Bool enablepricing, SCIP_Bool threadsafe, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)

void SCIPmergeNLPIStatistics(SCIP *sourcescip, SCIP *targetscip, SCIP_Bool reset)

SCIP_RETCODE SCIPcopyBenders(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_Bool threadsafe, SCIP_Bool *valid)

void SCIPsetSubscipDepth(SCIP *scip, int newdepth)

SCIP_RETCODE SCIPtranslateSubSols(SCIP *scip, SCIP *subscip, SCIP_HEUR *heur, SCIP_VAR **subvars, SCIP_Bool *success, int *solindex)

SCIP_RETCODE SCIPcopyOrigVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars)

SCIP_RETCODE SCIPcopyVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool global)

SCIP_RETCODE SCIPsetCommonSubscipParams(SCIP *sourcescip, SCIP *subscip, SCIP_Longint nsubnodes, SCIP_Longint nstallnodes, int bestsollimit)

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 SCIPcopy(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool threadsafe, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)

SCIP_RETCODE SCIPcopyOrigConsCompression(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool enablepricing, SCIP_Bool threadsafe, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)

SCIP_RETCODE SCIPcopyConsCompression(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool threadsafe, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)

SCIP_RETCODE SCIPcopyOrigConss(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool enablepricing, SCIP_Bool *valid)

SCIP_RETCODE SCIPcheckCopyLimits(SCIP *sourcescip, SCIP_Bool *success)

int SCIPgetSubscipDepth(SCIP *scip)

SCIP_RETCODE SCIPmergeVariableStatistics(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR **sourcevars, SCIP_VAR **targetvars, int nvars)

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 SCIPcopyCuts(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)

SCIP_RETCODE SCIPconvertCutsToConss(SCIP *scip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)

SCIP_RETCODE SCIPenableConsCompression(SCIP *scip)

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

SCIP_RETCODE SCIPtranslateSubSol(SCIP *scip, SCIP *subscip, SCIP_SOL *subsol, SCIP_HEUR *heur, SCIP_VAR **subvars, SCIP_SOL **newsol)

SCIP_Bool SCIPisConsCompressionEnabled(SCIP *scip)

SCIP_RETCODE SCIPcopyConss(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool *valid)

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 SCIPcopyConflicts(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool *valid)

SCIP_RETCODE SCIPcopyOrigProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name)

SCIP_Bool SCIPisTransformed(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

int SCIPgetNIntVars(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)

SCIP_Real SCIPgetOrigObjscale(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)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNConss(SCIP *scip)

SCIP_RETCODE SCIPfreeProb(SCIP *scip)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

SCIP_RETCODE SCIPaddOrigObjoffset(SCIP *scip, SCIP_Real addval)

SCIP_CONS ** SCIPgetOrigConss(SCIP *scip)

SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)

int SCIPgetNFixedVars(SCIP *scip)

int SCIPgetNBinVars(SCIP *scip)

SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

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

SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)

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

SCIP_RETCODE SCIPsetMessagehdlr(SCIP *scip, SCIP_MESSAGEHDLR *messagehdlr)

SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)

void SCIPsetMessagehdlrQuiet(SCIP *scip, SCIP_Bool quiet)

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

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

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

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

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

SCIP_RETCODE SCIPsetSubscipsOff(SCIP *scip, SCIP_Bool quiet)

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

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

SCIP_RETCODE SCIPsetCharParam(SCIP *scip, const char *name, char value)

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

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

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

SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)

SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)

int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)

SCIP_CONS ** SCIPconshdlrGetCheckConss(SCIP_CONSHDLR *conshdlr)

int SCIPgetNConshdlrs(SCIP *scip)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

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

int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)

SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)

SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)

SCIP_Bool SCIPconsIsConflict(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsOriginal(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLocal(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_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

SCIP_CUT ** SCIPgetDelayedPoolCuts(SCIP *scip)

SCIP_Real SCIPcutGetLPActivityQuot(SCIP_CUT *cut)

int SCIPgetNPoolCuts(SCIP *scip)

SCIP_ROW * SCIPcutGetRow(SCIP_CUT *cut)

SCIP_CUT ** SCIPgetPoolCuts(SCIP *scip)

int SCIPgetNDelayedPoolCuts(SCIP *scip)

int SCIPcutGetAge(SCIP_CUT *cut)

SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)

SCIP_Longint SCIPgetMemUsed(SCIP *scip)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

void SCIPnlpiMergeStatistics(SCIP_NLPI *targetnlpi, SCIP_NLPI *sourcenlpi, SCIP_Bool reset)

const char * SCIPnlpiGetName(SCIP_NLPI *nlpi)

SCIP_NODESEL * SCIPfindNodesel(SCIP *scip, const char *name)

int SCIPgetNActivePricers(SCIP *scip)

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

SCIP_Bool SCIProwIsModifiable(SCIP_ROW *row)

int SCIProwGetNNonz(SCIP_ROW *row)

SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)

const char * SCIProwGetName(SCIP_ROW *row)

SCIP_Real SCIProwGetConstant(SCIP_ROW *row)

SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)

SCIP_Real * SCIProwGetVals(SCIP_ROW *row)

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

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

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

SCIP_RETCODE SCIPclearSol(SCIP *scip, SCIP_SOL *sol)

int SCIPgetNSols(SCIP *scip)

int SCIPsolGetIndex(SCIP_SOL *sol)

SCIP_RETCODE SCIPsetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)

SCIP_SOL ** SCIPgetSols(SCIP *scip)

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_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)

SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)

SCIP_Bool SCIPisInRestart(SCIP *scip)

int SCIPgetNRuns(SCIP *scip)

SCIP_Real SCIPgetSolvingTime(SCIP *scip)

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)

SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)

int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetAggrScalar(SCIP_VAR *var)

SCIP_CLIQUE ** SCIPgetCliques(SCIP *scip)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)

SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)

SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)

int SCIPvarGetMultaggrNVars(SCIP_VAR *var)

SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)

int SCIPgetNCliques(SCIP *scip)

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

SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)

SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)

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

SCIP_VAR ** SCIPcliqueGetVars(SCIP_CLIQUE *clique)

int SCIPcliqueGetNVars(SCIP_CLIQUE *clique)

SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)

SCIP_Bool SCIPcliqueIsEquation(SCIP_CLIQUE *clique)

memory allocation routines

SCIP_Bool SCIPmessagehdlrIsQuiet(SCIP_MESSAGEHDLR *messagehdlr)

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

SCIP_RETCODE SCIPprimalCreate(SCIP_PRIMAL **primal)

internal methods for collecting primal CIP solutions and primal informations

void SCIPprobEnableConsCompression(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobCopy(SCIP_PROB **prob, BMS_BLKMEM *blkmem, SCIP_SET *set, const char *name, SCIP *sourcescip, SCIP_PROB *sourceprob, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool original, SCIP_Bool global)

SCIP_Bool SCIPprobIsConsCompressionEnabled(SCIP_PROB *prob)

internal methods for storing and manipulating the main problem

public methods for managing constraints

public methods for storing cuts in a cut pool

public methods for implications, variable bounds, and cliques

public methods for LP management

public methods for message output

#define SCIPdebugPrintCons(x, y, z)

public data structures and miscellaneous methods

public methods for NLP solver interfaces

public methods for primal CIP solutions

public methods for problem variables

public methods for branching rule plugins and branching

public methods for constraint handler plugins and constraints

static SCIP_Bool takeCut(SCIP *scip, SCIP_CUT *cut, char cutsel)

static SCIP_RETCODE doCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool useconscompression, SCIP_Bool global, SCIP_Bool original, SCIP_Bool enablepricing, SCIP_Bool threadsafe, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)

static SCIP_RETCODE copyCuts(SCIP *sourcescip, SCIP *targetscip, SCIP_CUT **cuts, int ncuts, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)

static SCIP_RETCODE translateSubSol(SCIP *scip, SCIP *subscip, SCIP_SOL *subsol, SCIP_VAR **subvars, SCIP_Real *solvals)

static SCIP_RETCODE copyVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool original, SCIP_Bool global)

static SCIP_RETCODE getCopyTimelimit(SCIP *sourcescip, SCIP_Real *timelimit)

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

static SCIP_RETCODE getCopyMemlimit(SCIP *sourcescip, SCIP_Real *memorylimit)

static SCIP_RETCODE copySofttimelimit(SCIP *sourcescip, SCIP *targetscip)

public methods for problem copies

public methods for cuts and aggregation rows

public methods for memory management

public methods for message handling

public methods for node selector plugins

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 solutions

public methods for querying solving statistics

public methods for timing

public methods for SCIP variables

SCIP_RETCODE SCIPsetCopyPlugins(SCIP_SET *sourceset, SCIP_SET *targetset, 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 *allvalid)

SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_NLPI * SCIPsetFindNlpi(SCIP_SET *set, const char *name)

SCIP_RETCODE SCIPsetCopyParams(SCIP_SET *sourceset, SCIP_SET *targetset, SCIP_MESSAGEHDLR *messagehdlr)

internal methods for global SCIP settings

SCIP_RETCODE SCIPbendersCopyInclude(SCIP_BENDERS *benders, SCIP_SET *sourceset, SCIP_SET *targetset, SCIP_HASHMAP *varmap, SCIP_Bool threadsafe, SCIP_Bool *valid)

internal methods for Benders' decomposition

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_DEBUGSOLDATA * debugsoldata

SCIP_Bool misc_avoidmemout

SCIP_Bool history_allowmerge

SCIP_CONCURRENT * concurrent

SCIP_SYNCSTORE * syncstore

SCIP_MESSAGEHDLR * messagehdlr

SCIP_CONFLICTSTORE * conflictstore

SCIP_DECOMPSTORE * decompstore

datastructures for block memory pools and memory buffers

SCIP main data structure.

datastructures for global SCIP settings

datastructures for problem statistics

datastructures for problem variables

SCIP_RETCODE SCIPsyncstoreRelease(SCIP_SYNCSTORE **syncstore)

SCIP_RETCODE SCIPsyncstoreCapture(SCIP_SYNCSTORE *syncstore)

the function declarations for the synchronization store

enum SCIP_BoundType SCIP_BOUNDTYPE

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_VARSTATUS_ORIGINAL

@ SCIP_VARSTATUS_MULTAGGR

@ SCIP_VARSTATUS_AGGREGATED

enum SCIP_Varstatus SCIP_VARSTATUS

SCIP_RETCODE SCIPvarCopy(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP *sourcescip, SCIP_VAR *sourcevar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global)

void SCIPvarMergeHistories(SCIP_VAR *targetvar, SCIP_VAR *othervar, SCIP_STAT *stat)

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