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__or_8c_source.php below:

SCIP Doxygen Documentation: cons_or.c Source File

74#define CONSHDLR_NAME "or" 75#define CONSHDLR_DESC "constraint handler for or constraints: r = or(x1, ..., xn)" 76#define CONSHDLR_SEPAPRIORITY +850000 77#define CONSHDLR_ENFOPRIORITY -850000 78#define CONSHDLR_CHECKPRIORITY -850000 79#define CONSHDLR_SEPAFREQ 0 80#define CONSHDLR_PROPFREQ 1 81#define CONSHDLR_EAGERFREQ 100 83#define CONSHDLR_MAXPREROUNDS -1 84#define CONSHDLR_DELAYSEPA FALSE 85#define CONSHDLR_DELAYPROP FALSE 86#define CONSHDLR_NEEDSCONS TRUE 88#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP 89#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_MEDIUM 91#define EVENTHDLR_NAME "or" 92#define EVENTHDLR_DESC "event handler for or constraints" 112 unsigned int

propagated:1;

113 unsigned int

nofixedone:1;

114 unsigned int

impladded:1;

115 unsigned int

opimpladded:1;

119struct

SCIP_ConshdlrData

185

assert(conshdlrdata !=

NULL

);

186

assert(eventhdlr !=

NULL

);

191

(*conshdlrdata)->eventhdlr = eventhdlr;

203

assert(conshdlrdata !=

NULL

);

204

assert(*conshdlrdata !=

NULL

);

215

assert(consdata !=

NULL

);

217 return

consdata->nvars + 1;

230

assert(consdata !=

NULL

);

231

assert(consdata->vars !=

NULL

);

232

assert(eventhdlr !=

NULL

);

233

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

234

assert(filterpos !=

NULL

);

254

assert(consdata !=

NULL

);

255

assert(consdata->vars !=

NULL

);

256

assert(eventhdlr !=

NULL

);

257

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

258

assert(filterpos >= 0);

277

assert(consdata !=

NULL

);

284 for

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

303

assert(consdata !=

NULL

);

310 for

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

329

assert(consdata !=

NULL

);

330

assert(watchedvar1 == -1 || watchedvar1 != watchedvar2);

331

assert(watchedvar1 != -1 || watchedvar2 == -1);

332

assert(watchedvar1 == -1 || (0 <= watchedvar1 && watchedvar1 < consdata->nvars));

333

assert(watchedvar2 == -1 || (0 <= watchedvar2 && watchedvar2 < consdata->nvars));

336 if

( watchedvar1 == consdata->watchedvar2 || watchedvar2 == consdata->watchedvar1 )

340

tmp = consdata->watchedvar1;

341

consdata->watchedvar1 = consdata->watchedvar2;

342

consdata->watchedvar2 = tmp;

343

tmp = consdata->filterpos1;

344

consdata->filterpos1 = consdata->filterpos2;

345

consdata->filterpos2 = tmp;

347

assert(watchedvar1 == -1 || watchedvar1 != consdata->watchedvar2);

348

assert(watchedvar2 == -1 || watchedvar2 != consdata->watchedvar1);

351 if

( consdata->watchedvar1 != -1 && consdata->watchedvar1 != watchedvar1 )

353

assert(consdata->filterpos1 != -1);

356 if

( consdata->watchedvar2 != -1 && consdata->watchedvar2 != watchedvar2 )

358

assert(consdata->filterpos2 != -1);

363 if

( watchedvar1 != -1 && watchedvar1 != consdata->watchedvar1 )

367 if

( watchedvar2 != -1 && watchedvar2 != consdata->watchedvar2 )

373

consdata->watchedvar1 = watchedvar1;

374

consdata->watchedvar2 = watchedvar2;

387

assert(consdata !=

NULL

);

388

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

390 if

( num > consdata->varssize )

396

consdata->varssize = newsize;

398

assert(num <= consdata->varssize);

414

assert(consdata !=

NULL

);

415

assert(nvars == 0 || vars !=

NULL

);

416

assert(resvar !=

NULL

);

420

(*consdata)->resvar = resvar;

421

(*consdata)->rows =

NULL

;

422

(*consdata)->nvars = nvars;

423

(*consdata)->varssize = nvars;

424

(*consdata)->rowssize = 0;

425

(*consdata)->watchedvar1 = -1;

