RetroSearch Browse

);

184

assert(eventhdlr !=

);

202

assert(eventhdlr !=

);

203

assert(event !=

);

212 for

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

215 if

( dualval !=

)

221 for

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

226 if

( transcons ==

)

236 if

( heurdata->heurverblevel > 2 )

256

assert(eventhdlr !=

);

280

assert(hashmap !=

);

284 for

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

322

assert(hashmap !=

);

326 for

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

363

assert(conshdlr !=

);

371 for

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

389 if

( !addcombconss || !addcontconss )

391

iscombinatorial =

;

393 for

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

397

iscombinatorial =

;

403 if

( (iscombinatorial && !addcombconss) || (!iscombinatorial && !addcontconss) )

439

assert(conshdlr !=

);

447 for

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

459 if

( (iscombinatorial && !addcombconss) || (!iscombinatorial && !addcontconss) )

466

2, vars, coefs,

496

assert(conshdlr !=

);

507 for

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

515 if

( coefssize < nvars )

525 for

( j = coefssize; j < nvars; ++j )

565

assert(conshdlr !=

);

576 for

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

584 if

( coefssize < nvars )

594 for

( j = coefssize; j < nvars; ++j )

655

assert(conshdlr !=

);

662

assert(conss !=

);

667 for

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

677 if

( coefssize < nvars )

691 for

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

722 if

( conshdlr !=

)

729 if

( conshdlr !=

)

738 if

( conshdlr !=

)

745 if

( conshdlr !=

)

752 if

( conshdlr !=

)

785

assert( heurdata !=

);

796 for

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

810 if

( subvar ==

)

812 SCIPdebugMsg

(

"return14 : abort building solution since a variable was not in our list\n"

);

830

assert(subvar !=

);

831

transval =

SCIPgetSolVal

(heurdata->subscip, subsol, subvar);

835

transval = tscalar * transval + tconstant;

837

val = scalar * transval + constant;

842

val = scalar * val + constant;

902

assert( heurdata !=

);

903

assert( heurdata->subscip ==

);

905

heurdata->usedcalls = 0;

906

heurdata->solfound =

;

907

heurdata->nonimprovingRounds = 0;

922 for

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

927 if

( currentconshdlr == conshdlrindi ||

928

currentconshdlr == conshdlrnonlin ||

929

currentconshdlr == conshdlrvarbound ||

930

currentconshdlr == conshdlrknapsack ||

931

currentconshdlr == conshdlrlogicor ||

932

currentconshdlr == conshdlrsetppc ||

933

currentconshdlr == conshdlrlin )

945 if

( heurdata->dynamicdepth == 1 )

947

heurdata->maxcalls = (int)

SCIPfloor

(

, sqrt((

double

)(nvars - ncontvars)));

950

heurdata->triedsetupsubscip =

;

964 FALSE

, &success) );

966 if

( success ==

)

968 SCIPdebugMsg

(

"In heur_dualval: failed to copy some plugins to sub-SCIP, continue anyway\n"

);

999 for

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

1005

assert( subcons !=

);

1013 if

( !heurdata->subscipisvalid )

1015 SCIPdebugMsg

(

"In heur_dualval: failed to copy some constraints to sub-SCIP, continue anyway\n"

);

1019

heurdata->nvars = nvars;

1033 if

( entry !=

)

1071 for

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

1076

currcons = indicatorconss[i];

1077

assert(currcons !=

);

1097

heurdata->integervarssize = nvars;

1101 for

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

1104

assert( var !=

);

1112

heurdata->integervars[j++] = vars[i];

1122 for

( k = 0; k < nconsindicator; k++ )

1129

currcons = indicatorconss[k];

1130

assert(currcons !=

);

1133

assert(indicatorbinvar !=

);

1137 if

( indicatorbinvar ==

SCIPhashmapGetImage

(heurdata->varsubsciptoscip, var) || indicatorbinvar == negatedvar )

1142

assert(indicatorbinvar == negatedvar);

1147

assert(indicatorbinvar != negatedvar);

1151

varobjective = heurdata->lambdaobj *

REALABS

(varobjective);

1153

indicons = currcons;

1154

assert( indicons !=

);

1158

assert( indicons !=

);

1172 if

( heurdata->relaxindicators )

1187

indicatorbinvar = negatedvar;

1264

assert(imagecons !=

);

1286 if

( heurdata->relaxindicators )

1289 for

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

1311 for

( k = 0; k < nconsindicator; k++ )

1316

currcons = indicatorconss[k];

1317

assert(currcons !=

);

1368 if

( heurdata->relaxcontvars )

