A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: prob.c Source File

58#define OBJSCALE_MAXDNOM 1000000LL 59#define OBJSCALE_MAXSCALE 1000000.0 60#define OBJSCALE_MAXFINALSCALE 1000.0 76

assert(prob !=

NULL

);

87

assert(num <= prob->varssize);

100

assert(prob !=

NULL

);

111

assert(num <= prob->fixedvarssize);

124

assert(prob !=

NULL

);

135

assert(num <= prob->deletedvarssize);

148

assert(prob !=

NULL

);

164

assert(num <= prob->consssize);

179 return

(name !=

NULL

&& name[0] !=

'\0'

);

192 return

(name !=

NULL

&& name[0] !=

'\0'

);

224

assert(prob !=

NULL

);

226

assert(blkmem !=

NULL

);

227

assert(sourcescip !=

NULL

);

228

assert(sourceprob !=

NULL

);

229

assert(varmap !=

NULL

);

230

assert(consmap !=

NULL

);

233 SCIP_CALL

(

SCIPprobCreate

(prob, blkmem,

set

, name,

NULL

,

NULL

,

NULL

,

NULL

,

NULL

,

NULL

,

NULL

,

FALSE

) );

238 SCIP_CALL

( sourceprob->probcopy(

set

->scip, sourcescip, sourceprob->

probdata

, varmap, consmap, &targetdata, original, global, &result) );

243 SCIPerrorMessage

(

"probdata copying method returned invalid result <%d>\n"

, result);

252

assert( targetdata !=

NULL

);

253

(*prob)->probdelorig = sourceprob->probdelorig;

254

(*prob)->probtrans = sourceprob->probtrans;

255

(*prob)->probdeltrans = sourceprob->probdeltrans;

256

(*prob)->probinitsol = sourceprob->probinitsol;

257

(*prob)->probexitsol = sourceprob->probexitsol;

258

(*prob)->probcopy = sourceprob->probcopy;

285

assert(prob !=

NULL

);

290

(*prob)->probdata = probdata;

291

(*prob)->probcopy = probcopy;

292

(*prob)->probdelorig = probdelorig;

293

(*prob)->probtrans = probtrans;

294

(*prob)->probdeltrans = probdeltrans;

295

(*prob)->probinitsol = probinitsol;

296

(*prob)->probexitsol = probexitsol;

297 if

(

set

->misc_usevartable )

301

SCIPhashGetKeyVar, SCIPhashKeyEqString, SCIPhashKeyValString,

NULL

) );

304

(*prob)->varnames =

NULL

;

305

(*prob)->vars =

NULL

;

306

(*prob)->varssize = 0;

308

(*prob)->nbinvars = 0;

309

(*prob)->nintvars = 0;

310

(*prob)->nimplvars = 0;

311

(*prob)->ncontvars = 0;

312

(*prob)->ncolvars = 0;

313

(*prob)->fixedvars =

NULL

;

314

(*prob)->fixedvarssize = 0;

315

(*prob)->nfixedvars = 0;

316

(*prob)->deletedvars =

NULL

;

317

(*prob)->deletedvarssize = 0;

318

(*prob)->ndeletedvars = 0;

319

(*prob)->nobjvars = 0;

320 if

(

set

->misc_useconstable )

324

SCIPhashGetKeyCons, SCIPhashKeyEqString, SCIPhashKeyValString,

NULL

) );

327

(*prob)->consnames =

NULL

;

328

(*prob)->conss =

NULL

;

329

(*prob)->origcheckconss =

NULL

;

330

(*prob)->consssize = 0;

332

(*prob)->maxnconss = 0;

333

(*prob)->startnvars = 0;

334

(*prob)->startnconss = 0;

336

(*prob)->objoffset = 0.0;

337

(*prob)->objscale = 1.0;

340

(*prob)->objisintegral =

FALSE

;

341

(*prob)->transformed = transformed;

342

(*prob)->nlpenabled =

FALSE

;

343

(*prob)->permuted =

FALSE

;

344