426

(*consdata)->watchedvar2 = -1;

427

(*consdata)->filterpos1 = -1;

428

(*consdata)->filterpos2 = -1;

429

(*consdata)->propagated =

FALSE

;

430

(*consdata)->nofixedone =

FALSE

;

431

(*consdata)->impladded =

FALSE

;

432

(*consdata)->opimpladded =

FALSE

;

456

assert(consdata !=

NULL

);

458 if

( consdata->rows !=

NULL

)

464 for

(

r

= 0;

r

< nrows; ++

r

)

482

assert(consdata !=

NULL

);

483

assert(*consdata !=

NULL

);

495

assert((*consdata)->watchedvar1 == -1);

496

assert((*consdata)->watchedvar2 == -1);

516

assert(consdata !=

NULL

);

545

assert(var !=

NULL

);

548

assert(consdata !=

NULL

);

549

assert(consdata->rows ==

NULL

);

559

assert(var !=

NULL

);

563

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

578 if

( consdata->rows !=

NULL

)

580 SCIPerrorMessage

(

"cannot add coefficients to or constraint after LP relaxation was created\n"

);

598

assert(eventhdlr !=

NULL

);

601

assert(consdata !=

NULL

);

602

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

618 if

( consdata->watchedvar1 == pos )

622 if

( consdata->watchedvar2 == pos )

627

assert(pos != consdata->watchedvar1);

628

assert(pos != consdata->watchedvar2);

631

consdata->vars[pos] = consdata->vars[consdata->nvars-1];

635 if

( consdata->watchedvar1 == consdata->nvars )

636

consdata->watchedvar1 = pos;

637 if

( consdata->watchedvar2 == consdata->nvars )

638

consdata->watchedvar2 = pos;

640

consdata->propagated =

FALSE

;

658

assert(consdata !=

NULL

);

659

assert(consdata->nvars == 0 || consdata->vars !=

NULL

);

662 while

( v < consdata->nvars )

664

var = consdata->vars[v];

717

assert(consdata !=

NULL

);

718

assert(consdata->rows ==

NULL

);

720

nvars = consdata->nvars;

725

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

728 for

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

760

assert(consdata !=

NULL

);

762 if

( consdata->rows ==

NULL

)

766

assert( consdata->rows !=

NULL

);

770 for

(

r

= 0;

r

< nrows && !(*infeasible); ++

r

)

796

assert(violated !=

NULL

);

799

assert(consdata !=

NULL

);

804

mustcheck = checklprows;

805

mustcheck = mustcheck || (consdata->rows ==

NULL

);

810

assert(consdata->rows !=

NULL

);

814 for

(

r

= 0;

r

< nrows; ++

r

)

841 for

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

845 if

( maxsolval < solval )

858

viol =

MAX3

(0.0, maxsolval - solval, solval - sumsolval);

911

assert(separated !=

NULL

);

914

assert(consdata !=

NULL

);

919 if

( consdata->rows ==

NULL

)

923

assert(consdata->rows !=

NULL

);

928 for

(

r

= 0;

r

< nrows; ++

r

)

938

assert( ! infeasible );

962

assert(consdata !=

NULL

);

964

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

996

assert(consdata !=

NULL

);

1003 for

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

1040

assert(cutoff !=

NULL

);

1041

assert(nfixedvars !=

NULL

);

1044

assert(consdata !=

NULL

);

1046

resvar = consdata->resvar;

1047

vars = consdata->vars;

1048

nvars = consdata->nvars;

1053 if

( consdata->propagated )

1055

assert(consdata->nofixedone);

1067 if

( !consdata->nofixedone )

1073 SCIPdebugMsg