1370 for

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

1373

assert( var !=

);

1438 SCIPinfinity

(

) );

1439

heurdata->objbound = cons;

1441 for

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

1444

assert( var !=

);

1450 if

( subvar ==

)

1466 if

( heurdata->heurverblevel > 3 )

1475

heurdata->nintegervars = j;

1489

assert(heurdata !=

);

1490

assert(heurdata->subscip !=

);

1492

heurdata->nsubvars = 0;

1493

heurdata->nvars = 0;

1518

assert(heur !=

);

1519

assert(sol !=

);

1522

assert(heurdata !=

);

1536 for

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

1538

subvar = subvars[i];

1539

assert(subvar !=

);

1553#define BIG_VALUE 1E+10 1574 for

( i = 0; i < heurdata->nintegervars; i++ )

1576

var = heurdata->integervars[i];

1577

assert(var !=

);

1580

assert(var !=

);

1583 if

( subvar ==

)

1619 if

( rcons ==

)

1655 if

( clearswitchedvars )

1658 for

( i = 0; i < heurdata->nintegervars; i++ )

1660

var = heurdata->integervars[i];

1686 if

( transsol !=

)

1691 if

( beforeswitching )

1700 for

( i = nsubbinvars + nsubintvars - 1; i >= 0; --i )

1702

subvar = subvars[i];

1710

assert(var !=

);

1744 for

( j = 0; j < heurdata->nintegervars; j++ )

1746

sortedvars[j] = heurdata->integervars[j];

1750 if

( sortedvars[j] ==

)

1754

assert(var !=

);

1765

assert(var !=

);

1769 if

( relaxcons !=

)

1774 if

( dualvalue ==

)

1777 if

( dualvalue ==

)

1780

assert(dualvalue !=

);

1781

ranks[j] = (*dualvalue);

1785

assert(ranks[j] == 0.0);

1793 if

( dualvalue ==

)

1796

assert(dualvalue !=

);

1798

ranks[j] = (*dualvalue);

1802 for

( k = 0; k < nconsindicator; k++ )

1808

currcons = indicatorconss[k];

1809

assert(currcons !=

);

1812

assert(indicatorbinvar !=

);

1817

indicons = currcons;

1818

assert(indicons !=

);

1821

assert(subcons !=

);

1824

assert(subcons !=

);

1828 if

( dualvalue ==

)

1831

assert(dualvalue !=

);

1834

ranks[j] = (*dualvalue);

1841

absranks[j] =

REALABS

(ranks[j]);

1870

maxslackset =

;

1875 for

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

1878 if

( subvar ==

)

1884 if

( heurdata->isnlp )

1890

maxslackset =

;

1895

assert(bestsol !=

);

1896 if

( maxslack <

SCIPgetSolVal

(heurdata->subscip, bestsol, subvar) )

1898

maxslack =

SCIPgetSolVal

(heurdata->subscip, bestsol, subvar);

1900

maxslackset =

;

1906 if

( ! maxslackset )

1912

assert(maxslack >= 0);

1914 if

( heurdata->heurverblevel > 0 && maxslackset )

1940

assert(heurdata !=

);

1947

heurdata->solfound =

;

1950

assert( heurdata->isnlp );

1961 if

( heurdata->heurverblevel > 1 )

1976 if

( heurdata->heurverblevel > 0 )

1988 if

( stored && heurdata->heurverblevel > 1 )

1991 if

( heurdata->isnlp )

1999

heurdata->solfound =

;

2001 if

( heurdata->heurverblevel >= 1 )

2009

heurdata->prevInfeasible =

;

2010

heurdata->solfound =

;

2013 if

( heurdata->heurverblevel >= 1 )

2060

assert(heur !=

);

2068

assert(heurdata !=

);

2082 if

( heurdata->subscip ==

&& !heurdata->triedsetupsubscip )

2088 if

( heurdata->solfound )

2097 if

( heurdata->subscip ==

)

2103

assert(heurdata->nsubvars > 0);

2104

assert(heurdata->varsubsciptoscip !=

);

2126

heurdata->prevInfeasible =

;

2136

retcode =

SCIPsolve

(heurdata->subscip);

2137

heurdata->isnlp =

;

2154

heurdata->isnlp =

;

2158 if

( heurdata->isnlp )

2175 if

( subvar ==

)

2177

startpoint[i] = constant;

2198 SCIP_CALL

(

SCIPsolveNLP

(heurdata->subscip, .verblevel = (

unsigned short

)heurdata->nlpverblevel) );

2205 SCIP_CALL

