A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: prop_pseudoobj.c Source File

68#define PROP_NAME "pseudoobj" 69#define PROP_DESC "pseudo objective function propagator" 70#define PROP_TIMING SCIP_PROPTIMING_BEFORELP | SCIP_PROPTIMING_DURINGLPLOOP | SCIP_PROPTIMING_AFTERLPLOOP 71#define PROP_PRIORITY 3000000 73#define PROP_DELAY FALSE 74#define PROP_PRESOL_PRIORITY +6000000 75#define PROP_PRESOL_MAXROUNDS -1 77#define PROP_PRESOLTIMING SCIP_PRESOLTIMING_FAST 79#define EVENTHDLR_NAME "pseudoobj" 80#define EVENTHDLR_DESC "bound change event handler for pseudo objective function propagator" 82#define DEFAULT_MINUSELESS 100 84#define DEFAULT_MAXVARSFRAC 0.1 86#define DEFAULT_PROPFULLINROOT TRUE 87#define DEFAULT_PROPCUTOFFBOUND TRUE 88#define DEFAULT_FORCE FALSE 92#define DEFAULT_MAXNEWVARS 1000 93#define DEFAULT_PROPUSEIMPLICS TRUE 94#define DEFAULT_RESPROPUSEIMPLICS TRUE 95#define DEFAULT_MAXIMPLVARS 50000 134 int

maxpseudoobjactinf;

142 int

glbfirstnonfixed;

143 int

maxactfirstnonfixed;

192 for

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

222 for

( v = 0; v < propdata->glbfirstnonfixed; ++v )

224

var = propdata->minactvars[v];

225

assert(var !=

NULL

);

230 for

( v = 0; v < propdata->maxactfirstnonfixed; ++v )

232

var = propdata->maxactvars[v];

233

assert(var !=

NULL

);

302 if

( locks1 < locks2 )

304 if

( locks1 > locks2 )

318 if

( locks1 < locks2 )

320 if

( locks1 > locks2 )

373

assert(objimplics !=

NULL

);

380 if

( nlbimpls + nubimpls == 0 )

382

assert(nlbimpls == 0);

383

assert(nubimpls == 0);

384

(*objimplics)->objvars =

NULL

;

385

(*objimplics)->maxobjchg = 0.0;

386

(*objimplics)->nlbimpls = 0;

387

(*objimplics)->nubimpls = 0;

388

(*objimplics)->size = 0;

397

assert(objvars !=

NULL

);

398

assert(binobjvarmap !=

NULL

);

399

assert(collectedlbvars !=

NULL

);

400

assert(collectedubvars !=

NULL

);

403

(*objimplics)->size = nlbimpls + nubimpls;

407 for

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

410

assert(var !=

NULL

);

416

assert(collectedlbvars[pos]);

418 if

( collectedubvars[pos] )

442

(*objimplics)->objvars[nvars] = var;

445

collectedlbvars[pos] =

FALSE

;

447

(*objimplics)->nlbimpls = nvars;

449 for

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

451

var = objvars[nlbimpls + v];

452

assert(var !=

NULL

);

458

assert(collectedubvars[pos]);

469

(*objimplics)->objvars[nvars] = var;

472

collectedubvars[pos] =

FALSE

;

474

(*objimplics)->nubimpls = nvars - (*objimplics)->nlbimpls;

477 for

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

485

(*objimplics)->maxobjchg =

MAX

(maxlbobjchg, maxubobjchg);

500

assert(objimplics !=

NULL

);

501

assert(*objimplics !=

NULL

);

504 for

( v = 0; v < (*objimplics)->nlbimpls + (*objimplics)->nubimpls; ++v )

527

assert(pos < objimplics->nlbimpls + objimplics->

nubimpls

);

535 if

( pos < objimplics->nlbimpls )

580

assert(propdata !=

NULL

);

581

assert(eventhdlr !=

NULL

);

611

assert(propdata !=

NULL

);

612

assert(eventhdlr !=

NULL

);

643

assert(propdata !=

NULL

);

645

eventhdlr = propdata->eventhdlr;

646

assert(eventhdlr !=

NULL

);

649 for

( k = 0; k < propdata->nminactvars; ++k )

651

var = propdata->minactvars[k];

652

assert(var !=

NULL

);

665 for

( k = 0; k < propdata->nmaxactvars; ++k )

667

var = propdata->maxactvars[k];

668

assert(var !=

NULL

);

679 for

( k = 0; k < propdata->nobjintvars; ++k )

681

var = propdata->objintvars[k];

682

assert(var !=

NULL

);

700

propdata->minactvars =

NULL

;

701

propdata->minactimpls =

NULL

;

702

propdata->maxactvars =

NULL

;

703

propdata->maxactchgs =

NULL

;

704

propdata->objintvars =

NULL

;

705

propdata->nminactvars = 0;

706

propdata->nmaxactvars = 0;

707

propdata->nobjintvars = 0;

709

propdata->maxpseudoobjactinf = 0;

710

propdata->lastvarnum = -1;

711

propdata->glbpropagated =

FALSE

;

715

propdata->glbfirstnonfixed = 0;

716

propdata->maxactfirstnonfixed = 0;

717

propdata->firstnonfixed = 0;

718

propdata->nnewvars = 0;

719

propdata->minactsize = 0;

720

propdata->maxactsize = 0;

721

