RetroSearch Browse

);

409 if

( *regforest ==

)

411

regforestptr = *regforest;

431

assert(regforest !=

);

432

assert(datapoint !=

);

437 for

( treeidx = 0; treeidx < regforest->

ntrees

; ++treeidx )

439 int

treepos = regforest->

nbegin

[treeidx];

440 int

* childtree = &(regforest->

child

[2 * treepos]);

441 int

* splitidxtree = &(regforest->

splitidx

[treepos]);

448 while

( splitidxtree[pos] != - 1 )

452

assert(splitidxtree[pos] < regforest->

dim

);

454

goright = (datapoint[splitidxtree[pos]] > valuetree[pos]) ? 1 : 0;

455

pos = childtree[2 * pos + goright];

458

value += valuetree[pos];

472 const char

* filename

498 if

(

SCIPfgets

(buffer, (

int

)

sizeof

(buffer), file) ==

)

501 SCIPerrorMessage

(

"Could not read first line of regression file '%s'\n"

, filename);

506

sscanret = sscanf(buffer, firstlineformat, &ntrees, &dim, &size);

511 SCIPerrorMessage

(

"Could not extract tree information from buffer line [%s]\n"

, buffer);

515 SCIPdebugMessage

(

"Read ntrees=%d, dim=%d, size=%d (return value %d)\n"

, ntrees, dim, size, sscanret);

525 if

( dim <= 0 || ntrees <= 0 || size <= 0 )

528 SCIPerrorMessage

(

"Cannot create regression tree with negative size, dimension, or number of trees\n"

);

535

regforestptr = *regforest;

543

regforestptr->

dim

= dim;

544

regforestptr->

size

= size;

545

regforestptr->

ntrees

= ntrees;

554 while

( !

SCIPfeof

(file) && !error )

560 if

(

SCIPfgets

(buffer, (

int

)

sizeof

(buffer), file) ==

)

563

