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

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

SCIP Doxygen Documentation: dialog_default.c Source File

( command[0] ==

)

( strcmp(command,

) == 0 )

( *nextdialog ==

)

*nextdialog = dialog;

( nfound >= 2 )

* valuestr,

assert( valuestr !=

);

assert( error !=

);

( valuestr[0] )

(

= 0;

< nreaders; ++

)

( filename[0] !=

)

( extension ==

)

, &extension, &endoffile) );

( extension[0] ==

)

( extension !=

);

assert(dialog !=

);

( str[0] !=

)

printf(

, str);

(

(

, &cons, str,

,

,

,

,

,

,

,

,

,

, &success) );

( varname[0] ==

|| endoffile )

( var ==

);

( boundstr[0] !=

)

= strtod(boundstr, &endptr);

( endptr == boundstr || *endptr !=

)

printf(

, endptr, boundstr);

(

,

,

,

( boundstr[0] !=

)

= strtod(boundstr, &endptr);

( endptr == boundstr || *endptr !=

)

(

,

,

,

( objsense[0] !=

&& !endoffile )

( strncmp(objsense,

, 3) == 0 )

( strncmp(objsense ,

, 3) == 0 )

assert(nextdialog !=

);

( filename[0] !=

)

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

((

**)sorted, SCIPbranchruleComp, nbranchrules);

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

((

**)sorted, SCIPrelaxComp, nrelaxs);

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

assert(sorted !=

);

((

**)sorted, SCIPconflicthdlrComp, nconflicthdlrs);

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

(

,

,

);

(

,

,

);

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

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

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

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

((

**)sorted, SCIPheurCompPriority, nheurs);

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

((

**)sorted, SCIPnlpiComp, nnlpis);

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

assert(sorted !=

);

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

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

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

(

,

,

);

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

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

assert(fixedvars !=

|| nfixedvars == 0);

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

);

( bestsol !=

)

*nextdialog =

;

( idx < 0 || idx >= nsols )

assert( sols[idx] !=

);

( nactivebenders == 0 )

( nactivebenders > 1 )

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

benders[count] = benders[i];

*nextdialog =

;

( idx < 0 || idx >= nactivebenders)

( nsubproblems > 1 )

*nextdialog =

;

( subidx < -1 || subidx >= nsubproblems)

nsubdisplay = nsubproblems;

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

( nsubdisplay > 1 )

( nactivebenders == 0 )

( nactivebenders > 1 )

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

benders[count] = benders[i];

*nextdialog =

;

( idx < 0 || idx >= nactivebenders)

( nsubproblems > 1 )

*nextdialog =

;

( subidx < -1 || subidx >= nsubproblems)

nsubdisplay = nsubproblems;

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

( nsubdisplay > 1 )

((

**)sorted, SCIPcomprComp, ncomprs);

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

*nextdialog =

;

( varname[0] !=

)

*nextdialog =

;

*nextdialog =

;

( filename[0] !=

)

( extension ==

)

tmpfilename, extension);

( extension ==

)

, &extension, &endoffile) );

( extension[0] ==

)

( extension !=

);

*nextdialog =

;

( filename[0] !=

)

*nextdialog =

;

( filename[0] !=

)

*nextdialog =

;

( filename[0] !=

)

*nextdialog =

;

( valuestr[0] ==

)

(

,

,

,

*nextdialog =

;

( valuestr[0] ==

)

(

,

,

,

*nextdialog =

;

( valuestr[0] ==

)

*nextdialog =

;

( valuestr[0] ==

)

(

,

,

,

*nextdialog =

;

( valuestr[0] ==

)

*nextdialog =

;

( valuestr[0] ==

)

( strchr(valuestr,

) ==

&& strchr(valuestr,

) ==

)

*nextdialog =

;

( valuestr[0] ==

)

*nextdialog =

;

( valuestr[0] ==

)

(

,

*nextdialog =

;

( valuestr[0] ==

)

( sscanf(valuestr,

, &direction) != 1 )

( direction < -1 || direction > +1 )

( direction == -1 )

( direction == 0 )

*nextdialog =

;

( valuestr[0] ==

)

*nextdialog =

;

( valuestr[0] ==

)

( sscanf(valuestr,

, &priority) != 1 )

*nextdialog =

;

( valuestr[0] ==

)

(

,

,

,

( filename[0] !=

)

*nextdialog =

;

( valuestr[0] ==

)

,

&valuestr, &endoffile) );

*nextdialog =

;

( valuestr[0] ==

)

,

&valuestr, &endoffile) );

*nextdialog =

;

( valuestr[0] ==

)

,

&valuestr, &endoffile) );

