A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: event.c Source File

65

assert(eventhdlr !=

NULL

);

69 if

( eventhdlr->eventcopy !=

NULL

)

72 SCIP_CALL

( eventhdlr->eventcopy(

set

->scip, eventhdlr) );

95

assert(eventhdlr !=

NULL

);

96

assert(name !=

NULL

);

97

assert(desc !=

NULL

);

98

assert(eventexec !=

NULL

);

104

(*eventhdlr)->eventcopy = eventcopy;

105

(*eventhdlr)->eventfree = eventfree;

106

(*eventhdlr)->eventinit = eventinit;

107

(*eventhdlr)->eventexit = eventexit;

108

(*eventhdlr)->eventinitsol = eventinitsol;

109

(*eventhdlr)->eventexitsol = eventexitsol;

110

(*eventhdlr)->eventdelete = eventdelete;

111

(*eventhdlr)->eventexec = eventexec;

112

(*eventhdlr)->eventhdlrdata = eventhdlrdata;

113

(*eventhdlr)->initialized =

FALSE

;

139

assert(eventhdlr !=

NULL

);

143

eventinitsol, eventexitsol, eventdelete, eventexec, eventhdlrdata), (

void

)

SCIPeventhdlrFree

(eventhdlr,

set

) );

154

assert(eventhdlr !=

NULL

);

157 if

( *eventhdlr ==

NULL

)

160

assert(!(*eventhdlr)->initialized);

163 if

( (*eventhdlr)->eventfree !=

NULL

)

165 SCIP_CALL

( (*eventhdlr)->eventfree(

set

->scip, *eventhdlr) );

185

assert(eventhdlr !=

NULL

);

194 if

(

set

->misc_resetstat )

200 if

( eventhdlr->eventinit !=

NULL

)

205 SCIP_CALL

( eventhdlr->eventinit(

set

->scip, eventhdlr) );

221

assert(eventhdlr !=

NULL

);

230 if

( eventhdlr->eventexit !=

NULL

)

235 SCIP_CALL

( eventhdlr->eventexit(

set

->scip, eventhdlr) );

251

assert(eventhdlr !=

NULL

);

255 if

( eventhdlr->eventinitsol !=

NULL

)

260 SCIP_CALL

( eventhdlr->eventinitsol(

set

->scip, eventhdlr) );

275

assert(eventhdlr !=

NULL

);

279 if

( eventhdlr->eventexitsol !=

NULL

)

284 SCIP_CALL

( eventhdlr->eventexitsol(

set

->scip, eventhdlr) );

301

assert(eventhdlr !=

NULL

);

302

assert(eventhdlr->eventexec !=

NULL

);

304

assert(event !=

NULL

);

313 SCIP_CALL

( eventhdlr->eventexec(

set

->scip, eventhdlr, event, eventdata) );

328

assert(eventhdlr !=

NULL

);

330 return

eventhdlr->

name

;

338

assert(eventhdlr !=

NULL

);

349

assert(eventhdlr !=

NULL

);

360

assert(eventhdlr !=

NULL

);

362

eventhdlr->eventcopy = eventcopy;

371

assert(eventhdlr !=

NULL

);

373

eventhdlr->eventfree = eventfree;

382

assert(eventhdlr !=

NULL

);

384

eventhdlr->eventinit = eventinit;

393

assert(eventhdlr !=

NULL

);

395

eventhdlr->eventexit = eventexit;

404

assert(eventhdlr !=

NULL

);

406

eventhdlr->eventinitsol = eventinitsol;

415

assert(eventhdlr !=

NULL

);

417

eventhdlr->eventexitsol = eventexitsol;

426

assert(eventhdlr !=

NULL

);

428

eventhdlr->eventdelete = eventdelete;

436

assert(eventhdlr !=

NULL

);

447

assert(eventhdlr !=

NULL

);

458

assert(eventhdlr !=

NULL

);

470

assert(eventhdlr !=

NULL

);

488

assert(event !=

NULL

);

507#undef SCIPeventGetType 508#undef SCIPeventGetOldobj 509#undef SCIPeventGetNewobj 510#undef SCIPeventGetOldtype 511#undef SCIPeventGetNewtype 512#undef SCIPeventGetOldbound 513#undef SCIPeventGetNewbound 514#undef SCIPeventGetNode 515#undef SCIPeventGetSol 516#undef SCIPeventGetRowCol 517#undef SCIPeventGetRowOldCoefVal 518#undef SCIPeventGetRowNewCoefVal 519#undef SCIPeventGetRowOldConstVal 520#undef SCIPeventGetRowNewConstVal 521#undef SCIPeventGetRowSide 522#undef SCIPeventGetRowOldSideVal 523#undef SCIPeventGetRowNewSideVal 532

assert(event !=

NULL

);

