RetroSearch Browse

);

57

assert(heur2 !=

);

63 return

(strcmp(heur1->

, heur2->

));

96

assert(paramdata !=

);

110

assert(divesetstats !=

);

121

divesetstats->

nlps

= 0;

125

divesetstats->

ncalls

= 0;

137

assert(diveset !=

);

141 for

( d = 0; d < 4; ++d )

193

assert(diveset !=

);

219

assert(diveset !=

);

224 for

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

227

nbacktracks, nsolsfound, nbestsolsfound, nconflictsfound, leavesol);

241

assert(heur !=

);

242

assert(diveset !=

);

245

diveset->

heur

= heur;

285 unsigned int

initialseed,

297 const char

* divesetname;

300

assert(divesetptr !=

);

302

assert(divesetgetscore !=

);

303

assert(heur !=

);

304

assert(blkmem !=

);

307

diveset = *divesetptr;

323

diveset->divesetgetscore = divesetgetscore;

324

diveset->divesetavailable = divesetavailable;

332 for

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

343 paramname

"minimal relative depth to start diving"

348 "maximal relative depth to start diving"

354 "maximal fraction of diving LP iterations compared to node LP iterations"

360 "additional number of allowed LP iterations"

366 "maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)"

372 "maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)"

378 "maximal UBQUOT when no solution was found yet (0.0: no limit)"

384 "maximal AVGQUOT when no solution was found yet (0.0: no limit)"

390 "use one level of backtracking if infeasibility is encountered?"

395 "percentage of immediate domain changes during probing to trigger LP resolve"

401 "LP solve frequency for diving heuristics (0: only after enough domain changes have been found)"

408 "should only LP branching candidates be considered instead of the slower but " 409 "more general constraint handler diving variable selection?"

420 return

diveset->

heur

;

428

assert(diveset !=

);

430 return

diveset->

sol

;

439

assert(diveset !=

);

449

assert(diveset !=

);

451 return

diveset->

;

479

assert(divesetstats !=

);

492

assert(divesetstats !=

);

494 return

divesetstats->

ncalls

;

505

assert(diveset !=

);

518

assert(divesetstats !=

);

531

assert(divesetstats !=

);

544

assert(divesetstats !=

);

557

assert(divesetstats !=

);

570

assert(divesetstats !=

);

583

assert(divesetstats !=

);

596

assert(divesetstats !=

);

609

assert(divesetstats !=

);

622

assert(divesetstats !=

);

635

assert(divesetstats !=

);

648

assert(divesetstats !=

);

714

assert(diveset !=

);

724

assert(diveset !=

);

735

assert(diveset !=

);

747

assert(diveset !=

);

758

assert(diveset !=

);

768

assert(diveset !=

);

780

assert(divesetstats !=

);

783

divesetstats->

nlps

++;

794

assert(diveset !=

);

816

assert(diveset !=

);

823 for

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

845

assert(diveset->divesetgetscore !=

);

846

assert(candscore !=

);

847

assert(roundup !=

);

848

assert(divecand !=

);

851 SCIP_CALL

( diveset->divesetgetscore(

->scip, diveset, divetype, divecand, divecandsol, divecandfrac,

852

candscore, roundup) );

865

assert(diveset !=

);

866

assert(available !=

);

868 if

( diveset->divesetavailable ==

)

873 SCIP_CALL

( diveset->divesetavailable(

->scip, diveset, available) );

887

assert(heur !=

);

891 if

( heur->heurcopy !=

)

929

assert(heur !=

);

930

assert(name !=

);

931

assert(desc !=

);

933

assert(freqofs >= 0);

934

assert(heurexec !=

);

941

(*heur)->dispchar = dispchar;

942

(*heur)->priority = priority;

943

(*heur)->freq = freq;

944

(*heur)->freqofs = freqofs;

945

(*heur)->maxdepth = maxdepth;

946

(*heur)->delaypos = -1;

947

(*heur)->timingmask = timingmask;

948

(*heur)->usessubscip = usessubscip;

949

(*heur)->heurcopy = heurcopy;

950

(*heur)->heurfree = heurfree;

951

(*heur)->heurinit = heurinit;

952

(*heur)->heurexit = heurexit;

953

(*heur)->heurinitsol = heurinitsol;

954

(*heur)->heurexitsol = heurexitsol;

955

(*heur)->heurexec = heurexec;

956

(*heur)->heurdata = heurdata;

960

(*heur)->nsolsfound = 0;

961

(*heur)->nbestsolsfound = 0;

962

(*heur)->initialized =

FALSE

;

963

(*heur)->divesets =

;

964

(*heur)->ndivesets = 0;

970

&(*heur)->priority,

TRUE

, priority, INT_MIN/4, INT_MAX/4,

973

(void)

SCIPsnprintf

(paramdesc,

SCIP_MAXSTRLEN

"frequency for calling primal heuristic <%s> (-1: never, 0: only at depth freqofs)"

, name);

1013

assert(heur !=

);

1014

assert(name !=

);

1015

assert(desc !=

);

1017

assert(freqofs >= 0);

1018

assert(heurexec !=

);

1020 SCIP_CALL_FINALLY