*nextdialog =

;

( valuestr[0] ==

)

( filename[0] !=

)

*nextdialog =

;

( filename[0] !=

)

file = fopen(filename,

);

*nextdialog =

;

( filename[0] !=

)

file = fopen(filename,

);

*nextdialog =

;

( filename[0] !=

)

, filename);

*nextdialog =

;

( filename[0] !=

)

file = fopen(filename,

);

( bestsol !=

)

*nextdialog =

;

( filename[0] !=

)

file = fopen(filename,

);

* primaldual[] = {

,

};

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

(void)

(prompt,

,

, primaldual[i]);

( endoffile || strncmp(refstrs[i],

, 1) == 0 )

( strncmp(refstrs[i],

, 1) == 0 )

SCIPdialogExecMenuLazy,

,

,

,

,

,

) );

,

,

,

) );

SCIPdialogExecChangeAddCons,

,

,

,

,

,

) );

SCIPdialogExecChangeBounds,

,

,

,

,

,

) );

SCIPdialogExecChangeFreetransproblem,

,

,

,

,

,

) );

SCIPdialogExecChangeObjSense,

,

,

,

,

,

) );

SCIPdialogExecChecksol,

,

,

,

,

,

) );

,

,

,

) );

SCIPdialogExecDisplayBenders,

,

,

,

,

,

) );

SCIPdialogExecDisplayBranching,

,

,

,

,

,

) );

SCIPdialogExecDisplayCompression,

,

,

,

,

,

) );

SCIPdialogExecDisplayConflict,

,

,

,

,

,

) );

SCIPdialogExecDisplayConshdlrs,

,

,

,

,

,

) );

SCIPdialogExecDisplayDisplaycols,

,

,

,

,

,

) );

SCIPdialogExecDisplayExprhdlrs,

,

,

,

,

,

) );

SCIPdialogExecDisplayCutselectors,

,

,

,

,

,

));

SCIPdialogExecDisplayHeuristics,

,

,

,

,

,

) );

SCIPdialogExecDisplayMemory,

,

,

,

,

,

) );

SCIPdialogExecDisplayNlpi,

,

,

,

,

,

) );

SCIPdialogExecDisplayNodeselectors,

,

,

,

,

,

) );

SCIPdialogExecDisplayParameters,

,

,

,

,

,

) );

SCIPdialogExecDisplayPresolvers,

,

,

,

,

,

) );

SCIPdialogExecDisplayPricers,

,

,

,

,

,

) );

SCIPdialogExecDisplayProblem,

,

,

,

,

,

) );

SCIPdialogExecDisplayPropagators,

,

,

,

,

,

) );

SCIPdialogExecDisplayReaders,

,

,

,

,

,

) );

SCIPdialogExecDisplayRelaxators,

,

,

,

,

,

) );

SCIPdialogExecDisplaySeparators,

,

,

,

,

,

) );

SCIPdialogExecDisplaySolution,

,

,

,

,

,

) );

SCIPdialogExecDisplayFiniteSolution,

,

,

,

,

,

) );

SCIPdialogExecDisplayDualSolution,

,

,

,

,

,

) );

SCIPdialogExecDisplaySolutionPool,

,

,

,

,

,

) );

SCIPdialogExecDisplaySubproblem,

,

,

,

,

,

) );

SCIPdialogExecDisplaySubSolution,

,

,

,

,

,

) );

SCIPdialogExecDisplayStatistics,

,

,

,

,

,

) );

SCIPdialogExecDisplayReoptStatistics,

,

,

,

,

,

) );

SCIPdialogExecDisplayTransproblem,

,

,

,

,

,

) );

SCIPdialogExecDisplayValue,

,

,

,

,

,

) );

SCIPdialogExecDisplayVarbranchstatistics,

,

,

,

,

,

) );

SCIPdialogExecDisplayLPSolutionQuality,

,

,

,

,

,

) );

SCIPdialogExecDisplayTranssolution,

,

,

,

,

,

) );

SCIPdialogExecDisplayLinearConsClassification,

,

,

,

,

,

) );

,

,

,

) );

,

,

,

) );

SCIPdialogExecNewstart,

,