533

assert(blkmem !=

NULL

);

538

(*event)->data.eventvaradded.var = var;

550

assert(event !=

NULL

);

551

assert(blkmem !=

NULL

);

556

(*event)->data.eventvardeleted.var = var;

568

assert(event !=

NULL

);

569

assert(blkmem !=

NULL

);

578

(*event)->data.eventvarfixed.var = var;

590

assert(event !=

NULL

);

591

assert(blkmem !=

NULL

);

599

(*event)->data.eventvarunlocked.var = var;

613

assert(event !=

NULL

);

614

assert(blkmem !=

NULL

);

615

assert(oldobj != newobj);

620

(*event)->data.eventobjchg.var = var;

621

(*event)->

data

.eventobjchg.oldobj = oldobj;

622

(*event)->

data

.eventobjchg.newobj = newobj;

636

assert(event !=

NULL

);

637

assert(blkmem !=

NULL

);

638

assert(oldbound != newbound);

643

(*event)->data.eventbdchg.var = var;

644

(*event)->

data

.eventbdchg.oldbound = oldbound;

645

(*event)->

data

.eventbdchg.newbound = newbound;

659

assert(event !=

NULL

);

660

assert(blkmem !=

NULL

);

661

assert(oldbound != newbound);

666

(*event)->data.eventbdchg.var = var;

667

(*event)->

data

.eventbdchg.oldbound = oldbound;

668

(*event)->

data

.eventbdchg.newbound = newbound;

682

assert(event !=

NULL

);

683

assert(blkmem !=

NULL

);

684

assert(oldbound != newbound);

688 if

( newbound > oldbound )

692

(*event)->data.eventbdchg.var = var;

693

(*event)->

data

.eventbdchg.oldbound = oldbound;

694

(*event)->

data

.eventbdchg.newbound = newbound;

708

assert(event !=

NULL

);

709

assert(blkmem !=

NULL

);

710

assert(oldbound != newbound);

714 if

( newbound < oldbound )

718

(*event)->data.eventbdchg.var = var;

719

(*event)->

data

.eventbdchg.oldbound = oldbound;

720

(*event)->

data

.eventbdchg.newbound = newbound;

734

assert(event !=

NULL

);

735

assert(blkmem !=

NULL

);

740

(*event)->data.eventhole.var = var;

741

(*event)->

data

.eventhole.left = left;

742

(*event)->

data

.eventhole.right = right;

756

assert(event !=

NULL

);

757

assert(blkmem !=

NULL

);

762

(*event)->data.eventhole.var = var;

763

(*event)->

data

.eventhole.left = left;

764

(*event)->

data

.eventhole.right = right;

778

assert(event !=

NULL

);

779

assert(blkmem !=

NULL

);

784

(*event)->data.eventhole.var = var;

785

(*event)->

data

.eventhole.left = left;

786

(*event)->

data

.eventhole.right = right;

800

assert(event !=

NULL

);

801

assert(blkmem !=

NULL

);

806

(*event)->data.eventhole.var = var;

807

(*event)->

data

.eventhole.left = left;

808

(*event)->

data

.eventhole.right = right;

820

assert(event !=

NULL

);

821

assert(blkmem !=

NULL

);

827

(*event)->data.eventimpladd.var = var;

841

assert(event !=

NULL

);

842

assert(blkmem !=

NULL

);

843

assert(oldtype != newtype);

848

(*event)->data.eventtypechg.var = var;

849

(*event)->

data

.eventtypechg.oldtype = oldtype;

850

(*event)->

data

.eventtypechg.newtype = newtype;

862

assert(event !=

NULL

);

863

assert(blkmem !=

NULL

);

864

assert(row !=

NULL

);

869

(*event)->data.eventrowaddedsepa.row = row;

881

assert(event !=

NULL

);

882

assert(blkmem !=

NULL

);

883

assert(row !=

NULL

);

888

(*event)->data.eventrowdeletedsepa.row = row;

900

assert(event !=

NULL

);

901

assert(blkmem !=

NULL

);

902

assert(row !=

NULL

);

907

(*event)->data.eventrowaddedlp.row = row;

919

assert(event !=

NULL

);

920

assert(blkmem !=

NULL

);

921

assert(row !=

NULL

);

926

(*event)->data.eventrowdeletedlp.row = row;

941

assert(event !=

NULL

);

942

assert(blkmem !=

NULL

);

943

assert(row !=

NULL

);

948

(*event)->data.eventrowcoefchanged.row = row;

949

(*event)->data.eventrowcoefchanged.col = col;

950

(*event)->data.eventrowcoefchanged.oldval = oldval;

951

(*event)->data.eventrowcoefchanged.newval = newval;

965

assert(event !=

NULL

);

966

assert(blkmem !=

NULL

);