sscanret = sscanf(buffer, dataformat,

565

&regforestptr->

child

[2 * pos],

566

&regforestptr->

child

[2 * pos + 1],

581

assert(treepos < regforestptr->ntrees);

583

regforestptr->

nbegin

[treepos++] = pos;

612

assert(stats !=

);

613

assert(other !=

);

628

assert(dest !=

);

629

assert(src !=

);

643

assert(treeprofilestats !=

);

657 if

( mindepth < treeprofile->profilesize )

692

assert(treeprofile !=

);

696

(*treeprofile)->profile =

;

697

(*treeprofile)->profilesize = 0;

703

(*treeprofile)->lastestimate = -1.0;

716

assert(treeprofile !=

);

718 if

( *treeprofile ==

)

725

*treeprofile =

;

742

assert(node !=

);

744 if

( treeprofile ==

)

748

assert(nodedepth >= 0);

756

nodedepthcnt = ++treeprofile->

profile

[nodedepth];

761

nbits = 8*

sizeof

(

unsigned

int);

763 if

( (

unsigned int

)nodedepth < nbits && nodedepthcnt == (1U << nodedepth) )

778 if

( nodedepthcnt > maxnodes )

784 else if

( nodedepthcnt == maxnodes )

811 if

( treeprofile ==

)

837

estimate += growthfac;

838

growthfac *= gamma_d;

842 for

( ; d < waist; ++d )

846

assert(1.0 <= gamma_d && gamma_d <= 2.0);

847

estimate += growthfac;

848

growthfac *= gamma_d;

855

assert(0.0 <= gamma_d && gamma_d <= 1.0);

857

estimate += growthfac;

858

growthfac *= gamma_d;

889

assert(pqueue !=

);

896

assert(nodeinfo !=

);

916

assert(ssg !=

);

941

assert(ssg !=

);

948

(*ssg)->nsubtrees = 0;

968 if

( (*ssg)->nodes2info !=

)

1000

assert(oldpos == -1 || oldpos == nodeinfo->

);

1001

nodeinfo->

= newpos;

1016

assert(ssg !=

);

1017

assert(node !=

);

1023

nodeinfo->

node

= node;

1025

nodeinfo->

= -1;

1036

assert(subtreeidx >= 0);

1037

assert(subtreeidx < ssg->nsubtrees);

1046

assert(0 <= nodeinfo->

);

1068

assert(ssg !=

);

1073

nnewsubtrees = nopennodes[0] + nopennodes[1] + nopennodes[2] + (addfocusnode ? 1 : 0);

1098 for

( t = 0; t < 3; ++t )

1101 int nnodes

= nopennodes[t];

1105 for

( n = 0; n <

; ++n )

1149

gap =

(gap, 1.0);

1173 if

( nodeinfo ==

)

1181 if

( nodeinfo ==

)

1188

assert(pqueue !=

);

1191

pos = nodeinfo->

;

1206

assert(nodeinfofirst ==

|| subtreeidx == nodeinfofirst->

subtreeidx

);

1237 int

parentnodelabel;

1241

assert(ssg !=

);

1248 if

( nchildren == 0 )

1258

parentnode = focusnode;

1267

parentnode = focusnode;

1270

parentnodelabel = parentnodeinfo->

subtreeidx

;

1273 for

( n = 0; n < nchildren; ++n )

1291#ifdef SCIP_DISABLED_CODE 1328 for

( l = 0; l < ssg->

nsubtrees

; ++l )

1335 for

( t = 0; t < 3; ++t )

1339 for

( n = 0; n < nopennodes[t]; ++n )

1349

assert(label >= 0 && label < ssg->nsubtrees);

1350

lowerbounds[label] =

(lowerbounds[label], lowerbound);

1356 for

( l = 0; l < ssg->

nsubtrees

; ++l )

1370

subtreegap =

(subtreegap, 1.0);

1372

gapsum += subtreegap;

1376 if

( updatescaling )

1417 for

( l = 0; l < ssg->

nsubtrees

; ++l )

1432

gapsum += subtreegap;

1436 if

( updatescaling )

1479

((ssg->

nmaxsubtrees

== -1 || nnewsubtrees <= ssg->nmaxsubtrees) &&

1491 SCIPdebugMsg

(

"Keep split into %d subtrees because new split into %d subtrees exceeds limit %d\n"

1501 if

( insertchildren )

1509

updatescaling =

TRUE

;

1515 else if

( insertchildren )

1521 if

( nchildren == 0 )

1542

treedata->

nopen

= 1;

1556

assert(treedata !=

);

1577 if

( *treedata ==

)

1595

assert(node !=

);

1598

treedata->

nopen

--;

1600 if

( nchildren == 0 )

1608

treedata->

+= nchildren;

1609

treedata->

nopen

+= nchildren;

1637char

* treeDataPrint(

1648 "weight: %.4Lf, ssg %.4f"

1681

assert(des !=

);

1707

newtrend = des->

* (newlevel - des->

) + (1.0 - des->

) * des->

;

1709

des->

level

= newlevel;

1710

des->

trend

= newtrend;

1720

assert(des !=

);

1725 return

des->

trend

;

1735

timeseries->

= 0;

1736

timeseries->

nobs

= 0L;

1758

assert(timeseries !=

);

1759

assert(name !=

);

1760

assert(alpha >= 0.0 && alpha <= 1);

1761

assert(beta >= 0.0 && beta <= 1);

1765

timeseriesptr = *timeseries;

1766

assert(timeseriesptr !=

);

1772

assert(timeseriesupdate !=

);

1773

timeseriesptr->timeseriesupdate = timeseriesupdate;

1784

timeseriesptr->

des

alpha

= alpha;

1785

timeseriesptr->

des

beta

= beta;

1800

assert(timeseries !=

);

1809

*timeseries =

;

1818

assert(timeseries !=

);

1855 if

( timeseries->

nobs

== 0L )

1862 if

(

EPSZ

(val - targetval, tolerance) )

1863 return

treedata->

;

1870 if

( (targetval > val && trend < tolerance) || (targetval < val && trend > -tolerance) )

1877 return

timeseries->

useleafts

? 2.0 * estimated - 1.0 : estimated;

1914

assert(timeseries->

% 2 == 0);

1916

des = &timeseries->

des

;

1920 for

( i = 0; i < timeseries->

/ 2; ++i )

1922

timeseries->

vals

[i] = timeseries->

vals

[2 * i];

1944

assert(timeseries !=

);

1945

assert(treedata !=

);

1948

assert(timeseries->timeseriesupdate !=

);

1949 SCIP_CALL

( timeseries->timeseriesupdate(

, timeseries, treedata, &value) );

1954 if

( timeseries->

useleafts

&& ! isleaf )

1957

timeseries->

nobs

++;

1966

tspos = timeseries->

++;

1967

timeseries->

vals

[tspos] = value;

1987 return

timeseries->

name

;

1996 TIMESERIES

** tss = eventhdlrdata->timeseries;

2002

assert(tss[t] !=

);

2005

tss[t]->

useleafts

= eventhdlrdata->useleafts;

2020 TIMESERIES

** tss = eventhdlrdata->timeseries;

2026

assert(tss[t] !=

);

2081

assert(eventhdlrdata !=

);

2082

treedata = eventhdlrdata->treedata;

2085 if

( treedata->

<= 0.3 )

2088

coeffs = coeffs_early;

2092 else if

( treedata->

<= 0.6 )

2094

coeffs = coeffs_intermediate;

2103

coeffs = coeffs_late;

2115 TSPOS

tspos = tsposs[t];

2119

testim = treedata->

;

2121

estim += coeffs[t] * testim;

2124 if

( estim < treedata->

)

2139 char

completiontype;

2141

assert(eventhdlrdata !=

);

2142

treedata = eventhdlrdata->treedata;

2143

completiontype = eventhdlrdata->completiontypeparam;

2157 SCIP_Bool

useweight = eventhdlrdata->treeisbinary;

2160 if

( eventhdlrdata->regforest !=

)

2162 else if

( useweight && usessg )

2164 else if

( useweight )

2173 switch

(completiontype)

2192

*completed = eventhdlrdata->coefmonoweight * (

SCIP_Real

)treedata->

2193

eventhdlrdata->coefmonossg * (1.0 - treedata->

ssg

value

);

2205

*completed = 1.0 - treedata->

ssg

value

;

2230

completed =

(completed, 1.0);

2232 if

( completed > 0.0 )

2246

assert(ts !=

);

2247

assert(value !=

);

2268

abspb =

REALABS

(primalbound);

2270

*value = 1.0 -

REALABS

(primalbound - dualbound)/

MAX

(abspb, absdb);

2274

*value =

MAX

(*value, 0.0);

2332

assert(eventhdlrdata !=

);

2363 switch

(eventhdlrdata->restartpolicyparam)

2374 SCIPerrorMessage

(

"Unknown restart policy %c\n"

, eventhdlrdata->restartpolicyparam);

2399 if

( eventhdlrdata->restartlimit != -1 && eventhdlrdata->nrestartsperformed >= eventhdlrdata->restartlimit )

2403 if

( eventhdlrdata->countonlyleaves )

2404 nnodes

= eventhdlrdata->treedata->nleaves;

2406 nnodes

= eventhdlrdata->treedata->nvisited;

2408 if

( nnodes < eventhdlrdata->minnodes )

2426 if

( completion < 1.0 / eventhdlrdata->restartfactor )

2430 "Completion %.5f less than restart threshold %.5f\n"

2431

completion, 1.0 / eventhdlrdata->restartfactor);

2451 if

( estimation < 0.0 )

2455 "Estimation %g is still unavailable\n"

2463 if

( estimation > eventhdlrdata->treedata->nnodes * eventhdlrdata->restartfactor )

2467 "Estimation %g exceeds number of estimation tree nodes %" SCIP_LONGINT_FORMAT " by a factor of %.1f\n"

2468

estimation, eventhdlrdata->treedata->nnodes, estimation / eventhdlrdata->treedata->nnodes);

2489

applyrestart =

TRUE

;

2492

applyrestart =

FALSE

;

2504 return

applyrestart;

2516 TIMESERIES

** tss = eventhdlrdata->timeseries;

2522

assert(tss[t] !=

);

2525#ifdef SCIP_MORE_DEBUG 2527 "Update of time series '%s', current value %.4f (%" SCIP_LONGINT_FORMAT " observations)\n"

2544 TREEDATA

* treedata = eventhdlrdata->treedata;

2545 char

* ptr = strbuf;

2552 if

( reportnum > 0 )

2561

completed =

(1.0, completed);

2562

completed =

MAX

(0.0, completed);

2571 "weight: %.4Lf completed %.4f\n"

2584 "estim"

"value"

"trend"

"resolution"

"smooth"

);

2589 real2String

(wbeestim, wbeestimstr, 0),

"-"

);