(

doHeurCreate

(heur,

, messagehdlr, blkmem, name, desc, dispchar, priority, freq, freqofs,

1021

maxdepth, timingmask, usessubscip, heurcopy, heurfree, heurinit, heurexit, heurinitsol, heurexitsol, heurexec,

1035

assert(heur !=

);

1036 if

( *heur ==

)

1038

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

1040

assert((*heur)->divesets !=

|| (*heur)->ndivesets == 0);

1043 if

( (*heur)->heurfree !=

)

1048 for

( d = 0; d < (*heur)->ndivesets; ++d )

1050

assert((*heur)->divesets[d] !=

);

1070

assert(heur !=

);

1079 if

(

->misc_resetstat )

1093 if

( heur->heurinit !=

)

1105 for

( d = 0; d < heur->

ndivesets

; ++d )

1122

assert(heur !=

);

1131 if

( heur->heurexit !=

)

1152

assert(heur !=

);

1162 if

( heur->heurinitsol !=

)

1182

assert(heur !=

);

1186 if

( heur->heurexitsol !=

)

1204 int

lpstateforkdepth,

1215

execute = heur->

>= 0;

1223

execute = (heur->

> 0 && depth >= heur->

freqofs 1225

!= (lpstateforkdepth + heur->

- heur->

freqofs

) / heur->

));

1234

execute = execute || (depth == heur->

freqofs

&& heur->

== 0);

1240

execute = execute || (heur->

delaypos

>= 0);

1257

execute = execute && (heur->

timingmask

& heurtiming) > 0;

1268 int

lpstateforkdepth,

1271 int

* ndelayedheurs,

1278

assert(heur !=

);

1279

assert(heur->heurexec !=

);

1280

assert(heur->

>= -1);

1285

assert(primal !=

);

1287

assert(ndelayedheurs !=

);

1288

assert(result !=

);

1315 SCIP_CALL

( heur->heurexec(

->scip, heur, heurtiming, nodeinfeasible, result) );

1327 SCIPerrorMessage

(

"execution method of primal heuristic <%s> returned invalid result <%d>\n"

1328

heur->

, *result);

1348 SCIPsetDebugMsg

(

"delaying execution of primal heuristic <%s> in depth %d (delaypos: %d), heur was%s delayed before, had delaypos %d\n"

1352 if

( heur->

delaypos

!= *ndelayedheurs )

1368

assert(heur !=

);

1379

assert(heur !=

);

1392

assert(heur !=

);

1394

heur->heurcopy = heurcopy;

1403

assert(heur !=

);

1405

heur->heurfree = heurfree;

1414

assert(heur !=

);

1416

heur->heurinit = heurinit;

1425

assert(heur !=

);

1427

heur->heurexit = heurexit;

1436

assert(heur !=

);

1438

heur->heurinitsol = heurinitsol;

1447

assert(heur !=

);

1449

heur->heurexitsol = heurexitsol;

1457

assert(heur !=

);

1459 return

heur->

;

1467

assert(heur !=

);

1469 return

heur->

desc

;

1477

assert(heur !=

);

1487

assert(heur !=

);

1498

assert(heur !=

);

1508

assert(heur !=

);

1518

assert(heur !=

);

1530

assert(heur !=

);

1542

assert(heur !=

);

1544 return

heur->

;

1553

assert(heur !=

);

1563

assert(heur !=

);

1573

assert(heur !=

);

1583

assert(heur !=

);

1593

assert(heur !=

);

1603

assert(heur !=

);

1613

assert(heur !=

);

1624

assert(heur !=

);

1635

assert(heur !=

);

1645

assert(heur !=

);

1655

assert(heur !=

);

1665

assert(heur !=

);

1709 int

currentdistance;

1719

assert(startvars !=

);

1720

assert(nstartvars >= 1);

1721

assert(distances !=

);

1722

assert(maxdistance >= 0);

1730

nbinintvars = nbinvars + nintvars;

1736 if

( vargraph ==

)

1739

assert(vargraph !=

);

1740

localvargraph =

TRUE

;

1743

localvargraph =

FALSE

;

1749 for

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

1758 for

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

1761

assert(probindex >= 0);

1763

distances[probindex] = 0;

1764

queue[i] = probindex;

1767 if

( probindex < nbinintvars )

1771

nextlvlidx = nvars - 1;

1780

currvar = vars[queue[currlvlidx]];

1782

currentdistance = distances[varpos];

1783

assert(currentdistance >= 0);

1786

assert(currentdistance <= maxdistance);

1789 if

( currentdistance == maxdistance )

1792

assert(varpos >= 0);

1795 for

( c = 0; c < vargraph->

nvarconss

[varpos]; ++c )

1819 for

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

1823

assert(nextvar !=

);

1828

assert(nextvarpos >= 0);

1831 if

( distances[nextvarpos] == -1 )

1833

distances[nextvarpos] = currentdistance + 1;

1834

queue[nextlvlidx] = nextvarpos;

1835

nextlvlidx -= increment;

1838 if

( nextvarpos < nbinintvars )

1847

queue[currlvlidx] = -1;

1848

currlvlidx += increment;

1851 if

( currlvlidx == nvars || currlvlidx == 0 || queue[currlvlidx] == -1 || currlvlidx == nextlvlidx )

1854 if

( nvarshit >= maxvars || nbinintvarshit >= maxbinintvars )

1860 if

( increment == +1 )

1862

currlvlidx = nvars - 1;

1869

nextlvlidx = nvars - 1;

1874 while

( queue[currlvlidx] != -1 && distances[queue[currlvlidx]] >= currentdistance );

1880 if

( localvargraph )

1899 int

* nrelaxedconstraints

1910

assert(vargraph !=

);

1918 if

( nrelaxedconstraints !=

)

1919

*nrelaxedconstraints = 0;

1921

relaxlimit = (int)(relaxdensity * nvars);

1923 for

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

1941 if

( relaxdenseconss && nconsvars >= relaxlimit )

1943 if

( nrelaxedconstraints !=

)

1944

++(*nrelaxedconstraints);

1956 for

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

2003 int

* nrelaxedconstraints

2010

assert(vargraph !=

);

2021

SCIPhashKeyEqPtr, SCIPhashKeyValPtr,

) );

2043

assert(vargraph !=