(*prob)->consschecksorted =

FALSE

;

345

(*prob)->conscompression =

FALSE

;

356

assert(prob !=

NULL

);

358

prob->probdelorig = probdelorig;

367

assert(prob !=

NULL

);

369

prob->probtrans = probtrans;

378

assert(prob !=

NULL

);

380

prob->probdeltrans = probdeltrans;

389

assert(prob !=

NULL

);

391

prob->probinitsol= probinitsol;

400

assert(prob !=

NULL

);

402

prob->probexitsol= probexitsol;

411

assert(prob !=

NULL

);

413

prob->probcopy= probcopy;

432

assert(prob !=

NULL

);

433

assert(*prob !=

NULL

);

437 while

( (*prob)->nconss > 0 )

440

assert((*prob)->conss !=

NULL

);

444 if

( (*prob)->transformed )

449 for

(

h

= 0;

h

<

set

->nconshdlrs; ++

h

)

463 if

( (*prob)->transformed )

465 if

( (*prob)->probdeltrans !=

NULL

)

467 SCIP_CALL

( (*prob)->probdeltrans(

set

->scip, &(*prob)->probdata) );

472 if

( (*prob)->probdelorig !=

NULL

)

474 SCIP_CALL

( (*prob)->probdelorig(

set

->scip, &(*prob)->probdata) );

479 for

( v = (*prob)->nvars - 1; v >= 0; --v )

488

unreleasedvar =

TRUE

;

498 for

( v = (*prob)->nfixedvars - 1; v >= 0; --v )

507

unreleasedvar =

TRUE

;

515

assert(! unreleasedvar);

521 if

( (*prob)->varnames !=

NULL

)

525 if

( (*prob)->consnames !=

NULL

)

560

assert(source !=

NULL

);

561

assert(blkmem !=

NULL

);

562

assert(target !=

NULL

);

569

source->probinitsol, source->probexitsol, source->probcopy,

NULL

,

TRUE

) );

582 for

( v = 0; v < source->

nvars

; ++v )

588

assert((*target)->nvars == source->

nvars

);

592 if

( source->probtrans !=

NULL

)

597

(*target)->probdata = source->

probdata

;

600 for

( c = 0; c < source->nconss; ++c )

608 for

(

h

= 0;

h

<

set

->nconshdlrs; ++

h

)

622 SCIP_CALL

(

SCIPprobCheckObjIntegral

(*target, source, blkmem,

set

, stat, primal, tree, reopt, lp, eventfilter, eventqueue) );

628

(*target)->permuted = source->

permuted

;

646

assert(prob !=

NULL

);

649 for

( v = 0; v < prob->

nvars

; ++v )

676

nvars = prob->

nvars

;

685

assert(vars !=

NULL

);

686

assert(nbinvars + nintvars + nimplvars + ncontvars == nvars);

688 SCIPdebugMessage

(

"entering sorting with respect to original block structure! \n"

);

692 SCIPsortPtr

((

void

**)vars, SCIPvarComp, nbinvars);

696 SCIPsortPtr

((

void

**)&vars[nbinvars], SCIPvarComp, nintvars);

700 SCIPsortPtr

((

void

**)&vars[nbinvars + nintvars], SCIPvarComp, nimplvars);

704 SCIPsortPtr

((

void

**)&vars[nbinvars + nintvars + nimplvars], SCIPvarComp, ncontvars);

707 for

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

710 SCIPdebugMessage

(

"Variable: Problem index <%d>, original index <%d> \n"

, vars[v]->probindex, vars[v]->index);

750

assert(prob !=

NULL

);

767

assert(prob !=

NULL

);

770

assert(var !=

NULL

);

779

insertpos = prob->

nvars

;

781

implstart = intstart + prob->

nintvars

;

782

contstart = implstart + prob->

nimplvars

;

788 if

( insertpos > contstart )

790

prob->

vars

[insertpos] = prob->

vars

[contstart];

792

insertpos = contstart;

794

assert(insertpos == contstart);

800 if

( insertpos > implstart )

