RetroSearch Browse

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

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

SCIP Doxygen Documentation: applications/MinIISC/src/miniisc.c Source File

38#define DEFAULT_SOLVEMASTERAPPROX FALSE 39#define DEFAULT_MASTERGAPLIMIT 0.1 40#define DEFAULT_REOPTIMIZATION TRUE 41#define DEFAULT_MASTERSTALLNODES 5000L 52#define SCIP_CALL_PARAM(x) do \ 54 SCIP_RETCODE _restat_; \ 55 if ( (_restat_ = (x)) != SCIP_OKAY && (_restat_ != SCIP_PARAMETERUNKNOWN) ) \ 57 SCIPerrorMessage("[%s:%d] Error <%d> in function call\n"

, __FILE__, __LINE__, _restat_); \

93 int

* indices =

NULL

;

97

assert( masterscip !=

NULL

);

106 for

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

141 int

* indices =

NULL

;

145

assert( masterscip !=

NULL

);

147

assert( lp !=

NULL

);

154 for

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

199

assert( masterscip !=

NULL

);

200

assert( lp !=

NULL

);

201

assert( infeasible !=

NULL

);

202

assert( error !=

NULL

);

254 SCIPwarningMessage

(masterscip,

"The dual simplex produced a primal ray. Retrying with primal ...\n"

);

296

*infeasible =

FALSE

;

332

assert( masterscip !=

NULL

);

333

assert( data !=

NULL

);

334

assert( mastersolution !=

NULL

);

335

assert( ncuts !=

NULL

);

336

assert( status !=

NULL

);

337

assert( data->lp !=

NULL

);

338

assert( data->m == nmastervars );

347

assert( nmastervars <= ncols );

351 for

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

354 if

( mastersolution[j] > 0.5 )

397 SCIPdebugMessage

(

" size: %4d produced possible cover with objective value %f.\n"

, size, value);

405 for

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

429

assert( candidate >= 0 );

430

assert( ! S[candidate] );

431

assert( sizeIIS > 0 );

433 SCIPdebugMessage

(

" size: %4d add %4d with objective value %6g and alt-LP solution value %-8.4g (IIS size: %4d).\n"

434

size, candidate, candobj, primsol[candidate], sizeIIS);

437

S[candidate] =

TRUE

;

444 for

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

448

vars[cnt++] = mastervars[j];

450

assert( cnt == sizeIIS );

454 SCIP_CALL

(

SCIPcreateConsLogicor

(masterscip, &cons, name, cnt, vars,

) );

456 SCIP_CALL

(

SCIPcreateConsLogicor

(masterscip, &cons,

""

, cnt, vars,

) );

477 while

(step < nmastervars);

509

assert( origscip !=

NULL

);

510

assert( vars !=

NULL

);

511

assert( vals !=

NULL

);

512

assert(

SCIPisEQ

(origscip, sign, 1.0) ||

SCIPisEQ

(origscip, sign, -1.0) );

525

matval[cnt++] = sign * rhscoef;

529 for

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

531

assert( vars[v] !=

NULL

);

533

matval[cnt] = vals[v] * sign;

563

assert( origscip !=

NULL

);

564

assert( lp !=

NULL

);

569 for

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

571 const char

* origconshdlrname;

577

origcons = origconss[c];

578

assert( origcons !=

NULL

);

581

assert( origconshdlr !=

NULL

);

584 if

( strcmp(origconshdlrname,

"linear"

) == 0 )

592 else if

( strcmp(origconshdlrname,

"setppc"

) == 0 )

611 else if

( strcmp(origconshdlrname,

"logicor"

) == 0 )

618 else if

( strcmp(origconshdlrname,

"knapsack"

) == 0 )

630 for

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

631

consvals[v] = (

SCIP_Real

) origweights[v];

637 else if

( strcmp(origconshdlrname,

"varbound"

) == 0 )

653 SCIPwarningMessage

(origscip,

"Cannot handle constraints of type <%s>.\n"

, origconshdlrname);

663 const char

* filename,

664 const char

* settingsname,

698 SCIPerrorMessage

(

"Cannot extract problem name for filename <%s>.\n"

, filename);

704 SCIPinfoMessage

(masterscip,

NULL

"Finding a minimum IIS cover using a set covering approach.\n"

);

712 "miniisc/solvemasterapprox"

713 "Solve master problem approximately?"

717 "miniisc/mastergaplimit"

718 "gap bound for approximately solving the master problem"

722 "miniisc/masterstallnodes"

723 "stall nodes for the master problem"

727 "miniisc/reoptimization"

728 "Use reoptimization to solve master problem?"

732 if

( settingsname !=

NULL

)

736 SCIPinfoMessage

(masterscip,

NULL

"\nreading user parameter file <%s> ...\n\n"

, settingsname);

742 SCIPwarningMessage

(masterscip,

"\nparameter file <%s> not found - using default parameters.\n"

, settingsname);

766 SCIPinfoMessage

(masterscip,

NULL

"ERROR: input file contains integer variables. The code only works for LPs.\n"

);

790 for

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

804 for

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

814

assert( var !=

NULL

);

824

matval[cnt++] = -val;

827

matval[cnt++] = -1.0;

856 for

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

861 SCIP_CALL

(

SCIPcreateVar

(masterscip, &var, name, 0.0, 1.0, 1.0,

) );