propdata->objintvarssize = 0;

722

propdata->catchvaradded =

FALSE

;

723

propdata->initialized =

FALSE

;

735 if

( !propdata->initialized )

738 if

( propdata->addedvars !=

NULL

)

744 for

( v = 0; v < propdata->nminactvars; ++v )

797

assert(var !=

NULL

);

798

assert(binobjvarmap !=

NULL

);

799

assert(collectedvars !=

NULL

);

800

assert(contributors !=

NULL

);

801

assert(ncontributors !=

NULL

);

818 if

( collectedvars[pos] )

822

assert(*ncontributors < nbinobjvars);

823

contributors[*ncontributors] = var;

827

collectedvars[pos] =

TRUE

;

833#define MAX_CLIQUELENGTH 50 878

assert(objchg !=

NULL

);

879

assert(contributors !=

NULL

);

880

assert(ncontributors !=

NULL

);

881

assert(*ncontributors == 0);

890 if

( uselesscliques ==

NULL

)

895 for

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

896

assert(collectedvars[c] ==

FALSE

);

900 for

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

905

assert(clique !=

NULL

);

923 for

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

926

assert(implvar !=

NULL

);

928 if

( implvar == var )

1013 while

( v < nbinvars )

1015

implvar = objimplics->

objvars

[v];

1016

assert(implvar !=

NULL

);

1071 int

* ncontributors,

1076

assert(contributors !=

NULL

);

1077

assert(ncontributors !=

NULL

);

1082

(*ncontributors) = 0;

1147

assert(objchg !=

NULL

);

1188

assert(cliques !=

NULL

);

1191 for

( c = ncliques - 1; c >= 0; --c )

1193

clique = cliques[c];

1197

assert(nclqvars > 0);

1198

assert(clqvars !=

NULL

);

1199

assert(clqvalues !=

NULL

);

1205 for

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

1207

clqvar = clqvars[v];

1208

assert(clqvar !=

NULL

);

1211

assert(-1 <= objmult && objmult <= 1);

1218

assert(0 < probindex && probindex < nentries);

1221

assert(entries[probindex] == 0 || entries[probindex] == objmult);

1222 if

( entries[probindex] == 0 )

1225

ids[nids] = probindex;

1228

assert(

ABS

(objmult) == 1);

1231

entries[probindex] = objmult;

1238

assert(probvars !=

NULL

);

1241 for

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

1244

assert(0 <

id

&&

id

< nentries);

1245

assert(entries[

id

] != 0);

1247

clqvar = probvars[

id

- 1];

1248

assert(clqvar !=

NULL

);

1257

*objchg += entries[id] * obj;

1265#ifdef SCIP_MORE_DEBUG 1267

varfixing, *objchg);

1288 for

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

1291

assert(implvar !=

NULL

);

1303

*objchg += (bounds[v] - lb)*obj;

1305

*objchg += (bounds[v] - ub)*obj;

1309#ifdef SCIP_MORE_DEBUG 1311

varfixing, *objchg);

1331

assert(objchg !=

NULL

);

1361 for

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

1363

var = contributors[c];

1364

assert(var !=

NULL

);

1369

collectedvars[pos] =

FALSE

;

1395

assert(objimplics !=

NULL

);

1398

(*objimplics) =

NULL

;

1401

(*collect) =

FALSE

;

1409 if

( useimplics && nlbcliques + nubcliques > 0 )

1411 int

nlbcontributors;

1412 int

nubcontributors;

1419

contributors, uselesscliques, &nlbcontributors, &lbobjchg) );

1428 if

( !(*collect) && nlbcontributors == 1 )

1431 resetContributors

(binobjvarmap, collectedlbvars, contributors, nlbcontributors);

1434

nlbcontributors = 0;

1439

&contributors[nlbcontributors], uselesscliques, &nubcontributors, &ubobjchg) );

1448 if

( !(*collect) && nubcontributors == 1 )

1451 resetContributors

(binobjvarmap, collectedubvars, &contributors[nlbcontributors], nubcontributors);

1454

nubcontributors = 0;

1457 if

( (*collect) || nlbcontributors > 1 || nubcontributors > 1 )

1462 SCIP_CALL

(

objimplicsCreate

(

scip

, objimplics, contributors, binobjvarmap, collectedlbvars, collectedubvars, lbobjchg, ubobjchg, nlbcontributors, nubcontributors) );

1468 resetContributors

(binobjvarmap, collectedlbvars, contributors, nlbcontributors);

1471 resetContributors

(binobjvarmap, collectedubvars, &contributors[nlbcontributors], nubcontributors);

1474 else if

( (*collect) )

1504

assert(objchg !=

NULL

);

1505

assert(isnotzero !=

NULL

);

1515

(*objchg) =

MIN

(lbobjchg, ubobjchg);

1519

*isnotzero =

FALSE

;

1548

assert(propdata !=

NULL

);

1562 for

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

1565

assert(var !=

NULL

);

1600

eventhdlr = propdata->eventhdlr;

1601

assert(eventhdlr !=

NULL

);

1603

useimplics = (propdata->propuseimplics && nbinobjvars < propdata->maximplvars);

1606

propdata->minactsize = nbinvars;

1607

propdata->maxactsize = nbinvars;

1608

propdata->objintvarssize = nobjvars - nbinobjvars;

1632