,

,

,

,

) );

SCIPdialogExecTransform,

,

,

,

,

,

) );

SCIPdialogExecOptimize,

,

,

,

,

,

) );

SCIPdialogExecConcurrentOpt,

,

,

,

,

,

) );

SCIPdialogExecPresolve,

,

,

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

SCIPdialogExecWriteLp,

,

,

,

,

,

) );

SCIPdialogExecWriteMip,

,

,

,

,

,

) );

SCIPdialogExecWriteNlp,

,

,

,

,

,

) );

SCIPdialogExecWriteProblem,

,

,

,

SCIPdialogExecWriteGenProblem,

,

,

,

SCIPdialogExecWriteSolution,

,

,

,

,

,

) );

SCIPdialogExecWriteFiniteSolution,

,

,

,

,

,

) );

SCIPdialogExecWriteMIPStart,

,

,

,

,

,

) );

SCIPdialogExecWriteStatistics,

,

,

,

,

,

) );

SCIPdialogExecWriteTransproblem,

,

,

,

SCIPdialogExecWriteGenTransproblem,

,

,

,

SCIPdialogExecCliquegraph,

,

,

,

SCIPdialogExecWriteCommandHistory,

,

,

,

,

( slash ==

)

( advmenu ==

)

SCIPdialogExecSetParam, SCIPdialogDescSetParam,

,

SCIPdialogExecSetParam, SCIPdialogDescSetParam,

,

( submenu ==

)

( slash ==

)

( advmenu ==

)

SCIPdialogExecFixParam, SCIPdialogDescFixParam,

,

SCIPdialogExecFixParam, SCIPdialogDescFixParam,

,

( submenu ==

)

,

,

,

) );

assert(*submenu !=

);

,

,

,

) );

SCIPdialogExecSetDefault,

,

,

,

,

,

) );

SCIPdialogExecSetLoad,

,

,

,

,

,

) );

SCIPdialogExecSetSave,

,

,

,

,

,

) );

SCIPdialogExecSetDiffsave,

,

,

,

,

,

) );

,

,

,

) );

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

SCIPdialogExecSetBranchingPriority,

,

,

,

,

,

) );

SCIPdialogExecSetBranchingDirection,

,

,

,

,

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

,

,

,

) );

,

,

,

) );

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

assert(emphasismenu !=

);

, SCIPdialogExecSetHeuristicsAggressive,

,

,

,

,

,

) );

, SCIPdialogExecSetHeuristicsDefault,

,

,

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

SCIPdialogExecSetLimitsObjective,

,

,

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

,

,

,

) );

,

,

,

) );

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

assert(emphasismenu !=

);

, SCIPdialogExecSetPresolvingAggressive,

,

,

,

,

,

) );

, SCIPdialogExecSetPresolvingDefault,

,

,

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

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

,

,

,

) );

,

,

,

) );

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

,

,

,

) );

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

assert(emphasismenu !=

);

, SCIPdialogExecSetSeparatingAggressive,

,

,

,

,

,

) );

, SCIPdialogExecSetSeparatingDefault,

,

,

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

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

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

,

,

,

) );

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

,

,

,

) );

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

,

,

,

) );

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

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

#define SCIP_LONGINT_FORMAT

#define SCIP_CALL_FINALLY(x, y)

static SCIP_RETCODE writeProblem(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG **nextdialog, SCIP_Bool transformed, SCIP_Bool genericnames)

static SCIP_RETCODE dialogExecMenu(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG **nextdialog)

static SCIP_RETCODE addFixParamDialog(SCIP *scip, SCIP_DIALOG *menu, SCIP_PARAM *param, char *paramname)

static SCIP_RETCODE createEmphasisSubmenu(SCIP *scip, SCIP_DIALOG *root, SCIP_DIALOG **submenu)

static SCIP_RETCODE addSetParamDialog(SCIP *scip, SCIP_DIALOG *menu, SCIP_PARAM *param, char *paramname)

static void displayReaders(SCIP *scip, SCIP_Bool reader, SCIP_Bool writer)

static SCIP_Bool parseBoolValue(SCIP *scip, const char *valuestr, SCIP_Bool *error)

static SCIP_DECL_DIALOGCOPY(dialogCopyDefault)

default user interface dialog

SCIP_RETCODE SCIPclassifyConstraintTypesLinear(SCIP *scip, SCIP_LINCONSSTATS *linconsstats)