869 SCIP_CALL

(

runBenders

(masterscip, cutoracle, &data, timelimit, memlimit, dispfreq, reoptimization, solvemasterapprox,

890 const char

* filename;

891 const char

* settingsname;

897

retcode =

readArguments

(argc, argv, &filename, &settingsname, &timelimit, &memlimit, &nodelimit, &dispfreq);

900

assert( filename !=

NULL

);

909

retcode =

solveMinIISC

(filename, settingsname, timelimit, memlimit, dispfreq);

SCIP_RETCODE runBenders(SCIP *masterscip, BENDERS_CUTORACLE((*Oracle)), BENDERS_DATA *data, SCIP_Real timelimit, SCIP_Real memlimit, int dispfreq, SCIP_Bool usereopt, SCIP_Bool solvemasterapprox, SCIP_Longint masterstallnodes, SCIP_Real mastergaplimit, SCIP_VERBLEVEL verblevel, SCIP_STATUS *status)

@ BENDERS_STATUS_ADDEDCUT

int SCIPgetNVarsKnapsack(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetVbdcoefVarbound(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNVarsLogicor(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)

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

SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNVarsLinear(SCIP *scip, SCIP_CONS *cons)

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

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

int SCIPgetNVarsSetppc(SCIP *scip, SCIP_CONS *cons)

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

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

SCIP_Longint * SCIPgetWeightsKnapsack(SCIP *scip, SCIP_CONS *cons)

SCIP_Longint SCIPgetCapacityKnapsack(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetLhsVarbound(SCIP *scip, SCIP_CONS *cons)

SCIP_SETPPCTYPE SCIPgetTypeSetppc(SCIP *scip, SCIP_CONS *cons)

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

SCIP_Real SCIPgetRhsVarbound(SCIP *scip, SCIP_CONS *cons)

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

SCIP_RETCODE SCIPcreateConsLogicor(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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_SETPPCTYPE_PARTITIONING

@ SCIP_SETPPCTYPE_COVERING

@ SCIP_SETPPCTYPE_PACKING

SCIP_Bool SCIPfileExists(const char *filename)

SCIP_RETCODE SCIPfree(SCIP **scip)

SCIP_RETCODE SCIPcreate(SCIP **scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

int SCIPgetNOrigBinVars(SCIP *scip)

SCIP_VAR ** SCIPgetOrigVars(SCIP *scip)

int SCIPgetNOrigIntVars(SCIP *scip)

SCIP_CONS ** SCIPgetConss(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNConss(SCIP *scip)

int SCIPgetNOrigVars(SCIP *scip)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

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

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

SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)

SCIP_Bool SCIPlpiExistsPrimalRay(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiAddRows(SCIP_LPI *lpi, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)

SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI *lpi, const char *fname)

int SCIPlpiGetInternalStatus(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)

SCIP_Bool SCIPlpiIsPrimalUnbounded(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)

SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)

SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)

SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiAddCols(SCIP_LPI *lpi, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)

SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)

SCIP_Bool SCIPlpiIsStable(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)

SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)

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

SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)

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

void SCIPprintError(SCIP_RETCODE retcode)

void SCIPprintVersion(SCIP *scip, FILE *file)

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

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

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

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

SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)

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

#define SCIPallocClearBufferArray(scip, ptr, num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

int SCIPvarGetIndex(SCIP_VAR *var)

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

SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

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

interface methods for specific LP solvers

#define BMScheckEmptyMemory()

#define SCIP_CALL_PARAM(x)

static BENDERS_CUTORACLE(cutoracle)

#define DEFAULT_MASTERSTALLNODES

int main(int argc, char **argv)

static SCIP_RETCODE solveMinIISC(const char *filename, const char *settingsname, SCIP_Real timelimit, SCIP_Real memlimit, int dispfreq)

static SCIP_RETCODE fixAltLPVariables(SCIP *masterscip, int nmastervars, SCIP_Bool *S, SCIP_LPI *lp)

static SCIP_RETCODE createAltLPColumn(SCIP *origscip, SCIP_LPI *lp, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhscoef, SCIP_Real sign)

static SCIP_RETCODE fixAltLPVariable(SCIP_LPI *lp, int ind)

#define DEFAULT_REOPTIMIZATION

#define DEFAULT_SOLVEMASTERAPPROX

static SCIP_RETCODE createAltLP(SCIP *origscip, SCIP_LPI *lp)

static SCIP_RETCODE unfixAltLPVariables(SCIP *masterscip, int nmastervars, SCIP_Bool *S, SCIP_LPI *lp)

static SCIP_RETCODE checkAltLPInfeasible(SCIP *masterscip, SCIP_LPI *lp, SCIP_Bool primal, SCIP_Bool *infeasible, SCIP_Bool *error)

#define DEFAULT_MASTERGAPLIMIT

SCIP_RETCODE readArguments(int argc, char **argv, const char **filename, const char **settingsname, SCIP_Real *timelimit, SCIP_Real *memlimit, SCIP_Longint *nodelimit, int *dispfreq)

int getProblemName(const char *filename, char *probname, int maxsize)

read comand line arguments

SCIP_RETCODE SCIPincludeDefaultPlugins(SCIP *scip)

internal methods for Benders' decomposition

enum SCIP_Retcode SCIP_RETCODE

enum SCIP_Status SCIP_STATUS

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

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

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