2593 "-"

"-"

);

2600 TIMESERIES

* ts = eventhdlrdata->timeseries[t];

2616 if

( reportnum > 0 )

2641

assert(eventhdlrdata !=

);

2659

assert(eventhdlrdata !=

);

2667

eventhdlrdata->lastrestartrun = 0;

2668

eventhdlrdata->nrestartsperformed = 0;

2680

assert(eventhdlrdata !=

);

2694

assert(eventhdlrdata !=

);

2696

eventhdlrdata->restarthitcounter = 0;

2697

eventhdlrdata->weightlastreport = 0.0;

2698

eventhdlrdata->nreports = 0;

2707 if

( eventhdlrdata->treeprofile_enabled )

2712

eventhdlrdata->treeisbinary =

TRUE

;

2724

assert(eventhdlrdata !=

);

2726 if

( eventhdlrdata->treeprofile !=

)

2745

assert(eventhdlr !=

);

2748

assert(eventhdlrdata !=

);

2750

treedata = eventhdlrdata->treedata;

2771 if

( nchildren != 2 )

2772

eventhdlrdata->treeisbinary =

FALSE

;

2787

(eventhdlrdata->reportfreq == 0

2788

|| treedata->

>= eventhdlrdata->weightlastreport + 1.0 / (

SCIP_Real

)eventhdlrdata->reportfreq) )