802

prob->

vars

[insertpos] = prob->

vars

[implstart];

804

insertpos = implstart;

806

assert(insertpos == implstart);

813 if

( insertpos > intstart )

815

prob->

vars

[insertpos] = prob->

vars

[intstart];

817

insertpos = intstart;

819

assert(insertpos == intstart);

834

prob->

vars

[insertpos] = var;

858

assert(prob !=

NULL

);

859

assert(var !=

NULL

);

865

implstart = intstart + prob->

nintvars

;

866

contstart = implstart + prob->

nimplvars

;

894 if

( freepos < intstart-1 )

897

prob->

vars

[freepos] = prob->

vars

[intstart-1];

899

freepos = intstart-1;

901 if

( freepos < implstart-1 )

904

prob->

vars

[freepos] = prob->

vars

[implstart-1];

906

freepos = implstart-1;

908 if

( freepos < contstart-1 )

911

prob->

vars

[freepos] = prob->

vars

[contstart-1];

913

freepos = contstart-1;

915 if

( freepos < prob->nvars-1 )

920

freepos = prob->

nvars

-1;

922

assert(freepos == prob->

nvars

-1);

981

assert(prob !=

NULL

);

983

assert(var !=

NULL

);

993 if

( var->

scip

!=

set

->scip )

1019 SCIPsetDebugMsg