967

assert(row !=

NULL

);

972

(*event)->data.eventrowconstchanged.row = row;

973

(*event)->data.eventrowconstchanged.oldval = oldval;

974

(*event)->data.eventrowconstchanged.newval = newval;

989

assert(event !=

NULL

);

990

assert(blkmem !=

NULL

);

991

assert(row !=

NULL

);

996

(*event)->data.eventrowsidechanged.row = row;

997

(*event)->data.eventrowsidechanged.side = side;

998

(*event)->data.eventrowsidechanged.oldval = oldval;

999

(*event)->data.eventrowsidechanged.newval = newval;

1010

assert(event !=

NULL

);

1011

assert(blkmem !=

NULL

);

1024

assert(event !=

NULL

);

1034

assert(event !=

NULL

);

1036 return event

->eventtype;

1045

assert(event !=

NULL

);

1047 event

->eventtype = eventtype;

1057

assert(event !=

NULL

);

1063 return event

->data.eventvaradded.var;

1067 return event

->data.eventvardeleted.var;

1071 return event

->data.eventvarfixed.var;

1075 return event

->data.eventvarunlocked.var;

1079 return event

->data.eventobjchg.var;

1088 return event

->data.eventbdchg.var;

1095 return event

->data.eventhole.var;

1099 return event

->data.eventimpladd.var;

1103 return event

->data.eventtypechg.var;

1118

assert(event !=

NULL

);

1124 event

->data.eventvaradded.var = var;

1129 event

->data.eventvardeleted.var = var;

1134 event

->data.eventvarfixed.var = var;

1139 event

->data.eventvarunlocked.var = var;

1144 event

->data.eventobjchg.var = var;

1154 event

->data.eventbdchg.var = var;

1162 event

->data.eventhole.var = var;

1167 event

->data.eventimpladd.var = var;

1172 event

->data.eventtypechg.var = var;

1188

assert(event !=

NULL

);

1197 return event

->data.eventobjchg.oldobj;

1205

assert(event !=

NULL

);

1214 return event

->data.eventobjchg.newobj;

1222

assert(event !=

NULL

);

1232 return event

->data.eventbdchg.oldbound;

1246

assert(event !=

NULL

);

1256 return event

->data.eventbdchg.newbound;

1270

assert(event !=

NULL

);

1279 return event

->data.eventtypechg.oldtype;

1287

assert(event !=

NULL

);

1296 return event

->data.eventtypechg.newtype;

1304

assert(event !=

NULL

);

1313 return event

->data.node;

1322

assert(event !=

NULL

);

1331 event

->data.node = node;

1341

assert(event !=

NULL

);

1350 return event

->data.sol;

1359

assert(event !=

NULL

);

1368 event

->data.sol = sol;

1378

assert(event !=

NULL

);

1387 return event

->data.eventhole.left;

1395

assert(event !=

NULL

);

1404 return event

->data.eventhole.right;

1412

assert(event !=

NULL

);

1417 return event

->data.eventrowaddedsepa.row;

1419 return event

->data.eventrowdeletedsepa.row;

1421 return event

->data.eventrowaddedlp.row;

1423 return event

->data.eventrowdeletedlp.row;

1425 return event

->data.eventrowcoefchanged.row;

1427 return event

->data.eventrowconstchanged.row;

1429 return event

->data.eventrowsidechanged.row;

1442

assert(event !=

NULL

);

1451 return event

->data.eventrowcoefchanged.col;

1459

assert(event !=

NULL

);

1468 return event

->data.eventrowcoefchanged.oldval;

1476

assert(event !=

NULL

);

1485 return event

->data.eventrowcoefchanged.newval;

1493

assert(event !=

NULL

);

1502 return event

->data.eventrowconstchanged.oldval;

1510

assert(event !=

NULL

);

1519 return event

->data.eventrowconstchanged.newval;

1527

assert(event !=

NULL

);

1536 return event

->data.eventrowsidechanged.side;

1544

assert(event !=

NULL

);

1553 return event

->data.eventrowsidechanged.oldval;

1561

assert(event !=

NULL

);

1570 return event

->data.eventrowsidechanged.newval;

1585

assert(event !=

NULL

);

1620

var =

event

->

data

.eventvardeleted.var;

1621

assert(var !=

NULL

);

1628

var =

event

->

data

.eventvarfixed.var;

1629

assert(var !=

NULL

);

1636

var =

event

->

data

.eventvarunlocked.var;

1637

assert(var !=

NULL

);

1644

var =

event

->

data

.eventobjchg.var;

1645

assert(var !=

NULL

);

1672

var =

event

->

data

.eventbdchg.var;

1673

assert(var !=

NULL

);

1688

var =

event

->

data

.eventbdchg.var;

1689

assert(var !=

NULL

);

