A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: cons_superindicator.c Source File

71#define CONSHDLR_NAME "superindicator" 72#define CONSHDLR_DESC "constraint handler for indicator constraints over arbitrary constraint types" 73#define CONSHDLR_SEPAPRIORITY 0 74#define CONSHDLR_ENFOPRIORITY -5000000 75#define CONSHDLR_CHECKPRIORITY -5000000 76#define CONSHDLR_SEPAFREQ -1 77#define CONSHDLR_PROPFREQ 1 78#define CONSHDLR_EAGERFREQ 100 80#define CONSHDLR_MAXPREROUNDS -1 82#define CONSHDLR_DELAYSEPA FALSE 83#define CONSHDLR_DELAYPROP FALSE 84#define CONSHDLR_NEEDSCONS TRUE 86#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP 87#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_MEDIUM 89#define DEFAULT_CHECKSLACKTYPE TRUE 90#define DEFAULT_UPGDPRIOINDICATOR 1 91#define DEFAULT_UPGDPRIOLINEAR 2 92#define DEFAULT_MAXUPGDCOEFLINEAR 1e4 108struct

SCIP_ConshdlrData

113 int

upgdprioindicator;

135

(*consdata)->binvar = binvar;

136

(*consdata)->slackcons = slackcons;

156

assert((*consdata)->slackcons !=

NULL

);

191 else if

( binval > 0.5 )

199 SCIPinfoMessage

(

scip

,

NULL

,

"violation: SCIPcheckCons() for slack constraint <%s> returns infeasible while binvar <%s> == 1\n"

,

212

assert(*result == testresultnotintegrality);

213

assert(*result == testresultnotlprows);

217 SCIPdebugMsg

(

scip

,

"binvar <%s> == 1, sol=%p --> SCIPcheckCons() on constraint <%s> --> %s\n"

,

250

assert(cons !=

NULL

);

251

assert(minactivity !=

NULL

);

252

assert(maxactivity !=

NULL

);

253

assert(minabscoef !=

NULL

);

265

ismininfinity =

FALSE

;

266

ismaxinfinity =

FALSE

;

271 for

( i = nvars-1; i >= 0; i-- )

289 if

( !ismininfinity )

290

*minactivity += (val > 0.0) ? val * lb : val * ub;

292 if

( !ismaxinfinity )

293

*maxactivity += (val > 0.0) ? val * ub : val * lb;

296 if

( val > 0.0 && val < *minabscoef )

298 else if

( val < 0.0 && -val < *minabscoef )

299

*minabscoef = -vals[i];

332

assert(cons !=

NULL

);

333

assert(success !=

NULL

);

334

assert(deleted !=

NULL

);

343

assert(consdata !=

NULL

);

351 if

( conshdlr ==

NULL

)

398 for

( i = nvars-1; i >= 0; i-- )

399

negvals[i] = -vals[i];

457

assert(cons !=

NULL

);

458

assert(success !=

NULL

);

459

assert(deleted !=

NULL

);

468

assert(consdata !=

NULL

);

470

slackcons = consdata->slackcons;

471

assert(slackcons !=

NULL

);

481 if

( conshdlr ==

NULL

)

519

maxact - rhs > maxcoef)) ||

521

lhs - minact > maxcoef)) )

523 SCIPdebugMsg