SCIP_DECL_DIALOGEXEC(SCIPdialogExecMenu)

SCIP_DECL_DIALOGDESC(SCIPdialogDescSetParam)

SCIP_RETCODE SCIPcreateRootDialog(SCIP *scip, SCIP_DIALOG **root)

SCIP_RETCODE SCIPincludeDialogDefaultBasic(SCIP *scip)

SCIP_RETCODE SCIPincludeDialogDefaultSet(SCIP *scip)

SCIP_RETCODE SCIPincludeDialogDefaultFix(SCIP *scip)

SCIP_Bool SCIPfileExists(const char *filename)

SCIP_Bool SCIPisTransformed(SCIP *scip)

SCIP_RETCODE SCIPprintStatus(SCIP *scip, FILE *file)

SCIP_STAGE SCIPgetStage(SCIP *scip)

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

SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)

SCIP_Real SCIPgetObjlimit(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPfreeProb(SCIP *scip)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

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

int SCIPgetNFixedVars(SCIP *scip)

SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)

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

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

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

SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)

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

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

SCIP_Bool SCIPisStringParamValid(SCIP *scip, SCIP_PARAM *param, const char *value)

SCIP_RETCODE SCIPresetParams(SCIP *scip)

SCIP_RETCODE SCIPchgCharParam(SCIP *scip, SCIP_PARAM *param, char value)

SCIP_RETCODE SCIPchgStringParam(SCIP *scip, SCIP_PARAM *param, const char *value)

int SCIPgetNParams(SCIP *scip)

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

SCIP_Bool SCIPisCharParamValid(SCIP *scip, SCIP_PARAM *param, const char value)

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

SCIP_Bool SCIPisIntParamValid(SCIP *scip, SCIP_PARAM *param, int value)

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

SCIP_RETCODE SCIPwriteParams(SCIP *scip, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)

SCIP_RETCODE SCIPchgBoolParam(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)

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

SCIP_RETCODE SCIPchgRealParam(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)

SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)

SCIP_RETCODE SCIPchgLongintParam(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)

SCIP_PARAM ** SCIPgetParams(SCIP *scip)

SCIP_Bool SCIPisLongintParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)

SCIP_Bool SCIPisRealParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)

SCIP_RETCODE SCIPchgIntParam(SCIP *scip, SCIP_PARAM *param, int value)

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

SCIP_Bool SCIPisBoolParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)

int SCIPgetNActiveBenders(SCIP *scip)

SCIP_BENDERS ** SCIPgetBenders(SCIP *scip)

int SCIPgetNBenders(SCIP *scip)

int SCIPbendersGetPriority(SCIP_BENDERS *benders)

const char * SCIPbendersGetDesc(SCIP_BENDERS *benders)

SCIP_BENDERSSUBTYPE SCIPbendersGetSubproblemType(SCIP_BENDERS *benders, int probnumber)

SCIP_RETCODE SCIPfreeBendersSubproblem(SCIP *scip, SCIP_BENDERS *benders, int probnumber)

SCIP_RETCODE SCIPsetupBendersSubproblem(SCIP *scip, SCIP_BENDERS *benders, SCIP_SOL *sol, int probnumber, SCIP_BENDERSENFOTYPE type)

SCIP_RETCODE SCIPsolveBendersSubproblem(SCIP *scip, SCIP_BENDERS *benders, SCIP_SOL *sol, int probnumber, SCIP_Bool *infeasible, SCIP_Bool solvecip, SCIP_Real *objective)

SCIP_Bool SCIPbendersIsActive(SCIP_BENDERS *benders)

const char * SCIPbendersGetName(SCIP_BENDERS *benders)

int SCIPbendersGetNSubproblems(SCIP_BENDERS *benders)

SCIP * SCIPbendersSubproblem(SCIP_BENDERS *benders, int probnumber)

int SCIPbranchruleGetMaxdepth(SCIP_BRANCHRULE *branchrule)

SCIP_BRANCHRULE ** SCIPgetBranchrules(SCIP *scip)

const char * SCIPbranchruleGetName(SCIP_BRANCHRULE *branchrule)

int SCIPbranchruleGetPriority(SCIP_BRANCHRULE *branchrule)

SCIP_Real SCIPbranchruleGetMaxbounddist(SCIP_BRANCHRULE *branchrule)

const char * SCIPbranchruleGetDesc(SCIP_BRANCHRULE *branchrule)