(

scip

,

"constraint <%s>: operator var <%s> fixed to 1.0 -> fix resultant <%s> to 1.0\n"

,

1096

consdata->nofixedone =

TRUE

;

1098

assert(consdata->nofixedone);

1103 for

( i = 0; i < nvars && !(*cutoff); ++i )

1105 SCIPdebugMsg

(

scip

,

"constraint <%s>: resultant var <%s> fixed to 0.0 -> fix operator var <%s> to 0.0\n"

,

1115 else if

( tightened )

1138

watchedvar1 = consdata->watchedvar1;

1139

watchedvar2 = consdata->watchedvar2;

1142 if

( watchedvar1 != -1 )

1148 if

( watchedvar2 != -1 )

1156 if

( watchedvar1 == -1 )

1158

watchedvar1 = watchedvar2;

1161

assert(watchedvar1 != -1 || watchedvar2 == -1);

1164 if

( watchedvar2 == -1 )

1166 for

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

1171 if

( watchedvar1 == -1 )

1173

assert(watchedvar2 == -1);

1176 else if

( watchedvar1 != i )

1184

assert(watchedvar1 != -1 || watchedvar2 == -1);

1187 if

( watchedvar1 == -1 )

1189

assert(watchedvar2 == -1);

1191 SCIPdebugMsg

(

scip

,

"constraint <%s>: all operator vars fixed to 0.0 -> fix resultant <%s> to 0.0\n"

,

1219

assert(watchedvar1 != -1);

1221 SCIPdebugMsg

(

scip

,

"constraint <%s>: resultant <%s> fixed to 1.0, only one unfixed operand -> fix operand <%s> to 1.0\n"

,

1248

consdata->propagated =

TRUE

;

1275

assert(result !=

NULL

);

1278

assert(consdata !=

NULL

);

1279

vars = consdata->vars;

1280

nvars = consdata->nvars;

1287

assert(infervar == consdata->resvar);

1288 for

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

1311

assert(infervar == consdata->resvar);

1312 for

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

1325 for

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

1327 if

( vars[i] != infervar )

1359

assert(nupgdconss !=

NULL

);

1365 SCIPdebugMsg

(

scip

,

"upgrading or constraint <%s> into equivalent and constraint on negated variables\n"

,

1369

assert(consdata !=

NULL

);

1373 for

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

1419

assert(cons !=

NULL

);

1420

assert(graph !=

NULL

);

1421

assert(success !=

NULL

);

1424

assert(consdata !=

NULL

);

1435

assert(consdata->resvar !=

NULL

);

1436

vars[0] = consdata->resvar;

1447

orvars = consdata->vars;

1448 for

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

1450

assert(orvars[i] !=

NULL

);

1451

vars[0] = orvars[i];

1476

assert(conshdlr !=

NULL

);

1495

assert(conshdlrdata !=

NULL

);

1513 for

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

1530

assert(conshdlrdata !=

NULL

);

1547

assert(conshdlrdata !=

NULL

);

1550

assert(sourcedata !=

NULL

);

1554

sourcedata->nvars, sourcedata->vars, sourcedata->resvar) );

1573

*infeasible =

FALSE

;

1575 for

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

1595 for

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

1619 for

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

1641 for

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

1675 for

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

1709 for

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

1732 for

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

SCIP_FEASIBLE

|| completely ); ++i )

1752

assert(conshdlrdata !=

NULL

);

1758 for

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

1766 else if

( nfixedvars > 0 )

1790

assert(result !=

NULL

);

1793

oldnfixedvars = *nfixedvars;

1794

oldnaggrvars = *naggrvars;

1795

oldnupgdconss = *nupgdconss;

1798

assert(conshdlrdata !=

NULL

);

1805

assert(cons !=

NULL

);

1807

assert(consdata !=

NULL

);

1811

consdata->propagated =

FALSE

;

1826

assert(consdata->nvars >= 1);

1829 if

( consdata->nvars == 1 )

1833

assert(consdata->vars !=

NULL

);

1839

&cutoff, &redundant, &aggregated) );

1855 else if

( !consdata->impladded )

1860 for

( i = 0; i < consdata->nvars && !cutoff; ++i )

1866

*nchgbds += nimplbdchgs;

1868

consdata->impladded =

TRUE

;

1872 if