(

set

,

"added variable <%s> to problem (%d variables: %d binary, %d integer, %d implicit, %d continuous)\n"

,

1052

assert(prob !=

NULL

);

1054

assert(var !=

NULL

);

1055

assert(deleted !=

NULL

);

1076 SCIPsetDebugMsg

(

set

,

"deleting variable <%s> from problem (%d variables: %d binary, %d integer, %d implicit, %d continuous)\n"

,

1086

assert(eventqueue !=

NULL

);

1117

assert(prob !=

NULL

);

1125 for

( i = 0; i <

set

->nconshdlrs; ++i )

1188

assert(prob !=

NULL

);

1189

assert(var !=

NULL

);

1200 if

( branchcand !=

NULL

)

1215 if

( branchcand !=

NULL

)

1233

assert(prob !=

NULL

);

1234

assert(var !=

NULL

);

1307 if

( currentcons == cons )

1326

assert(prob !=

NULL

);

1327

assert(cons !=

NULL

);

1333 if

( cons->

scip

!=

set

->scip )

1339 SCIPsetDebugMsg

(

set

,

"adding constraint <%s> to global problem -> %d constraints\n"

,

1400

assert(prob !=

NULL

);

1401

assert(blkmem !=

NULL

);

1402

assert(cons !=

NULL

);

1432

assert(prob->

conss

[arraypos] !=

NULL

);

1459

assert(prob !=

NULL

);

1473

assert(prob !=

NULL

);

1486

assert(prob !=

NULL

);

1499

assert(prob !=

NULL

);

1510

assert(prob !=

NULL

);

1520

assert(prob !=

NULL

);

1545

assert(transprob !=

NULL

);

1546

assert(origprob !=

NULL

);

1553 if

(

set

->nactivepricers != 0 ||

set

->nactivebenders != 0 )

1561 for

( v = 0; v < transprob->

nvars

; ++v )

1580 if

( v == transprob->

nvars

)

1585 SCIP_CALL

(

SCIPprimalUpdateObjoffset

(primal, blkmem,

set

, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );

1640

assert(prob !=

NULL

);

1663

assert(transprob !=

NULL

);

1667 if

(

set

->nactivepricers != 0 ||

set

->nactivebenders != 0 || !

set

->misc_scaleobj )

1673 for

( v = nints; v < transprob->

nvars

; ++v )

1684 if

( v == transprob->

nvars

)

1694 for

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

1699

&intscalar, &success) );

1701 SCIPsetDebugMsg

(

set

,

"integral objective scalar: success=%u, intscalar=%g\n"

, success, intscalar);

1707

assert(intscalar > 0.0);

1711 for

( v = 0; v < nints && gcd != 1; ++v )

1725 else if

( absobj > 0 )

1739 for

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

1753 for

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

1764 SCIP_CALL

(

SCIPprimalUpdateObjoffset

(primal, blkmem,

set

, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );

1788

assert(prob !=

NULL

);

1793 for

( v = 0; v < prob->

nvars

; ++v )

1815

assert(prob !=

NULL

);

1816

assert(lp !=

NULL

);

1833 for

( v = 0; v < prob->

nvars

; ++v )

1840

var = prob->

vars

[v];

1841

assert(var !=

NULL

);

1848

assert(col !=

NULL

);

1884 if

( -lbrootredcost > ubrootredcost )

1886

rootredcost = lbrootredcost;

1891

rootredcost = ubrootredcost;

1920

assert(prob !=

NULL

);

1925 for

( c = 0; c < prob->

nconss

; ++c )

1931 for

( v = 0; v < prob->

nvars

; ++v )

1935 if

( prob->probinitsol !=

NULL

)

1959

assert(prob !=

NULL

);

1964 if

( prob->probexitsol !=

NULL

)

1974 if

( prob->

ncolvars

> 0 || restart )

1976 for

( v = 0; v < prob->

nvars

; ++v )

1978

var = prob->

vars

[v];

2027

assert(prob !=

NULL

);

2048 int

nimplbinvars = 0;

2056 return

nimplbinvars;

2068#ifdef SCIP_MORE_DEBUG 2074 for

( v = prob->

nvars

- 1; v >= 0; --v )

2081

assert(prob->

nobjvars

== nobjvars);

2092 for

( v = prob->

nvars

- 1; v >= 0; --v )

2117 for

( v = 0; v < prob->

nvars

; v++ )

2144 for

( v = 0; v < prob->

nvars

; v++ )

2165

assert(origprob !=

NULL

);

2166

assert(transprob !=

NULL

);

2168

assert(transprob->

objscale

> 0.0);

2187

assert(origprob !=

NULL

);

2188

assert(transprob !=

NULL

);

2190

assert(transprob->

objscale

> 0.0);

2206

assert(prob !=

NULL

);

2207

assert(name !=

NULL

);

2211 SCIPerrorMessage

(

"Cannot find variable if variable-names hashtable was disabled (due to parameter <misc/usevartable>)\n"

);

2225

assert(prob !=

NULL

);

2226

assert(name !=

NULL

);

2230 SCIPerrorMessage

(

"Cannot find constraint if constraint-names hashtable was disabled (due to parameter <misc/useconstable>)\n"

);

2249 for

( v = 0; v < prob->

nvars

; ++v )

2251

var = prob->

vars

[v];

2252

assert(var !=

NULL

);

2268

assert(prob !=

NULL

);

2271 SCIPmessageFPrintInfo

(messagehdlr, file,

" Variables : %d (%d binary, %d integer, %d implicit integer, %d continuous)\n"

,

2274 SCIPmessageFPrintInfo

(messagehdlr, file,

" Objective : %s, %d non-zeros (abs.min = %g, abs.max = %g)\n"

,

2288#undef SCIPprobIsPermuted 2289#undef SCIPprobMarkPermuted 2290#undef SCIPprobIsTransformed 2291#undef SCIPprobIsObjIntegral 2292#undef SCIPprobAllColsInLP 2293#undef SCIPprobGetObjlim 2294#undef SCIPprobGetData 2295#undef SCIPprobGetName 2296#undef SCIPprobGetNVars 2297#undef SCIPprobGetNBinVars 2298#undef SCIPprobGetNIntVars 2299#undef SCIPprobGetNImplVars 2300#undef SCIPprobGetNContVars 2301#undef SCIPprobGetVars 2302#undef SCIPprobGetNFixedVars 2303#undef SCIPprobGetFixedVars 2304#undef SCIPprobGetStartNVars 2305#undef SCIPprobGetNConss 2306#undef SCIPprobGetConss 2307#undef SCIPprobGetMaxNConss 2308#undef SCIPprobGetStartNConss 2309#undef SCIPprobGetObjsense 2310#undef SCIPprobGetObjoffset 2311#undef SCIPprobGetObjscale 2312#undef SCIPisConsCompressedEnabled 2313#undef SCIPprobEnableConsCompression 2320

assert(prob !=

NULL

);

2330

assert(prob !=

NULL

);

2340

assert(prob !=

NULL

);

2350

assert(prob !=

NULL

);

2375

assert(prob !=

NULL

);

2386

assert(prob !=

NULL

);

2396

assert(prob !=

NULL

);

2397 return

prob->

name

;

2405

assert(prob !=

NULL

);

2406 return

prob->

nvars

;

2414

assert(prob !=

NULL

);

2423

assert(prob !=

NULL

);

2432

assert(prob !=

NULL

);

2441

assert(prob !=

NULL

);

2450

assert(prob !=

NULL

);

2451 return

prob->

vars

;

2459

assert(prob !=

NULL

);

2468

assert(prob !=

NULL

);

2477

assert(prob !=

NULL

);

2486

assert(prob !=

NULL

);

2495

assert(prob !=

NULL

);

2496 return

prob->

conss

;

2504

assert(prob !=

NULL

);

2513

assert(prob !=

NULL

);

2522

assert(prob !=

NULL

);

2531

assert(prob !=

NULL

);

2540

assert(prob !=

NULL

);

2549

assert(prob !=

NULL

);

2559

assert(prob !=

NULL

);

SCIP_RETCODE SCIPbranchcandRemoveVar(SCIP_BRANCHCAND *branchcand, SCIP_VAR *var)

SCIP_RETCODE SCIPbranchcandUpdateVar(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_VAR *var)

internal methods for branching rules and branching candidate storage

SCIP_RETCODE SCIPconflictstoreTransform(SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_REOPT *reopt)

internal methods for storing conflicts

SCIP_RETCODE SCIPconsAddLocks(SCIP_CONS *cons, SCIP_SET *set, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)

void SCIPconsCapture(SCIP_CONS *cons)

void SCIPconsSetLocal(SCIP_CONS *cons, SCIP_Bool local)

SCIP_RETCODE SCIPconsDeactivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPconshdlrLockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)

SCIP_RETCODE SCIPconsResetAge(SCIP_CONS *cons, SCIP_SET *set)

SCIP_RETCODE SCIPconsTransform(SCIP_CONS *origcons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS **transcons)

SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)

SCIP_RETCODE SCIPconshdlrUnlockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)

SCIP_RETCODE SCIPconsActivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)

SCIP_RETCODE SCIPconshdlrDelVars(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

internal methods for constraints and constraint handlers

#define SCIP_HASHSIZE_NAMES_SMALL

#define SCIP_HASHSIZE_NAMES

#define SCIP_LONGINT_FORMAT

SCIP_RETCODE SCIPeventCreateVarAdded(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)

SCIP_RETCODE SCIPeventqueueAdd(SCIP_EVENTQUEUE *eventqueue, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENT **event)

SCIP_RETCODE SCIPeventCreateVarDeleted(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)

internal methods for managing events

void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)

SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)