int SCIPgetNBranchrules(SCIP *scip)

int SCIPcomprGetPriority(SCIP_COMPR *compr)

int SCIPgetNCompr(SCIP *scip)

SCIP_COMPR ** SCIPgetComprs(SCIP *scip)

const char * SCIPcomprGetDesc(SCIP_COMPR *compr)

const char * SCIPcomprGetName(SCIP_COMPR *compr)

int SCIPcomprGetMinNodes(SCIP_COMPR *compr)

int SCIPconflicthdlrGetPriority(SCIP_CONFLICTHDLR *conflicthdlr)

const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)

const char * SCIPconflicthdlrGetDesc(SCIP_CONFLICTHDLR *conflicthdlr)

SCIP_CONFLICTHDLR ** SCIPgetConflicthdlrs(SCIP *scip)

int SCIPgetNConflicthdlrs(SCIP *scip)

int SCIPconshdlrGetEagerFreq(SCIP_CONSHDLR *conshdlr)

SCIP_PRESOLTIMING SCIPconshdlrGetPresolTiming(SCIP_CONSHDLR *conshdlr)

int SCIPgetNConshdlrs(SCIP *scip)

int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetPropFreq(SCIP_CONSHDLR *conshdlr)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

const char * SCIPconshdlrGetDesc(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetCheckPriority(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetSepaFreq(SCIP_CONSHDLR *conshdlr)

SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)

int SCIPconshdlrGetEnfoPriority(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPparseCons(SCIP *scip, SCIP_CONS **cons, const char *str, 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 *success)

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

const char * SCIPcutselGetDesc(SCIP_CUTSEL *cutsel)

int SCIPcutselGetPriority(SCIP_CUTSEL *cutsel)

const char * SCIPcutselGetName(SCIP_CUTSEL *cutsel)

SCIP_CUTSEL ** SCIPgetCutsels(SCIP *scip)

int SCIPgetNCutsels(SCIP *scip)

void SCIPdialoghdlrClearBuffer(SCIP_DIALOGHDLR *dialoghdlr)

SCIP_RETCODE SCIPreleaseDialog(SCIP *scip, SCIP_DIALOG **dialog)

SCIP_DIALOG * SCIPdialoghdlrGetRoot(SCIP_DIALOGHDLR *dialoghdlr)

SCIP_Bool SCIPdialogHasEntry(SCIP_DIALOG *dialog, const char *entryname)

SCIP_RETCODE SCIPdialoghdlrAddHistory(SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG *dialog, const char *command, SCIP_Bool escapecommand)

SCIP_RETCODE SCIPincludeDialog(SCIP *scip, SCIP_DIALOG **dialog, SCIP_DECL_DIALOGCOPY((*dialogcopy)), SCIP_DECL_DIALOGEXEC((*dialogexec)), SCIP_DECL_DIALOGDESC((*dialogdesc)), SCIP_DECL_DIALOGFREE((*dialogfree)), const char *name, const char *desc, SCIP_Bool issubmenu, SCIP_DIALOGDATA *dialogdata)

SCIP_Bool SCIPdialoghdlrIsBufferEmpty(SCIP_DIALOGHDLR *dialoghdlr)

SCIP_RETCODE SCIPaddDialogEntry(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOG *subdialog)

SCIP_RETCODE SCIPdialoghdlrGetWord(SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG *dialog, const char *prompt, char **inputword, SCIP_Bool *endoffile)

SCIP_DIALOGDATA * SCIPdialogGetData(SCIP_DIALOG *dialog)

SCIP_RETCODE SCIPdialogDisplayCompletions(SCIP_DIALOG *dialog, SCIP *scip, const char *entryname)

SCIP_RETCODE SCIPsetRootDialog(SCIP *scip, SCIP_DIALOG *dialog)

SCIP_DIALOG * SCIPgetRootDialog(SCIP *scip)

SCIP_RETCODE SCIPdialogWriteHistory(const char *filename)

int SCIPdialogFindEntry(SCIP_DIALOG *dialog, const char *entryname, SCIP_DIALOG **subdialog)

SCIP_RETCODE SCIPdialoghdlrGetLine(SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG *dialog, const char *prompt, char **inputline, SCIP_Bool *endoffile)

SCIP_DIALOG * SCIPdialogGetParent(SCIP_DIALOG *dialog)

SCIP_RETCODE SCIPdialogDisplayMenu(SCIP_DIALOG *dialog, SCIP *scip)

SCIP_DISP ** SCIPgetDisps(SCIP *scip)

int SCIPgetNDisps(SCIP *scip)

SCIP_DISPSTATUS SCIPdispGetStatus(SCIP_DISP *disp)

const char * SCIPdispGetName(SCIP_DISP *disp)

const char * SCIPdispGetHeader(SCIP_DISP *disp)

int SCIPdispGetPosition(SCIP_DISP *disp)

int SCIPdispGetPriority(SCIP_DISP *disp)

int SCIPdispGetWidth(SCIP_DISP *disp)

const char * SCIPdispGetDesc(SCIP_DISP *disp)

const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)

int SCIPgetNExprhdlrs(SCIP *scip)

unsigned int SCIPexprhdlrGetPrecedence(SCIP_EXPRHDLR *exprhdlr)

const char * SCIPexprhdlrGetDescription(SCIP_EXPRHDLR *exprhdlr)

SCIP_EXPRHDLR ** SCIPgetExprhdlrs(SCIP *scip)

char SCIPheurGetDispchar(SCIP_HEUR *heur)

SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)