cliqueGetHashkey, cliqueIsHashkeyEq, cliqueGetHashkeyVal,

NULL

) );

1635

uselesscliques =

NULL

;

1639

contributors =

NULL

;

1640

collectedlbvars =

NULL

;

1641

collectedubvars =

NULL

;

1642

uselesscliques =

NULL

;

1648 for

( v = 0; v < nvars && (nobjintvars == 0 || nobjintvars < propdata->objintvarssize); ++v )

1651

assert(var !=

NULL

);

1669

nbinobjvars, contributors, uselesscliques, &collect) );

1673

assert(nminactvars < nbinvars);

1674

assert(objimplics !=

NULL

);

1678

propdata->minactvars[nminactvars] = var;

1679

propdata->minactimpls[nminactvars] = objimplics;

1685 SCIPdebugMsg

(

scip

,

"variable <%s>[obj: <%g>] implicit objective change %g\n"

,

1696

assert(nmaxactvars < nbinvars);

1699

propdata->maxactvars[nmaxactvars] = var;

1700

propdata->maxactchgs[nmaxactvars] = -objchg;

1718

assert(nobjintvars < propdata->objintvarssize);

1720

propdata->objintvars[nobjintvars] = var;

1723 if

( v >= nintvars )

1738 if

( uselesscliques !=

NULL

)

1746 if

( nminactvars == 0 )

1750

propdata->minactsize = 0;

1751

propdata->minactvars =

NULL

;

1752

propdata->minactimpls =

NULL

;

1759 SCIPsortDownPtrPtr

((

void

**)propdata->minactimpls, (

void

**)propdata->minactvars, objimplicsComp, nminactvars);

1761 SCIPdebugMsg

(

scip

,

"%d binary variables with non-zero objective contribution w.r.t. the minimum activity of the objective function\n"

, nminactvars);

1764 if

( nmaxactvars == 0 )

1768

propdata->maxactsize = 0;

1769

propdata->maxactvars =

NULL

;

1770

propdata->maxactchgs =

NULL

;

1779 SCIPdebugMsg

(

scip

,

"%d binary variables with non-zero objective contribution w.r.t. the maximum activity of the objective function\n"

, nmaxactvars);

1782 if

( nobjintvars == 0 )

1785

propdata->objintvarssize = 0;

1786

propdata->objintvars =

NULL

;

1791 SCIPsortDownPtr

((

void

**)propdata->objintvars, varCompObj, nobjintvars - nobjcontvars);

1794 SCIPsortDownPtr

((

void

**)(&propdata->objintvars[nobjintvars - nobjcontvars]), varCompObj, nobjcontvars);

1796 SCIPdebugMsg

(

scip

,

"%d integer variables and %d continuous variables with non-zero objective contribution\n"

,

1797

nobjintvars - nobjcontvars, nobjcontvars);

1803

propdata->nminactvars = nminactvars;

1804

propdata->nmaxactvars = nmaxactvars;

1805

propdata->nobjintvars = nobjintvars;

1807

propdata->maxpseudoobjactinf = 0;

1808

propdata->lastvarnum = -1;

1809

propdata->glbfirstnonfixed = 0;

1810

propdata->maxactfirstnonfixed = 0;

1811

propdata->firstnonfixed = 0;

1812

propdata->nnewvars = 0;

1817

propdata->initialized =

TRUE

;

1820

propdata->glbpropagated =

FALSE

;

1826 if

( nminactvars > 0 )

1829

SCIPvarGetHashkey, SCIPvarIsHashkeyEq, SCIPvarGetHashkeyVal,

NULL

) );

1832

propdata->addedvars =

NULL

;

1867

assert((loclb - glblb) * objval > 0.0);

1869

(*reqpseudoobjval) -= (loclb - glblb) * objval;

1888

assert((locub - glbub) * objval > 0.0);

1890

(*reqpseudoobjval) -= (locub - glbub) * objval;

1915

assert(foundimplics !=

NULL

);

1916

assert(*foundimplics ==

FALSE

);

1918 for

( v = start; v < end; ++v )

1921

assert(var !=

NULL

);

1937

(*foundimplics) =

TRUE

;

1970

foundimplics =

FALSE

;

1975 if

( respropuseimplics )

1977

assert(objimplics !=

NULL

);

1979

bdchgidx, addedvars, reqpseudoobjval, &foundimplics) );

1990

(*reqpseudoobjval) -=

MAX

(0.0, objval);

1992 if

( addedvars !=

NULL

)

1999 else if

( ub < 0.5 )

2001 if

( respropuseimplics )

2003

assert(objimplics !=

NULL

);

2005

bdchgidx, addedvars, reqpseudoobjval, &foundimplics) );

2016

(*reqpseudoobjval) +=

MIN

(0.0, objval);

2018 if

( addedvars !=

NULL

)

2045 if

( inferinfo != -1 )

2051

assert(var !=

NULL

);

2053

assert(bdchgidx !=

NULL

);

2055

assert(inferinfo >= 0);

2056

assert(inferinfo < propdata->nminactvars);

2060

objimplics = propdata->minactimpls[inferinfo];

2061

assert(objimplics !=

NULL

);

2077 if

( addedvars !=

NULL

)

2119

(*cutoffbound) -= objval * (newbound - glbbound);

2151

nvars = propdata->nminactvars;

2166

reqpseudoobjval = cutoffbound;