1705

var =

event

->

data

.eventbdchg.var;

1706

assert(var !=

NULL

);

1728

var =

event

->

data

.eventbdchg.var;

1729

assert(var !=

NULL

);

1753

var =

event

->

data

.eventhole.var;

1754

assert(var !=

NULL

);

1761

var =

event

->

data

.eventimpladd.var;

1762

assert(var !=

NULL

);

1770

var =

event

->

data

.eventtypechg.var;

1771

assert(var !=

NULL

);

1800

assert(eventfilter !=

NULL

);

1801

assert(blkmem !=

NULL

);

1804 if

( num > eventfilter->

size

)

1813

eventfilter->

size

= newsize;

1815

assert(num <= eventfilter->size);

1826

assert(eventfilter !=

NULL

);

1827

assert(blkmem !=

NULL

);

1830

(*eventfilter)->eventtypes =

NULL

;

1831

(*eventfilter)->eventhdlrs =

NULL

;

1832

(*eventfilter)->eventdata =

NULL

;

1833

(*eventfilter)->nextpos =

NULL

;

1834

(*eventfilter)->size = 0;

1835

(*eventfilter)->len = 0;

1836

(*eventfilter)->firstfreepos = -1;

1837

(*eventfilter)->firstdeletedpos = -1;

1840

(*eventfilter)->delayupdates =

FALSE

;

1854

assert(eventfilter !=

NULL

);

1855

assert(*eventfilter !=

NULL

);

1856

assert(!(*eventfilter)->delayupdates);

1857

assert(blkmem !=

NULL

);

1862 for

( i = 0; i < (*eventfilter)->len; ++i )

1866

assert((*eventfilter)->eventhdlrs[i] !=

NULL

);

1867 if

( (*eventfilter)->eventhdlrs[i]->eventdelete !=

NULL

)

1869 SCIP_CALL

( (*eventfilter)->eventhdlrs[i]->eventdelete(

set

->scip, (*eventfilter)->eventhdlrs[i],

1870

&(*eventfilter)->eventdata[i]) );

1898

assert(eventfilter !=

NULL

);

1899

assert(blkmem !=

NULL

);

1901

assert(eventhdlr !=

NULL

);

1910

pos = eventfilter->

len

;

1911

eventfilter->

len

++;

1922

pos = eventfilter->

len

;

1923

eventfilter->

len

++;

1929

assert(0 <= pos && pos < eventfilter->len);

1938

assert(0 <= pos && pos < eventfilter->len);

1942

eventfilter->

eventdata

[pos] = eventdata;

1943

eventfilter->

nextpos

[pos] = -2;

1945 if

( filterpos !=

NULL

)

1962

assert(eventfilter !=

NULL

);

1964

assert(eventhdlr !=

NULL

);

1966 for

( i = eventfilter->

len

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

1968 if

( eventdata == eventfilter->

eventdata

[i]

1971

&& eventfilter->

nextpos

[i] == -2 )

1989

assert(eventfilter !=

NULL

);

1990

assert(blkmem !=

NULL

);

1993

assert(eventhdlr !=

NULL

);

1994

assert(-1 <= filterpos && filterpos < eventfilter->len);

1997 if

( filterpos == -1 )

1999 if

( filterpos == -1 )

2002

(

void

*)eventhdlr, (

void

*)eventdata, eventtype, (

void

*)eventfilter);

2005

assert(0 <= filterpos && filterpos < eventfilter->len);

2006

assert(eventfilter->

eventtypes

[filterpos] == eventtype);

2007

assert(eventfilter->

eventhdlrs

[filterpos] == eventhdlr);

2008

assert(eventfilter->

eventdata

[filterpos] == eventdata);

2009

assert(eventfilter->

nextpos

[filterpos] == -2);

2023

assert(eventfilter->

nextpos

[filterpos] == -2);

2038

assert(eventfilter !=

NULL

);

2054

assert(eventfilter !=

NULL

);

2061

assert(0 <= pos && pos < eventfilter->len);

2063

assert(eventfilter->

nextpos

[pos] >= -1);

2065

nextpos = eventfilter->

nextpos

[pos];

2094

assert(eventfilter !=

NULL

);

2096

assert(event !=

NULL

);

2101

eventtype =

event

->eventtype;

2104 if

( (eventtype & eventfilter->

eventmask

) == 0 )

2114

len = eventfilter->

len

;

2116 for

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

2119 if

( (eventtype & eventtypes[i]) != 0 )

2130

eventfilter->

eventmask

&= ~event->eventtype;

2157#undef SCIPeventqueueIsDelayed 2167

assert(eventqueue !=

NULL

);

2178

assert(num <= eventqueue->eventssize);

2188

assert(eventqueue !=

NULL

);

2191