const char * SCIPheurGetDesc(SCIP_HEUR *heur)

int SCIPheurGetPriority(SCIP_HEUR *heur)

int SCIPgetNHeurs(SCIP *scip)

int SCIPheurGetFreqofs(SCIP_HEUR *heur)

int SCIPheurGetFreq(SCIP_HEUR *heur)

const char * SCIPheurGetName(SCIP_HEUR *heur)

SCIP_RETCODE SCIPprintLPSolutionQuality(SCIP *scip, FILE *file)

SCIP_RETCODE SCIPwriteMIP(SCIP *scip, const char *filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)

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

void SCIPprintMemoryDiagnostic(SCIP *scip)

#define SCIPfreeBufferArray(scip, ptr)

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

#define SCIPfreeBufferArrayNull(scip, ptr)

const char * SCIPnlpiGetDesc(SCIP_NLPI *nlpi)

int SCIPnlpiGetPriority(SCIP_NLPI *nlpi)

const char * SCIPnlpiGetName(SCIP_NLPI *nlpi)

int SCIPgetNNlpis(SCIP *scip)

SCIP_NLPI ** SCIPgetNlpis(SCIP *scip)

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

SCIP_Bool SCIPisNLPConstructed(SCIP *scip)

SCIP_NODESEL ** SCIPgetNodesels(SCIP *scip)

const char * SCIPnodeselGetDesc(SCIP_NODESEL *nodesel)

int SCIPnodeselGetMemsavePriority(SCIP_NODESEL *nodesel)

int SCIPnodeselGetStdPriority(SCIP_NODESEL *nodesel)

int SCIPgetNNodesels(SCIP *scip)

const char * SCIPnodeselGetName(SCIP_NODESEL *nodesel)

int SCIPpresolGetPriority(SCIP_PRESOL *presol)

SCIP_PRESOL ** SCIPgetPresols(SCIP *scip)

const char * SCIPpresolGetDesc(SCIP_PRESOL *presol)

int SCIPgetNPresols(SCIP *scip)

int SCIPpresolGetMaxrounds(SCIP_PRESOL *presol)

SCIP_PRESOLTIMING SCIPpresolGetTiming(SCIP_PRESOL *presol)

const char * SCIPpresolGetName(SCIP_PRESOL *presol)

const char * SCIPpricerGetDesc(SCIP_PRICER *pricer)

SCIP_Bool SCIPpricerIsDelayed(SCIP_PRICER *pricer)

int SCIPpricerGetPriority(SCIP_PRICER *pricer)

int SCIPgetNPricers(SCIP *scip)

SCIP_PRICER ** SCIPgetPricers(SCIP *scip)

const char * SCIPpricerGetName(SCIP_PRICER *pricer)

void SCIPlinConsStatsFree(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)

void SCIPprintLinConsStats(SCIP *scip, FILE *file, SCIP_LINCONSSTATS *linconsstats)

SCIP_RETCODE SCIPlinConsStatsCreate(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)

SCIP_Bool SCIPpropIsDelayed(SCIP_PROP *prop)

int SCIPpropGetFreq(SCIP_PROP *prop)

int SCIPgetNProps(SCIP *scip)

const char * SCIPpropGetDesc(SCIP_PROP *prop)