2175

addedvars = propdata->addedvars;

2179 if

( infervar !=

NULL

)

2184

reqpseudoobjval = cutoffbound - glbpseudoobjval;

2187 SCIPdebugMsg

(

scip

,

"resolve propagation global pseudo objective <%g>, cutoff bounda <%g>, required minactivity <%g>\n"

,

2188

glbpseudoobjval, cutoffbound, reqpseudoobjval);

2203

vars = propdata->minactvars;

2204

assert(vars !=

NULL

);

2206

minactimpls = propdata->minactimpls;

2207

assert(minactimpls !=

NULL

);

2219 for

( v = propdata->glbfirstnonfixed; v < nvars; ++v )

2222

assert(var !=

NULL

);

2226 if

( var == infervar )

2234

assert(addedvars !=

NULL

);

2236 for

( v = propdata->glbfirstnonfixed; v < nvars &&

SCIPisPositive

(

scip

, reqpseudoobjval); ++v )

2239

assert(var !=

NULL

);

2243 if

( var == infervar )

2254

vars = propdata->objintvars;

2255

nvars = propdata->nobjintvars;

2256

assert(nvars == 0 || vars !=

NULL

);

2262

assert(var !=

NULL

);

2265 if

( var == infervar )

2296

assert(

SCIPisLT

(

scip

, pseudoobjval, cutoffbound) );

2297

assert(tightened !=

NULL

);

2299

*tightened =

FALSE

;

2304

assert(prop !=

NULL

);

2331

assert(!infeasible);

2335 SCIPdebugMsg