(*eventqueue)->events =

NULL

;

2192

(*eventqueue)->eventssize = 0;

2193

(*eventqueue)->nevents = 0;

2194

(*eventqueue)->delayevents =

FALSE

;

2204

assert(eventqueue !=

NULL

);

2205

assert(*eventqueue !=

NULL

);

2206

assert((*eventqueue)->nevents == 0);

2222

assert(eventqueue !=

NULL

);

2224

assert(event !=

NULL

);

2225

assert(*event !=

NULL

);

2228

(

void

*)*event, (*event)->

eventtype

, (

void

*)eventqueue, eventqueue->

nevents

);

2255

assert(eventqueue !=

NULL

);

2256

assert(event !=

NULL

);

2257

assert(*event !=

NULL

);

2277 switch

( (*event)->eventtype )

2317

var = (*event)->

data

.eventobjchg.var;

2318

assert(var !=

NULL

);

2323

assert(pos < eventqueue->nevents);

2324

qevent = eventqueue->events[pos];

2325

assert(qevent !=

NULL

);

2330 SCIPsetDebugMsg

(

set

,

" -> merging OBJ event (<%s>,%g -> %g) with event at position %d (<%s>,%g -> %g)\n"

,

2331 SCIPvarGetName

((*event)->data.eventobjchg.var), (*event)->data.eventobjchg.oldobj,

2332

(*event)->data.eventobjchg.newobj,

2359

var = (*event)->

data

.eventbdchg.var;

2360

assert(var !=

NULL

);

2365

assert(pos < eventqueue->nevents);

2366

qevent = eventqueue->events[pos];

2367

assert(qevent !=

NULL

);

2372 SCIPsetDebugMsg

(

set

,

" -> merging LB event (<%s>,%g -> %g) with event at position %d (<%s>,%g -> %g)\n"

,

2373 SCIPvarGetName

((*event)->data.eventbdchg.var), (*event)->data.eventbdchg.oldbound,

2374

(*event)->data.eventbdchg.newbound,

2408

var = (*event)->

data

.eventbdchg.var;

2409

assert(var !=

NULL

);

2414

assert(pos < eventqueue->nevents);

2415

qevent = eventqueue->events[pos];

2416

assert(qevent !=

NULL

);

2421 SCIPsetDebugMsg

(

set

,

" -> merging UB event (<%s>,%g -> %g) with event at position %d (<%s>,%g -> %g)\n"

,

2422 SCIPvarGetName

((*event)->data.eventbdchg.var), (*event)->data.eventbdchg.oldbound,

2423

(*event)->data.eventbdchg.newbound,

2455

var = (*event)->

data

.eventimpladd.var;

2456

assert(var !=

NULL

);

2475

assert(*event ==

NULL

);

2485

assert(eventqueue !=

NULL

);

2509

assert(eventqueue !=

NULL

);

2520 for

( i = 0; i < eventqueue->

nevents

; ++i )

2522 event

= eventqueue->

events

[i];

2523

assert(event !=

NULL

);

2533 event

->data.eventobjchg.var->eventqueueindexobj = -1;

2538 event

->data.eventbdchg.var->eventqueueindexlb = -1;

2543 event

->data.eventbdchg.var->eventqueueindexub = -1;

2548 event

->data.eventimpladd.var->eventqueueimpl =

FALSE

;

2560

assert(i == eventqueue->

nevents

);

2572

assert(eventqueue !=

NULL

);

SCIP_DECL_EVENTDELETE(EventhdlrNewSol::scip_delete)

SCIP_DECL_EVENTEXEC(EventhdlrNewSol::scip_exec)

SCIP_DECL_EVENTINIT(EventhdlrNewSol::scip_init)

SCIP_DECL_EVENTINITSOL(EventhdlrNewSol::scip_initsol)

SCIP_DECL_EVENTEXIT(EventhdlrNewSol::scip_exit)

SCIP_DECL_EVENTEXITSOL(EventhdlrNewSol::scip_exitsol)

SCIP_DECL_EVENTFREE(EventhdlrNewSol::scip_free)

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

internal methods for branching rules and branching candidate storage

void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)

void SCIPclockEnableOrDisable(SCIP_CLOCK *clck, SCIP_Bool enable)

void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)

SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)

void SCIPclockReset(SCIP_CLOCK *clck)

void SCIPclockFree(SCIP_CLOCK **clck)

SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)

internal methods for clocks and timing issues

#define SCIP_CALL_FINALLY(x, y)

SCIP_RETCODE SCIPeventhdlrCopyInclude(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)

SCIP_RETCODE SCIPeventFree(SCIP_EVENT **event, BMS_BLKMEM *blkmem)

static SCIP_RETCODE eventqueueAppend(SCIP_EVENTQUEUE *eventqueue, SCIP_SET *set, SCIP_EVENT **event)