int SCIPpropGetPresolPriority(SCIP_PROP *prop)

const char * SCIPpropGetName(SCIP_PROP *prop)

int SCIPpropGetPriority(SCIP_PROP *prop)

SCIP_PROP ** SCIPgetProps(SCIP *scip)

SCIP_PRESOLTIMING SCIPpropGetPresolTiming(SCIP_PROP *prop)

const char * SCIPreaderGetExtension(SCIP_READER *reader)

int SCIPgetNReaders(SCIP *scip)

const char * SCIPreaderGetName(SCIP_READER *reader)

SCIP_Bool SCIPreaderCanRead(SCIP_READER *reader)

SCIP_READER ** SCIPgetReaders(SCIP *scip)

SCIP_Bool SCIPreaderCanWrite(SCIP_READER *reader)

const char * SCIPreaderGetDesc(SCIP_READER *reader)

SCIP_RELAX ** SCIPgetRelaxs(SCIP *scip)

int SCIPgetNRelaxs(SCIP *scip)

int SCIPrelaxGetFreq(SCIP_RELAX *relax)

const char * SCIPrelaxGetName(SCIP_RELAX *relax)

const char * SCIPrelaxGetDesc(SCIP_RELAX *relax)

int SCIPrelaxGetPriority(SCIP_RELAX *relax)

int SCIPgetNSepas(SCIP *scip)

int SCIPsepaGetPriority(SCIP_SEPA *sepa)

SCIP_Real SCIPsepaGetMaxbounddist(SCIP_SEPA *sepa)

int SCIPsepaGetFreq(SCIP_SEPA *sepa)

const char * SCIPsepaGetName(SCIP_SEPA *sepa)

const char * SCIPsepaGetDesc(SCIP_SEPA *sepa)

SCIP_Bool SCIPsepaIsDelayed(SCIP_SEPA *sepa)

SCIP_SEPA ** SCIPgetSepas(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 SCIPprintBestSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)

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

SCIP_Real SCIPsolGetRelBoundViolation(SCIP_SOL *sol)

SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)

SCIP_Real SCIPsolGetAbsConsViolation(SCIP_SOL *sol)

SCIP_Real SCIPsolGetAbsBoundViolation(SCIP_SOL *sol)

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

SCIP_Real SCIPsolGetAbsIntegralityViolation(SCIP_SOL *sol)

SCIP_Real SCIPtransformObj(SCIP *scip, SCIP_Real obj)

int SCIPgetNSols(SCIP *scip)

SCIP_Real SCIPsolGetAbsLPRowViolation(SCIP_SOL *sol)

SCIP_RETCODE SCIPcreateFiniteSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol, SCIP_Bool *success)

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

SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)

SCIP_RETCODE SCIPprintMIPStart(SCIP *scip, SCIP_SOL *sol, FILE *file)

SCIP_Real SCIPsolGetRelLPRowViolation(SCIP_SOL *sol)

SCIP_SOL ** SCIPgetSols(SCIP *scip)

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

SCIP_Real SCIPsolGetRelConsViolation(SCIP_SOL *sol)

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

SCIP_RETCODE SCIPtransformProb(SCIP *scip)

SCIP_RETCODE SCIPpresolve(SCIP *scip)

SCIP_RETCODE SCIPsolveConcurrent(SCIP *scip)

SCIP_RETCODE SCIPfreeTransform(SCIP *scip)

SCIP_RETCODE SCIPfreeSolve(SCIP *scip, SCIP_Bool restart)

SCIP_RETCODE SCIPsolve(SCIP *scip)

SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)

SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)

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

SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)

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

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_RETCODE SCIPchgFeastol(SCIP *scip, SCIP_Real feastol)

SCIP_Real SCIPfeastol(SCIP *scip)

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

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

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

SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)

SCIP_RETCODE SCIPvalidateSolve(SCIP *scip, SCIP_Real primalreference, SCIP_Real dualreference, SCIP_Real reftol, SCIP_Bool quiet, SCIP_Bool *feasible, SCIP_Bool *primalboundcheck, SCIP_Bool *dualboundcheck)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)

SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)

SCIP_BRANCHDIR SCIPvarGetBranchDirection(SCIP_VAR *var)

SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)