2792 if

( eventhdlrdata->reportfreq > 0 )

2810

eventhdlrdata->restarthitcounter++;

2812 if

( eventhdlrdata->restarthitcounter >= eventhdlrdata->hitcounterlim )

2817

eventhdlrdata->nrestartsperformed++;

2820 "Restart triggered after %d consecutive estimations that the remaining tree will be large\n"

2821

eventhdlrdata->restarthitcounter);

2831

eventhdlrdata->restarthitcounter = 0;

2846

assert(eventhdlr !=

);

2849

assert(eventhdlrdata !=

);

2851 if

( eventhdlrdata->showstats )

2866

assert(disp !=

);

2871

assert(eventhdlr !=

);

2873

assert(eventhdlrdata !=

);

2874

treedata = eventhdlrdata->treedata;

2878

completed =

(completed, 1.0);

2880 if

( treedata->

>= 0.005 && completed > 0 )

2904

eventExecEstim, eventhdlrdata) );

2905

assert(eventhdlr !=

);

2916 SCIP_CALL

(

SCIPaddCharParam

(

"estimation/restarts/restartpolicy"

"restart policy: (a)lways, (c)ompletion, (e)stimation, (n)ever"

2920 "tree size estimation method: (c)ompletion, (e)nsemble, " 2921 "time series forecasts on either (g)ap, (l)eaf frequency, (o)open nodes, tree (w)eight, (s)sg, " 2922 "or (t)ree profile or w(b)e"

2935 "factor by which the estimated number of nodes should exceed the current number of nodes"

2939 "whether to apply a restart when nonlinear constraints are present"

2943 "whether to apply a restart when active pricers are used"

2947 "coefficient of tree weight in monotone approximation of search completion"

2951 "coefficient of 1 - SSG in monotone approximation of search completion"

2954 SCIP_CALL

(

SCIPaddIntParam

(

"estimation/restarts/hitcounterlim"

"limit on the number of successive samples to really trigger a restart"

2958 "report frequency on estimation: -1: never, 0:always, k >= 1: k times evenly during search"

2965 "approximation of search tree completion: (a)uto, (g)ap, tree (w)eight, (m)onotone regression, (r)egression forest, (s)sg"

2969 "should the event handler collect data?"

2973 "minimum average number of nodes at each depth before producing estimations"

2977 "use leaf nodes as basic observations for time series, or all nodes?"

2981 "should statistics be shown at the end?"

2986 "the maximum number of individual SSG subtrees; -1: no limit"

2990 "minimum number of nodes to process between two consecutive SSG splits"

3029 if

( eventhdlr ==

)

3036

assert(eventhdlrdata !=