SCIP_RETCODE SCIPhashtableCreate(SCIP_HASHTABLE **hashtable, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)

void * SCIPhashtableRetrieve(SCIP_HASHTABLE *hashtable, void *key)

SCIP_RETCODE SCIPhashtableRemove(SCIP_HASHTABLE *hashtable, void *element)

SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)

SCIP_Longint SCIPcalcGreComDiv(SCIP_Longint val1, SCIP_Longint val2)

SCIP_RETCODE SCIPcalcIntegralScalar(SCIP_Real *vals, int nvals, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Real *intscalar, SCIP_Bool *success)

SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)

SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)

SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)

SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)

SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

int SCIPvarGetNLocksDown(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

void SCIPvarSetBestRootSol(SCIP_VAR *var, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)

int SCIPvarGetNUses(SCIP_VAR *var)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Bool SCIPvarIsDeletable(SCIP_VAR *var)

SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)

SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)

SCIP_Real SCIPvarGetPseudoSol(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)

int SCIPvarGetNLocksUp(SCIP_VAR *var)

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

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

SCIP_Bool SCIPlpIsSolBasic(SCIP_LP *lp)

SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)

void SCIPlpStoreRootObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

SCIP_Real SCIPlpGetColumnObjval(SCIP_LP *lp)

SCIP_RETCODE SCIPlpUpdateAddVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)

SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)

SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

SCIP_RETCODE SCIPlpUpdateDelVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)

SCIP_Real SCIPcolGetRedcost(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)

SCIP_Bool SCIPlpIsDualReliable(SCIP_LP *lp)

int SCIPlpGetNCols(SCIP_LP *lp)

void SCIPlpSetRootLPIsRelax(SCIP_LP *lp, SCIP_Bool isrelax)

internal methods for LP management

#define BMSfreeMemory(ptr)

#define BMSreallocMemoryArray(ptr, num)

#define BMSduplicateMemoryArray(ptr, source, num)

#define BMSfreeMemoryArray(ptr)

struct BMS_BlkMem BMS_BLKMEM

#define BMSfreeMemoryArrayNull(ptr)

#define BMSallocMemory(ptr)

void SCIPmessageFPrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)

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

void SCIPmessagePrintInfo(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)

SCIP_RETCODE SCIPprimalUpdateObjoffset(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp)

internal methods for collecting primal CIP solutions and primal informations

SCIP_RETCODE SCIPprobScaleObj(SCIP_PROB *transprob, SCIP_PROB *origprob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue)

void SCIPprobPrintStatistics(SCIP_PROB *prob, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)

static SCIP_RETCODE probEnsureVarsMem(SCIP_PROB *prob, SCIP_SET *set, int num)