( !cutoff &&

SCIPconsIsActive

(cons) && consdata->nvars == 2 && !consdata->opimpladded

1879

(*nchgbds) += nimplbdchgs;

1880

consdata->opimpladded =

TRUE

;

1888 else if

( *nfixedvars > oldnfixedvars || *naggrvars > oldnaggrvars || *nupgdconss > oldnupgdconss )

1915

assert(consdata !=

NULL

);

1921 for

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

1935

assert( conshdlr !=

NULL

);

1936

assert( cons !=

NULL

);

1954

assert(valid !=

NULL

);

1970 for

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

1973

assert(!(*valid) || vars[v] !=

NULL

);

1980

assert(!(*valid) || resvar !=

NULL

);

1984

assert(resvar !=

NULL

);

1986

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

2018

token =

SCIPstrtok

(strcopy,

"="

, &saveptr );

2023 if

( resvar ==

NULL

)

2047 if

( varssize < requiredsize )

2050

varssize = requiredsize;

2058

assert(varssize >= requiredsize);

2062

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

2082

assert(consdata !=

NULL

);

2084 if

( varssize < consdata->nvars + 1 )

2085

(*success) =

FALSE

;

2089

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

2102

assert(cons !=

NULL

);

2105

assert(consdata !=

NULL

);

2107

(*nvars) = consdata->nvars + 1;

2140

assert(eventhdlr !=

NULL

);

2141

assert(eventdata !=

NULL

);

2142

assert(event !=

NULL

);

2145

assert(consdata !=

NULL

);

2149

consdata->nofixedone =

FALSE

;

2151

consdata->propagated =

FALSE

;

2172

eventExecOr,

NULL

) );

2180

consEnfolpOr, consEnfopsOr, consCheckOr, consLockOr,

2182

assert(conshdlr !=

NULL

);

2251 if

( conshdlr ==

NULL

)

2265

assert(vars !=

NULL

|| nvars == 0);

2266 for

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

2276

assert(conshdlrdata !=

NULL

);

2282 SCIP_CALL

(

SCIPcreateCons

(

scip

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

2283

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

2302 SCIP_CALL

(

SCIPcreateConsOr

(

scip

, cons, name, resvar, nvars, vars,

TRUE

,

TRUE

,

TRUE

,

TRUE

,

TRUE

,

2326

assert(consdata !=

NULL

);

2328 return

consdata->nvars;

2349

assert(consdata !=

NULL

);

2351 return

consdata->vars;

2372

assert(consdata !=

NULL

);

2374 return

consdata->resvar;

Constraint handler for AND constraints, .

static SCIP_RETCODE addRelaxation(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)

static SCIP_RETCODE consdataFreeRows(SCIP *scip, SCIP_CONSDATA *consdata)

static SCIP_DECL_CONSFREE(consFreeOr)

static int consdataGetNRows(SCIP_CONSDATA *consdata)

static SCIP_RETCODE consdataPrint(SCIP *scip, SCIP_CONSDATA *consdata, FILE *file)

static SCIP_RETCODE consdataCatchWatchedEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos, int *filterpos)

static SCIP_RETCODE consdataDropEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr)

static SCIP_RETCODE consdataSwitchWatchedvars(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int watchedvar1, int watchedvar2)

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_SEPAFREQ

static SCIP_DECL_CONSPARSE(consParseOr)

static SCIP_RETCODE delCoefPos(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)

#define CONSHDLR_CHECKPRIORITY

static SCIP_RETCODE addCoef(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_VAR *var)

static SCIP_DECL_CONSENFOPS(consEnfopsOr)

static SCIP_DECL_CONSTRANS(consTransOr)

static SCIP_RETCODE createRelaxation(SCIP *scip, SCIP_CONS *cons)

#define CONSHDLR_PROP_TIMING

static SCIP_DECL_CONSGETNVARS(consGetNVarsOr)

static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)

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

#define CONSHDLR_MAXPREROUNDS

static SCIP_DECL_CONSPRESOL(consPresolOr)

#define CONSHDLR_SEPAPRIORITY

static SCIP_DECL_CONSLOCK(consLockOr)

static SCIP_RETCODE analyzeConflictOne(SCIP *scip, SCIP_CONS *cons)

static SCIP_RETCODE analyzeConflictZero(SCIP *scip, SCIP_CONS *cons, int truepos)

static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)

static SCIP_DECL_CONSSEPASOL(consSepasolOr)

static SCIP_DECL_CONSRESPROP(consRespropOr)

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

static SCIP_DECL_CONSSEPALP(consSepalpOr)

static SCIP_RETCODE consdataEnsureVarsSize(SCIP *scip, SCIP_CONSDATA *consdata, int num)

static SCIP_RETCODE checkCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool *violated)

static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_EVENTHDLR *eventhdlr)

static SCIP_DECL_CONSPRINT(consPrintOr)

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopyOr)

static SCIP_DECL_CONSGETVARS(consGetVarsOr)

static SCIP_DECL_CONSCHECK(consCheckOr)