SCIP_RETCODE SCIPeventCreateLbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)

static void eventfilterProcessUpdates(SCIP_EVENTFILTER *eventfilter)

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

SCIP_RETCODE SCIPeventhdlrInitsol(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)

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

SCIP_RETCODE SCIPeventCreateRowDeletedLP(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row)

SCIP_RETCODE SCIPeventhdlrCreate(SCIP_EVENTHDLR **eventhdlr, SCIP_SET *set, const char *name, const char *desc, SCIP_DECL_EVENTCOPY((*eventcopy)), SCIP_DECL_EVENTFREE((*eventfree)), SCIP_DECL_EVENTINIT((*eventinit)), SCIP_DECL_EVENTEXIT((*eventexit)), SCIP_DECL_EVENTINITSOL((*eventinitsol)), SCIP_DECL_EVENTEXITSOL((*eventexitsol)), SCIP_DECL_EVENTDELETE((*eventdelete)), SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)

static SCIP_RETCODE doEventhdlrCreate(SCIP_EVENTHDLR **eventhdlr, const char *name, const char *desc, SCIP_DECL_EVENTCOPY((*eventcopy)), SCIP_DECL_EVENTFREE((*eventfree)), SCIP_DECL_EVENTINIT((*eventinit)), SCIP_DECL_EVENTEXIT((*eventexit)), SCIP_DECL_EVENTINITSOL((*eventinitsol)), SCIP_DECL_EVENTEXITSOL((*eventexitsol)), SCIP_DECL_EVENTDELETE((*eventdelete)), SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)

SCIP_RETCODE SCIPeventqueueFree(SCIP_EVENTQUEUE **eventqueue)

void SCIPeventhdlrSetFree(SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTFREE((*eventfree)))

SCIP_RETCODE SCIPeventCreateGholeRemoved(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real left, SCIP_Real right)

SCIP_RETCODE SCIPeventhdlrExitsol(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)

SCIP_RETCODE SCIPeventCreateUbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)

void SCIPeventhdlrEnableOrDisableClocks(SCIP_EVENTHDLR *eventhdlr, SCIP_Bool enable)

void SCIPeventhdlrSetExitsol(SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXITSOL((*eventexitsol)))

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

SCIP_RETCODE SCIPeventhdlrExit(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)

SCIP_RETCODE SCIPeventChgSol(SCIP_EVENT *event, SCIP_SOL *sol)

static SCIP_RETCODE eventqueueEnsureEventsMem(SCIP_EVENTQUEUE *eventqueue, SCIP_SET *set, int num)

void SCIPeventhdlrSetInitsol(SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINITSOL((*eventinitsol)))

SCIP_RETCODE SCIPeventCreateObjChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real newobj)

SCIP_RETCODE SCIPeventChgNode(SCIP_EVENT *event, SCIP_NODE *node)

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 SCIPeventhdlrFree(SCIP_EVENTHDLR **eventhdlr, SCIP_SET *set)

SCIP_RETCODE SCIPeventfilterFree(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set)

SCIP_RETCODE SCIPeventCreateRowSideChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row, SCIP_SIDETYPE side, SCIP_Real oldval, SCIP_Real newval)

SCIP_RETCODE SCIPeventCreateRowAddedSepa(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row)

SCIP_Bool SCIPeventqueueIsDelayed(SCIP_EVENTQUEUE *eventqueue)

SCIP_RETCODE SCIPeventCreateGholeAdded(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real left, SCIP_Real right)

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

SCIP_RETCODE SCIPeventCreateRowDeletedSepa(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row)

void SCIPeventhdlrSetCopy(SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTCOPY((*eventcopy)))

SCIP_RETCODE SCIPeventCreateLholeAdded(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real left, SCIP_Real right)

void SCIPeventhdlrSetInit(SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINIT((*eventinit)))

SCIP_RETCODE SCIPeventhdlrInit(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)

SCIP_RETCODE SCIPeventfilterDel(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)

SCIP_RETCODE SCIPeventfilterCreate(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem)

void SCIPeventhdlrSetDelete(SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTDELETE((*eventdelete)))

void SCIPeventhdlrSetExit(SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXIT((*eventexit)))

SCIP_RETCODE SCIPeventhdlrExec(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set, SCIP_EVENT *event, SCIP_EVENTDATA *eventdata)

SCIP_RETCODE SCIPeventChgVar(SCIP_EVENT *event, SCIP_VAR *var)

SCIP_RETCODE SCIPeventCreateRowConstChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row, SCIP_Real oldval, SCIP_Real newval)

SCIP_RETCODE SCIPeventProcess(SCIP_EVENT *event, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter)

SCIP_RETCODE SCIPeventCreateSync(SCIP_EVENT **event, BMS_BLKMEM *blkmem)