SCIP_Bool SCIPprobIsPermuted(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobExitPresolve(SCIP_PROB *prob, SCIP_SET *set)

void SCIPprobSetTrans(SCIP_PROB *prob, SCIP_DECL_PROBTRANS((*probtrans)))

void SCIPprobUpdateNObjVars(SCIP_PROB *prob, SCIP_SET *set, SCIP_Real oldobj, SCIP_Real newobj)

int SCIPprobGetNContVars(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobAddConsName(SCIP_PROB *prob, SCIP_CONS *cons)

void SCIPprobSetInitsol(SCIP_PROB *prob, SCIP_DECL_PROBINITSOL((*probinitsol)))

SCIP_CONS ** SCIPprobGetConss(SCIP_PROB *prob)

int SCIPprobGetNFixedVars(SCIP_PROB *prob)

void SCIPprobInvalidateDualbound(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobAddVarName(SCIP_PROB *prob, SCIP_VAR *var)

static SCIP_RETCODE probRemoveVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_VAR *var)

void SCIPprobSetObjIntegral(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobAddVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var)

SCIP_RETCODE SCIPprobVarChangedStatus(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BRANCHCAND *branchcand, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var)

const char * SCIPprobGetName(SCIP_PROB *prob)

SCIP_Real SCIPprobGetObjoffset(SCIP_PROB *prob)

int SCIPprobGetNConss(SCIP_PROB *prob)

int SCIPprobGetNObjVars(SCIP_PROB *prob, SCIP_SET *set)

SCIP_Real SCIPprobGetAbsMinObjCoef(SCIP_PROB *prob, SCIP_SET *set)

static SCIP_RETCODE probEnsureConssMem(SCIP_PROB *prob, SCIP_SET *set, int num)

static void probInsertVar(SCIP_PROB *prob, SCIP_VAR *var)

SCIP_RETCODE SCIPprobPerformVarDeletions(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand)

void SCIPprobSetExitsol(SCIP_PROB *prob, SCIP_DECL_PROBEXITSOL((*probexitsol)))

SCIP_Real SCIPprobGetAbsMaxObjCoef(SCIP_PROB *prob, SCIP_SET *set)

SCIP_RETCODE SCIPprobRemoveVarName(SCIP_PROB *prob, SCIP_VAR *var)

static SCIP_RETCODE probEnsureFixedvarsMem(SCIP_PROB *prob, SCIP_SET *set, int num)

int SCIPprobGetNImplBinVars(SCIP_PROB *prob)

int SCIPprobGetStartNConss(SCIP_PROB *prob)

SCIP_Real SCIPprobGetObjlim(SCIP_PROB *prob, SCIP_SET *set)

void SCIPprobUpdateDualbound(SCIP_PROB *prob, SCIP_Real newbound)

SCIP_RETCODE SCIPprobInitSolve(SCIP_PROB *prob, SCIP_SET *set)

void SCIPprobMarkNConss(SCIP_PROB *prob)

SCIP_OBJSENSE SCIPprobGetObjsense(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobTransform(SCIP_PROB *source, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CONFLICTSTORE *conflictstore, SCIP_PROB **target)

void SCIPprobPrintPseudoSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)

int SCIPprobGetStartNVars(SCIP_PROB *prob)

#define OBJSCALE_MAXSCALE

SCIP_RETCODE SCIPprobSetName(SCIP_PROB *prob, const char *name)

void SCIPprobSetDeltrans(SCIP_PROB *prob, SCIP_DECL_PROBDELTRANS((*probdeltrans)))

void SCIPprobSetData(SCIP_PROB *prob, SCIP_PROBDATA *probdata)

#define OBJSCALE_MAXFINALSCALE

SCIP_Real SCIPprobGetObjscale(SCIP_PROB *prob)

void SCIPprobAddObjoffset(SCIP_PROB *prob, SCIP_Real addval)

SCIP_RETCODE SCIPprobCheckObjIntegral(SCIP_PROB *transprob, SCIP_PROB *origprob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue)

void SCIPprobSetCopy(SCIP_PROB *prob, SCIP_DECL_PROBCOPY((*probcopy)))

SCIP_VAR * SCIPprobFindVar(SCIP_PROB *prob, const char *name)

int SCIPprobGetNImplVars(SCIP_PROB *prob)

static SCIP_Bool varHasName(SCIP_VAR *var)

SCIP_RETCODE SCIPprobExitSolve(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Bool restart)

SCIP_RETCODE SCIPprobCreate(SCIP_PROB **prob, BMS_BLKMEM *blkmem, SCIP_SET *set, 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_Bool transformed)

void SCIPprobSetObjlim(SCIP_PROB *prob, SCIP_Real objlim)

SCIP_VAR ** SCIPprobGetFixedVars(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobDelVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var, SCIP_Bool *deleted)

SCIP_Bool SCIPprobIsObjIntegral(SCIP_PROB *prob)

void SCIPprobEnableConsCompression(SCIP_PROB *prob)

SCIP_CONS * SCIPprobFindCons(SCIP_PROB *prob, const char *name)

void SCIPprobMarkPermuted(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobRemoveConsName(SCIP_PROB *prob, SCIP_CONS *cons)

int SCIPprobGetNIntVars(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobDelCons(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)

int SCIPprobGetNVars(SCIP_PROB *prob)

SCIP_PROBDATA * SCIPprobGetData(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobChgVarType(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_VARTYPE vartype)

static SCIP_RETCODE probEnsureDeletedvarsMem(SCIP_PROB *prob, SCIP_SET *set, int num)

SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)

void SCIPprobResortVars(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobFree(SCIP_PROB **prob, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)

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

SCIP_RETCODE SCIPprobAddCons(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)

int SCIPprobGetMaxNConss(SCIP_PROB *prob)

SCIP_RETCODE SCIPprobResetBounds(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

void SCIPprobSetDualbound(SCIP_PROB *prob, SCIP_Real dualbound)

void SCIPprobStoreRootSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Bool roothaslp)

int SCIPprobGetNBinVars(SCIP_PROB *prob)

SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)

void SCIPprobSetDelorig(SCIP_PROB *prob, SCIP_DECL_PROBDELORIG((*probdelorig)))

SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)

void SCIPprobUpdateBestRootSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)

static SCIP_Bool consHasName(SCIP_CONS *cons)

SCIP_Bool SCIPprobIsTransformed(SCIP_PROB *prob)

SCIP_Bool SCIPprobIsConsCompressionEnabled(SCIP_PROB *prob)

void SCIPprobSetObjsense(SCIP_PROB *prob, SCIP_OBJSENSE objsense)

SCIP_Real SCIPprobInternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)

SCIP_RETCODE SCIPprobSortConssCheck(SCIP_PROB *prob)

internal methods for storing and manipulating the main problem

public methods for managing constraints

public methods for LP management

public methods for message output

public data structures and miscellaneous methods

methods for sorting joint arrays of various types

public methods for problem variables

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

SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsDualfeasNegative(SCIP_SET *set, SCIP_Real val)

SCIP_Real SCIPsetEpsilon(SCIP_SET *set)

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

SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)