static SCIP_RETCODE consdataDropWatchedEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos, int filterpos)

static SCIP_DECL_CONSDELETE(consDeleteOr)

#define CONSHDLR_PROPFREQ

static SCIP_RETCODE upgradeCons(SCIP *scip, SCIP_CONS *cons, int *nupgdconss)

static SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(consGetSignedPermsymGraphOr)

#define CONSHDLR_PRESOLTIMING

static SCIP_RETCODE propagateCons(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, int *nfixedvars)

static SCIP_DECL_CONSENFOLP(consEnfolpOr)

static SCIP_DECL_CONSGETPERMSYMGRAPH(consGetPermsymGraphOr)

static SCIP_DECL_CONSPROP(consPropOr)

#define CONSHDLR_EAGERFREQ

static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *separated)

static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)

static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_EVENTHDLR *eventhdlr, int nvars, SCIP_VAR **vars, SCIP_VAR *resvar)

#define CONSHDLR_ENFOPRIORITY

static SCIP_DECL_CONSINITLP(consInitlpOr)

static SCIP_RETCODE applyFixings(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)

static SCIP_DECL_EVENTEXEC(eventExecOr)

static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, PROPRULE proprule, SCIP_BDCHGIDX *bdchgidx, SCIP_RESULT *result)

#define CONSHDLR_DELAYSEPA

static SCIP_DECL_CONSCOPY(consCopyOr)

static SCIP_DECL_CONSENFORELAX(consEnforelaxOr)

static SCIP_DECL_CONSEXITSOL(consExitsolOr)

#define CONSHDLR_DELAYPROP

static SCIP_RETCODE consdataCatchEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr)

Constraint handler for "or" constraints, .

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

int SCIPgetNVarsOr(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsAnd(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, 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_RETCODE SCIPcreateConsBasicOr(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, int nvars, SCIP_VAR **vars)

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

SCIP_RETCODE SCIPcreateConsOr(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, 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_RETCODE SCIPincludeConshdlrOr(SCIP *scip)

SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)

SCIP_Bool SCIPisTransformed(SCIP *scip)

SCIP_Bool SCIPisStopped(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)

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

#define SCIPdebugMsgPrint

SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)

SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)

SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)

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 SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)

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

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

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

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

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

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

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

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

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

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

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

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

SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)

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

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

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

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

SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLockedType(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)

SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

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

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

SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)

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

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

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

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

#define SCIPallocBlockMemoryArray(scip, ptr, num)

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

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

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

SCIP_Bool SCIPinProbing(SCIP *scip)

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

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

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

SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)

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

SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)

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

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

SCIP_Real SCIPinfinity(SCIP *scip)

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

SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPinRepropagation(SCIP *scip)

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

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)

SCIP_Bool SCIPdoNotAggr(SCIP *scip)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)

SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)

SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)

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

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

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

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

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

const char * SCIPvarGetName(SCIP_VAR *var)

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

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_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

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

SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)

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

SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)

SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)

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

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

char * SCIPstrtok(char *s, const char *delim, char **ptrptr)

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

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

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

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

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

memory allocation routines

#define BMScopyMemoryArray(ptr, source, num)

public methods for managing constraints

public methods for managing events

public methods for LP management

public methods for message output

public data structures and miscellaneous methods

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 cuts and aggregation rows

public methods for event handler plugins and event handlers

public methods for the LP relaxation, rows and columns

public methods for memory management

public methods for message handling

public methods for numerical tolerances

public methods for global and local (sub)problems

public methods for the probing mode

public methods for solutions

public methods for the branch-and-bound tree

public methods for SCIP variables

structs for symmetry computations

methods for dealing with symmetry detection graphs

@ SCIP_CONFTYPE_PROPAGATION

struct SCIP_ConshdlrData SCIP_CONSHDLRDATA

struct SCIP_ConsData SCIP_CONSDATA

#define SCIP_EVENTTYPE_BOUNDCHANGED

struct SCIP_EventData SCIP_EVENTDATA

#define SCIP_EVENTTYPE_UBTIGHTENED

#define SCIP_EVENTTYPE_LBRELAXED

#define SCIP_EVENTTYPE_LBTIGHTENED

#define SCIP_EVENTTYPE_UBRELAXED

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

enum SYM_Symtype SYM_SYMTYPE

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