(

scip

,

" -> new (local) upper bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n"

,

2336 SCIPvarGetName

(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);

2342

assert(!infeasible);

2346 SCIPdebugMsg

(

scip

,

" -> new (global) upper bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n"

,

2347 SCIPvarGetName

(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);

2364

assert(!infeasible);

2368 SCIPdebugMsg

(

scip

,

" -> new (local) lower bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n"

,

2369 SCIPvarGetName

(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);

2375

assert(!infeasible);

2379 SCIPdebugMsg

(

scip

,

" -> new (global) lower bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n"

,

2380 SCIPvarGetName

(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);

2411

assert(propdata !=

NULL

);

2413

objimplics = propdata->minactimpls[pos];

2414

assert(objimplics !=

NULL

);

2424

(*tightened) =

FALSE

;

2437 if

(

SCIPisLT

(

scip

, cutoffbound, pseudoobjval + ubobjchg) &&

SCIPisLT

(

scip

, cutoffbound, pseudoobjval + lbobjchg) )

2459 if

( lbobjchg > ubobjchg )

2498

assert(propdata !=

NULL

);

2501

cutoffbound = propdata->cutoffbound;

2516

minactvars = propdata->minactvars;

2517

objintvars = propdata->objintvars;

2518

nminactvars = propdata->nminactvars;

2519

nobjintvars = propdata->nobjintvars;

2528 for

( v = propdata->glbfirstnonfixed; v < nminactvars; ++v )

2530

var = minactvars[v];

2531

assert(var !=

NULL

);

2547 SCIPdebugMsg

(

scip

,

"interrupt global pseudo objective propagation w.r.t. cutoff bound <%.15g> for binary variables after %d from %d binary variables\n"

,

2548

cutoffbound, v, nminactvars);

2561

propdata->glbfirstnonfixed = v;

2562

propdata->firstnonfixed =

MAX

(propdata->firstnonfixed, v);

2565 for

( ; v < nminactvars && cutoffbound - pseudoobjval < propdata->minactimpls[v]->maxobjchg; ++v )

2567

var = minactvars[v];

2568

assert(var !=

NULL

);

2585#ifdef SCIP_DISABLED_CODE 2589 for

( ; v < nminactvars; ++v )

2591

assert(cutoffbound - pseudoobjval >= propdata->minactimpls[v]->maxobjchg);

2593

var = minactvars[v];

2594

assert(var !=

NULL

);

2611 for

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

2613

var = objintvars[v];

2614

assert(var !=

NULL

);

2625

propdata->glbpropagated =

TRUE

;

2649

assert(propdata !=

NULL

);

2651

minactvars = propdata->minactvars;

2652

nminactvars = propdata->nminactvars;

2653

assert(nminactvars == 0 || minactvars !=

NULL

);

2664 for

( v = propdata->glbfirstnonfixed; v < propdata->firstnonfixed; ++v )

2666

var = minactvars[v];

2667

assert(var !=

NULL

);

2675 for

( v = propdata->firstnonfixed; v < nminactvars; ++v )

2677

var = minactvars[v];

2678

assert(var !=

NULL

);

2697 SCIPdebugMsg

(

scip

,

"interrupt local pseudo objective propagation w.r.t. cutoff bound <%.15g> for binary variables after %d from %d binary variables\n"

,

2698

cutoffbound, v, nminactvars);

2709

propdata->firstnonfixed = v;

2712 for

( ; v < nminactvars && cutoffbound - pseudoobjval < propdata->minactimpls[v]->maxobjchg; ++v )

2714

var = minactvars[v];

2715

assert(var !=

NULL

);

2736#ifdef SCIP_DISABLED_CODE 2740 for

( ; v < nminactvars; ++v )

2742

var = minactvars[v];

2743

assert(var !=

NULL

);

2745

assert(cutoffbound - pseudoobjval >= propdata->minactimpls[v]->maxobjchg);

2779

assert(result !=

NULL

);

2784

assert(propdata !=

NULL

);

2802 if

( cutoffbound < propdata->cutoffbound )

2804

propdata->glbpropagated =

FALSE

;

2805

propdata->cutoffbound = cutoffbound;

2817 if

( propdata->propcutoffbound && !propdata->glbpropagated &&

SCIPgetDepth

(

scip

) > 0 )

2844 SCIPdebugMsg

(

scip

,

"pseudo objective value <%g> exceeds cutoff bound <%g>\n"

, pseudoobjval, cutoffbound);

2865 SCIPdebugMsg

(

scip

,

"propagating pseudo objective function (pseudoobj: %g, cutoffbound: %g)\n"

, pseudoobjval, cutoffbound);

2887

objintvars = propdata->objintvars;

2888

nobjintvars = propdata->nobjintvars;

2889

assert(nobjintvars == 0 || objintvars !=

NULL

);

2892 for

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

2894

var = objintvars[v];

2895

assert(var !=

NULL

);

2919

objintvars = propdata->objintvars;

2920

nobjintvars = propdata->nobjintvars;

2921

assert(nobjintvars == 0 || objintvars !=

NULL

);

2924

nmaxuseless =

MAX

(propdata->minuseless, (

int

)propdata->maxvarsfrac*(nobjintvars));

2927

v = propdata->lastvarnum;

2929 for

( c = 0; c < nobjintvars && nuseless < nmaxuseless; ++c )

2932 if

( v >= nobjintvars )

2935

var = objintvars[v];

2936

assert(var !=

NULL

);

2950

propdata->lastvarnum = v;

2973

assert(propdata !=

NULL

);

2980

propdata->maxpseudoobjact = 0.0;

2981

propdata->maxpseudoobjactinf = 0;

2983 for

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

3004

propdata->maxpseudoobjactinf++;

3006

propdata->maxpseudoobjact += contrib;

3017

assert(propdata !=

NULL

);

3035

assert(propdata !=

NULL

);

3044

assert(propdata->maxpseudoobjactinf >= 1);

3046 if

( propdata->maxpseudoobjactinf == 1 )

3047

residual = propdata->maxpseudoobjact;

3054 if

( propdata->maxpseudoobjactinf >= 1 )

3057

residual = propdata->maxpseudoobjact - contrib;

3074

assert(propdata !=

NULL

);

3137

(*infeasible) =

FALSE

;

3138

(*tightened) =

FALSE

;

3148

(*infeasible) =

TRUE

;

3182

(*tightened) =

FALSE

;

3191

newbd = (lowerbound - residual) / objval;

3243

assert(result !=

NULL

);

3250

assert(propdata !=

NULL

);

3251

assert(propdata->nminactvars > 0 || propdata->nobjintvars > 0);

3270 if

( propdata->maxpseudoobjactinf > 1 )

3292 if

( propdata->maxpseudoobjactinf == 0 && !

SCIPisInfinity

(

scip

, maxpseudoobjact) )

3297

maxactvars = propdata->maxactvars;

3298

nmaxactvars = propdata->nmaxactvars;

3299

assert(nmaxactvars == 0 || maxactvars !=

NULL

);

3301 for

( v = propdata->maxactfirstnonfixed; v < nmaxactvars; ++v )

3303

var = maxactvars[v];

3304

assert(var !=

NULL

);

3326 SCIPdebugMsg

(

scip

,

"interrupt pseudo objective propagation w.r.t. lower bound <%.15g> for binary variables after %d from %d binary variables\n"

,

3327

lowerbound, v, nmaxactvars);

3342

propdata->maxactfirstnonfixed = v;

3345 for

( ; v < nmaxactvars && maxpseudoobjact - lowerbound < propdata->maxactchgs[v] && !cutoff; ++v )

3347

var = maxactvars[v];

3348

assert(var !=

NULL

);

3368#ifdef SCIP_DISABLED_CODE 3372 for

( ; v < nmaxactvars && !cutoff; ++v )

3374

var = maxactvars[v];

3375

assert(var !=

NULL

);

3391

objintvars = propdata->objintvars;

3392

nobjintvars = propdata->nobjintvars;

3393

assert(nobjintvars == 0 || objintvars !=

NULL

);

3396 for

( v = 0; v < nobjintvars && !cutoff; ++v )

3398

var = objintvars[v];

3399

assert(var !=

NULL

);

3417 else if

( nchgbds > 0 )

3421

propdata->lastlowerbound = lowerbound;

3436

assert(prop !=

NULL

);

3467

assert(propdata !=

NULL

);

3476

assert(!propdata->catchvaradded);

3478

propdata->catchvaradded =

TRUE

;

3491

assert(propdata !=

NULL

);

3493 if

( propdata->catchvaradded )

3497

propdata->catchvaradded =

FALSE

;

3519

assert(result !=

NULL

);

3522

assert(propdata !=

NULL

);

3549 if

( cutoffbound < propdata->cutoffbound || pseudoobjval > propdata->glbpseudoobjval )

3555

oldnchgbds = *nchgbds;

3564 for

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

3578 if

( *nchgbds > oldnchgbds )

3582

propdata->cutoffbound = cutoffbound;

3583

propdata->glbpseudoobjval = pseudoobjval;

3584

propdata->glbpropagated =

TRUE

;

3597

assert(propdata !=

NULL

);

3616 if

( !propdata->initialized || propdata->nnewvars > propdata->maxnewvars )

3626 if

( propdata->nminactvars == 0 && propdata->nmaxactvars == 0 && propdata->nobjintvars == 0 )

3640

(*result) = dualresult;

3656

assert(propdata !=

NULL

);

3660

assert(infervar !=

NULL

);

3687

assert(propdata !=

NULL

);

3689

assert(eventhdlr !=

NULL

);

3690

assert(eventdata !=

NULL

);

3692

assert(event !=

NULL

);

3696 switch

( eventtype )

3701

propdata->firstnonfixed = 0;

3704

propdata->nnewvars++;

3711

propdata->maxpseudoobjactinf = 0;

3736

propdata->eventhdlr =

NULL

;

3739

eventExecPseudoobj,

NULL

) );

3741 if

( propdata->eventhdlr ==

NULL

)

3743 SCIPerrorMessage

(

"event handler for pseudo objective propagator not found\n"

);

3751

assert(prop !=

NULL

);

3763 "propagating/" PROP_NAME "/minuseless"

,

3764 "minimal number of successive non-binary variable propagations without a bound reduction before aborted"

,

3768 "propagating/" PROP_NAME "/maxvarsfrac"

,

3769 "maximal fraction of non-binary variables with non-zero objective without a bound reduction before aborted"

,

3773 "propagating/" PROP_NAME "/propfullinroot"

,

3774 "whether to propagate all non-binary variables when we are propagating the root node"

,

3778 "propagating/" PROP_NAME "/propcutoffbound"

,

3779 "propagate new cutoff bound directly globally"

,

3784 "should the propagator be forced even if active pricer are present?"

,

3788 "propagating/" PROP_NAME "/maxnewvars"

,

3789 "number of variables added after the propagator is reinitialized?"

,

3793 "propagating/" PROP_NAME "/propuseimplics"

,

3794 "use implications to strengthen the propagation of binary variable (increasing the objective change)?"

,

3798 "propagating/" PROP_NAME "/respropuseimplics"

,

3799 "use implications to strengthen the resolve propagation of binary variable (increasing the objective change)?"

,

3803 "propagating/" PROP_NAME "/maximplvars"

,

3804 "maximum number of binary variables the implications are used if turned on (-1: unlimited)?"

,

defines macros for basic operations in double-double arithmetic giving roughly twice the precision of...

#define SCIPquadprecDivQD(r, a, b)

#define SCIPquadprecSumQD(r, a, b)

#define SCIPquadprecSumDD(r, a, b)

SCIP_Bool SCIPisTransformed(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

int SCIPgetNObjVars(SCIP *scip)

int SCIPgetNContVars(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)

SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)

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 SCIPhashtableRemoveAll(SCIP_HASHTABLE *hashtable)

SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)

#define SCIPdebugMsgPrint

SCIP_RETCODE SCIPpropagateCutoffboundVar(SCIP *scip, SCIP_PROP *prop, SCIP_VAR *var, SCIP_Real cutoffbound, SCIP_Real pseudoobjval, SCIP_Bool *tightened)

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 SCIPincludePropPseudoobj(SCIP *scip)

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

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

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

SCIP_RETCODE SCIPanalyzeConflict(SCIP *scip, int validdepth, SCIP_Bool *success)

SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)

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