(

scip

,

"constraint <%s> not upgraded to a linear constraint due to large big-M coefficient\n"

,

537

assert(slackvars !=

NULL

);

538

assert(slackvals !=

NULL

);

540 for

( i = nvars-1; i >= 0; i-- )

542

newvars[i] = slackvars[i];

543

newvals[i] = slackvals[i];

547

newvars[nvars] = consdata->binvar;

548

assert(newvars[nvars] !=

NULL

);

564

newvals[nvars] = maxact - rhs;

595

newvals[nvars] = minact - lhs;

640

assert(cons !=

NULL

);

641

assert(success !=

NULL

);

642

assert(deleted !=

NULL

);

650 if

( conshdlrdata->upgdprioindicator > conshdlrdata->upgdpriolinear )

652

assert(conshdlrdata->upgdprioindicator >= 0);

656 if

( !*deleted && !*success && conshdlrdata->upgdpriolinear >= 0 )

662 else if

( conshdlrdata->upgdpriolinear >= 0 )

666 if

( !*deleted && !*success && conshdlrdata->upgdprioindicator >= 0 )

692

assert(conshdlr !=

NULL

);

693

assert(result !=

NULL

);

702 SCIPdebugMsg

(

scip

,

"executing enforcement callback for %s solution\n"

, sol ==

NULL

?

"LP"

:

"relaxation"

);

712 for

( i = nconss-1; i >= 0 && cont; i-- )

718

assert(consdata !=

NULL

);

729 SCIPdebugMsg

(

scip

,

"binvar <%s> == 1 locally --> SCIPenfolpCons() on constraint <%s>\n"

,

736 SCIPdebugMsg

(

scip

,

"binvar <%s> == 1 locally --> SCIPenforelaxCons() on constraint <%s>\n"

,

814

assert(conshdlr !=

NULL

);

831

assert(conshdlr !=

NULL

);

839

assert(conshdlrdata !=

NULL

);

857 for

( i = nconss-1; i >= 0; i-- )

860

assert(consdata !=

NULL

);

873

assert(conshdlr !=

NULL

);

875

assert(consdata !=

NULL

);

876

assert(*consdata !=

NULL

);

877

assert((*consdata)->slackcons !=

NULL

);

904

assert(sourcedata !=

NULL

);

927

assert(infeasible !=

NULL

);

929

*infeasible =

FALSE

;

933 for

( c = nconss-1; c >= 0 && !(*infeasible); c-- )

939

assert(consdata !=

NULL

);

946 SCIPdebugMsg

(

scip

,

"binvar <%s> == 1 --> SCIPinitlpCons() on constraint <%s>\n"

,

962

assert(conshdlr !=

NULL

);

964

assert(conss !=

NULL

);

965

assert(result !=

NULL

);

976 for

( c = nusefulconss-1; c >= 0 && *result !=

SCIP_CUTOFF

; c-- )

982

assert(consdata !=

NULL

);

991 SCIPdebugMsg

(

scip

,

"binvar <%s> == 1 --> SCIPsepalpCons() on constraint <%s>\n"

,

1000 switch

( locresult )

1005

*result = locresult;

1010

*result = locresult;

1016

*result = locresult;

1023

*result = locresult;

1031

*result = locresult;

1040

*result = locresult;

1050

*result = locresult;

1071

assert(conshdlr !=

NULL

);

1073

assert(conss !=

NULL

);

1074

assert(result !=

NULL

);

1085 for

( c = 0; c < nusefulconss && *result !=

SCIP_CUTOFF

; ++c )

1091

assert(consdata !=

NULL

);

1100 SCIPdebugMsg

(

scip

,

"binvar <%s> == 0 --> SCIPsepasolCons() on constraint <%s>\n"

,

1109 switch

( locresult )

1114

*result = locresult;

1119

*result = locresult;

1125

*result = locresult;

1132

*result = locresult;

1140

*result = locresult;

1149

*result = locresult;

1159

*result = locresult;

1200

assert(conshdlr !=

NULL

);

1201

assert(result !=

NULL

);

1204 if

( solinfeasible )

1209 else if

( objinfeasible )

1221 for

( i = nconss-1; i >= 0 && cont; i-- )

1227

assert(consdata !=

NULL

);

1236 SCIPdebugMsg

(

scip

,

"binvar <%s> == 1 locally --> SCIPenfopsCons() on constraint <%s>\n"

,

1250 switch

( locresult )

1256

*result = locresult;

1263

*result = locresult;

1270

*result = locresult;

1279

*result = locresult;

1289

*result = locresult;

1300

*result = locresult;

1312

*result = locresult;

1332

assert(conshdlr !=

NULL

);

1333

assert(result !=

NULL

);

1334

assert(sol !=

NULL

);

1338 for

( i = nconss-1; i >= 0 && (*result ==

SCIP_FEASIBLE

|| completely); i-- )

1346 SCIPdebugMsg

(

scip

,

"checked solution from <%s> (checkintegrality=%u, checklprows=%u) --> result=%d (%sfeasible)\n"

,

1360

assert(conshdlr !=

NULL

);

1361

assert(result !=

NULL

);

1368 for

( i = nusefulconss-1; i >= 0 && *result !=

SCIP_CUTOFF

; i-- )

1374

assert(consdata !=

NULL

);

1383 SCIPdebugMsg

(

scip

,

"binvar <%s> == 1 globally --> deleting superindicator and adding slack constraint <%s>\n"

,

1396 SCIPdebugMsg

(

scip

,

"binvar <%s> == 1 locally --> propagating slack constraint <%s>\n"

,

1409 switch

( locresult )

1415

*result = locresult;

1420

*result = locresult;

1426

*result = locresult;

1433

*result = locresult;

1453

assert(conss !=

NULL

);

1454

assert(conshdlr !=

NULL

);

1460 for

( i = nconss-1; i >= 0 && *result !=

SCIP_CUTOFF

; i-- )

1466

assert(consdata !=

NULL

);

1479 SCIPdebugMsg

(

scip

,

"binvar <%s> == 1 globally --> deleting superindicator and adding slack constraint <%s>\n"

,

1506 if

( deleted || success )

1514 switch

( locresult )

1519

*result = locresult;

1525

*result = locresult;

1542

assert(cons !=

NULL

);

1543

assert(infervar !=

NULL

);

1544

assert(bdchgidx !=

NULL

);

1545

assert(result !=

NULL

);

1550

assert(consdata !=

NULL

);

1580

assert(consdata !=

NULL

);

1601

assert(conshdlr !=

NULL

);

1602

assert(cons !=

NULL

);

1606

assert(consdata !=

NULL

);

1609

binvar = consdata->binvar;

1610

assert(binvar !=

NULL

);

1618

assert(binvar !=

NULL

);

1628

assert(consdata->slackcons !=

NULL

);

1643 const char

* consname;

1646

assert(sourcescip !=

NULL

);

1647

assert(sourcecons !=

NULL

);

1661 SCIPwarningMessage

(

scip

,

"cannot create modifiable superindicator constraint when trying to copy constraint <%s>\n"

,

1668

assert(sourceconsdata !=

NULL

);

1671

sourceslackcons = sourceconsdata->slackcons;

1672

assert(sourceslackcons !=

NULL

);

1677 SCIPdebugMsg

(

scip

,

"slack constraint <%s> deleted; creating empty linear constraint\n"

,

1689

assert(conshdlrslack !=

NULL

);

1700

assert(transslackcons !=

NULL

);

1704

sourceconsdata->slackcons = transslackcons;

1705

sourceslackcons = transslackcons;

1720

sourcebinvar = sourceconsdata->binvar;

1721

assert(sourcebinvar !=

NULL

);

1726

targetbinvar =

NULL

;

1731

assert(targetslackcons !=

NULL

);

1732

assert(targetbinvar !=

NULL

);

1733

assert(!modifiable);

1736

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

1740 if

( targetslackcons !=

NULL

)

1759 char

binvarname[1024];

1760 const char

* slackstr;

1764

assert(cons !=

NULL

);

1766

assert(success !=

NULL

);

1767

assert(str !=

NULL

);

1768

assert(name !=

NULL

);

1774

nargs = sscanf(str,

" <%1023[^>]>[B] = %d"

, binvarname, &zeroone);

1776 if

( nargs != 2 || (zeroone != 0 && zeroone != 1) )

1784

slackstr = strstr(str,

"->"

);

1786 if

( slackstr ==

NULL

)

1793

slackstr = strstr(slackstr,

"["

);

1795 if

( slackstr ==

NULL

)

1802 SCIPdebugMsg

(

scip

,

"binvarname=%s, zeroone=%d, slackstr=%s\n"

, binvarname, zeroone, slackstr);

1806 if

( binvar ==

NULL

)

1826 SCIP_CALL

(

SCIPparseCons

(

scip

, &slackcons, slackstr, initial, separate, enforce, check, propagate, local, modifiable,

1827

dynamic, removable, stickingatnode, success) );

1831

assert(binvar !=

NULL

);

1832

assert(slackcons !=

NULL

);

1836

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

1852

assert(consdata !=

NULL

);

1855 if

( varssize <= 0 )

1860

vars[0] = consdata->binvar;

1876

assert(consdata !=

NULL

);

1907

conshdlrdata->nrejects = 0;

1912

consEnfolpSuperindicator, consEnfopsSuperindicator, consCheckSuperindicator, consLockSuperindicator,

1915

assert(conshdlr !=

NULL

);

1944 "change"

,

"change the problem"

,

TRUE

,

NULL

) );

1960

SCIPdialogExecChangeMinUC,

NULL

,

NULL

,

1961 "minuc"

,

"transforms the current problem into a MinUC problem minimizing the number of unsatisfied constraints"

,

1971 "should type of slack constraint be checked when creating superindicator constraint?"

,

1976 "maximum big-M coefficient of binary variable in upgrade to a linear constraint (relative to smallest coefficient)"

,

1981 "priority for upgrading to an indicator constraint (-1: never)"

,

1986 "priority for upgrading to an indicator constraint (-1: never)"

,

2030

assert(cons !=

NULL

);

2031

assert(name !=

NULL

);

2032

assert(binvar !=

NULL

);

2033

assert(slackcons !=

NULL

);

2035

modifiable =

FALSE

;

2039 if

( conshdlr ==

NULL

)

2046

assert(conshdlrdata !=

NULL

);

2049 if

( conshdlrdata->checkslacktype &&

2067 if

( conshdlrdata->nrejects < 5 )

2069 SCIPwarningMessage

(

scip

,

"rejected creation of superindicator with slack constraint <%s> of type <%s> " 2070 "(use parameter <checkslacktype> to disable check)\n"

,

2072

conshdlrdata->nrejects++;

2075 if

( conshdlrdata->nrejects == 5 )

2078

conshdlrdata->nrejects++;

2086

assert(consdata !=

NULL

);

2089 SCIP_CALL

(

SCIPcreateCons

(

scip

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

2090

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

2112

assert(cons !=

NULL

);

2113

assert(name !=

NULL

);

2114

assert(binvar !=

NULL

);

2115

assert(slackcons !=

NULL

);

2129

assert(cons !=

NULL

);

2141

assert(cons !=

NULL

);

2173

assert(success !=

NULL

);

2179 SCIPerrorMessage

(

"method <SCIPtransformMinUC> can only be called in problem stage\n"

);

2193 for

( i = nvars-1; i >= 0; i-- )

2207 for

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

2216

assert(cons !=

NULL

);

2255 SCIPdebugMsg

(

scip

,

"constraint <%s> of type <%s> could not be transformed to superindicator and was removed\n"

,

2274 if

( ntransconss == nconss )

2312 SCIPdialogMessage

(

scip

,

NULL

,

"some constraints could not be transformed to superindicator constraints and were removed\n"

);

2316 SCIPdialogMessage

(

scip

,

NULL

,

"changed problem has %d variables (%d bin, %d int, %d impl, %d cont) and %d constraints\n"

,

constraint handler for indicator constraints

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

static SCIP_DECL_CONSENFORELAX(consEnforelaxSuperindicator)

#define DEFAULT_MAXUPGDCOEFLINEAR

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_SEPAFREQ

#define CONSHDLR_CHECKPRIORITY

#define DEFAULT_UPGDPRIOLINEAR

static SCIP_DECL_CONSRESPROP(consRespropSuperindicator)

static SCIP_DECL_CONSINITPRE(consInitpreSuperindicator)

#define CONSHDLR_PROP_TIMING

static SCIP_DECL_CONSFREE(consFreeSuperindicator)

#define CONSHDLR_MAXPREROUNDS

#define DEFAULT_CHECKSLACKTYPE

static SCIP_RETCODE upgradeLinearSuperindicator(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success, SCIP_Bool *deleted)

static SCIP_DECL_CONSLOCK(consLockSuperindicator)

static SCIP_RETCODE enforceConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopySuperindicator)

static SCIP_DECL_CONSSEPALP(consSepalpSuperindicator)

#define CONSHDLR_SEPAPRIORITY

static void extractLinearValues(SCIP *scip, SCIP_CONS *cons, SCIP_Real *minactivity, SCIP_Real *maxactivity, SCIP_Real *minabscoef)

#define DEFAULT_UPGDPRIOINDICATOR

static SCIP_DECL_CONSPRINT(consPrintSuperindicator)

static SCIP_DECL_CONSDELETE(consDeleteSuperindicator)

static SCIP_DECL_CONSSEPASOL(consSepasolSuperindicator)

static SCIP_RETCODE upgradeSuperindicator(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success, SCIP_Bool *deleted)

static SCIP_DECL_CONSGETVARS(consGetVarsSuperindicator)

static SCIP_RETCODE upgradeIndicatorSuperindicator(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success, SCIP_Bool *deleted)

static SCIP_DECL_CONSPARSE(consParseSuperindicator)

static SCIP_RETCODE consdataCheckSuperindicator(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)

static SCIP_DECL_CONSGETNVARS(consGetNVarsSuperindicator)

static SCIP_DECL_CONSINITLP(consInitlpSuperindicator)

#define CONSHDLR_PROPFREQ

static SCIP_RETCODE consdataCreateSuperindicator(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_VAR *binvar, SCIP_CONS *slackcons)

static SCIP_DECL_CONSCOPY(consCopySuperindicator)

#define CONSHDLR_PRESOLTIMING

#define CONSHDLR_EAGERFREQ

static SCIP_DECL_CONSCHECK(consCheckSuperindicator)

#define CONSHDLR_ENFOPRIORITY

static SCIP_DECL_CONSENFOLP(consEnfolpSuperindicator)

#define CONSHDLR_DELAYSEPA

static SCIP_DECL_CONSPRESOL(consPresolSuperindicator)

static SCIP_DECL_CONSTRANS(consTransSuperindicator)

static SCIP_DECL_CONSENFOPS(consEnfopsSuperindicator)

static SCIP_DECL_CONSPROP(consPropSuperindicator)

#define CONSHDLR_DELAYPROP

constraint handler for indicator constraints over arbitrary constraint types

default user interface dialog

SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR * SCIPgetBinaryVarSuperindicator(SCIP_CONS *cons)

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

SCIP_DECL_DIALOGEXEC(SCIPdialogExecChangeMinUC)

SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNVarsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsIndicator(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs, 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_Real * SCIPgetValsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPtransformMinUC(SCIP *scip, SCIP_Bool *success)

SCIP_CONS * SCIPgetSlackConsSuperindicator(SCIP_CONS *cons)

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 SCIPcreateConsSuperindicator(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *slackcons, 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 SCIPcreateConsBasicSuperindicator(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *slackcons)

SCIP_RETCODE SCIPincludeConshdlrSuperindicator(SCIP *scip)

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 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)

SCIP_STAGE SCIPgetStage(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

int SCIPgetNIntVars(SCIP *scip)

int SCIPgetNImplVars(SCIP *scip)

int SCIPgetNContVars(SCIP *scip)

SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)

SCIP_CONS ** SCIPgetConss(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNConss(SCIP *scip)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

int SCIPgetNBinVars(SCIP *scip)

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

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

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

#define SCIPdebugMsgPrint

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

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

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

SCIP_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 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)

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

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

void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)

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

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

SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))

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 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 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_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)

SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)

SCIP_RETCODE SCIPenfopsCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)

SCIP_RETCODE SCIPcheckCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

SCIP_RETCODE SCIPenfolpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_RESULT *result)

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

SCIP_RETCODE SCIPpropCons(SCIP *scip, SCIP_CONS *cons, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)

SCIP_RETCODE SCIPsepalpCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)

SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)

SCIP_RETCODE SCIPaddConsLocksType(SCIP *scip, SCIP_CONS *cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_RETCODE SCIPinitlpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)

SCIP_RETCODE SCIPrespropCons(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)

SCIP_RETCODE SCIPsetConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_Bool local)

SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)

SCIP_RETCODE SCIPgetTransformedCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)

SCIP_RETCODE SCIPenforelaxCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)

SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)

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 SCIPsepasolCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result)

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

SCIP_RETCODE SCIPtransformCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)

SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

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_RETCODE SCIPaddDialogEntry(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOG *subdialog)

SCIP_DIALOG * SCIPgetRootDialog(SCIP *scip)

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

const char * SCIPheurGetName(SCIP_HEUR *heur)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

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

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

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

SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)

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

SCIP_Real SCIPinfinity(SCIP *scip)

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

SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)

SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

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

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

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

const char * SCIPvarGetName(SCIP_VAR *var)

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

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

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

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

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

SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)

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

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

memory allocation routines

public methods for managing constraints

public methods for user interface dialog

public methods for primal heuristics

public methods for message output

public data structures and miscellaneous methods

public methods for primal CIP solutions

public methods for problem variables

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 dialog handler plugins

public methods for memory management

public methods for message handling

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for global and local (sub)problems

public methods for solutions

public methods for SCIP variables

struct SCIP_ConshdlrData SCIP_CONSHDLRDATA

struct SCIP_ConsData SCIP_CONSDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STAGE_INITPRESOLVE

@ SCIP_STAGE_EXITPRESOLVE

@ SCIP_STAGE_TRANSFORMING

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