int SCIPvarGetBranchPriority(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

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

SCIP_Bool SCIPstrToIntValue(const char *str, int *value, char **endptr)

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

void SCIPescapeString(char *t, int bufsize, const char *s)

void SCIPprintSysError(const char *message)

int SCIPstrncpy(char *t, const char *s, int size)

static const char * paramname[]

memory allocation routines

#define BMSduplicateMemoryArray(ptr, source, num)

#define BMSfreeMemoryArray(ptr)

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

const char * SCIPparamGetName(SCIP_PARAM *param)

SCIP_Real SCIPparamGetRealMin(SCIP_PARAM *param)

char * SCIPparamGetCharAllowedValues(SCIP_PARAM *param)

SCIP_Bool SCIPparamIsAdvanced(SCIP_PARAM *param)

SCIP_PARAMTYPE SCIPparamGetType(SCIP_PARAM *param)

char * SCIPparamGetString(SCIP_PARAM *param)

int SCIPparamGetIntMin(SCIP_PARAM *param)

void SCIPparamSetFixed(SCIP_PARAM *param, SCIP_Bool fixed)

SCIP_Longint SCIPparamGetLongintMin(SCIP_PARAM *param)

SCIP_Bool SCIPparamGetBool(SCIP_PARAM *param)

const char * SCIPparamGetDesc(SCIP_PARAM *param)

int SCIPparamGetInt(SCIP_PARAM *param)

int SCIPparamGetIntMax(SCIP_PARAM *param)

SCIP_Real SCIPparamGetReal(SCIP_PARAM *param)

char SCIPparamGetChar(SCIP_PARAM *param)

SCIP_Longint SCIPparamGetLongint(SCIP_PARAM *param)

SCIP_Longint SCIPparamGetLongintMax(SCIP_PARAM *param)

SCIP_Real SCIPparamGetRealMax(SCIP_PARAM *param)

SCIP_Bool SCIPparamIsFixed(SCIP_PARAM *param)

public methods for Benders' decomposition

public methods for branching rules

public methods for tree compressions

public methods for conflict analysis handlers

public methods for managing constraints

public methods for cut selectors

public methods for user interface dialog

public methods for displaying runtime statistics

public functions to work with algebraic expressions

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 node selectors

public methods for handling parameter settings

public methods for presolvers

public methods for variable pricers

public methods for propagators

public methods for input file readers

public methods for relaxation handlers

public methods for separators

public methods for primal CIP solutions

public methods for problem variables

public methods for Benders decomposition

public methods for branching rule plugins and branching

public methods for compression plugins

public methods for conflict handler plugins and conflict analysis

public methods for constraint handler plugins and constraints

public methods for cut selector plugins

public methods for dialog handler plugins

public methods for display handler plugins

public functions to work with algebraic expressions

public methods for primal heuristic plugins and divesets

public methods for the LP relaxation, rows and columns

public methods for memory management

public methods for message handling

public methods for nonlinear relaxation

public methods for NLPI solver interfaces

public methods for node selector plugins

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for presolving plugins

public methods for variable pricer plugins

public methods for global and local (sub)problems

public methods for propagator plugins

public methods for reader plugins

public methods for relaxator plugins

public methods for separator plugins

public methods for solutions

public methods for querying solving statistics

public methods for validation

public methods for SCIP variables

@ SCIP_BENDERSENFOTYPE_CHECK

@ SCIP_BENDERSSUBTYPE_CONVEXCONT

struct SCIP_DialogData SCIP_DIALOGDATA

@ SCIP_BRANCHDIR_DOWNWARDS

@ SCIP_PARAMSETTING_AGGRESSIVE

@ SCIP_PARAMSETTING_DEFAULT

@ SCIP_PARAMEMPHASIS_NUMERICS

@ SCIP_PARAMEMPHASIS_CPSOLVER

@ SCIP_PARAMEMPHASIS_HARDLP

@ SCIP_PARAMEMPHASIS_FEASIBILITY

@ SCIP_PARAMEMPHASIS_BENCHMARK

@ SCIP_PARAMEMPHASIS_EASYCIP

@ SCIP_PARAMEMPHASIS_COUNTER

@ SCIP_PARAMEMPHASIS_OPTIMALITY

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STAGE_INITPRESOLVE

@ SCIP_STAGE_EXITPRESOLVE

@ SCIP_STAGE_TRANSFORMING

#define SCIP_PRESOLTIMING_MEDIUM

#define SCIP_PRESOLTIMING_FAST

#define SCIP_PRESOLTIMING_EXHAUSTIVE

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