SCIP_Real SCIPsetInfinity(SCIP_SET *set)

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

SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsDualfeasPositive(SCIP_SET *set, SCIP_Real val)

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

SCIP_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)

int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)

SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)

internal methods for global SCIP settings

#define SCIPsetFreeBufferArray(set, ptr)

#define SCIPsetAllocBufferArray(set, ptr, num)

void SCIPstatComputeRootLPBestEstimate(SCIP_STAT *stat, SCIP_SET *set, SCIP_Real rootlpobjval, SCIP_VAR **vars, int nvars)

internal methods for problem statistics

SCIP_CONSSETCHG * addconssetchg

unsigned int updatedeactivate

SCIP_Bool consschecksorted

SCIP_CONS ** origcheckconss

SCIP_HASHTABLE * consnames

SCIP_Bool conscompression

SCIP_HASHTABLE * varnames

SCIP_Longint nactiveconssadded

datastructures for constraints and constraint handlers

data structures for LP management

datastructures for storing and manipulating the main problem

datastructures for global SCIP settings

datastructures for problem statistics

datastructures for problem variables

enum SCIP_BaseStat SCIP_BASESTAT

#define SCIP_DECL_PROBCOPY(x)

#define SCIP_DECL_PROBDELTRANS(x)

#define SCIP_DECL_PROBEXITSOL(x)

struct SCIP_ProbData SCIP_PROBDATA

#define SCIP_DECL_PROBDELORIG(x)

#define SCIP_DECL_PROBTRANS(x)

#define SCIP_DECL_PROBINITSOL(x)

enum SCIP_Objsense SCIP_OBJSENSE

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STAGE_TRANSFORMING

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_VARSTATUS_ORIGINAL

@ SCIP_VARSTATUS_MULTAGGR

@ SCIP_VARSTATUS_AGGREGATED

enum SCIP_Vartype SCIP_VARTYPE

SCIP_RETCODE SCIPvarRemove(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_Bool final)

SCIP_RETCODE SCIPvarResetBounds(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPvarChgObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newobj)

SCIP_Real SCIPvarGetImplRedcost(SCIP_VAR *var, SCIP_SET *set, SCIP_Bool varfixing, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)

void SCIPvarInitSolve(SCIP_VAR *var)

SCIP_RETCODE SCIPvarTransform(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_OBJSENSE objsense, SCIP_VAR **transvar)

SCIP_RETCODE SCIPvarRelease(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)

void SCIPvarCapture(SCIP_VAR *var)

void SCIPvarStoreRootSol(SCIP_VAR *var, SCIP_Bool roothaslp)

SCIP_RETCODE SCIPvarChgType(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_VARTYPE vartype)

void SCIPvarUpdateBestRootSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)

void SCIPvarMarkDeleted(SCIP_VAR *var)

SCIP_RETCODE SCIPvarLoose(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp)

void SCIPvarSetProbindex(SCIP_VAR *var, int probindex)

internal methods for problem variables

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

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

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