static SCIP_RETCODE eventfilterEnsureMem(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)

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

SCIP_RETCODE SCIPeventChgType(SCIP_EVENT *event, SCIP_EVENTTYPE eventtype)

SCIP_RETCODE SCIPeventqueueCreate(SCIP_EVENTQUEUE **eventqueue)

SCIP_RETCODE SCIPeventfilterProcess(SCIP_EVENTFILTER *eventfilter, SCIP_SET *set, SCIP_EVENT *event)

SCIP_RETCODE SCIPeventfilterAdd(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)

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

SCIP_RETCODE SCIPeventCreateRowCoefChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row, SCIP_COL *col, SCIP_Real oldval, SCIP_Real newval)

SCIP_RETCODE SCIPeventCreateGubChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)

SCIP_RETCODE SCIPeventCreateGlbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)

SCIP_RETCODE SCIPeventqueueDelay(SCIP_EVENTQUEUE *eventqueue)

SCIP_RETCODE SCIPeventCreateLholeRemoved(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real left, SCIP_Real right)

SCIP_RETCODE SCIPeventCreateTypeChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_VARTYPE oldtype, SCIP_VARTYPE newtype)

static int eventfilterSearch(SCIP_EVENTFILTER *const eventfilter, SCIP_EVENTTYPE const eventtype, SCIP_EVENTHDLR *const eventhdlr, SCIP_EVENTDATA *const eventdata)

static void eventfilterDelayUpdates(SCIP_EVENTFILTER *eventfilter)

SCIP_RETCODE SCIPeventCreateRowAddedLP(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row)

static void eventDisable(SCIP_EVENT *event)

internal methods for managing events

SCIP_Real SCIPeventhdlrGetSetupTime(SCIP_EVENTHDLR *eventhdlr)

SCIP_Bool SCIPeventhdlrIsInitialized(SCIP_EVENTHDLR *eventhdlr)

SCIP_Real SCIPeventhdlrGetTime(SCIP_EVENTHDLR *eventhdlr)

const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)

SCIP_EVENTHDLRDATA * SCIPeventhdlrGetData(SCIP_EVENTHDLR *eventhdlr)

void SCIPeventhdlrSetData(SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTHDLRDATA *eventhdlrdata)

SCIP_Real SCIPeventGetRowOldCoefVal(SCIP_EVENT *event)

SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)

SCIP_SOL * SCIPeventGetSol(SCIP_EVENT *event)

SCIP_VARTYPE SCIPeventGetNewtype(SCIP_EVENT *event)

SCIP_Real SCIPeventGetHoleRight(SCIP_EVENT *event)

SCIP_Real SCIPeventGetHoleLeft(SCIP_EVENT *event)

SCIP_Real SCIPeventGetOldobj(SCIP_EVENT *event)

SCIP_Real SCIPeventGetOldbound(SCIP_EVENT *event)

SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)

SCIP_Real SCIPeventGetRowNewConstVal(SCIP_EVENT *event)

SCIP_COL * SCIPeventGetRowCol(SCIP_EVENT *event)

SCIP_Real SCIPeventGetNewobj(SCIP_EVENT *event)

SCIP_SIDETYPE SCIPeventGetRowSide(SCIP_EVENT *event)

SCIP_Real SCIPeventGetRowOldSideVal(SCIP_EVENT *event)

SCIP_Real SCIPeventGetNewbound(SCIP_EVENT *event)

SCIP_NODE * SCIPeventGetNode(SCIP_EVENT *event)

SCIP_Real SCIPeventGetRowNewCoefVal(SCIP_EVENT *event)

SCIP_Real SCIPeventGetRowNewSideVal(SCIP_EVENT *event)

SCIP_Real SCIPeventGetRowOldConstVal(SCIP_EVENT *event)

SCIP_ROW * SCIPeventGetRow(SCIP_EVENT *event)

SCIP_VARTYPE SCIPeventGetOldtype(SCIP_EVENT *event)

SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_RETCODE SCIPcolChgUb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newub)

SCIP_RETCODE SCIPcolChgLb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newlb)

SCIP_RETCODE SCIPlpUpdateVarLb(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb)

SCIP_RETCODE SCIPlpUpdateVarLbGlobal(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb)

SCIP_RETCODE SCIPcolChgObj(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)

SCIP_RETCODE SCIPlpUpdateVarUbGlobal(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub)

SCIP_RETCODE SCIPlpUpdateVarUb(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub)

SCIP_RETCODE SCIPlpUpdateVarObj(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real newobj)

internal methods for LP management

#define BMSfreeMemory(ptr)

#define BMSfreeBlockMemory(mem, ptr)

#define BMSallocBlockMemory(mem, ptr)