(

SCIPsolveNLP

(heurdata->subscip, .verblevel = (

unsigned short

)heurdata->nlpverblevel) );

2213 for

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

2221 for

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

2227 if

( transcons ==

)

2267

assert(bestsol !=

);

2270 for

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

2279 if

( heurdata->forceimprovements )

2283

heurdata->nonimprovingRounds++;

2284 SCIPdebugMsg

(

"nonimpr rounds %d prevobj %f \n"

, heurdata->nonimprovingRounds, heurdata->prevobjective);

2287 if

( heurdata->nonimprovingRounds > heurdata->maxcalls/8 )

2291 if

( heurdata->isnlp )

2298

heurdata->solfound =

;

2299

heurdata->switchdifferent =

;

2308

heurdata->prevobjective =

SCIPgetSolOrigObj

(heurdata->subscip, bestsol) - objvalue;

2322 if

( heurdata->heurverblevel > 1 )

2324

k = heurdata->rankvalue;

2326 if

( heurdata->nintegervars < heurdata->rankvalue )

2327

k = heurdata->nintegervars;

2329 for

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

2336 if

( heurdata->isnlp )

2340

maxequalranks =

MIN

(heurdata->maxequalranks, heurdata->nintegervars/3);

2356 for

( k = 0; k < heurdata->nintegervars; ++k )

2358

var = heurdata->integervars[k];

2366 if

( rcons !=

)

2369

assert(var !=

);

2370

assert(subvar !=

);

2380 for

( i = 0; i < heurdata->nintegervars; i++ )

2395 if

( heurdata->heurverblevel > 1 )

2442 if

( seclastval !=

)

2450 if

( heurdata->heurverblevel > 1 )

2457 if

( heurdata->usedcalls >= heurdata->maxcalls )

2466

heurdata->usedcalls++;

2468 if

( heurdata->heurverblevel > 1 )

2475 if

( *result ==

SCIP_DIDNOTFIND

|| heurdata->solfound || heurdata->prevInfeasible )

2481 if

( heurdata->switchdifferent )

2483

heurdata->switchdifferent =

;

2484

heurdata->solfound =

;

2486

heurdata->nonimprovingRounds -= 2;

2489 if

( heurdata->prevInfeasible )

2491

heurdata->prevInfeasible =

;

2492

heurdata->solfound =

;

2494

heurdata->nonimprovingRounds++;

2502 if

( heurdata->subscip ==

)

2530

assert(heur !=

);

2546

assert(heur !=

);

2563

assert(heur !=

);

2572

assert(heurdata !=

);

2573

assert(heurdata->subscip ==

);

2574

assert(!heurdata->triedsetupsubscip);

2580 if

( heurdata->subscip ==

)

2603

assert(heur !=

);

2606

assert(heurdata !=

);

2610 if

( heurdata->subscip !=

)

2616 for

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

2624 if

( heurdata->varsciptosubscip !=

)

2630 if

( heurdata->origsubscipConsMap !=

)

2636 if

( heurdata->relaxcons !=

)

2642 if

( heurdata->conss2nlrow !=

)

2648 if

( heurdata->slack2var !=

)

2654 if

( heurdata->indicopymap !=

)

2660 if

( heurdata->indicopymapback !=

)

2666 if

( heurdata->relaxconsindi !=

)

2672 if

( heurdata->slackvarlbMap !=

)

2678 if

( heurdata->slackvarubMap !=

)

2685 if

( heurdata->subscip !=

)

2691 if

( heurdata->varsubsciptoscip !=

)

2697 if

( heurdata->slacktoindivarsmap !=

)

2703 if

( heurdata->indicators !=

)

2709 if

( heurdata->switchedvars !=

)

2713 if

( heurdata->switchedvars2 !=

)

2719

heurdata->triedsetupsubscip =

;

2720

heurdata->usedcalls = 0;

2721

heurdata->solfound =

;

2722

heurdata->prevInfeasible =

;

2724

assert(heurdata->subscip ==

);

2725

assert(heurdata->varsubsciptoscip ==

);

2726

assert(heurdata->varsciptosubscip ==

);

2738

assert(heur !=

);

2745

assert(heurdata !=

);

2748 if

( heurdata->subscip ==

)

2764

assert(heur !=

);

2779

assert(heur !=

);

2780

assert(result !=

);

2784

assert(heurdata !=

);

2790

heurdata->usedcalls = 0;

2791

heurdata->prevInfeasible =

;

2792

heurdata->solfound =

;

2793

heurdata->nonimprovingRounds = 0;

2794

heurdata->prevobjective = INT_MAX;

2832

assert(heur !=