const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)

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)

SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)

SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)

SCIP_Real SCIPgetPseudoObjval(SCIP *scip)

SCIP_Real SCIPgetGlobalPseudoObjval(SCIP *scip)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

#define SCIPallocClearBufferArray(scip, ptr, num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPallocBlockMemory(scip, ptr)

int SCIPgetNActivePricers(SCIP *scip)

SCIP_Bool SCIPinProbing(SCIP *scip)

void SCIPpropSetData(SCIP_PROP *prop, SCIP_PROPDATA *propdata)

SCIP_RETCODE SCIPsetPropInitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITSOL((*propinitsol)))

SCIP_RETCODE SCIPsetPropResprop(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPRESPROP((*propresprop)))

SCIP_PROPDATA * SCIPpropGetData(SCIP_PROP *prop)

SCIP_RETCODE SCIPsetPropPresol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPPRESOL((*proppresol)), int presolpriority, int presolmaxrounds, SCIP_PRESOLTIMING presoltiming)

const char * SCIPpropGetName(SCIP_PROP *prop)

SCIP_RETCODE SCIPsetPropFree(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPFREE((*propfree)))

SCIP_RETCODE SCIPsetPropCopy(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPCOPY((*propcopy)))

SCIP_RETCODE SCIPsetPropExitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITSOL((*propexitsol)))

SCIP_RETCODE SCIPincludePropBasic(SCIP *scip, SCIP_PROP **propptr, const char *name, const char *desc, int priority, int freq, SCIP_Bool delay, SCIP_PROPTIMING timingmask, SCIP_DECL_PROPEXEC((*propexec)), SCIP_PROPDATA *propdata)

SCIP_Real SCIPgetLowerbound(SCIP *scip)

SCIP_Real SCIPgetCutoffbound(SCIP *scip)

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

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

SCIP_Real SCIPinfinity(SCIP *scip)

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

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