#define BMSreallocMemoryArray(ptr, num)

#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)

#define BMSduplicateMemoryArray(ptr, source, num)

#define BMSclearMemory(ptr)

#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)

struct BMS_BlkMem BMS_BLKMEM

#define BMSfreeMemoryArrayNull(ptr)

#define BMSallocMemory(ptr)

void SCIPprimalUpdateVarObj(SCIP_PRIMAL *primal, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real newobj)

internal methods for collecting primal CIP solutions and primal informations

public methods for managing events

public methods for message output

public methods for problem variables

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

int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)

internal methods for global SCIP settings

SCIP_EVENTTYPE delayedeventmask

SCIP_EVENTHDLR ** eventhdlrs

SCIP_EVENTTYPE * eventtypes

SCIP_EVENTDATA ** eventdata

SCIP_EVENTVARFIXED eventvarfixed

SCIP_EVENTTYPECHG eventtypechg

union SCIP_Event::@16 data

SCIP_EVENTVARUNLOCKED eventvarunlocked

SCIP_EVENTBDCHG eventbdchg

SCIP_EVENTIMPLADD eventimpladd

SCIP_EVENTOBJCHG eventobjchg

SCIP_EVENTVARADDED eventvaradded

SCIP_EVENTVARDELETED eventvardeleted

SCIP_EVENTHDLRDATA * eventhdlrdata

SCIP_EVENTFILTER * eventfilter

unsigned int eventqueueimpl

datastructures for managing events

data structures for LP management

datastructures for global SCIP settings

datastructures for problem variables

#define SCIP_EVENTTYPE_GHOLEADDED

#define SCIP_EVENTTYPE_FIRSTLPSOLVED

#define SCIP_EVENTTYPE_NODEFEASIBLE

#define SCIP_EVENTTYPE_BOUNDCHANGED

#define SCIP_EVENTTYPE_VARUNLOCKED

#define SCIP_EVENTTYPE_ROWSIDECHANGED

#define SCIP_EVENTTYPE_SYNC

#define SCIP_EVENTTYPE_ROWADDEDLP

#define SCIP_EVENTTYPE_POORSOLFOUND

#define SCIP_EVENTTYPE_TYPECHANGED

#define SCIP_EVENTTYPE_PRESOLVEROUND

#define SCIP_EVENTTYPE_GUBCHANGED

#define SCIP_EVENTTYPE_GHOLEREMOVED

struct SCIP_EventData SCIP_EVENTDATA

#define SCIP_EVENTTYPE_UBTIGHTENED

#define SCIP_EVENTTYPE_NODEFOCUSED

#define SCIP_EVENTTYPE_NODEINFEASIBLE

#define SCIP_EVENTTYPE_OBJCHANGED

#define SCIP_EVENTTYPE_VARFIXED

#define SCIP_EVENTTYPE_VARDELETED

struct SCIP_EventhdlrData SCIP_EVENTHDLRDATA

#define SCIP_EVENTTYPE_NODEEVENT

#define SCIP_EVENTTYPE_LHOLEREMOVED

#define SCIP_EVENTTYPE_NODEBRANCHED

#define SCIP_DECL_EVENTCOPY(x)

#define SCIP_EVENTTYPE_LBRELAXED

#define SCIP_EVENTTYPE_BESTSOLFOUND

#define SCIP_EVENTTYPE_FORMAT

#define SCIP_EVENTTYPE_GLBCHANGED

#define SCIP_EVENTTYPE_HOLECHANGED

#define SCIP_EVENTTYPE_ROWDELETEDSEPA

#define SCIP_EVENTTYPE_VARADDED

#define SCIP_EVENTTYPE_LBCHANGED

#define SCIP_EVENTTYPE_ROWDELETEDLP

#define SCIP_EVENTTYPE_UBCHANGED

#define SCIP_EVENTTYPE_LHOLEADDED

#define SCIP_EVENTTYPE_LPSOLVED

#define SCIP_EVENTTYPE_IMPLADDED

#define SCIP_EVENTTYPE_ROWCOEFCHANGED

#define SCIP_EVENTTYPE_ROWADDEDSEPA

#define SCIP_EVENTTYPE_LPEVENT

#define SCIP_EVENTTYPE_NODEDELETE

#define SCIP_EVENTTYPE_DISABLED

#define SCIP_EVENTTYPE_SOLEVENT

#define SCIP_EVENTTYPE_ROWCONSTCHANGED

#define SCIP_EVENTTYPE_LBTIGHTENED

#define SCIP_EVENTTYPE_UBRELAXED

enum SCIP_SideType SCIP_SIDETYPE

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_VARSTATUS_MULTAGGR

@ SCIP_VARSTATUS_AGGREGATED

enum SCIP_Vartype SCIP_VARTYPE

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