SCIP_Bool SCIPisDualfeasLT(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 SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

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

SCIP_Real SCIPfeastol(SCIP *scip)

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

SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)

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

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

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

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

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

int SCIPgetCutoffdepth(SCIP *scip)

int SCIPgetDepth(SCIP *scip)

SCIP_RETCODE SCIPcutoffNode(SCIP *scip, SCIP_NODE *node)

SCIP_NODE * SCIPgetRootNode(SCIP *scip)

SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

SCIP_RETCODE SCIPinferVarUbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)

int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)

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

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

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

SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)

SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)

int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

int SCIPgetNCliques(SCIP *scip)

SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

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

int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)

SCIP_BOUNDTYPE SCIPvarGetWorstBoundType(SCIP_VAR *var)

SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)

int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_Bool SCIPallowWeakDualReds(SCIP *scip)

SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_RETCODE SCIPinferVarLbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

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

void SCIPsortDownRealPtr(SCIP_Real *realarray, void **ptrarray, int len)

void SCIPsortDownPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

SCIP_VAR ** SCIPcliqueGetVars(SCIP_CLIQUE *clique)

int SCIPcliqueGetNVars(SCIP_CLIQUE *clique)

SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)

unsigned int SCIPcliqueGetId(SCIP_CLIQUE *clique)

memory allocation routines

#define BMSclearMemoryArray(ptr, num)

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

#define PROP_PRESOL_MAXROUNDS

#define PROP_PRESOLTIMING

static SCIP_RETCODE addConflictBinvar(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_OBJIMPLICS *objimplics, SCIP_HASHTABLE *addedvars, SCIP_Bool respropuseimplics, SCIP_Real *reqpseudoobjval)

static SCIP_RETCODE getConflictImplics(SCIP *scip, SCIP_VAR **vars, int start, int end, SCIP_BDCHGIDX *bdchgidx, SCIP_HASHTABLE *addedvars, SCIP_Real *reqpseudoobjval, SCIP_Bool *foundimplics)

static SCIP_RETCODE dropVarEvents(SCIP *scip, SCIP_PROPDATA *propdata)

static SCIP_DECL_HASHKEYEQ(cliqueIsHashkeyEq)

#define DEFAULT_MAXNEWVARS

#define DEFAULT_PROPCUTOFFBOUND

static SCIP_RETCODE getMaxactObjchg(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE bound, SCIP_Bool useimplics, SCIP_Real *objchg)

static SCIP_RETCODE adjustCutoffbound(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_VAR *var, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_HASHTABLE *addedvars, SCIP_Real *cutoffbound)

static void resetContributors(SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedvars, SCIP_VAR **contributors, int ncontributors)

static SCIP_DECL_HASHGETKEY(cliqueGetHashkey)

static SCIP_DECL_PROPCOPY(propCopyPseudoobj)

static SCIP_RETCODE propagateLowerbound(SCIP *scip, SCIP_PROP *prop, SCIP_RESULT *result)

static void checkImplicsApplied(SCIP *scip, SCIP_VAR *var)

static SCIP_RETCODE collectMinactVar(SCIP *scip, SCIP_VAR *var, SCIP_OBJIMPLICS **objimplics, SCIP_Bool useimplics, SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedlbvars, SCIP_Bool *collectedubvars, int nbinobjvars, SCIP_VAR **contributors, SCIP_HASHTABLE *uselesscliques, SCIP_Bool *collect)

#define DEFAULT_MAXIMPLVARS

static SCIP_RETCODE propagateLowerboundVar(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_VAR *var, SCIP_Real lowerbound, SCIP_Bool *infeasible, SCIP_Bool *tightened)

#define DEFAULT_MINUSELESS

#define DEFAULT_RESPROPUSEIMPLICS

static SCIP_RETCODE catchObjEvent(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_EVENTHDLR *eventhdlr, SCIP_VAR *var)

static void updateMaxObjPseudoactivity(SCIP *scip, SCIP_PROPDATA *propdata)

static SCIP_DECL_PROPEXEC(propExecPseudoobj)

static SCIP_DECL_PROPPRESOL(propPresolPseudoobj)

static SCIP_RETCODE collectMaxactVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool useimplics, SCIP_Real *objchg, SCIP_Bool *isnotzero)

static SCIP_DECL_PROPFREE(propFreePseudoobj)

static SCIP_Real collectMinactImplicVar(SCIP *scip, SCIP_VAR *var, SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedvars, int nbinobjvars, SCIP_VAR **contributors, int *ncontributors)

static SCIP_RETCODE getMinactImplicObjchg(SCIP *scip, SCIP_VAR *var, SCIP_OBJIMPLICS *objimplics, SCIP_BDCHGIDX *bdchgidx, SCIP_BOUNDTYPE bound, SCIP_Bool local, SCIP_Real *objchg)

static SCIP_DECL_PROPEXITSOL(propExitsolPseudoobj)

static SCIP_Real getVarObjchg(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BOUNDTYPE bound)

static SCIP_RETCODE propagateCutoffbound(SCIP *scip, SCIP_PROP *prop, SCIP_RESULT *result)

#define DEFAULT_MAXVARSFRAC

#define DEFAULT_PROPUSEIMPLICS

static SCIP_DECL_PROPINITSOL(propInitsolPseudoobj)

static SCIP_RETCODE propdataInit(SCIP *scip, SCIP_PROPDATA *propdata)

static void checkGlbfirstnonfixed(SCIP_PROPDATA *propdata)

static void calcMaxObjPseudoactivity(SCIP *scip, SCIP_PROPDATA *propdata)

#define DEFAULT_PROPFULLINROOT

static SCIP_Real getMaxObjPseudoactivityResidual(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_VAR *var)

static void propdataReset(SCIP_PROPDATA *propdata)

static SCIP_RETCODE objimplicsCreate(SCIP *scip, SCIP_OBJIMPLICS **objimplics, SCIP_VAR **objvars, SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedlbvars, SCIP_Bool *collectedubvars, SCIP_Real maxlbobjchg, SCIP_Real maxubobjchg, int nlbimpls, int nubimpls)

static SCIP_DECL_PROPRESPROP(propRespropPseudoobj)

static SCIP_RETCODE collectMinactImplicVars(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE bound, SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedvars, int nbinobjvars, SCIP_VAR **contributors, SCIP_HASHTABLE *uselesscliques, int *ncontributors, SCIP_Real *objchg)

static SCIP_RETCODE collectMinactObjchg(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE bound, SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedvars, int nbinobjvars, SCIP_VAR **contributors, SCIP_HASHTABLE *uselesscliques, int *ncontributors, SCIP_Real *objchg)

static SCIP_RETCODE propagateCutoffboundBinvars(SCIP *scip, SCIP_PROP *prop, SCIP_Real cutoffbound, SCIP_Real pseudoobjval, int *nfixedvars, SCIP_Bool *cutoff)

static SCIP_RETCODE propdataExit(SCIP *scip, SCIP_PROPDATA *propdata)

static SCIP_DECL_HASHKEYVAL(cliqueGetHashkeyVal)

static SCIP_RETCODE propagateLowerboundBinvar(SCIP *scip, SCIP_VAR *var, SCIP_Real lowerbound, SCIP_Real maxpseudoobjact, SCIP_Bool useimplics, SCIP_Bool *infeasible, SCIP_Bool *tightened)

static SCIP_RETCODE objimplicsDelPos(SCIP *scip, SCIP_OBJIMPLICS *objimplics, int pos)

static SCIP_RETCODE addConflictBounds(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real *reqpseudoobjval)

static SCIP_DECL_SORTPTRCOMP(objimplicsComp)

static SCIP_Real getMaxObjPseudoactivityResidualValue(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Real contrib)

static SCIP_RETCODE getMaxactImplicObjchg(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE bound, SCIP_Real *objchg)

static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Real cutoffbound, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)

static SCIP_RETCODE propagateCutoffboundGlobally(SCIP *scip, SCIP_PROP *prop, int *nchgbds, SCIP_Bool *cutoff)

static SCIP_RETCODE propagateCutoffboundBinvar(SCIP *scip, SCIP_PROP *prop, SCIP_VAR *var, int pos, SCIP_Real cutoffbound, SCIP_Real pseudoobjval, SCIP_Bool *tightened, SCIP_Bool *cutoff, SCIP_Bool local)

static SCIP_DECL_EVENTEXEC(eventExecPseudoobj)

static SCIP_RETCODE objimplicsFree(SCIP *scip, SCIP_OBJIMPLICS **objimplics)

static SCIP_RETCODE dropObjEvent(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_EVENTHDLR *eventhdlr, SCIP_VAR *var)

static SCIP_Real getMaxObjPseudoactivity(SCIP *scip, SCIP_PROPDATA *propdata)

static SCIP_RETCODE getMinactObjchg(SCIP *scip, SCIP_VAR *var, SCIP_OBJIMPLICS *objimplics, SCIP_BDCHGIDX *bdchgidx, SCIP_BOUNDTYPE bound, SCIP_Bool local, SCIP_Real *objchg)

#define PROP_PRESOL_PRIORITY

static SCIP_RETCODE propagateCutoffboundVar(SCIP *scip, SCIP_PROP *prop, SCIP_VAR *var, int inferinfo, SCIP_Real objchg, SCIP_Real cutoffbound, SCIP_Real pseudoobjval, SCIP_Bool local, SCIP_Bool *tightened)

Pseudo objective propagator.

public methods for managing events

public methods for implications, variable bounds, and cliques

public methods for message output

public data structures and miscellaneous methods

methods for sorting joint arrays of various types

public methods for propagators

public methods for problem variables

public methods for conflict handler plugins and conflict analysis

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 SCIP parameter handling

public methods for variable pricer plugins

public methods for global and local (sub)problems

public methods for the probing mode

public methods for propagator plugins

public methods for querying solving statistics

public methods for the branch-and-bound tree

public methods for SCIP variables

@ SCIP_CONFTYPE_PROPAGATION

#define SCIP_EVENTTYPE_GUBCHANGED

struct SCIP_EventData SCIP_EVENTDATA

#define SCIP_EVENTTYPE_LBRELAXED

#define SCIP_EVENTTYPE_GLBCHANGED

#define SCIP_EVENTTYPE_BOUNDRELAXED

#define SCIP_EVENTTYPE_VARADDED

#define SCIP_EVENTTYPE_UBRELAXED

enum SCIP_BoundType SCIP_BOUNDTYPE

struct SCIP_PropData SCIP_PROPDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

#define SCIP_PROPTIMING_DURINGLPLOOP

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