RetroSearch Browse

(pooledvariance, 1e-9);

152

tresult = (meanx - meany) / sqrt(pooledvariance);

153

tresult *= sqrt(countx * county / (countx + county));

163#if defined(_WIN32) || defined(_WIN64) 174

sign = (

>= 0) ? 1 : -1;

177

t = 1.0/(1.0 + p*

);

178 y

= 1.0 - (((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t*exp(-

);

209

assert(variance >= -1e-9);

210 if

( variance < 1e-9 )

213 std

= sqrt(variance);

218 if

( value < mean + 1e-9 )

223

assert(

std

!= 0.0 );

228 SCIPdebugMessage

(

" Normalized value %g = ( %g - %g ) / (%g * 1.4142136)\n"

, normvalue, value, mean,

std

);

233 if

( normvalue < 1e-9 && normvalue > -1e-9 )

235 else if

( normvalue > 0 )

239

erfresult =

SCIPerf

(normvalue);

240 return

erfresult / 2.0 + 0.5;

246

erfresult =

SCIPerf

(-normvalue);

248 return

0.5 - erfresult / 2.0;

261

assert(regression !=

);

271

assert(regression !=

);

273 return

regression->

slope

;

281

assert(regression !=

);

302

regression->

slope

= 0.0;

336

assert(meanptr !=

);

337

assert(sumvarptr !=

);

338

assert(nobservations > 0 || add);

340

addfactor = add ? 1.0 : -1.0;

343

*meanptr = oldmean + addfactor * (value - oldmean)/(

SCIP_Real

)nobservations;

344

*sumvarptr += addfactor * (value - oldmean) * (value - (*meanptr));

347

assert(*sumvarptr >= -1e-4);

348

*sumvarptr =

(0.0, *sumvarptr);

358

assert(regression !=

);

376

regression->

sumxy

-= (

);

391

assert(regression !=

);

410

regression->

meanx

= 0;

412

regression->

sumxy

= 0;

413

regression->

meany

= 0;

423

assert(regression !=

);

452

assert(initsize >= 0);

453

assert(growfac >= 1.0);

456 if

( growfac == 1.0 )

457

size =

(initsize, num);

463

initsize =

(initsize, 4);

468 while

( size < num && size > oldsize )

471

size = (int)(growfac * size + initsize);

475 if

( size <= oldsize )

479

assert(size >= initsize);

490#define GMLNODEWIDTH 120.0 491#define GMLNODEHEIGTH 30.0 492#define GMLFONTSIZE 13 493#define GMLNODETYPE "rectangle" 494#define GMLNODEFILLCOLOR "#ff0000" 495#define GMLEDGECOLOR "black" 496#define GMLNODEBORDERCOLOR "#000000" 504 const char

* nodetype,

505 const char

* fillcolor,

506 const char

* bordercolor

509

assert(file !=

);

510

assert(label !=

);

512

fprintf(file,

" node\n"

);

513

fprintf(file,

" [\n"

);

514

fprintf(file,

" id %u\n"

id

);

515

fprintf(file,

" label \"%s\"\n"

, label);

516

fprintf(file,

" graphics\n"

);

517

fprintf(file,

" [\n"

);

521 if

( nodetype !=

)

522

fprintf(file,

" type \"%s\"\n"

, nodetype);

526 if

( fillcolor !=

)

527

fprintf(file,

" fill \"%s\"\n"

, fillcolor);

531 if

( bordercolor !=

)

532

fprintf(file,

" outline \"%s\"\n"

, bordercolor);

536

fprintf(file,

" ]\n"

);

537

fprintf(file,

" LabelGraphics\n"

);

538

fprintf(file,

" [\n"

);

539

fprintf(file,

" text \"%s\"\n"

, label);

541

fprintf(file,

" fontName \"Dialog\"\n"

);

542

fprintf(file,

" anchor \"c\"\n"

);

543

fprintf(file,

" ]\n"

);

544

fprintf(file,

" ]\n"

);

552 const char

* nodetype,

553 const char

* fillcolor,

554 const char

* bordercolor,

558

assert(file !=

);

559

assert(label !=

);

561

fprintf(file,

" node\n"

);

562

fprintf(file,

" [\n"

);

563

fprintf(file,

" id %u\n"

id

);

564

fprintf(file,

" label \"%s\"\n"

, label);

565

fprintf(file,

" weight %g\n"

, weight);

566

fprintf(file,

" graphics\n"

);

567

fprintf(file,

" [\n"

);

571 if

( nodetype !=

)

572

fprintf(file,

" type \"%s\"\n"

, nodetype);

576 if

( fillcolor !=

)

577

fprintf(file,

" fill \"%s\"\n"

, fillcolor);

581 if

( bordercolor !=

)

582

fprintf(file,

" outline \"%s\"\n"

, bordercolor);

586

fprintf(file,

" ]\n"

);

587

fprintf(file,

" LabelGraphics\n"

);

588

fprintf(file,

" [\n"

);

589

fprintf(file,

" text \"%s\"\n"

, label);

591

fprintf(file,

" fontName \"Dialog\"\n"

);

592

fprintf(file,

" anchor \"c\"\n"

);

593

fprintf(file,

" ]\n"

);

594

fprintf(file,

" ]\n"

);

606

assert(file !=

);

608

fprintf(file,

" edge\n"

);

609

fprintf(file,

" [\n"

);

610

fprintf(file,

" source %u\n"

, source);

611

fprintf(file,

" target %u\n"

, target);

614

fprintf(file,

" label \"%s\"\n"

, label);

616

fprintf(file,

" graphics\n"

);

617

fprintf(file,

" [\n"

);

620

fprintf(file,

" fill \"%s\"\n"

, color);

625

fprintf(file,

" ]\n"

);

629

fprintf(file,

" LabelGraphics\n"

);

630

fprintf(file,

" [\n"

);

631

fprintf(file,

" text \"%s\"\n"

, label);

633

fprintf(file,

" fontName \"Dialog\"\n"

);

634

fprintf(file,

" anchor \"c\"\n"

);

635

fprintf(file,

" ]\n"

);

638

fprintf(file,

" ]\n"

);

650

assert(file !=

);

652

fprintf(file,

" edge\n"

);

653

fprintf(file,

" [\n"

);

654

fprintf(file,

" source %u\n"

, source);

655

fprintf(file,

" target %u\n"

, target);

658

fprintf(file,

" label \"%s\"\n"

, label);

660

fprintf(file,

" graphics\n"

);

661

fprintf(file,

" [\n"

);

664

fprintf(file,

" fill \"%s\"\n"

, color);

668

fprintf(file,

" targetArrow \"standard\"\n"

);

669

fprintf(file,

" ]\n"

);

673

fprintf(file,

" LabelGraphics\n"

);

674

fprintf(file,

" [\n"

);

675

fprintf(file,

" text \"%s\"\n"

, label);

677

fprintf(file,

" fontName \"Dialog\"\n"

);

678

fprintf(file,

" anchor \"c\"\n"

);

679

fprintf(file,

" ]\n"

);

682

fprintf(file,

" ]\n"

);

691

assert(file !=

);

693

fprintf(file,

"graph\n"

);

694

fprintf(file,

"[\n"

);

695

fprintf(file,

" hierarchic 1\n"

);

698

fprintf(file,

" directed 1\n"

);

706

assert(file !=

);

708

fprintf(file,

"]\n"

);

718

assert(file !=

);

720

fprintf(file,

"digraph G {\n"

);

728 const char

* nodetype,

729 const char

* fillcolor,

730 const char

* bordercolor

733

assert(file !=

);

735

fprintf(file,

"\t%d [shape=\"%s\", label=\"%s\", style=\"filled\", fillcolor=\"%s\", color=\"%s\"];\n"

, node, nodetype, label, fillcolor, bordercolor);

746

assert(file !=

);

748

fprintf(file,

"\t%d -> %d [color=\"%s\"];\n"

, source, target, color);

756

assert(file !=

);

758

fprintf(file,

"}\n"

);

779

assert(sparsesol !=

);

780

assert(vars !=

);

789 for

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

791

assert(vars[v] !=

);

812

(*sparsesol)->nvars = nvars;

822

assert(sparsesol !=

);

823

assert(*sparsesol !=

);

836

assert(sparsesol !=

);

838 return

sparsesol->

vars

;

846

assert(sparsesol !=

);

848 return

sparsesol->

nvars

;

856

assert(sparsesol !=

);

866

assert(sparsesol !=

);

881

assert(sparsesol !=

);

882

assert(sol !=

);

886

assert(lbvalues !=

);

889 for

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

890

sol[v] = lbvalues[v];

909

assert(sparsesol !=

);

910

assert(sol !=

);

920

assert(lbvalues !=

);

921

assert(ubvalues !=

);

926 for

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

928

lbvalue = lbvalues[v];

929

ubvalue = ubvalues[v];

931 if

( lbvalue < ubvalue )

935 if

( carryflag ==

)

937 if

( sol[v] < ubvalue )

945

assert(sol[v] == ubvalue);

952 if

( sol[v] < ubvalue )

960

assert(sol[v] == ubvalue);

967 return

(!carryflag && !singular);

982

assert(queue !=

);

985 if

( minsize <= queue->size )

1002

assert(queue !=

);

1004

initsize =

(1, initsize);

1005

sizefac =

(1.0, sizefac);

1008

(*queue)->firstfree = 0;

1009

(*queue)->firstused = -1;

1011

(*queue)->sizefac = sizefac;

1012

(*queue)->slots =

;

1024

assert(queue !=

);

1035

assert(queue !=

);

1050 int

oldsize = queue->

;

1053

assert(oldsize < queue->size);

1055

sizediff = queue->

- oldsize;

1087

assert(queue !=

);

1092

assert(elem !=

);

1113

assert(queue !=

);

1139

assert(queue !=

);

1163 return

(queue->

[pos].

ptr

);

1173

assert(queue !=

);

1205

assert(queue !=

);

1223

assert(queue !=

);

1241

assert(queue !=

);

1254

assert(queue !=

);

1264 return

queue->

;

1274#define PQ_PARENT(q) (((q)+1)/2-1) 1275#define PQ_LEFTCHILD(p) (2*(p)+1) 1276#define PQ_RIGHTCHILD(p) (2*(p)+2) 1286

assert(pqueue !=

);

1288 if

( minsize <= pqueue->size )

1306

assert(pqueue !=

);

1307

assert(ptrcomp !=

);

1309

initsize =

(1, initsize);

1310

sizefac =

(1.0, sizefac);

1314

(*pqueue)->size = 0;

1315

(*pqueue)->sizefac = sizefac;

1316

(*pqueue)->slots =

;

1317

(*pqueue)->ptrcomp = ptrcomp;

1318

(*pqueue)->elemchgpos = elemchgpos;

1329

assert(pqueue !=

);

1340

assert(pqueue !=

);

1354

pqueue->

[newpos] = elem;

1357 if

( pqueue->elemchgpos !=

)

1359

pqueue->elemchgpos(elem, oldpos, newpos);

1363#ifdef SCIP_MORE_DEBUG 1386 if

( pqueue->ptrcomp(pqueue->

[i], pqueue->

[leftchild]) > 0 )

1405

assert(pqueue !=

);

1406

assert(pqueue->

>= 0);

1407

assert(elem !=

);

1412

pos = pqueue->

;

1415 while

( pos > 0 && (*pqueue->ptrcomp)(elem, pqueue->

[parentpos]) < 0 )

1417

assert((*pqueue->ptrcomp)(pqueue->

[parentpos], elem) >= 0);

1427#ifdef SCIP_MORE_DEBUG 1428

assert(pqueueHasHeapProperty(pqueue));

1443

assert(pqueue !=

);

1453 if

( pos == pqueue->

)

1456

last = pqueue->

[pqueue->

];

1461 while

( pos > 0 && (*pqueue->ptrcomp)(last, pqueue->

[

PQ_PARENT

(pos)]) < 0 )

1473 if

( brotherpos < pqueue->len && (*pqueue->ptrcomp)(pqueue->

[brotherpos], pqueue->

[childpos]) < 0 )

1474

childpos = brotherpos;

1476 if

( (*pqueue->ptrcomp)(last, pqueue->

[childpos]) <= 0 )

1486

assert(pos <= pqueue->len - 1);

1490#ifdef SCIP_MORE_DEBUG 1491

assert(pqueueHasHeapProperty(pqueue));

1502

assert(pqueue !=

);

1503

assert(pqueue->

>= 0);

1505 if

( pqueue->

== 0 )

1508

root = pqueue->

[0];

1520

assert(pqueue !=

);

1521

assert(pqueue->

>= 0);

1523 if

( pqueue->

== 0 )

1526 return

pqueue->

[0];

1534

assert(pqueue !=

);

1535

assert(pqueue->

>= 0);

1537 return

pqueue->

;

1545

assert(pqueue !=

);

1546

assert(pqueue->

>= 0);

1548 return

pqueue->

;

1561 if

( pqueue->

[pos] == elem )

1636 return

( (uint32_t) ((UINT64_C(0x9e3779b97f4a7c15) * input)>>32) ) | 1u;

1662

assert(multihashlist !=

);

1663

assert(blkmem !=

);

1664

assert(element !=

);

1668

newlist->

= *multihashlist;

1669

*multihashlist = newlist;

1684

assert(multihashlist !=

);

1685

assert(blkmem !=

);

1687

list = *multihashlist;

1688 while

( list !=

)

1690

nextlist = list->

;

1695

*multihashlist =

;

1710

uint64_t currentkeyval;

1713

assert(hashkeyeq !=

);

1714

assert(key !=

);

1716 while

( multihashlist !=

)

1718

currentkey = hashgetkey(userptr, multihashlist->

element

);

1719

currentkeyval = hashkeyval(userptr, currentkey);

1720 if

( currentkeyval == keyval && hashkeyeq(userptr, currentkey, key) )

1721 return

multihashlist;

1723

multihashlist = multihashlist->

;

1744 h

multihashlistFind

(multihashlist, hashgetkey, hashkeyeq, hashkeyval, userptr, keyval, key);

1752

h2 =

multihashlistFind

(

->next, hashgetkey, hashkeyeq, hashkeyval, userptr, keyval, key);

1759

key1 = hashgetkey(userptr,

->element);

1760

key2 = hashgetkey(userptr, h2->

element

);

1761

assert(hashkeyval(userptr, key1) == hashkeyval(userptr, key2));

1763 if

( hashkeyeq(userptr, key1, key2) )

1765 SCIPerrorMessage

(

"WARNING: hashkey with same value exists multiple times (e.g. duplicate constraint/variable names), so the return value is maybe not correct\n"

);

1794

assert(multihashlist !=

);

1797 h

multihashlistFind

(*multihashlist, hashgetkey, hashkeyeq, hashkeyval, userptr, keyval, key);

1802

*multihashlist =

->next;

1807

*multihashlist =

;

1822

assert(multihashlist !=

);

1823

assert(blkmem !=

);

1824

assert(element !=

);

1826 while

( *multihashlist !=

&& (*multihashlist)->element != element )

1827

multihashlist = &(*multihashlist)->

;

1829 if

( *multihashlist !=

)

1831

nextlist = (*multihashlist)->

;

1833

*multihashlist = nextlist;

1841#define SCIP_MULTIHASH_MAXSIZE 33554431 1842#define SCIP_MULTIHASH_RESIZE_PERCENTAGE 65 1843#define SCIP_MULTIHASH_GROW_FACTOR 1.31 1857

assert(multihash !=

);

1859

assert(multihash->

> 0);

1860

assert(multihash->hashgetkey !=

);

1861

assert(multihash->hashkeyeq !=

);

1862

assert(multihash->hashkeyval !=

);

1866

nnewlists =

(nnewlists, multihash->

);

1870 if

( nnewlists > multihash->

)

1875 unsigned int

hashval;

1880 for

( l = multihash->

- 1; l >= 0; --l )

1882

multihashlist = multihash->

[l];

1886 while

( multihashlist !=

)

1889

key = multihash->hashgetkey(multihash->

, multihashlist->

element

);

1890

keyval = multihash->hashkeyval(multihash->

, key);

1891

hashval = (

unsigned

int) (keyval % (

unsigned

) nnewlists);

1896 if

( multihashlist->

&& onlyone )

1899 if

( newlists[hashval] ==

)

1900

newlists[hashval] = multihashlist;

1907 while

( next !=

)

1910

next = next->

;

1913

lastnext->

= multihashlist;

1925

multihashlist = multihashlist->

;

1937

multihash->

= newlists;

1938

multihash->

= nnewlists;

1941#ifdef SCIP_MORE_DEBUG 1945 for

( l = 0; l < multihash->

; ++l )

1947

multihashlist = multihash->

[l];

1948 while

( multihashlist !=

)

1951

multihashlist = multihashlist->

;

1954

assert(sumslotsize == multihash->

);

1976

assert(tablesize >= 0);

1977

assert(multihash !=

);

1978

assert(hashgetkey !=

);

1979

assert(hashkeyeq !=

);

1980

assert(hashkeyval !=

);

1984

(*multihash)->blkmem = blkmem;

1985

(*multihash)->nlists = tablesize;

1986

(*multihash)->hashgetkey = hashgetkey;

1987

(*multihash)->hashkeyeq = hashkeyeq;

1988

(*multihash)->hashkeyval = hashkeyval;

1989

(*multihash)->userptr = userptr;

1990

(*multihash)->nelements = 0;

2005

assert(multihash !=

);

2006

assert(*multihash !=

);

2008

table = (*multihash);

2009

blkmem = table->

;

2010

lists = table->

;

2013 for

( i = table->

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

2034 unsigned int

hashval;

2036

assert(multihash !=

);

2038

assert(multihash->

> 0);

2039

assert(multihash->hashgetkey !=

);

2040

assert(multihash->hashkeyeq !=

);

2041

assert(multihash->hashkeyval !=

);

2042

assert(element !=

);

2051

key = multihash->hashgetkey(multihash->

, element);

2052

keyval = multihash->hashkeyval(multihash->

, key);

2053

hashval = (

unsigned

int) (keyval % (

unsigned

) multihash->

);

2073

assert(multihash !=

);

2074

assert(multihash->hashgetkey !=

);

2093 unsigned int

hashval;

2095

assert(multihash !=

);

2097

assert(multihash->

> 0);

2098

assert(multihash->hashgetkey !=

);

2099

assert(multihash->hashkeyeq !=

);

2100

assert(multihash->hashkeyval !=

);

2101

assert(key !=

);

2104

keyval = multihash->hashkeyval(multihash->

, key);

2105

hashval = (

unsigned

int) (keyval % (

unsigned

) multihash->

);

2108

multihash->hashkeyval, multihash->

, keyval, key);

2126

assert(multihash !=

);

2128

assert(multihash->

> 0);

2129

assert(multihash->hashgetkey !=

);

2130

assert(multihash->hashkeyeq !=

);

2131

assert(multihash->hashkeyval !=

);

2132

assert(multihashlist !=

);

2133

assert(key !=

);

2135

keyval = multihash->hashkeyval(multihash->

, key);

2137 if

( *multihashlist ==

)

2139 unsigned int

hashval;

2142

hashval = (

unsigned

int) (keyval % (

unsigned

) multihash->

);

2144

*multihashlist = multihash->

[hashval];

2148

multihash->hashkeyval, multihash->

, keyval, key);

2159 unsigned int

hashval;

2161

assert(multihash !=

);

2163

assert(multihash->

> 0);

2164

assert(multihash->hashgetkey !=

);

2165

assert(multihash->hashkeyeq !=

);

2166

assert(multihash->hashkeyval !=

);

2167

assert(element !=

);

2170

key = multihash->hashgetkey(multihash->

, element);

2171

keyval = multihash->hashkeyval(multihash->

, key);

2172

hashval = (

unsigned

int) (keyval % (

unsigned

) multihash->

);

2175

multihash->hashkeyval, multihash->

, keyval, key) !=

);

2186 unsigned int

hashval;

2188

assert(multihash !=

);

2190

assert(multihash->

> 0);

2191

assert(multihash->hashgetkey !=

);

2192

assert(multihash->hashkeyeq !=

);

2193

assert(multihash->hashkeyval !=

);

2194

assert(element !=

);

2197

key = multihash->hashgetkey(multihash->

, element);

2198

keyval = multihash->hashkeyval(multihash->

, key);

2199

hashval = (

unsigned

int) (keyval % (

unsigned

) multihash->

);

2221

assert(multihash !=

);

2223

blkmem = multihash->

;

2224

lists = multihash->

;

2227 for

( i = multihash->

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

2238

assert(multihash !=

);

2248

assert(multihash !=

);

2266

assert(multihash !=

);

2271 for

( i = 0; i < multihash->

; ++i )

2273

multihashlist = multihash->

[i];

2274 if

( multihashlist !=

)

2278 while

( multihashlist !=

)

2281

multihashlist = multihashlist->

;

2283

maxslotsize =

(maxslotsize, slotsize);

2284

sumslotsize += slotsize;

2287

assert(sumslotsize == multihash->

);

2292 if

( usedslots > 0 )

2309 unsigned int

nslots;

2314

assert(tablesize >= 0);

2315

assert(hashtable !=

);

2316

assert(hashgetkey !=

);

2317

assert(hashkeyeq !=

);

2318

assert(hashkeyval !=

);

2319

assert(blkmem !=

);

2328

(*hashtable)->shift = 32;

2329

(*hashtable)->shift -= (

unsigned

int)ceil(

LOG2

(

(32.0, tablesize / 0.9)));

2332

nslots = 1u << (32 - (*hashtable)->shift);

2335

(*hashtable)->mask = nslots - 1;

2338

(*hashtable)->blkmem = blkmem;

2339

(*hashtable)->hashgetkey = hashgetkey;

2340

(*hashtable)->hashkeyeq = hashkeyeq;

2341

(*hashtable)->hashkeyval = hashkeyval;

2342

(*hashtable)->userptr = userptr;

2343

(*hashtable)->nelements = 0;

2356

assert(hashtable !=

);

2357

assert(*hashtable !=

);

2359

nslots = (*hashtable)->

+ 1;

2362

uint32_t maxprobelen = 0;

2363

uint64_t probelensum = 0;

2366

assert(table !=

);

2368 for

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

2370 if

( table->

[i] != 0 )

2372

uint32_t probelen = ((i + table->

+ 1 - (table->

[i]>>(table->

))) & table->

) + 1;

2373

probelensum += probelen;

2374

maxprobelen =

(probelen, maxprobelen);

2379

(

unsigned int

)table->

, (

unsigned int

)table->

, (

unsigned int

)nslots,

2382 SCIPdebugMessage

(

", avg. probe length is %.1f, max. probe length is %u"

2409#define ELEM_DISTANCE(pos) (((pos) + hashtable->mask + 1 - (hashtable->hashes[(pos)]>>(hashtable->shift))) & hashtable->mask) 2421

uint32_t elemdistance;

2427

assert(hashtable !=

);

2430

assert(hashtable->

> 0);

2431

assert(hashtable->hashgetkey !=

);

2432

assert(hashtable->hashkeyeq !=

);

2433

assert(hashtable->hashkeyval !=

);

2434

assert(element !=

);

2436

pos = hashval>>(hashtable->

);

2443 if

( hashtable->

[pos] == 0 )

2445

hashtable->

[pos] = element;

2446

hashtable->

[pos] = hashval;

2451 if

( hashtable->

[pos] == hashval && hashtable->hashkeyeq(hashtable->

2452

hashtable->hashgetkey(hashtable->

, hashtable->

[pos]), key) )

2459

hashtable->

[pos] = element;

2460

hashtable->

[pos] = hashval;

2471 if

( distance < elemdistance )

2476

elemdistance = distance;

2479

hashval = hashtable->

[pos];

2480

hashtable->

[pos] = tmp;

2481

key = hashtable->hashgetkey(hashtable->

, element);

2490

pos = (pos + 1) & hashtable->

;

2501

assert(hashtable !=

);

2502

assert(hashtable->

< 32);

2505 if

( ((((uint64_t)hashtable->

)<<10)>>(32-hashtable->

) > 921) )

2514

nslots = hashtable->

+ 1;

2515

newnslots = 2*nslots;

2516

hashtable->

= newnslots-1;

2517

--hashtable->

;

2528 for

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

2533 if

( hashes[i] != 0 )

2559

assert(hashtable !=

);

2562

assert(hashtable->

> 0);

2563

assert(hashtable->hashgetkey !=

);

2564

assert(hashtable->hashkeyeq !=

);

2565

assert(hashtable->hashkeyval !=

);

2566

assert(element !=

);

2571

key = hashtable->hashgetkey(hashtable->

, element);

2572

keyval = hashtable->hashkeyval(hashtable->

, key);

2591

assert(hashtable !=

);

2594

assert(hashtable->

> 0);

2595

assert(hashtable->hashgetkey !=

);

2596

assert(hashtable->hashkeyeq !=

);

2597

assert(hashtable->hashkeyval !=

);

2598

assert(element !=

);

2603

key = hashtable->hashgetkey(hashtable->

, element);

2604

keyval = hashtable->hashkeyval(hashtable->

, key);

2619

uint32_t elemdistance;

2621

assert(hashtable !=

);

2624

assert(hashtable->

> 0);

2625

assert(hashtable->hashgetkey !=

);

2626

assert(hashtable->hashkeyeq !=

);

2627

assert(hashtable->hashkeyval !=

);

2628

assert(key !=

);

2631

keyval = hashtable->hashkeyval(hashtable->

, key);

2634

pos = hashval>>(hashtable->

);

2642 if

( hashtable->

[pos] == 0 )

2648 if

( elemdistance > distance )

2652 if

( hashtable->

[pos] == hashval && hashtable->hashkeyeq(hashtable->

2653

hashtable->hashgetkey(hashtable->

, hashtable->

[pos]), key) )

2654 return

hashtable->

[pos];

2656

pos = (pos + 1) & hashtable->

;

2667

assert(hashtable !=

);

2670

assert(hashtable->

> 0);

2671

assert(hashtable->hashgetkey !=

);

2672

assert(hashtable->hashkeyeq !=

);

2673

assert(hashtable->hashkeyval !=

);

2674

assert(element !=

);

2688

uint32_t elemdistance;

2692

assert(hashtable !=

);

2695

assert(hashtable->

> 0);

2696

assert(hashtable->hashgetkey !=

);

2697

assert(hashtable->hashkeyeq !=

);

2698

assert(hashtable->hashkeyval !=

);

2699

assert(element !=

);

2702

key = hashtable->hashgetkey(hashtable->

, element);

2703

keyval = hashtable->hashkeyval(hashtable->

, key);

2707

pos = hashval>>(hashtable->

);

2711 if

( hashtable->

[pos] == 0 )

2717 if

( elemdistance > distance )

2720 if

( hashtable->

[pos] == hashval && hashtable->hashkeyeq(hashtable->

2721

hashtable->hashgetkey(hashtable->

, hashtable->

[pos]), key) )

2727

pos = (pos + 1) & hashtable->

;

2732

hashtable->

[pos] = 0;

2736

uint32_t nextpos = (pos + 1) & hashtable->

;

2739 if

( hashtable->

[nextpos] == 0 )

2743 if

( (hashtable->

[nextpos]>>(hashtable->

)) == nextpos )

2747

hashtable->

[pos] = hashtable->

[nextpos];

2748

hashtable->

[pos] = hashtable->

[nextpos];

2749

hashtable->

[nextpos] = 0;

2762

assert(hashtable !=

);

2774

assert(hashtable !=

);

2784 return

(

int

) hashtable->

+ 1;

2793 return

hashtable->

[entryidx] == 0 ?

: hashtable->

[entryidx];

2801

assert(hashtable !=

);

2812

uint32_t maxprobelen = 0;

2813

uint64_t probelensum = 0;

2817

assert(hashtable !=

);

2819

nslots = hashtable->

+ 1;

2822 for

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

2824 if

( hashtable->

[i] != 0 )

2827

probelensum += probelen;

2828

maxprobelen =

(probelen, maxprobelen);

2847 const char

* string1 = (

const char

*)key1;

2848 const char

* string2 = (

const char

*)key2;

2850 return

(strcmp(string1, string2) == 0);

2859

str = (

const char

*)key;

2861 while

( *str !=

'\0'

)

2864

hash += (

unsigned

int)(*str);

2882 return

(key1 == key2);

2889 return

(uint64_t) (uintptr_t) key;

2901#define ELEM_DISTANCE(pos) (((pos) + hashmap->mask + 1 - (hashmap->hashes[(pos)]>>(hashmap->shift))) & hashmap->mask) 2913

uint32_t elemdistance;

2916

assert(hashmap !=

);

2919

assert(hashmap->

> 0);

2920

assert(hashval != 0);

2922

pos = hashval>>(hashmap->

);

2929 if

( hashmap->

[pos] == 0 )

2933

hashmap->

[pos] = hashval;

2938 if

( hashval == hashmap->

[pos] && origin == hashmap->

[pos].

origin

)

2944

hashmap->

[pos] = hashval;

2955 if

( distance < elemdistance )

2961

elemdistance = distance;

2963

hashval = hashmap->

[pos];

2964

hashmap->

[pos] = tmphash;

2972

pos = (pos + 1) & hashmap->

;

2988

uint32_t elemdistance;

2990

assert(hashmap !=

);

2993

assert(hashmap->

> 0);

2997

assert(hashval != 0);

2999

*pos = hashval>>(hashmap->

);

3007 if

( hashmap->

[*pos] == 0 )

3012 if

( elemdistance > distance )

3016 if

( hashmap->

[*pos] == hashval && hashmap->

[*pos].

origin

== origin )

3019

*pos = (*pos + 1) & hashmap->

;

3030

assert(hashmap !=

);

3031

assert(hashmap->

< 32);

3034 if

( ((((uint64_t)hashmap->

)<<10)>>(32-hashmap->

) > 921) )

3043

nslots = hashmap->

+ 1;

3045

newnslots = 2*nslots;

3046

hashmap->

= newnslots-1;

3057 for

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

3062 if

( hashes[i] != 0 )

3085

assert(hashmap !=

);

3086

assert(mapsize >= 0);

3087

assert(blkmem !=

);

3096

(*hashmap)->shift = 32;

3097

(*hashmap)->shift -= (

unsigned

int)ceil(log(

(32, mapsize / 0.9)) / log(2.0));

3098

nslots = 1u << (32 - (*hashmap)->shift);

3099

(*hashmap)->mask = nslots - 1;

3100

(*hashmap)->blkmem = blkmem;

3101

(*hashmap)->nelements = 0;

3117

assert(hashmap !=

);

3118

assert(*hashmap !=

);

3120

nslots = (*hashmap)->mask + 1;

3123

uint32_t maxprobelen = 0;

3124

uint64_t probelensum = 0;

3127

assert(hashmap !=

);

3129 for

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

3131 if

( (*hashmap)->hashes[i] != 0 )

3133

uint32_t probelen = ((i + (*hashmap)->mask + 1 - ((*hashmap)->hashes[i]>>((*hashmap)->shift))) & (*hashmap)->mask) + 1;

3134

probelensum += probelen;

3135

maxprobelen =

(probelen, maxprobelen);

3140

(

unsigned int

)(*hashmap)->nelements, (

unsigned int

)(*hashmap)->nelements, (

unsigned int

)nslots,

3142 if

( (*hashmap)->nelements > 0 )

3143 SCIPdebugPrintf

(

", avg. probe length is %.1f, max. probe length is %u"

3144

(

SCIP_Real

)(probelensum)/(

SCIP_Real

)(*hashmap)->nelements, (

unsigned int

)maxprobelen);

3168

assert(hashmap !=

);

3171

assert(hashmap->

> 0);

3204

assert(hashmap !=

);

3207

assert(hashmap->

> 0);

3240

assert(hashmap !=

);

3243

assert(hashmap->

> 0);

3271

assert(hashmap !=

);

3274

assert(hashmap->

> 0);

3291

assert(hashmap !=

);

3294

assert(hashmap->

> 0);

3311

assert(hashmap !=

);

3314

assert(hashmap->

> 0);

3335

assert(hashmap !=

);

3337

assert(hashmap->

> 0);

3369

assert(hashmap !=

);

3371

assert(hashmap->

> 0);

3403

assert(hashmap !=

);

3405

assert(hashmap->

> 0);

3433

assert(hashmap !=

);

3436

assert(hashmap->

> 0);

3449

assert(hashmap !=

);

3451

assert(hashmap->

> 0);

3453

assert(origin !=

);

3458

hashmap->

[pos] = 0;

3464

uint32_t nextpos = (pos + 1) & hashmap->

;

3467 if

( hashmap->

[nextpos] == 0 )

3471 if

( (hashmap->

[nextpos]>>(hashmap->

)) == nextpos )

3478

hashmap->

[nextpos] = 0;

3493

uint32_t maxprobelen = 0;

3494

uint64_t probelensum = 0;

3498

assert(hashmap !=

);

3500

nslots = hashmap->

+ 1;

3503 for

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

3505 if

( hashmap->

[i] != 0 )

3508

probelensum += probelen;

3509

maxprobelen =

(probelen, maxprobelen);

3530

assert(hashmap !=

);

3548 return

(

int

) hashmap->

+ 1;

3557

assert(hashmap !=

);

3559 return

hashmap->

[entryidx] == 0 ?

: &hashmap->

[entryidx];

3567

assert(entry !=

);

3577

assert(entry !=

);

3587

assert(entry !=

);

3597

assert(entry !=

);

3608

assert(entry !=

);

3619

assert(entry !=

);

3630

assert(entry !=

);

3640

assert(hashmap !=

);

3657#define ELEM_DISTANCE(pos) (((pos) + nslots - hashSetDesiredPos(hashset, hashset->slots[(pos)])) & mask) 3666 return

(uint32_t)((UINT64_C(0x9e3779b97f4a7c15) * (uintptr_t)element)>>(hashset->

));

3675

uint32_t elemdistance;

3680

assert(hashset !=

);

3682

assert(element !=

);

3696

hashset->

[pos] = element;

3701 if

( hashset->

[pos] == element )

3706 if

( distance < elemdistance )

3709

elemdistance = distance;

3714

pos = (pos + 1) & mask;

3726

assert(hashset !=

);

3727

assert(hashset->

< 64);

3730 if

( ((((uint64_t)hashset->

)<<10)>>(64-hashset->

) > 921) )

3739

newnslots = 2*nslots;

3749 for

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

3751 if

( slots[i] !=

)

3771

assert(hashset !=

);

3773

assert(blkmem !=

);

3782

(*hashset)->shift = 64;

3783

(*hashset)->shift -= (

unsigned

int)ceil(log(

(8.0, size / 0.9)) / log(2.0));

3785

(*hashset)->nelements = 0;

3809

assert(hashset !=

);

3828

uint32_t elemdistance;

3830

assert(hashset !=

);

3843 if

( hashset->

[pos] == element )

3852 if

( elemdistance > distance )

3855

pos = (pos + 1) & mask;

3869

uint32_t elemdistance;

3871

assert(hashset !=

);

3873

assert(element !=

);

3885 if

( hashset->

[pos] == element )

3894 if

( elemdistance > distance )

3897

pos = (pos + 1) & mask;

3901

assert(hashset->

[pos] == element);

3910

uint32_t nextpos = (pos + 1) & mask;

3913 if

( hashset->

[nextpos] ==

)

3929

hashset->

[pos] = hashset->

[nextpos];

3941

uint32_t maxprobelen = 0;

3942

uint64_t probelensum = 0;

3947

assert(hashset !=

);

3953 for

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

3958

probelensum += probelen;

3959

maxprobelen =

(probelen, maxprobelen);

3981#undef SCIPhashsetIsEmpty 3982#undef SCIPhashsetGetNElements 3983#undef SCIPhashsetGetNSlots 3984#undef SCIPhashsetGetSlots 4007 return

(

int

) (1u << (64 - hashset->

));

4015 return

hashset->

;

4038

assert(realarray !=

);

4039

assert(blkmem !=

);

4042

(*realarray)->blkmem = blkmem;

4043

(*realarray)->vals =

;

4044

(*realarray)->valssize = 0;

4045

(*realarray)->firstidx = -1;

4046

(*realarray)->minusedidx = INT_MAX;

4047

(*realarray)->maxusedidx = INT_MIN;

4059

assert(realarray !=

);

4060

assert(sourcerealarray !=

);

4063 if

( sourcerealarray->

> 0 )

4068

(*realarray)->valssize = sourcerealarray->

;

4069

(*realarray)->firstidx = sourcerealarray->

;

4070

(*realarray)->minusedidx = sourcerealarray->

;

4071

(*realarray)->maxusedidx = sourcerealarray->

;

4081

assert(realarray !=

);

4082

assert(*realarray !=

);

4104

assert(realarray !=

);

4109

assert(0 <= minidx);

4110

assert(minidx <= maxidx);

4114

assert(0 <= minidx);

4115

assert(minidx <= maxidx);

4117 SCIPdebugMessage

(

"extending realarray %p (firstidx=%d, size=%d, range=[%d,%d]) to range [%d,%d]\n"

4121

nused = maxidx - minidx + 1;

4122 if

( nused > realarray->

)

4128

newvalssize =

(arraygrowinit, arraygrowfac, nused);

4130

nfree = newvalssize - nused;

4131

newfirstidx = minidx - nfree/2;

4132

newfirstidx =

(newfirstidx, 0);

4133

assert(newfirstidx <= minidx);

4134

assert(maxidx < newfirstidx + newvalssize);

4139 for

( i = 0; i < realarray->

- newfirstidx; ++i )

4148 for

( i = realarray->

- newfirstidx + 1; i < newvalssize; ++i )

4153 for

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

4159

realarray->

= newvals;

4160

realarray->

= newvalssize;

4161

realarray->

= newfirstidx;

4163 else if

( realarray->

== -1 )

4166

nfree = realarray->

- nused;

4168

realarray->

= minidx - nfree/2;

4169

assert(realarray->

<= minidx);

4170

assert(maxidx < realarray->firstidx + realarray->

);

4172 for

( i = 0; i < realarray->

; ++i )

4173

assert(realarray->

[i] == 0.0);

4176 else if

( minidx < realarray->firstidx )

4179

nfree = realarray->

- nused;

4181

newfirstidx = minidx - nfree/2;

4182

newfirstidx =

(newfirstidx, 0);

4183

assert(newfirstidx <= minidx);

4184

assert(maxidx < newfirstidx + realarray->valssize);

4194

shift = realarray->

- newfirstidx;

4198

assert(0 <= i + shift && i + shift < realarray->valssize);

4199

realarray->

[i + shift] = realarray->

[i];

4202 for

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

4205

realarray->

= newfirstidx;

4210

nfree = realarray->

- nused;

4212

newfirstidx = minidx - nfree/2;

4213

newfirstidx =

(newfirstidx, 0);

4214

assert(newfirstidx <= minidx);

4215

assert(maxidx < newfirstidx + realarray->valssize);

4225

shift = newfirstidx - realarray->

;

4229

assert(0 <= i - shift && i - shift < realarray->valssize);

4230

realarray->

[i - shift] = realarray->

[i];

4233 for

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

4236

realarray->

= newfirstidx;

4239

assert(minidx >= realarray->

);

4240

assert(maxidx < realarray->firstidx + realarray->

);

4250

assert(realarray !=

);

4252 SCIPdebugMessage

(

"clearing realarray %p (firstidx=%d, size=%d, range=[%d,%d])\n"

4259

assert(realarray->

!= -1);

4282

assert(realarray !=

);

4285 if

( idx < realarray->minusedidx || idx > realarray->

)

4290

assert(idx - realarray->

>= 0);

4306

assert(realarray !=

);

4309 SCIPdebugMessage

(

"setting realarray %p (firstidx=%d, size=%d, range=[%d,%d]) index %d to %g\n"

4316

assert(idx >= realarray->

);

4317

assert(idx < realarray->firstidx + realarray->

);

4326 else if

( idx >= realarray->

&& idx < realarray->firstidx + realarray->

)

4379 return SCIPrealarraySetVal

(realarray, arraygrowinit, arraygrowfac, idx, oldval + incval);

4389

assert(realarray !=

);

4399

assert(realarray !=

);

4410

assert(intarray !=

);

4411

assert(blkmem !=

);

4414

(*intarray)->blkmem = blkmem;

4415

(*intarray)->vals =

;

4416

(*intarray)->valssize = 0;

4417

(*intarray)->firstidx = -1;

4418

(*intarray)->minusedidx = INT_MAX;

4419

(*intarray)->maxusedidx = INT_MIN;

4431

assert(intarray !=

);

4432

assert(sourceintarray !=

);

4435 if

( sourceintarray->

> 0 )

4439

(*intarray)->valssize = sourceintarray->

;

4440

(*intarray)->firstidx = sourceintarray->

;

4441

(*intarray)->minusedidx = sourceintarray->

;

4442

(*intarray)->maxusedidx = sourceintarray->

;

4452

assert(intarray !=

);

4453

assert(*intarray !=

);

4475

assert(intarray !=

);

4480

assert(0 <= minidx);

4481

assert(minidx <= maxidx);

4485

assert(0 <= minidx);

4486

assert(minidx <= maxidx);

4488 SCIPdebugMessage

(

"extending intarray %p (firstidx=%d, size=%d, range=[%d,%d]) to range [%d,%d]\n"

4492

nused = maxidx - minidx + 1;

4499

newvalssize =

(arraygrowinit, arraygrowfac, nused);

4501

nfree = newvalssize - nused;

4502

newfirstidx = minidx - nfree/2;

4503

newfirstidx =

(newfirstidx, 0);

4504

assert(newfirstidx <= minidx);

4505

assert(maxidx < newfirstidx + newvalssize);

4510 for

( i = 0; i < intarray->

- newfirstidx; ++i )

4519 for

( i = intarray->

- newfirstidx + 1; i < newvalssize; ++i )

4524 for

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

4530

intarray->

= newvals;

4534 else if

( intarray->

== -1 )

4537

nfree = intarray->

- nused;

4539

intarray->

= minidx - nfree/2;

4540

assert(intarray->

<= minidx);

4541

assert(maxidx < intarray->firstidx + intarray->

);

4543 for

( i = 0; i < intarray->

; ++i )

4544

assert(intarray->

[i] == 0);

4547 else if

( minidx < intarray->firstidx )

4550

nfree = intarray->

- nused;

4552

newfirstidx = minidx - nfree/2;

4553

newfirstidx =

(newfirstidx, 0);

4554

assert(newfirstidx <= minidx);

4555

assert(maxidx < newfirstidx + intarray->valssize);

4565

shift = intarray->

- newfirstidx;

4569

assert(0 <= i + shift && i + shift < intarray->valssize);

4570

intarray->

[i + shift] = intarray->

[i];

4573 for

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

4581

nfree = intarray->

- nused;

4583

newfirstidx = minidx - nfree/2;

4584

newfirstidx =

(newfirstidx, 0);

4585

assert(newfirstidx <= minidx);

4586

assert(maxidx < newfirstidx + intarray->valssize);

4596

shift = newfirstidx - intarray->

;

4600

assert(0 <= i - shift && i - shift < intarray->valssize);

4601

intarray->

[i - shift] = intarray->

[i];

4604 for

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

4610

assert(minidx >= intarray->

);

4611

assert(maxidx < intarray->firstidx + intarray->

);

4621

assert(intarray !=

);

4623 SCIPdebugMessage

(

"clearing intarray %p (firstidx=%d, size=%d, range=[%d,%d])\n"

4653

assert(intarray !=

);

4656 if

( idx < intarray->minusedidx || idx > intarray->

)

4661

assert(idx - intarray->

>= 0);

4677

assert(intarray !=

);

4680 SCIPdebugMessage

(

"setting intarray %p (firstidx=%d, size=%d, range=[%d,%d]) index %d to %d\n"

4687

assert(idx >= intarray->

);

4688

assert(idx < intarray->firstidx + intarray->

);

4697 else if

( idx >= intarray->

&& idx < intarray->firstidx + intarray->

)

4753

assert(intarray !=

);

4763

assert(intarray !=

);

4775

assert(boolarray !=

);

4776

assert(blkmem !=

);

4779

(*boolarray)->blkmem = blkmem;

4780

(*boolarray)->vals =

;

4781

(*boolarray)->valssize = 0;

4782

(*boolarray)->firstidx = -1;

4783

(*boolarray)->minusedidx = INT_MAX;

4784

(*boolarray)->maxusedidx = INT_MIN;

4796

assert(boolarray !=

);

4797

assert(sourceboolarray !=

);

4800 if

( sourceboolarray->

> 0 )

4805

(*boolarray)->valssize = sourceboolarray->

;

4806

(*boolarray)->firstidx = sourceboolarray->

;

4807

(*boolarray)->minusedidx = sourceboolarray->

;

4808

(*boolarray)->maxusedidx = sourceboolarray->

;

4818

assert(boolarray !=

);

4819

assert(*boolarray !=

);

4841

assert(boolarray !=

);

4846

assert(0 <= minidx);

4847

assert(minidx <= maxidx);

4851

assert(0 <= minidx);

4852

assert(minidx <= maxidx);

4854 SCIPdebugMessage

(

"extending boolarray %p (firstidx=%d, size=%d, range=[%d,%d]) to range [%d,%d]\n"

4858

nused = maxidx - minidx + 1;

4859 if

( nused > boolarray->

)

4865

newvalssize =

(arraygrowinit, arraygrowfac, nused);

4867

nfree = newvalssize - nused;

4868

newfirstidx = minidx - nfree/2;

4869

newfirstidx =

(newfirstidx, 0);

4870

assert(newfirstidx <= minidx);

4871

assert(maxidx < newfirstidx + newvalssize);

4876 for

( i = 0; i < boolarray->

- newfirstidx; ++i )

4877

newvals[i] =

;

4885 for

( i = boolarray->

- newfirstidx + 1; i < newvalssize; ++i )

4886

newvals[i] =

;

4890 for

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

4891

newvals[i] =

;

4896

boolarray->

= newvals;

4897

boolarray->

= newvalssize;

4898

boolarray->

= newfirstidx;

4900 else if

( boolarray->

== -1 )

4903

nfree = boolarray->

- nused;

4905

boolarray->

= minidx - nfree/2;

4906

assert(boolarray->

<= minidx);

4907

assert(maxidx < boolarray->firstidx + boolarray->

);

4909 for

( i = 0; i < boolarray->

; ++i )

4913 else if

( minidx < boolarray->firstidx )

4916

nfree = boolarray->

- nused;

4918

newfirstidx = minidx - nfree/2;

4919

newfirstidx =

(newfirstidx, 0);

4920

assert(newfirstidx <= minidx);

4921

assert(maxidx < newfirstidx + boolarray->valssize);

4931

shift = boolarray->

- newfirstidx;

4935

assert(0 <= i + shift && i + shift < boolarray->valssize);

4936

boolarray->

[i + shift] = boolarray->

[i];

4939 for

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

4942

boolarray->

= newfirstidx;

4947

nfree = boolarray->

- nused;

4949

newfirstidx = minidx - nfree/2;

4950

newfirstidx =

(newfirstidx, 0);

4951

assert(newfirstidx <= minidx);

4952

assert(maxidx < newfirstidx + boolarray->valssize);

4962

shift = newfirstidx - boolarray->

;

4972 for

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

4975

boolarray->

= newfirstidx;

4978

assert(minidx >= boolarray->

);

4979

assert(maxidx < boolarray->firstidx + boolarray->

);

4989

assert(boolarray !=

);

4991 SCIPdebugMessage

(

"clearing boolarray %p (firstidx=%d, size=%d, range=[%d,%d])\n"

4998

assert(boolarray->

!= -1);

5021

assert(boolarray !=

);

5024 if

( idx < boolarray->minusedidx || idx > boolarray->

)

5029

assert(idx - boolarray->

>= 0);

5045

assert(boolarray !=

);

5048 SCIPdebugMessage

(

"setting boolarray %p (firstidx=%d, size=%d, range=[%d,%d]) index %d to %u\n"

5055

assert(idx >= boolarray->

);

5056

assert(idx < boolarray->firstidx + boolarray->

);

5065 else if

( idx >= boolarray->

&& idx < boolarray->firstidx + boolarray->

)

5109

assert(boolarray !=

);

5119

assert(boolarray !=

);

5131

assert(ptrarray !=

);

5132

assert(blkmem !=

);

5135

(*ptrarray)->blkmem = blkmem;

5136

(*ptrarray)->vals =

;

5137

(*ptrarray)->valssize = 0;

5138

(*ptrarray)->firstidx = -1;

5139

(*ptrarray)->minusedidx = INT_MAX;

5140

(*ptrarray)->maxusedidx = INT_MIN;

5152

assert(ptrarray !=

);

5153

assert(sourceptrarray !=

);

5156 if

( sourceptrarray->

> 0 )

5160

(*ptrarray)->valssize = sourceptrarray->

;

5161

(*ptrarray)->firstidx = sourceptrarray->

;

5162

(*ptrarray)->minusedidx = sourceptrarray->

;

5163

(*ptrarray)->maxusedidx = sourceptrarray->

;

5173

assert(ptrarray !=

);

5174

assert(*ptrarray !=

);

5196

assert(ptrarray !=

);

5201

assert(0 <= minidx);

5202

assert(minidx <= maxidx);

5206

assert(0 <= minidx);

5207

assert(minidx <= maxidx);

5209 SCIPdebugMessage

(

"extending ptrarray %p (firstidx=%d, size=%d, range=[%d,%d]) to range [%d,%d]\n"

5213

nused = maxidx - minidx + 1;

5220

newvalssize =

(arraygrowinit, arraygrowfac, nused);

5222

nfree = newvalssize - nused;

5223

newfirstidx = minidx - nfree/2;

5224

newfirstidx =

(newfirstidx, 0);

5225

assert(newfirstidx <= minidx);

5226

assert(maxidx < newfirstidx + newvalssize);

5231 for

( i = 0; i < ptrarray->

- newfirstidx; ++i )

5240 for

( i = ptrarray->

- newfirstidx + 1; i < newvalssize; ++i )

5245 for

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

5251

ptrarray->

= newvals;

5255 else if

( ptrarray->

== -1 )

5258

nfree = ptrarray->

- nused;

5260

ptrarray->

= minidx - nfree/2;

5261

assert(ptrarray->

<= minidx);

5262

assert(maxidx < ptrarray->firstidx + ptrarray->

);

5264 for

( i = 0; i < ptrarray->

; ++i )

5265

assert(ptrarray->

[i] ==

);

5268 else if

( minidx < ptrarray->firstidx )

5271

nfree = ptrarray->

- nused;

5273

newfirstidx = minidx - nfree/2;

5274

newfirstidx =

(newfirstidx, 0);

5275

assert(newfirstidx <= minidx);

5276

assert(maxidx < newfirstidx + ptrarray->valssize);

5286

shift = ptrarray->

- newfirstidx;

5290

assert(0 <= i + shift && i + shift < ptrarray->valssize);

5291

ptrarray->

[i + shift] = ptrarray->

[i];

5294 for

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

5302

nfree = ptrarray->

- nused;

5304

newfirstidx = minidx - nfree/2;

5305

newfirstidx =

(newfirstidx, 0);

5306

assert(newfirstidx <= minidx);

5307

assert(maxidx < newfirstidx + ptrarray->valssize);

5317

shift = newfirstidx - ptrarray->

;

5321

assert(0 <= i - shift && i - shift < ptrarray->valssize);

5322

ptrarray->

[i - shift] = ptrarray->

[i];

5325 for

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

5331

assert(minidx >= ptrarray->

);

5332

assert(maxidx < ptrarray->firstidx + ptrarray->

);

5342

assert(ptrarray !=

);

5344 SCIPdebugMessage

(

"clearing ptrarray %p (firstidx=%d, size=%d, range=[%d,%d])\n"

5374

assert(ptrarray !=

);

5377 if

( idx < ptrarray->minusedidx || idx > ptrarray->

)

5382

assert(idx - ptrarray->

>= 0);

5398

assert(ptrarray !=

);

5401 SCIPdebugMessage

(

"setting ptrarray %p (firstidx=%d, size=%d, range=[%d,%d]) index %d to %p\n"

5408

assert(idx >= ptrarray->

);

5409

assert(idx < ptrarray->firstidx + ptrarray->

);

5418 else if

( idx >= ptrarray->

&& idx < ptrarray->firstidx + ptrarray->

)

5462

assert(ptrarray !=

);

5472

assert(ptrarray !=

);

5488

value1 = (int)(

size_t

)elem1;

5489

value2 = (int)(

size_t

)elem2;

5491 if

( value1 < value2 )

5494 if

( value2 < value1 )

5507

args = (

int

*) dataptr;

5509 if

( args[ind1] < args[ind2] )

5512 if

( args[ind1] > args[ind2] )

5526

args = (

void

*) dataptr;

5528 if

( args[ind1] < args[ind2] )

5531 if

( args[ind1] > args[ind2] )

5550

assert(indcomp !=

);

5551

assert(len == 0 || perm !=

);

5554 for

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

5561#define SORTTPL_NAMEEXT Ind 5562#define SORTTPL_KEYTYPE int 5563#define SORTTPL_INDCOMP 5568#define SORTTPL_NAMEEXT Ptr 5569#define SORTTPL_KEYTYPE void* 5570#define SORTTPL_PTRCOMP 5575#define SORTTPL_NAMEEXT PtrPtr 5576#define SORTTPL_KEYTYPE void* 5577#define SORTTPL_FIELD1TYPE void* 5578#define SORTTPL_PTRCOMP 5583#define SORTTPL_NAMEEXT PtrReal 5584#define SORTTPL_KEYTYPE void* 5585#define SORTTPL_FIELD1TYPE SCIP_Real 5586#define SORTTPL_PTRCOMP 5591#define SORTTPL_NAMEEXT PtrInt 5592#define SORTTPL_KEYTYPE void* 5593#define SORTTPL_FIELD1TYPE int 5594#define SORTTPL_PTRCOMP 5599#define SORTTPL_NAMEEXT PtrBool 5600#define SORTTPL_KEYTYPE void* 5601#define SORTTPL_FIELD1TYPE SCIP_Bool 5602#define SORTTPL_PTRCOMP 5607#define SORTTPL_NAMEEXT PtrIntInt 5608#define SORTTPL_KEYTYPE void* 5609#define SORTTPL_FIELD1TYPE int 5610#define SORTTPL_FIELD2TYPE int 5611#define SORTTPL_PTRCOMP 5616#define SORTTPL_NAMEEXT PtrRealInt 5617#define SORTTPL_KEYTYPE void* 5618#define SORTTPL_FIELD1TYPE SCIP_Real 5619#define SORTTPL_FIELD2TYPE int 5620#define SORTTPL_PTRCOMP 5624#define SORTTPL_NAMEEXT PtrRealRealInt 5625#define SORTTPL_KEYTYPE void* 5626#define SORTTPL_FIELD1TYPE SCIP_Real 5627#define SORTTPL_FIELD2TYPE SCIP_Real 5628#define SORTTPL_FIELD3TYPE int 5629#define SORTTPL_PTRCOMP 5633#define SORTTPL_NAMEEXT PtrRealRealBoolBool 5634#define SORTTPL_KEYTYPE void* 5635#define SORTTPL_FIELD1TYPE SCIP_Real 5636#define SORTTPL_FIELD2TYPE SCIP_Real 5637#define SORTTPL_FIELD3TYPE SCIP_Bool 5638#define SORTTPL_FIELD4TYPE SCIP_Bool 5639#define SORTTPL_PTRCOMP 5643#define SORTTPL_NAMEEXT PtrRealRealIntBool 5644#define SORTTPL_KEYTYPE void* 5645#define SORTTPL_FIELD1TYPE SCIP_Real 5646#define SORTTPL_FIELD2TYPE SCIP_Real 5647#define SORTTPL_FIELD3TYPE int 5648#define SORTTPL_FIELD4TYPE SCIP_Bool 5649#define SORTTPL_PTRCOMP 5653#define SORTTPL_NAMEEXT PtrRealBool 5654#define SORTTPL_KEYTYPE void* 5655#define SORTTPL_FIELD1TYPE SCIP_Real 5656#define SORTTPL_FIELD2TYPE SCIP_Bool 5657#define SORTTPL_PTRCOMP 5662#define SORTTPL_NAMEEXT PtrPtrInt 5663#define SORTTPL_KEYTYPE void* 5664#define SORTTPL_FIELD1TYPE void* 5665#define SORTTPL_FIELD2TYPE int 5666#define SORTTPL_PTRCOMP 5671#define SORTTPL_NAMEEXT PtrPtrReal 5672#define SORTTPL_KEYTYPE void* 5673#define SORTTPL_FIELD1TYPE void* 5674#define SORTTPL_FIELD2TYPE SCIP_Real 5675#define SORTTPL_PTRCOMP 5680#define SORTTPL_NAMEEXT PtrRealIntInt 5681#define SORTTPL_KEYTYPE void* 5682#define SORTTPL_FIELD1TYPE SCIP_Real 5683#define SORTTPL_FIELD2TYPE int 5684#define SORTTPL_FIELD3TYPE int 5685#define SORTTPL_PTRCOMP 5690#define SORTTPL_NAMEEXT PtrPtrIntInt 5691#define SORTTPL_KEYTYPE void* 5692#define SORTTPL_FIELD1TYPE void* 5693#define SORTTPL_FIELD2TYPE int 5694#define SORTTPL_FIELD3TYPE int 5695#define SORTTPL_PTRCOMP 5700#define SORTTPL_NAMEEXT PtrPtrRealInt 5701#define SORTTPL_KEYTYPE void* 5702#define SORTTPL_FIELD1TYPE void* 5703#define SORTTPL_FIELD2TYPE SCIP_Real 5704#define SORTTPL_FIELD3TYPE int 5705#define SORTTPL_PTRCOMP 5710#define SORTTPL_NAMEEXT PtrPtrRealBool 5711#define SORTTPL_KEYTYPE void* 5712#define SORTTPL_FIELD1TYPE void* 5713#define SORTTPL_FIELD2TYPE SCIP_Real 5714#define SORTTPL_FIELD3TYPE SCIP_Bool 5715#define SORTTPL_PTRCOMP 5720#define SORTTPL_NAMEEXT PtrPtrLongInt 5721#define SORTTPL_KEYTYPE void* 5722#define SORTTPL_FIELD1TYPE void* 5723#define SORTTPL_FIELD2TYPE SCIP_Longint 5724#define SORTTPL_FIELD3TYPE int 5725#define SORTTPL_PTRCOMP 5730#define SORTTPL_NAMEEXT PtrPtrLongIntInt 5731#define SORTTPL_KEYTYPE void* 5732#define SORTTPL_FIELD1TYPE void* 5733#define SORTTPL_FIELD2TYPE SCIP_Longint 5734#define SORTTPL_FIELD3TYPE int 5735#define SORTTPL_FIELD4TYPE int 5736#define SORTTPL_PTRCOMP 5741#define SORTTPL_NAMEEXT Real 5742#define SORTTPL_KEYTYPE SCIP_Real 5747#define SORTTPL_NAMEEXT RealBoolPtr 5748#define SORTTPL_KEYTYPE SCIP_Real 5749#define SORTTPL_FIELD1TYPE SCIP_Bool 5750#define SORTTPL_FIELD2TYPE void* 5755#define SORTTPL_NAMEEXT RealPtr 5756#define SORTTPL_KEYTYPE SCIP_Real 5757#define SORTTPL_FIELD1TYPE void* 5762#define SORTTPL_NAMEEXT RealInt 5763#define SORTTPL_KEYTYPE SCIP_Real 5764#define SORTTPL_FIELD1TYPE int 5769#define SORTTPL_NAMEEXT RealIntInt 5770#define SORTTPL_KEYTYPE SCIP_Real 5771#define SORTTPL_FIELD1TYPE int 5772#define SORTTPL_FIELD2TYPE int 5777#define SORTTPL_NAMEEXT RealIntLong 5778#define SORTTPL_KEYTYPE SCIP_Real 5779#define SORTTPL_FIELD1TYPE int 5780#define SORTTPL_FIELD2TYPE SCIP_Longint 5785#define SORTTPL_NAMEEXT RealIntPtr 5786#define SORTTPL_KEYTYPE SCIP_Real 5787#define SORTTPL_FIELD1TYPE int 5788#define SORTTPL_FIELD2TYPE void* 5793#define SORTTPL_NAMEEXT RealRealPtr 5794#define SORTTPL_KEYTYPE SCIP_Real 5795#define SORTTPL_FIELD1TYPE SCIP_Real 5796#define SORTTPL_FIELD2TYPE void* 5801#define SORTTPL_NAMEEXT RealLongRealInt 5802#define SORTTPL_KEYTYPE SCIP_Real 5803#define SORTTPL_FIELD1TYPE SCIP_Longint 5804#define SORTTPL_FIELD2TYPE SCIP_Real 5805#define SORTTPL_FIELD3TYPE int 5809#define SORTTPL_NAMEEXT RealRealIntInt 5810#define SORTTPL_KEYTYPE SCIP_Real 5811#define SORTTPL_FIELD1TYPE SCIP_Real 5812#define SORTTPL_FIELD2TYPE int 5813#define SORTTPL_FIELD3TYPE int 5818#define SORTTPL_NAMEEXT RealRealRealInt 5819#define SORTTPL_KEYTYPE SCIP_Real 5820#define SORTTPL_FIELD1TYPE SCIP_Real 5821#define SORTTPL_FIELD2TYPE SCIP_Real 5822#define SORTTPL_FIELD3TYPE int 5827#define SORTTPL_NAMEEXT RealRealRealPtr 5828#define SORTTPL_KEYTYPE SCIP_Real 5829#define SORTTPL_FIELD1TYPE SCIP_Real 5830#define SORTTPL_FIELD2TYPE SCIP_Real 5831#define SORTTPL_FIELD3TYPE void* 5836#define SORTTPL_NAMEEXT RealPtrPtrInt 5837#define SORTTPL_KEYTYPE SCIP_Real 5838#define SORTTPL_FIELD1TYPE void* 5839#define SORTTPL_FIELD2TYPE void* 5840#define SORTTPL_FIELD3TYPE int 5845#define SORTTPL_NAMEEXT RealPtrPtrIntInt 5846#define SORTTPL_KEYTYPE SCIP_Real 5847#define SORTTPL_FIELD1TYPE void* 5848#define SORTTPL_FIELD2TYPE void* 5849#define SORTTPL_FIELD3TYPE int 5850#define SORTTPL_FIELD4TYPE int 5855#define SORTTPL_NAMEEXT RealRealRealBoolPtr 5856#define SORTTPL_KEYTYPE SCIP_Real 5857#define SORTTPL_FIELD1TYPE SCIP_Real 5858#define SORTTPL_FIELD2TYPE SCIP_Real 5859#define SORTTPL_FIELD3TYPE SCIP_Bool 5860#define SORTTPL_FIELD4TYPE void* 5865#define SORTTPL_NAMEEXT RealRealRealBoolBoolPtr 5866#define SORTTPL_KEYTYPE SCIP_Real 5867#define SORTTPL_FIELD1TYPE SCIP_Real 5868#define SORTTPL_FIELD2TYPE SCIP_Real 5869#define SORTTPL_FIELD3TYPE SCIP_Bool 5870#define SORTTPL_FIELD4TYPE SCIP_Bool 5871#define SORTTPL_FIELD5TYPE void* 5876#define SORTTPL_NAMEEXT Int 5877#define SORTTPL_KEYTYPE int 5882#define SORTTPL_NAMEEXT IntInt 5883#define SORTTPL_KEYTYPE int 5884#define SORTTPL_FIELD1TYPE int 5889#define SORTTPL_NAMEEXT IntReal 5890#define SORTTPL_KEYTYPE int 5891#define SORTTPL_FIELD1TYPE SCIP_Real 5896#define SORTTPL_NAMEEXT IntPtr 5897#define SORTTPL_KEYTYPE int 5898#define SORTTPL_FIELD1TYPE void* 5903#define SORTTPL_NAMEEXT IntIntInt 5904#define SORTTPL_KEYTYPE int 5905#define SORTTPL_FIELD1TYPE int 5906#define SORTTPL_FIELD2TYPE int 5911#define SORTTPL_NAMEEXT IntIntLong 5912#define SORTTPL_KEYTYPE int 5913#define SORTTPL_FIELD1TYPE int 5914#define SORTTPL_FIELD2TYPE SCIP_Longint 5918#define SORTTPL_NAMEEXT IntRealLong 5919#define SORTTPL_KEYTYPE int 5920#define SORTTPL_FIELD1TYPE SCIP_Real 5921#define SORTTPL_FIELD2TYPE SCIP_Longint 5926#define SORTTPL_NAMEEXT IntIntPtr 5927#define SORTTPL_KEYTYPE int 5928#define SORTTPL_FIELD1TYPE int 5929#define SORTTPL_FIELD2TYPE void* 5934#define SORTTPL_NAMEEXT IntIntReal 5935#define SORTTPL_KEYTYPE int 5936#define SORTTPL_FIELD1TYPE int 5937#define SORTTPL_FIELD2TYPE SCIP_Real 5942#define SORTTPL_NAMEEXT IntPtrReal 5943#define SORTTPL_KEYTYPE int 5944#define SORTTPL_FIELD1TYPE void* 5945#define SORTTPL_FIELD2TYPE SCIP_Real 5950#define SORTTPL_NAMEEXT IntIntIntPtr 5951#define SORTTPL_KEYTYPE int 5952#define SORTTPL_FIELD1TYPE int 5953#define SORTTPL_FIELD2TYPE int 5954#define SORTTPL_FIELD3TYPE void* 5958#define SORTTPL_NAMEEXT IntIntIntReal 5959#define SORTTPL_KEYTYPE int 5960#define SORTTPL_FIELD1TYPE int 5961#define SORTTPL_FIELD2TYPE int 5962#define SORTTPL_FIELD3TYPE SCIP_Real 5966#define SORTTPL_NAMEEXT IntPtrIntReal 5967#define SORTTPL_KEYTYPE int 5968#define SORTTPL_FIELD1TYPE void* 5969#define SORTTPL_FIELD2TYPE int 5970#define SORTTPL_FIELD3TYPE SCIP_Real 5975#define SORTTPL_NAMEEXT Long 5976#define SORTTPL_KEYTYPE SCIP_Longint 5981#define SORTTPL_NAMEEXT LongPtr 5982#define SORTTPL_KEYTYPE SCIP_Longint 5983#define SORTTPL_FIELD1TYPE void* 5988#define SORTTPL_NAMEEXT LongPtrInt 5989#define SORTTPL_KEYTYPE SCIP_Longint 5990#define SORTTPL_FIELD1TYPE void* 5991#define SORTTPL_FIELD2TYPE int 5996#define SORTTPL_NAMEEXT LongPtrRealBool 5997#define SORTTPL_KEYTYPE SCIP_Longint 5998#define SORTTPL_FIELD1TYPE void* 5999#define SORTTPL_FIELD2TYPE SCIP_Real 6000#define SORTTPL_FIELD3TYPE SCIP_Bool 6005#define SORTTPL_NAMEEXT LongPtrRealRealBool 6006#define SORTTPL_KEYTYPE SCIP_Longint 6007#define SORTTPL_FIELD1TYPE void* 6008#define SORTTPL_FIELD2TYPE SCIP_Real 6009#define SORTTPL_FIELD3TYPE SCIP_Real 6010#define SORTTPL_FIELD4TYPE SCIP_Bool 6015#define SORTTPL_NAMEEXT LongPtrRealRealIntBool 6016#define SORTTPL_KEYTYPE SCIP_Longint 6017#define SORTTPL_FIELD1TYPE void* 6018#define SORTTPL_FIELD2TYPE SCIP_Real 6019#define SORTTPL_FIELD3TYPE SCIP_Real 6020#define SORTTPL_FIELD4TYPE int 6021#define SORTTPL_FIELD5TYPE SCIP_Bool 6026#define SORTTPL_NAMEEXT LongPtrPtrInt 6027#define SORTTPL_KEYTYPE SCIP_Longint 6028#define SORTTPL_FIELD1TYPE void* 6029#define SORTTPL_FIELD2TYPE void* 6030#define SORTTPL_FIELD3TYPE int 6035#define SORTTPL_NAMEEXT LongPtrPtrIntInt 6036#define SORTTPL_KEYTYPE SCIP_Longint 6037#define SORTTPL_FIELD1TYPE void* 6038#define SORTTPL_FIELD2TYPE void* 6039#define SORTTPL_FIELD3TYPE int 6040#define SORTTPL_FIELD4TYPE int 6045#define SORTTPL_NAMEEXT LongPtrPtrBoolInt 6046#define SORTTPL_KEYTYPE SCIP_Longint 6047#define SORTTPL_FIELD1TYPE void* 6048#define SORTTPL_FIELD2TYPE void* 6049#define SORTTPL_FIELD3TYPE SCIP_Bool 6050#define SORTTPL_FIELD4TYPE int 6055#define SORTTPL_NAMEEXT PtrIntIntBoolBool 6056#define SORTTPL_KEYTYPE void* 6057#define SORTTPL_FIELD1TYPE int 6058#define SORTTPL_FIELD2TYPE int 6059#define SORTTPL_FIELD3TYPE SCIP_Bool 6060#define SORTTPL_FIELD4TYPE SCIP_Bool 6061#define SORTTPL_PTRCOMP 6066#define SORTTPL_NAMEEXT IntPtrIntIntBoolBool 6067#define SORTTPL_KEYTYPE int 6068#define SORTTPL_FIELD1TYPE void* 6069#define SORTTPL_FIELD2TYPE int 6070#define SORTTPL_FIELD3TYPE int 6071#define SORTTPL_FIELD4TYPE SCIP_Bool 6072#define SORTTPL_FIELD5TYPE SCIP_Bool 6089

assert(indcomp !=

);

6090

assert(len == 0 || perm !=

);

6093 for

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

6101#define SORTTPL_NAMEEXT DownInd 6102#define SORTTPL_KEYTYPE int 6103#define SORTTPL_INDCOMP 6104#define SORTTPL_BACKWARDS 6109#define SORTTPL_NAMEEXT DownPtr 6110#define SORTTPL_KEYTYPE void* 6111#define SORTTPL_PTRCOMP 6112#define SORTTPL_BACKWARDS 6117#define SORTTPL_NAMEEXT DownPtrPtr 6118#define SORTTPL_KEYTYPE void* 6119#define SORTTPL_FIELD1TYPE void* 6120#define SORTTPL_PTRCOMP 6121#define SORTTPL_BACKWARDS 6126#define SORTTPL_NAMEEXT DownPtrReal 6127#define SORTTPL_KEYTYPE void* 6128#define SORTTPL_FIELD1TYPE SCIP_Real 6129#define SORTTPL_PTRCOMP 6130#define SORTTPL_BACKWARDS 6135#define SORTTPL_NAMEEXT DownPtrInt 6136#define SORTTPL_KEYTYPE void* 6137#define SORTTPL_FIELD1TYPE int 6138#define SORTTPL_PTRCOMP 6139#define SORTTPL_BACKWARDS 6143#define SORTTPL_NAMEEXT DownPtrBool 6144#define SORTTPL_KEYTYPE void* 6145#define SORTTPL_FIELD1TYPE SCIP_Bool 6146#define SORTTPL_PTRCOMP 6147#define SORTTPL_BACKWARDS 6151#define SORTTPL_NAMEEXT DownPtrIntInt 6152#define SORTTPL_KEYTYPE void* 6153#define SORTTPL_FIELD1TYPE int 6154#define SORTTPL_FIELD2TYPE int 6155#define SORTTPL_PTRCOMP 6156#define SORTTPL_BACKWARDS 6161#define SORTTPL_NAMEEXT DownPtrRealInt 6162#define SORTTPL_KEYTYPE void* 6163#define SORTTPL_FIELD1TYPE SCIP_Real 6164#define SORTTPL_FIELD2TYPE int 6165#define SORTTPL_PTRCOMP 6166#define SORTTPL_BACKWARDS 6171#define SORTTPL_NAMEEXT DownPtrRealBool 6172#define SORTTPL_KEYTYPE void* 6173#define SORTTPL_FIELD1TYPE SCIP_Real 6174#define SORTTPL_FIELD2TYPE SCIP_Bool 6175#define SORTTPL_PTRCOMP 6176#define SORTTPL_BACKWARDS 6181#define SORTTPL_NAMEEXT DownPtrPtrInt 6182#define SORTTPL_KEYTYPE void* 6183#define SORTTPL_FIELD1TYPE void* 6184#define SORTTPL_FIELD2TYPE int 6185#define SORTTPL_PTRCOMP 6186#define SORTTPL_BACKWARDS 6191#define SORTTPL_NAMEEXT DownPtrPtrReal 6192#define SORTTPL_KEYTYPE void* 6193#define SORTTPL_FIELD1TYPE void* 6194#define SORTTPL_FIELD2TYPE SCIP_Real 6195#define SORTTPL_PTRCOMP 6196#define SORTTPL_BACKWARDS 6201#define SORTTPL_NAMEEXT DownPtrRealIntInt 6202#define SORTTPL_KEYTYPE void* 6203#define SORTTPL_FIELD1TYPE SCIP_Real 6204#define SORTTPL_FIELD2TYPE int 6205#define SORTTPL_FIELD3TYPE int 6206#define SORTTPL_PTRCOMP 6207#define SORTTPL_BACKWARDS 6212#define SORTTPL_NAMEEXT DownPtrPtrIntInt 6213#define SORTTPL_KEYTYPE void* 6214#define SORTTPL_FIELD1TYPE void* 6215#define SORTTPL_FIELD2TYPE int 6216#define SORTTPL_FIELD3TYPE int 6217#define SORTTPL_PTRCOMP 6218#define SORTTPL_BACKWARDS 6223#define SORTTPL_NAMEEXT DownPtrPtrRealInt 6224#define SORTTPL_KEYTYPE void* 6225#define SORTTPL_FIELD1TYPE void* 6226#define SORTTPL_FIELD2TYPE SCIP_Real 6227#define SORTTPL_FIELD3TYPE int 6228#define SORTTPL_PTRCOMP 6229#define SORTTPL_BACKWARDS 6234#define SORTTPL_NAMEEXT DownPtrPtrRealBool 6235#define SORTTPL_KEYTYPE void* 6236#define SORTTPL_FIELD1TYPE void* 6237#define SORTTPL_FIELD2TYPE SCIP_Real 6238#define SORTTPL_FIELD3TYPE SCIP_Bool 6239#define SORTTPL_PTRCOMP 6240#define SORTTPL_BACKWARDS 6245#define SORTTPL_NAMEEXT DownPtrPtrLongInt 6246#define SORTTPL_KEYTYPE void* 6247#define SORTTPL_FIELD1TYPE void* 6248#define SORTTPL_FIELD2TYPE SCIP_Longint 6249#define SORTTPL_FIELD3TYPE int 6250#define SORTTPL_PTRCOMP 6251#define SORTTPL_BACKWARDS 6256#define SORTTPL_NAMEEXT DownPtrPtrLongIntInt 6257#define SORTTPL_KEYTYPE void* 6258#define SORTTPL_FIELD1TYPE void* 6259#define SORTTPL_FIELD2TYPE SCIP_Longint 6260#define SORTTPL_FIELD3TYPE int 6261#define SORTTPL_FIELD4TYPE int 6262#define SORTTPL_PTRCOMP 6263#define SORTTPL_BACKWARDS 6268#define SORTTPL_NAMEEXT DownReal 6269#define SORTTPL_KEYTYPE SCIP_Real 6270#define SORTTPL_BACKWARDS 6275#define SORTTPL_NAMEEXT DownRealBoolPtr 6276#define SORTTPL_KEYTYPE SCIP_Real 6277#define SORTTPL_FIELD1TYPE SCIP_Bool 6278#define SORTTPL_FIELD2TYPE void* 6279#define SORTTPL_BACKWARDS 6284#define SORTTPL_NAMEEXT DownRealPtr 6285#define SORTTPL_KEYTYPE SCIP_Real 6286#define SORTTPL_FIELD1TYPE void* 6287#define SORTTPL_BACKWARDS 6292#define SORTTPL_NAMEEXT DownRealInt 6293#define SORTTPL_KEYTYPE SCIP_Real 6294#define SORTTPL_FIELD1TYPE int 6295#define SORTTPL_BACKWARDS 6299#define SORTTPL_NAMEEXT DownRealIntInt 6300#define SORTTPL_KEYTYPE SCIP_Real 6301#define SORTTPL_FIELD1TYPE int 6302#define SORTTPL_FIELD2TYPE int 6303#define SORTTPL_BACKWARDS 6307#define SORTTPL_NAMEEXT DownRealIntLong 6308#define SORTTPL_KEYTYPE SCIP_Real 6309#define SORTTPL_FIELD1TYPE int 6310#define SORTTPL_FIELD2TYPE SCIP_Longint 6311#define SORTTPL_BACKWARDS 6316#define SORTTPL_NAMEEXT DownRealIntPtr 6317#define SORTTPL_KEYTYPE SCIP_Real 6318#define SORTTPL_FIELD1TYPE int 6319#define SORTTPL_FIELD2TYPE void* 6320#define SORTTPL_BACKWARDS 6325#define SORTTPL_NAMEEXT DownRealPtrPtr 6326#define SORTTPL_KEYTYPE SCIP_Real 6327#define SORTTPL_FIELD1TYPE void* 6328#define SORTTPL_FIELD2TYPE void* 6329#define SORTTPL_BACKWARDS 6333#define SORTTPL_NAMEEXT DownRealRealInt 6334#define SORTTPL_KEYTYPE SCIP_Real 6335#define SORTTPL_FIELD1TYPE SCIP_Real 6336#define SORTTPL_FIELD2TYPE int 6337#define SORTTPL_BACKWARDS 6341#define SORTTPL_NAMEEXT DownRealRealPtr 6342#define SORTTPL_KEYTYPE SCIP_Real 6343#define SORTTPL_FIELD1TYPE SCIP_Real 6344#define SORTTPL_FIELD2TYPE void* 6345#define SORTTPL_BACKWARDS 6349#define SORTTPL_NAMEEXT DownRealRealPtrPtr 6350#define SORTTPL_KEYTYPE SCIP_Real 6351#define SORTTPL_FIELD1TYPE SCIP_Real 6352#define SORTTPL_FIELD2TYPE void* 6353#define SORTTPL_FIELD3TYPE void* 6354#define SORTTPL_BACKWARDS 6359#define SORTTPL_NAMEEXT DownRealLongRealInt 6360#define SORTTPL_KEYTYPE SCIP_Real 6361#define SORTTPL_FIELD1TYPE SCIP_Longint 6362#define SORTTPL_FIELD2TYPE SCIP_Real 6363#define SORTTPL_FIELD3TYPE int 6364#define SORTTPL_BACKWARDS 6369#define SORTTPL_NAMEEXT DownRealRealIntInt 6370#define SORTTPL_KEYTYPE SCIP_Real 6371#define SORTTPL_FIELD1TYPE SCIP_Real 6372#define SORTTPL_FIELD2TYPE int 6373#define SORTTPL_FIELD3TYPE int 6374#define SORTTPL_BACKWARDS 6379#define SORTTPL_NAMEEXT DownRealRealRealInt 6380#define SORTTPL_KEYTYPE SCIP_Real 6381#define SORTTPL_FIELD1TYPE SCIP_Real 6382#define SORTTPL_FIELD2TYPE SCIP_Real 6383#define SORTTPL_FIELD3TYPE int 6384#define SORTTPL_BACKWARDS 6389#define SORTTPL_NAMEEXT DownRealRealRealPtr 6390#define SORTTPL_KEYTYPE SCIP_Real 6391#define SORTTPL_FIELD1TYPE SCIP_Real 6392#define SORTTPL_FIELD2TYPE SCIP_Real 6393#define SORTTPL_FIELD3TYPE void* 6394#define SORTTPL_BACKWARDS 6399#define SORTTPL_NAMEEXT DownRealPtrPtrInt 6400#define SORTTPL_KEYTYPE SCIP_Real 6401#define SORTTPL_FIELD1TYPE void* 6402#define SORTTPL_FIELD2TYPE void* 6403#define SORTTPL_FIELD3TYPE int 6404#define SORTTPL_BACKWARDS 6408#define SORTTPL_NAMEEXT DownRealPtrPtrIntInt 6409#define SORTTPL_KEYTYPE SCIP_Real 6410#define SORTTPL_FIELD1TYPE void* 6411#define SORTTPL_FIELD2TYPE void* 6412#define SORTTPL_FIELD3TYPE int 6413#define SORTTPL_FIELD4TYPE int 6414#define SORTTPL_BACKWARDS 6419#define SORTTPL_NAMEEXT DownRealRealRealBoolPtr 6420#define SORTTPL_KEYTYPE SCIP_Real 6421#define SORTTPL_FIELD1TYPE SCIP_Real 6422#define SORTTPL_FIELD2TYPE SCIP_Real 6423#define SORTTPL_FIELD3TYPE SCIP_Bool 6424#define SORTTPL_FIELD4TYPE void* 6425#define SORTTPL_BACKWARDS 6430#define SORTTPL_NAMEEXT DownRealRealRealBoolBoolPtr 6431#define SORTTPL_KEYTYPE SCIP_Real 6432#define SORTTPL_FIELD1TYPE SCIP_Real 6433#define SORTTPL_FIELD2TYPE SCIP_Real 6434#define SORTTPL_FIELD3TYPE SCIP_Bool 6435#define SORTTPL_FIELD4TYPE SCIP_Bool 6436#define SORTTPL_FIELD5TYPE void* 6441#define SORTTPL_NAMEEXT DownInt 6442#define SORTTPL_KEYTYPE int 6443#define SORTTPL_BACKWARDS 6448#define SORTTPL_NAMEEXT DownIntInt 6449#define SORTTPL_KEYTYPE int 6450#define SORTTPL_FIELD1TYPE int 6451#define SORTTPL_BACKWARDS 6456#define SORTTPL_NAMEEXT DownIntIntReal 6457#define SORTTPL_KEYTYPE int 6458#define SORTTPL_FIELD1TYPE int 6459#define SORTTPL_FIELD2TYPE SCIP_Real 6460#define SORTTPL_BACKWARDS 6465#define SORTTPL_NAMEEXT DownIntReal 6466#define SORTTPL_KEYTYPE int 6467#define SORTTPL_FIELD1TYPE SCIP_Real 6468#define SORTTPL_BACKWARDS 6473#define SORTTPL_NAMEEXT DownIntPtr 6474#define SORTTPL_KEYTYPE int 6475#define SORTTPL_FIELD1TYPE void* 6476#define SORTTPL_BACKWARDS 6481#define SORTTPL_NAMEEXT DownIntIntInt 6482#define SORTTPL_KEYTYPE int 6483#define SORTTPL_FIELD1TYPE int 6484#define SORTTPL_FIELD2TYPE int 6485#define SORTTPL_BACKWARDS 6490#define SORTTPL_NAMEEXT DownIntIntLong 6491#define SORTTPL_KEYTYPE int 6492#define SORTTPL_FIELD1TYPE int 6493#define SORTTPL_FIELD2TYPE SCIP_Longint 6494#define SORTTPL_BACKWARDS 6499#define SORTTPL_NAMEEXT DownIntIntPtr 6500#define SORTTPL_KEYTYPE int 6501#define SORTTPL_FIELD1TYPE int 6502#define SORTTPL_FIELD2TYPE void* 6503#define SORTTPL_BACKWARDS 6508#define SORTTPL_NAMEEXT DownIntIntIntPtr 6509#define SORTTPL_KEYTYPE int 6510#define SORTTPL_FIELD1TYPE int 6511#define SORTTPL_FIELD2TYPE int 6512#define SORTTPL_FIELD3TYPE void* 6513#define SORTTPL_BACKWARDS 6518#define SORTTPL_NAMEEXT DownIntPtrIntReal 6519#define SORTTPL_KEYTYPE int 6520#define SORTTPL_FIELD1TYPE void* 6521#define SORTTPL_FIELD2TYPE int 6522#define SORTTPL_FIELD3TYPE SCIP_Real 6523#define SORTTPL_BACKWARDS 6528#define SORTTPL_NAMEEXT DownLong 6529#define SORTTPL_KEYTYPE SCIP_Longint 6530#define SORTTPL_BACKWARDS 6535#define SORTTPL_NAMEEXT DownLongPtr 6536#define SORTTPL_KEYTYPE SCIP_Longint 6537#define SORTTPL_FIELD1TYPE void* 6538#define SORTTPL_BACKWARDS 6543#define SORTTPL_NAMEEXT DownLongPtrInt 6544#define SORTTPL_KEYTYPE SCIP_Longint 6545#define SORTTPL_FIELD1TYPE void* 6546#define SORTTPL_FIELD2TYPE int 6547#define SORTTPL_BACKWARDS 6552#define SORTTPL_NAMEEXT DownLongPtrRealBool 6553#define SORTTPL_KEYTYPE SCIP_Longint 6554#define SORTTPL_FIELD1TYPE void* 6555#define SORTTPL_FIELD2TYPE SCIP_Real 6556#define SORTTPL_FIELD3TYPE SCIP_Bool 6557#define SORTTPL_BACKWARDS 6562#define SORTTPL_NAMEEXT DownLongPtrRealRealBool 6563#define SORTTPL_KEYTYPE SCIP_Longint 6564#define SORTTPL_FIELD1TYPE void* 6565#define SORTTPL_FIELD2TYPE SCIP_Real 6566#define SORTTPL_FIELD3TYPE SCIP_Real 6567#define SORTTPL_FIELD4TYPE SCIP_Bool 6568#define SORTTPL_BACKWARDS 6573#define SORTTPL_NAMEEXT DownLongPtrRealRealIntBool 6574#define SORTTPL_KEYTYPE SCIP_Longint 6575#define SORTTPL_FIELD1TYPE void* 6576#define SORTTPL_FIELD2TYPE SCIP_Real 6577#define SORTTPL_FIELD3TYPE SCIP_Real 6578#define SORTTPL_FIELD4TYPE int 6579#define SORTTPL_FIELD5TYPE SCIP_Bool 6580#define SORTTPL_BACKWARDS 6585#define SORTTPL_NAMEEXT DownLongPtrPtrInt 6586#define SORTTPL_KEYTYPE SCIP_Longint 6587#define SORTTPL_FIELD1TYPE void* 6588#define SORTTPL_FIELD2TYPE void* 6589#define SORTTPL_FIELD3TYPE int 6590#define SORTTPL_BACKWARDS 6595#define SORTTPL_NAMEEXT DownLongPtrPtrIntInt 6596#define SORTTPL_KEYTYPE SCIP_Longint 6597#define SORTTPL_FIELD1TYPE void* 6598#define SORTTPL_FIELD2TYPE void* 6599#define SORTTPL_FIELD3TYPE int 6600#define SORTTPL_FIELD4TYPE int 6601#define SORTTPL_BACKWARDS 6606#define SORTTPL_NAMEEXT DownLongPtrPtrBoolInt 6607#define SORTTPL_KEYTYPE SCIP_Longint 6608#define SORTTPL_FIELD1TYPE void* 6609#define SORTTPL_FIELD2TYPE void* 6610#define SORTTPL_FIELD3TYPE SCIP_Bool 6611#define SORTTPL_FIELD4TYPE int 6612#define SORTTPL_BACKWARDS 6617#define SORTTPL_NAMEEXT DownPtrIntIntBoolBool 6618#define SORTTPL_KEYTYPE void* 6619#define SORTTPL_FIELD1TYPE int 6620#define SORTTPL_FIELD2TYPE int 6621#define SORTTPL_FIELD3TYPE SCIP_Bool 6622#define SORTTPL_FIELD4TYPE SCIP_Bool 6623#define SORTTPL_PTRCOMP 6624#define SORTTPL_BACKWARDS 6629#define SORTTPL_NAMEEXT DownIntPtrIntIntBoolBool 6630#define SORTTPL_KEYTYPE int 6631#define SORTTPL_FIELD1TYPE void* 6632#define SORTTPL_FIELD2TYPE int 6633#define SORTTPL_FIELD3TYPE int 6634#define SORTTPL_FIELD4TYPE SCIP_Bool 6635#define SORTTPL_FIELD5TYPE SCIP_Bool 6636#define SORTTPL_BACKWARDS 6651

assert(activity !=

);

6655

(*activity)->var = var;

6656

(*activity)->duration = duration;

6657

(*activity)->demand = demand;

6667

assert(activity !=

);

6668

assert(*activity !=

);

6683#undef SCIPactivityGetVar 6684#undef SCIPactivityGetDuration 6685#undef SCIPactivityGetDemand 6686#undef SCIPactivityGetEnergy 6693

assert(activity !=

);

6695 return

activity->

var

;

6703

assert(activity !=

);

6713

assert(activity !=

);

6715 return

activity->

demand

;

6723

assert(activity !=

);

6744

(*profile)->arraysize = 10;

6749

(*profile)->ntimepoints = 1;

6750

(*profile)->timepoints[0] = 0;

6751

(*profile)->loads[0] = 0;

6752

(*profile)->capacity = capacity;

6763

assert(profile !=

);

6764

assert(capacity > 0);

6776

assert(profile !=

);

6779 if

( *profile !=

)

6814

assert(profile !=

);

6824

assert(profile !=

);

6834

assert(profile !=

);

6844

assert(profile !=

);

6846 return

profile->

;

6855

assert(profile !=

);

6856

assert(pos >= 0 && pos < profile->ntimepoints);

6867

assert(profile !=

);

6868

assert(pos >= 0 && pos < profile->ntimepoints);

6870 return

profile->

[pos];

6882

assert(profile !=

);

6883

assert(timepoint >= 0);

6907 if

( neededsize <= profile->arraysize )

6928

assert(profile !=

);

6929

assert(timepoint >= 0);

6937

assert(*pos >= 0 && *pos < profile->ntimepoints);

6938

assert(timepoint >= profile->

[*pos]);

6976

assert(profile !=

);

6979

assert(left < right);

6980

assert(infeasible !=

);

6982

(*infeasible) =

;

6987

assert(profile->

[startpos] == left);

6991

assert(profile->

[endpos] == right);

6993

assert(startpos < endpos);

6997 for

( i = startpos; i < endpos; ++i )

6999

profile->

[i] += demand;

7004 SCIPdebugMessage

(

"core insertion detected infeasibility (pos %d)\n"

, i);

7006

(*infeasible) =

;

7010 for

( ; i >= startpos; --i )

7011

profile->

[i] -= demand;

7032

assert(profile !=

);

7033

assert(left < right);

7034

assert(demand >= 0);

7035

assert(infeasible !=

);

7037

(*infeasible) =

;

7041 SCIPdebugMessage

(

"insert core [%d,%d] with demand %d\n"

, left, right, demand);

7063

assert(left < right);

7075 SCIPdebugMessage

(

"delete core [%d,%d] with demand %d\n"

, left, right, demand);

7078

assert(!infeasible);

7094 int

remainingduration;

7097

assert(profile !=

);

7099

assert(pos < profile->ntimepoints);

7100

assert(duration > 0);

7104

remainingduration = duration;

7106

(*infeasible) =

;

7110

(*infeasible) =

;

7114 while

( pos < profile->ntimepoints - 1 )

7118 SCIPdebugMessage

(

"profile <%p>: core does not fit at time point %d (pos %d)\n"

, (

void

*)profile, profile->

[pos], pos);

7120

remainingduration = duration;

7122 if

( profile->timepoints[startpos] > lst )

7124

(*infeasible) =

;

7131 if

( remainingduration <= 0 )

7155

assert(profile !=

);

7158

assert(duration >= 0);

7159

assert(demand >= 0);

7160

assert(infeasible !=

);

7164 SCIPdebugMessage

(

"profile <%p>: find earliest start time (demad %d, duration %d) [%d,%d]\n"

, (

void

*)profile, demand, duration, est, lst);

7166 if

( duration == 0 || demand == 0 )

7168

*infeasible =

;

7173 SCIPdebugMessage

(

"profile <%p>: earliest start time does %s exist as time point (pos %d)\n"

, (

void

*)profile, found ?

""

"not"

, pos);

7178

(*infeasible) =

;

7188

assert(pos < profile->ntimepoints);

7191 else if

( profile->

[pos] + demand > profile->

capacity

)

7199

assert(pos < profile->ntimepoints);

7204 int

remainingduration;

7208

assert(pos < profile->ntimepoints - 1);

7210

remainingduration = duration - (profile->

[pos+1] - est);

7213 if

( remainingduration <= 0 )

7214

(*infeasible) =

;

7218 SCIPdebugMessage

(

"remaining duration can%s be processed\n"

, *infeasible ?

"not"

""

);

7224

assert(pos < profile->ntimepoints);

7244 int

remainingduration;

7247

assert(profile !=

);

7249

assert(pos < profile->ntimepoints);

7250

assert(duration > 0);

7255

remainingduration = duration;

7257

(*infeasible) =

;

7259 if

( profile->

[endpos] < ect - duration )

7264 if

( profile->

[pos-1] + demand > profile->

capacity

)

7266 SCIPdebugMessage

(

"profile <%p>: core does not fit at time point %d (pos %d)\n"

, (

void

*)profile, profile->

[pos-1], pos-1);

7269

remainingduration = duration;

7271 if

( profile->timepoints[endpos] < ect - duration )

7277 if

( remainingduration <= 0 )

7279

*infeasible =

;

7306

assert(profile !=

);

7309

assert(duration >= 0);

7310

assert(demand >= 0);

7311

assert(infeasible !=

);

7315 if

( duration == 0 || demand == 0 )

7317

*infeasible =

;

7321

ect = est + duration;

7322

lct = lst + duration;

7325 SCIPdebugMessage

(

"profile <%p>: latest completion time %d does %s exist as time point (pos %d)\n"

, (

void

*)profile, lct, found ?

""

"not"

, pos);

7333

assert(pos < profile->ntimepoints && pos >= 0);

7336 else if

( profile->

[pos] + demand > profile->

capacity

)

7344

assert(pos < profile->ntimepoints && pos >= 0);

7349 int

remainingduration;

7354

remainingduration = duration - (lct - profile->

[pos]);

7356 if

( remainingduration <= 0 )

7357

(*infeasible) =

;

7366

assert(pos < profile->ntimepoints && pos >= 0);

7372 return

lct - duration;

7386

assert(digraph !=

);

7387

assert(blkmem !=

);

7399

(*digraph)->nnodes =

;

7402

(*digraph)->blkmem = blkmem;

7403

(*digraph)->ncomponents = 0;

7404

(*digraph)->componentstartsize = 0;

7405

(*digraph)->components =

;

7406

(*digraph)->componentstarts =

;

7409

(*digraph)->narticulations = -1;

7410

(*digraph)->articulations =

;

7411

(*digraph)->articulationscheck =

;

7423

assert(digraph !=

);

7427 if

( nnodes <= digraph->

)

7469

assert(sourcedigraph !=

);

7470

assert(targetdigraph !=

);

7473 if

( targetblkmem ==

)

7474

targetblkmem = sourcedigraph->

;

7476

assert(targetblkmem !=

);

7483

(*targetdigraph)->nnodes =

;

7484

(*targetdigraph)->ncomponents = ncomponents;

7485

(*targetdigraph)->blkmem = targetblkmem;

7493 for

( i = 0; i <

; ++i )

7506

(*targetdigraph)->nodedata[i] = sourcedigraph->

nodedata

[i];

7514 if

( ncomponents > 0 )

7520

(*targetdigraph)->componentstartsize = ncomponents + 1;

7524

(*targetdigraph)->components =

;

7525

(*targetdigraph)->componentstarts =

;

7526

(*targetdigraph)->componentstartsize = 0;

7530 if

( articulationscheck )

7533

(*targetdigraph)->narticulations = sourcedigraph->

narticulations

;

7534

(*targetdigraph)->articulationscheck =

;

7538

(*targetdigraph)->narticulations = -1;

7539

(*targetdigraph)->articulations =

;

7540

(*targetdigraph)->articulationscheck =

;

7555

assert(digraph !=

);

7556

assert(digraph->

> 0);

7557

blkmem = digraph->

;

7559 for

( i = 0; i < digraph->

; ++i )

7579

assert(digraph !=

);

7580

assert(*digraph !=

);

7581

assert((*digraph)->blkmem !=

);

7583

blkmem = (*digraph)->blkmem;

7584

digraphptr = *digraph;

7587 for

( i = digraphptr->

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

7614#define STARTSUCCESSORSSIZE 5 7626

assert(digraph !=

);

7629

assert(idx < digraph->

);

7630

assert(newsize > 0);

7634

blkmem = digraph->

;

7656

assert(newsize <= digraph->successorssize[idx]);

7672

assert(digraph !=

);

7673

assert(startnode >= 0);

7674

assert(endnode >= 0);

7675

assert(startnode < digraph->

);

7676

assert(endnode < digraph->

);

7706

assert(digraph !=

);

7707

assert(startnode >= 0);

7708

assert(endnode >= 0);

7709

assert(startnode < digraph->

);

7710

assert(endnode < digraph->

);

7715 for

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

7716 if

( digraph->

[startnode][i] == endnode )

7722

digraph->

[startnode][nsuccessors] = endnode;

7723

digraph->

arcdata

[startnode][nsuccessors] = data;

7739

assert(digraph !=

);

7741

assert(node < digraph->

);

7753

assert(digraph !=

);

7755 return

digraph->

;

7764

assert(digraph !=

);

7766

assert(node < digraph->

);

7781

assert(digraph !=

);

7783

assert(node < digraph->

);

7785

digraph->

nodedata

[node] = dataptr;

7796

assert(digraph !=

);

7800 for

( i = 0; i < digraph->

; ++i )

7812

assert(digraph !=

);

7814

assert(node < digraph->

);

7827

assert(digraph !=

);

7829

assert(node < digraph->

);

7845

assert(digraph !=

);

7847

assert(node < digraph->

);

7852 return

digraph->

arcdata

[node];

7863 int

* stackadjvisited,

7871

assert(digraph !=

);

7872

assert(startnode >= 0);

7873

assert(startnode < digraph->

);

7874

assert(visited !=

);

7875

assert(visited[startnode] ==

);

7876

assert(dfsstack !=

);

7877

assert(dfsnodes !=

);

7878

assert(ndfsnodes !=

);

7881

dfsstack[0] = startnode;

7882

stackadjvisited[0] = 0;

7885 while

( stackidx >= 0 )

7891

currnode = dfsstack[stackidx];

7893

sadv = stackadjvisited[stackidx];

7894

assert( 0 <= sadv && sadv <= digraph->nsuccessors[currnode] );

7897

assert( visited[currnode] == (sadv > 0) );

7898

visited[currnode] =

;

7901 while

( sadv < digraph->nsuccessors[currnode] && visited[digraph->

[currnode][sadv]] )

7910

dfsnodes[(*ndfsnodes)++] = currnode;

7915

assert( ! visited[digraph->

[currnode][sadv]] );

7918

stackadjvisited[stackidx] = sadv + 1;

7922

dfsstack[stackidx] = digraph->

[currnode][sadv];

7923

stackadjvisited[stackidx] = 0;

7924

assert( stackidx < digraph->

);

7953

assert(digraph !=

);

7954

assert(startnode >= 0);

7955

assert(startnode < digraph->

);

7956

assert(visited !=

);

7957

assert(visited[startnode] ==

);

7958

assert(tdisc !=

);

7959

assert(mindisc !=

);

7960

assert(parent !=

);

7961

assert(articulationflag !=

);

7966

visited[startnode] =

;

7967

tdisc[startnode] = time + 1;

7968

mindisc[startnode] = time + 1;

7971 for

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

7973 if

( !visited[succnodes[n]] )

7975

parent[succnodes[n]] = startnode;

7979

mindisc[startnode] =

(mindisc[startnode], mindisc[succnodes[n]]);

7982 if

( parent[startnode] == -1 && nchildren > 1 )

7983

articulationflag[startnode] =

;

7986 if

( parent[startnode] > -1 && mindisc[succnodes[n]] >= tdisc[startnode] )

7987

articulationflag[startnode] =

;

7991 if

( parent[startnode] != succnodes[n] )

7992

mindisc[startnode] =

(mindisc[startnode], tdisc[succnodes[n]]);

7996 if

( articulationflag[startnode] )

8005 int

** articulations,

8006 int

* narticulations

8013 int

* tdisc =

;

8014 int

* mindisc =

;

8015 int

* parent =

;

8017 int

articulationidx = 0;

8020

assert(digraph !=

);

8021

assert(digraph->

> 0);

8033

blkmem = digraph->

;

8041 for

( n = 0; n < digraph->

; ++n )

8043

visited[n] =

;

8045

articulationflag[n] =

;

8049 for

( n = 0; n < digraph->

; ++n )

8058 for

( n = 0; n < digraph->

; ++n )

8060 if

( articulationflag[n] )

8068 if

( articulations !=

)

8070 if

( narticulations !=

)

8105 int

* ndirectedsuccessors;

8106 int

* stackadjvisited;

8116

assert(digraph !=

);

8117

assert(digraph->

> 0);

8120

blkmem = digraph->

;

8147 for

( i = digraph->

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

8149 for

( j = 0; j < ndirectedsuccessors[i]; ++j )

8155 for

( v = 0; v < digraph->

; ++v )

8163

&digraph->

components

[compstart], &ndfsnodes);

8166 if

( ndfsnodes >= minsize )

8184 if

( components !=

)

8199 if

( ncomponents !=

)

8229 int

* stackadjvisited =

;

8230 int

* dfsstack =

;

8231 int

* dfsnodes =

;

8240

assert(digraph !=

);

8252 for

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

8254

endidx = compstarts[i+1] - 1;

8256 for

( j = compstarts[i]; j < compstarts[i+1]; ++j )

8258 if

( visited[comps[j]] )

8265 depthFirstSearch

(digraph, comps[j], visited, dfsstack, stackadjvisited, dfsnodes, &ndfsnodes);

8267

assert(endidx - ndfsnodes == compstarts[i] - 1);

8272 for

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

8274

digraph->

components

[endidx - k] = dfsnodes[k];

8292

assert(digraph !=

);

8309

assert(digraph !=

);

8310

assert(compidx >= 0);

8311

assert(compidx < digraph->ncomponents);

8314 if

( nodes !=

)

8334 int

* strongcomponents,

8337 int

* nstrongcomponents,

8338 int

* strongcompstartidx,

8344

assert(digraph !=

);

8346

assert(v < digraph->

);

8347

assert(lowlink !=

);

8348

assert(dfsidx !=

);

8349

assert(stack !=

);

8350

assert(stacksize !=

);

8351

assert(*stacksize >= 0);

8352

assert(*stacksize < digraph->

);

8353

assert(unprocessed !=

);

8354

assert(nodeinstack !=

);

8355

assert(maxdfs !=

);

8356

assert(strongcomponents !=

);

8357

assert(nstrongcomponents !=

);

8358

assert(strongcompstartidx !=

);

8359

assert(nstorednodes !=

);

8360

assert(*nstorednodes >= 0 && *nstorednodes < digraph->

);

8362

dfsidx[v] = *maxdfs;

8363

lowlink[v] = *maxdfs;

8367

stack[*stacksize] = v;

8369

nodeinstack[v] =

;

8372

unprocessed[v] =

;

8381 if

( unprocessed[

] )

8383 tarjan

(digraph,

, lowlink, dfsidx, stack, stacksize, unprocessed, nodeinstack, maxdfs, strongcomponents,

8384

nstrongcomponents, strongcompstartidx, nstorednodes);

8386

assert(lowlink[v] >= 0 && lowlink[v] < digraph->

);

8387

assert(lowlink[

] >= 0 && lowlink[

] < digraph->

);

8390

lowlink[v] =

(lowlink[v], lowlink[

]);

8392 else if

( nodeinstack[

] )

8394

assert(lowlink[v] >= 0 && lowlink[v] < digraph->

);

8395

assert(dfsidx[

] >= 0 && dfsidx[

] < digraph->

);

8398

lowlink[v] =

(lowlink[v], dfsidx[

]);

8403 if

( lowlink[v] == dfsidx[v] )

8407

strongcompstartidx[*nstrongcomponents] = *nstorednodes;

8408

*nstrongcomponents += 1;

8412

assert(*stacksize > 0);

8415 w

= stack[*stacksize - 1];

8417

nodeinstack[

] =

;

8420

strongcomponents[*nstorednodes] =

;

8436 int

* strongcomponents,

8438 int

* strongcompstartidx,

8440 int

* nstrongcomponents

8444 int

* lowlink =

;

8445 int

* dfsidx =

;

8446 int

* stack =

;

8455

assert(digraph !=

);

8456

assert(compidx >= 0);

8457

assert(compidx < digraph->ncomponents);

8458

assert(strongcomponents !=

);

8459

assert(strongcompstartidx !=

);

8460

assert(nstrongcomponents !=

);

8470 for

( i = 0; i < digraph->

; ++i )

8475

unprocessed[i] =

;

8476

nodeinstack[i] =

;

8482

*nstrongcomponents = 0;

8485 for

( i = digraph->

componentstarts

[compidx]; i < digraph->componentstarts[compidx + 1]; ++i )

8490

assert(v >= 0 && v < digraph->

);

8493 if

( unprocessed[v] )

8496 tarjan

(digraph, v, lowlink, dfsidx, stack, &stacksize, unprocessed, nodeinstack, &maxdfs,

8497

strongcomponents, nstrongcomponents, strongcompstartidx, &nstorednodes);

8505

assert(*nstrongcomponents < digraph->

+ 1);

8506

strongcompstartidx[*nstrongcomponents] = nstorednodes;

8527

assert(digraph !=

);

8530

blkmem = digraph->

;

8561 for

( n = 0; n < digraph->

; ++n )

8572 for

( m = 0; m < nsuccessors ; ++m )

8599 for

( n = 0; n < digraph->

; ++n )

8608 for

( n = 0; n < digraph->

; ++n )

8617 for

( m = 0; m < nsuccessors; ++m )

8643 for

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

8671

(*node)->parent =

;

8672

(*node)->left =

;

8673

(*node)->right =

;

8674

(*node)->dataptr =

;

8686

assert(tree !=

);

8687

assert(node !=

);

8691

assert((*node)->parent ==

);

8692

assert((*node)->left ==

);

8693

assert((*node)->right ==

);

8696

(*node)->dataptr = dataptr;

8708

assert(tree !=

);

8709

assert(node !=

);

8710

assert(*node !=

);

8712

assert((*node)->left ==

);

8713

assert((*node)->right ==

);

8715#ifdef SCIP_DISABLED_CODE 8717 if

( (*node)->parent !=

)

8719

assert(*node !=

);

8721

assert((*node)->parent->left == *node || ((*node)->parent->right == *node));

8723 if

( (*node)->parent->left == *node )

8725

(*node)->parent->left =

;

8729

assert((*node)->parent->right == *node);

8730

(*node)->parent->right =

;

8735

assert(*node !=

);

8737

assert(*node ==

);

8749

assert(tree !=

);

8750

assert(node !=

);

8751

assert(*node !=

);

8753 if

( (*node)->left !=

)

8756

assert((*node)->left ==

);

8759 if

( (*node)->right !=

)

8762

assert((*node)->right ==

);

8766

assert(*node ==

);

8777#undef SCIPbtnodeGetData 8778#undef SCIPbtnodeGetKey 8779#undef SCIPbtnodeGetParent 8780#undef SCIPbtnodeGetLeftchild 8781#undef SCIPbtnodeGetRightchild 8782#undef SCIPbtnodeGetSibling 8783#undef SCIPbtnodeIsRoot 8784#undef SCIPbtnodeIsLeaf 8785#undef SCIPbtnodeIsLeftchild 8786#undef SCIPbtnodeIsRightchild 8793

assert(node !=

);

8803

assert(node !=

);

8813

assert(node !=

);

8815 return

node->

left

;

8823

assert(node !=

);

8825 return

node->

right

;

8837 if

( parent ==

)

8853

assert(node !=

);

8863

assert(node !=

);

8913

assert(node !=

);

8927

assert(node !=

);

8941

assert(node !=

);

8955

assert(node !=

);

8957

node->

right

= right;

8966

assert(tree !=

);

8967

assert(blkmem !=

);

8970

(*tree)->blkmem = blkmem;

8971

(*tree)->root =

;

8984

assert(tree !=

);

8986 if

( (*tree)->root !=

)

9006

assert(node !=

);

9023 if

( right !=

)

9046

assert(root !=

);

9066

assert(tree !=

);

9076

assert(tree !=

);

9078 return

tree->

root

;

9090

assert(tree !=

);

9116

onepluseps = one +

;

9118 while

( onepluseps > one );

9136 while

( !(val1 & 1) )

9150 while

( !(val1 & 1) )

9158 while

( !(val2 & 1) )

9171 while

( !(val1 & 1) )

9174 else if

( val1 < val2 )

9179 while

( !(val2 & 1) )

9185 while

( val1 != val2 )

9196 if

( ((val1 ^ val2) & 2) == 2 )

9201

assert((val1 & 3) == 0);

9205 while

( !(val1 & 1) )

9217 if

( ((val2 ^ val1) & 2) == 2 )

9222

assert((val2 & 3) == 0);

9226 while

( !(val2 & 1) )

9236#if defined(_MSC_VER) && !defined(NO_NEXTAFTER) 9237#define nextafter(x,y) _nextafter(x,y) 9254#define __HI(x) *(1+(int*)&x) 9255#define __LO(x) *(int*)&x 9256#define __HIp(x) *(1+(int*)x) 9257#define __LOp(x) *(int*)x 9260double

nextafter(

double x

double y

)

9280 if

( ((ix>=0x7ff00000) && ((ix-0x7ff00000)|lx) != 0 ) ||

9281

( (iy>=0x7ff00000) && ((iy-0x7ff00000)|ly) != 0 ))

9293

__HI(

) = hy&0x80000000;

9306 if

( hx > hy || ((hx == hy) && (lx > ly)) )

9323 if

( hy >= 0 || hx > hy || ((hx == hy) && (lx > ly)) )

9340 if

( hy >= 0x7ff00000 )

9342 if

( hy < 0x00100000 )

9372 return

nextafter(from, to);

9388 return

val1/gcd * val2;

9391static const SCIP_Real simplednoms

[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,

9392

17.0, 18.0, 19.0, 25.0, -1.0};

9419

assert(mindelta <= 0.0);

9420

assert(maxdelta >= 0.0);

9421

assert(numerator !=

);

9422

assert(denominator !=

);

9439 while

( dnom <= maxdnom )

9441

nom = floor(val * dnom);

9443

ratval1 = (nom+1.0)/dnom;

9444 if

( mindelta <= val - ratval0 && val - ratval1 <= maxdelta )

9446 if

( val - ratval0 <= maxdelta )

9452 if

( mindelta <= val - ratval1 )

9464

epsilon =

(-mindelta, maxdelta)/2.0;

9472

delta0 = val - g0/h0;

9473

delta1 = (delta0 < 0.0 ? val - (g0-1.0)/h0 : val - (g0+1.0)/h0);

9475 while

( (delta0 < mindelta || delta0 > maxdelta) && (delta1 < mindelta || delta1 > maxdelta) )

9477

assert(

EPSGT

(

, epsilon));

9481 b

= 1.0 / (

);

9497

delta0 = val - g0/h0;

9498

delta1 = (delta0 < 0.0 ? val - (g0-1.0)/h0 : val - (g0+1.0)/h0);

9506 if

( delta0 < mindelta )

9508

assert(mindelta <= delta1 && delta1 <= maxdelta);

9512 else if

( delta0 > maxdelta )

9514

assert(mindelta <= delta1 && delta1 <= maxdelta);

9523

assert(*denominator >= 1);

9543

assert(mindelta <= 0.0);

9544

assert(maxdelta >= 0.0);

9546

sval = val * scalar;

9547

downval = floor(sval);

9586

assert(vals !=

);

9588

assert(maxdnom >= 1);

9589

assert(mindelta < 0.0);

9590

assert(maxdelta > 0.0);

9591

assert(success !=

);

9593 SCIPdebugMessage

(

"trying to find rational representation for given values\n"

);

9595 if

( intscalar !=

)

9601 for

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

9604 if

( val < mindelta || val > maxdelta )

9607

minval =

(minval, absval);

9614 if

( intscalar !=

)

9621

assert(minval >

(-mindelta, maxdelta));

9625 for

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

9631

scaleval = 1.0/minval;

9636 for

( c = 0; c < nvals && scalable; ++c )

9644 while

( scaleval <= maxscale

9645

&& (absval * scaleval < 0.5 || !

isIntegralScalar

(val, scaleval, mindelta, maxdelta)) )

9658

scalable = (scaleval <= maxscale);

9659 SCIPdebugMessage

(

" -> val=%g, scaleval=%g, val*scaleval=%g, scalable=%u\n"

9660

val, scaleval, val*scaleval, scalable);

9665

assert(scaleval <= maxscale);

9668 if

( scaleval < bestscalar )

9669

bestscalar = scaleval;

9671 SCIPdebugMessage

(

" -> integrality could be achieved by scaling with %g\n"

, scaleval);

9676 if

( intscalar !=

)

9677

*intscalar = bestscalar;

9693 for

( c = 0; c < nvals && rational; ++c )

9699

rational =

SCIPrealToRational

(val, mindelta, maxdelta, maxdnom, &numerator, &denominator);

9700 if

( rational && numerator != 0 )

9702

assert(denominator > 0);

9703

gcd =

ABS

(numerator);

9707

c, val, numerator, denominator, gcd, scm, rational);

9713 for

( ++c; c < nvals && rational; ++c )

9719

rational =

SCIPrealToRational

(val, mindelta, maxdelta, maxdnom, &numerator, &denominator);

9720 if

( rational && numerator != 0 )

9722

assert(denominator > 0);

9727

c, val, numerator, denominator, gcd, scm, rational);

9731 SCIPdebugMessage

(

" -> failed to convert %g into a rational representation\n"

, val);

9750 if

( intscalar !=

)

9751

*intscalar = bestscalar;

9754 SCIPdebugMessage

(

" -> smallest value to achieve integrality is %g \n"

, bestscalar);

9764#if defined(__INTEL_COMPILER) || defined(_MSC_VER) 9765#pragma fenv_access (on) 9766#elif defined(__GNUC__) && !defined(__clang__) 9767#pragma STDC FENV_ACCESS ON 9769#if defined(__GNUC__) && !defined(__INTEL_COMPILER) 9770#if defined(__clang__) 9771

__attribute__((optnone))

9793

center = 0.5*(lb+ub);

9805

delta = 0.5*(ub-lb);

9811

delta = 0.5*(ub-lb);

9817#if defined(__INTEL_COMPILER) || defined(_MSC_VER) 9818#pragma fenv_access (off) 9819#elif defined(__GNUC__) && !defined(__clang__) 9820#pragma STDC FENV_ACCESS OFF 9850 if

( val - lb < 0.0 || val - ub > 0.0 )

9852 SCIPdebugPrintf

(

" value is out of interval bounds by %g -> failed\n"

(lb-val, val-ub));

9881

assert(function !=

);

9882

assert(derivative !=

);

9883

assert(params !=

|| nparams == 0);

9888 while

( iteration < k )

9890 SCIP_Real

deriv = derivative(result, params, nparams);

9896

result = result - function(result, params, nparams) / deriv;

9899 if

(

REALABS

(function(result, params, nparams)) <=

)

9905 if

( k == iteration )

9916#if defined(NO_RAND_R) || defined(_WIN32) || defined(_WIN64) 9918#define SCIP_RAND_MAX 32767 9922 unsigned int

* seedp

9927

assert(seedp !=

);

9929

nextseed = (*seedp) * (

SCIP_Longint

)1103515245 + 12345;

9930

*seedp = (

unsigned

int)nextseed;

9937#define SCIP_RAND_MAX RAND_MAX 9942 unsigned int

* seedp

9945 return

rand_r(seedp);

9955 unsigned int

* seedp

9961

assert(randnumber >= 0.0);

9962

assert(randnumber < 1.0);

9967 return

(

int

) (minrandval*(1.0 - randnumber) + maxrandval*randnumber + randnumber);

9975 unsigned int

* seedp

9981

assert(randnumber >= 0.0);

9982

assert(randnumber <= 1.0);

9987 return

minrandval*(1.0 - randnumber) + maxrandval*randnumber;

9997 unsigned int

* seedp

10010 unsigned int

* seedp

10018#define DEFAULT_SEED UINT32_C(123456789) 10019#define DEFAULT_XOR UINT32_C(362436000) 10020#define DEFAULT_MWC UINT32_C(521288629) 10021#define DEFAULT_CST UINT32_C(7654321) 10027 unsigned int

initseed

10030

assert(randnumgen !=

);

10038

assert(randnumgen->

seed

> 0);

10039

assert(randnumgen->

xor_seed

> 0);

10040

assert(randnumgen->

mwc_seed

> 0);

10063

randnumgen->

seed

= (uint32_t) (randnumgen->

seed

* UINT64_C(1103515245) + UINT64_C(12345));

10072

randnumgen->

cst_seed

= (uint32_t) (t >> 32);

10073

randnumgen->

mwc_seed

= (uint32_t) t;

10082 unsigned int

initialseed

10085

assert(randnumgen !=

);

10100

assert(randnumgen !=

);

10101

assert((*randnumgen) !=

);

10121

assert(randnumber >= 0.0);

10122

assert(randnumber < 1.0);

10142

assert(randnumber >= 0.0);

10143

assert(randnumber <= 1.0);

10148 return

minrandval*(1.0 - randnumber) + maxrandval*randnumber;

10167 while

( end > begin+1 )

10176

array[i] = array[end];

10197 while

( end > begin+1 )

10206

array[i] = array[end];

10226 if

( nelems == nsubelems)

10233 if

( nsubelems > nelems )

10235 SCIPerrorMessage

(

"Cannot create %d-elementary subset of %d-elementary set.\n"

, nsubelems, nelems);

10239 for

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

10240 for

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

10241

assert(

[i] !=

[j]);

10246 while

( i < nsubelems )

10251

subset[i] =

[

];

10254 for

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

10256 if

( subset[i] == subset[j] )

10280 if

( m == 0 || m >= n )

10304 if

( m > 16 || n > 33 )

10309 return

(n*(n-1)*(n-2)/6);

10318

1166803110, 601080390, 1037158320, 565722720, 300540195, 155117520, 818809200, 471435600, 265182525, 145422675,

10319

77558760, 40116600, 573166440, 347373600, 206253075, 119759850, 67863915, 37442160, 20058300, 10400600,

10320

354817320, 225792840, 141120525, 86493225, 51895935, 30421755, 17383860, 9657700, 5200300, 2704156, 193536720,

10321

129024480, 84672315, 54627300, 34597290, 21474180, 13037895, 7726160, 4457400, 2496144, 1352078, 705432,

10322

92561040, 64512240, 44352165, 30045015, 20030010, 13123110, 8436285, 5311735, 3268760, 1961256, 1144066,

10323

646646, 352716, 184756, 38567100, 28048800, 20160075, 14307150, 10015005, 6906900, 4686825, 3124550, 2042975,

10324

1307504, 817190, 497420, 293930, 167960, 92378, 48620, 13884156, 10518300, 7888725, 5852925, 4292145, 3108105,

10325

2220075, 1562275, 1081575, 735471, 490314, 319770, 203490, 125970, 75582, 43758, 24310, 12870, 4272048, 3365856,

10326

2629575, 2035800, 1560780, 1184040, 888030, 657800, 480700, 346104, 245157, 170544, 116280, 77520, 50388, 31824,

10327

19448, 11440, 6435, 3432, 1107568, 906192, 736281, 593775, 475020, 376740, 296010, 230230, 177100, 134596,

10328

100947, 74613, 54264, 38760, 27132, 18564, 12376, 8008, 5005, 3003, 1716, 924, 237336, 201376, 169911, 142506,

10329

118755, 98280, 80730, 65780, 53130, 42504, 33649, 26334, 20349, 15504, 11628, 8568, 6188, 4368, 3003, 2002,

10330

1287, 792, 462, 252, 40920, 35960, 31465, 27405, 23751, 20475, 17550, 14950, 12650, 10626, 8855, 7315, 5985,

10331

4845, 3876, 3060, 2380, 1820, 1365, 1001, 715, 495, 330, 210, 126, 70};

10334 const int

t = 16-m;

10339

assert(t*(t+1)+(33-n) < 182);

10341 return

binoms[t*(t+1)+(33-n)];

10347#if defined(__GNUC__) && __GNUC__ * 100 + __GNUC_MINOR__ * 10 >= 490 && !defined(__INTEL_COMPILER) 10348

__attribute__((no_sanitize_undefined))

10355 return

((

unsigned long long

)(v * 2654435769)) % UINT_MAX;

10356 return

((

unsigned long long

)(-v * 683565275)) % UINT_MAX;

10407

*pointer1 = *pointer2;

10423 unsigned int

* randseed

10430 while

( end > begin+1 )

10439

array[i] = array[end];

10457 unsigned int

* randseed

10464 while

( end > begin+1 )

10473

array[i] = array[end];

10488 unsigned int

randseed

10495 if

( nelems == nsubelems)

10502 if

( nsubelems > nelems )

10504 SCIPerrorMessage

(

"Cannot create %d-elementary subset of %d-elementary set.\n"

, nsubelems, nelems);

10508 for

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

10509 for

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

10510

assert(

[i] !=

[j]);

10515 while

( i < nsubelems )

10520

subset[i] =

[

];

10523 for

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

10525 if

( subset[i] == subset[j] )

10550 int

* intersectarray,

10552 int

* nintersectarray

10567 int

* intersectarray,

10569 int

* nintersectarray

10578

assert( array1 !=

);

10579

assert( array2 !=

);

10580

assert( intersectarray !=

);

10581

assert( nintersectarray !=

);

10584 for

(v1 = 0; v1 < narray1; ++v1)

10586

assert( v1 == 0 || array1[v1] >= array1[v1-1] );

10589 if

( v1+1 < narray1 && array1[v1] == array1[v1+1])

10592 for

(v2 = k; v2 < narray2; ++v2)

10594

assert( v2 == 0 || array2[v2] >= array2[v2-1] );

10596 if

( array2[v2] > array1[v1] )

10601 else if

( array2[v2] == array1[v1] )

10603

intersectarray[cnt++] = array2[v2];

10611

*nintersectarray = cnt;

10621 void

** intersectarray,

10623 int

* nintersectarray

10632

assert( array1 !=

);

10633

assert( array2 !=

);

10634

assert( ptrcomp !=

);

10635

assert( intersectarray !=

);

10636

assert( nintersectarray !=

);

10639 for

( v1 = 0; v1 < narray1; ++v1 )

10641

assert( v1 == 0 || (*ptrcomp)(array1[v1], array1[v1-1]) >= 0 );

10644 if

( v1+1 < narray1 && array1[v1] == array1[v1+1] )

10647 for

( v2 = k; v2 < narray2; ++v2 )

10649

assert( v2 == 0 || (*ptrcomp)(array2[v2], array2[v2-1]) > 0 || array2[v2] == array2[v2-1] );

10651 if

( (*ptrcomp)(array2[v2], array1[v1]) > 0 )

10657 if

( array2[v2] == array1[v1] )

10659

intersectarray[cnt++] = array2[v2];

10667

*nintersectarray = cnt;

10680 int

* setminusarray,

10682 int

* nsetminusarray

10697 int

* setminusarray,

10699 int

* nsetminusarray

10707

assert( array1 !=

);

10708

assert( array2 !=

);

10709

assert( setminusarray !=

);

10710

assert( nsetminusarray !=

);

10712 while

( v1 < narray1 )

10716

assert( v1 == 0 || array1[v1] >= array1[v1-1] );

10719 while

( v1 + 1 < narray1 && array1[v1] == array1[v1 + 1] )

10722

entry1 = array1[v1];

10724 while

( v2 < narray2 && array2[v2] < entry1 )

10727 if

( v2 >= narray2 || entry1 < array2[v2] )

10728

setminusarray[cnt++] = entry1;

10733

*nsetminusarray = cnt;

10754 if

( dest ==

|| src ==

|| cnt == 0 )

10758 char

* destination = dest;

10760 while

( cnt-- && (*destination++ = *src++) != stop );

10762 return

(

int

)(destination - dest);

10773 const char

* message

10776#ifdef NO_STRERROR_R 10781#if defined(_WIN32) || defined(_WIN64) 10786#elif (_POSIX_C_SOURCE >= 200112L || __DARWIN_C_LEVEL > 200112L || _XOPEN_SOURCE >= 600) && ! defined(_GNU_SOURCE) 10801 if

( *buf !=

'\0'

)

10806 else if

( errordescr !=

)

10823 const char

* delim,

10827#ifdef SCIP_NO_STRTOK_R 10828 return

strtok(s, delim);

10830 return

strtok_r(s, delim, ptrptr);

10845

assert(t !=

);

10846

assert(bufsize > 0);

10848

len = (int)strlen(s);

10849 for

( p = 0, i = 0; i <= len && p < bufsize; ++i, ++p )

10851 if

( s[i] ==

'\\'

)

10857 else if

( s[i] ==

' '

|| s[i] ==

'\"'

|| s[i] ==

'\''

)

10862 if

( i <= len && p < bufsize )

10865

t[bufsize-1] =

'\0'

;

10873 while

( isspace(**s) || ( **s ==

'\\'

&& *(*s+1) !=

'\0'

&& strchr(

SCIP_SPACECONTROL

, *(*s+1)) ) )

10874

*s += **s ==

'\\'

? 2 : 1;

10890

assert(t !=

);

10895#if defined(_MSC_VER) && _MSC_VER < 1900 10896

n = _vsnprintf(t, (

size_t

) len, s, ap);

10898

n = vsnprintf(t, (

size_t

) len, s, ap);

10902 if

( n < 0 || n >= len )

10922 return

_stricmp(s1, s2);

10924 return

strcasecmp(s1, s2);

10935

assert(length >= 0);

10937 return

_strnicmp(s1, s2, (

size_t

)length);

10939 return

strncasecmp(s1, s2, (

size_t

)length);

10963 for

( n = 0; n < size && *s !=

'\0'

; n++ )

10983

assert(str !=

);

10984

assert(value !=

);

10985

assert(endptr !=

);

10990

*value = (int) strtol(str, endptr, 10);

10992 if

( *endptr != str && *endptr !=

)

10997

*endptr = (

char

*)str;

11014

assert(str !=

);

11015

assert(value !=

);

11016

assert(endptr !=

);

11021

*value = strtod(str, endptr);

11023 if

( *endptr != str && *endptr !=

)

11028

*endptr = (

char

*)str;

11047 const char

* copystr;

11050

assert(str !=

);

11051

assert(token !=

);

11053

assert(endptr !=

);

11060 while

( *str !=

'\0'

&& *str != startchar )

11064 if

( *str ==

'\0'

)

11066

*endptr = (

char

*)copystr;

11074 while

( *str !=

'\0'

&& *str != endchar && nchars < size-1 )

11077

token[nchars] = *str;

11083

token[nchars] =

'\0'

;

11086 if

( nchars == (size-1) )

11087 while

( *str !=

'\0'

&& *str != endchar )

11091 if

( *str ==

'\0'

)

11093

*endptr = (

char

*)copystr;

11102

*endptr = (

char

*) str;

11111 const char

* filename

11116

f = fopen(filename,

"r"

);

11131 char

** compression

11135 char

* lastbackslash;

11138

assert(filename !=

);

11140 if

( path !=

)

11142 if

( name !=

)

11144 if

( extension !=

)

11145

*extension =

;

11146 if

( compression !=

)

11147

*compression =

;

11150

lastslash = strrchr(filename,

'/'

);

11151

lastbackslash = strrchr(filename,

'\\'

);

11152

lastslash =

(lastslash, lastbackslash);

11153

lastdot = strrchr(filename,

'.'

);

11154 if

( lastslash !=

&& lastdot !=

&& lastdot < lastslash )

11158#ifdef SCIP_WITH_ZLIB 11159 if

( lastdot !=

)

11163

compext = lastdot+1;

11164 if

( strcmp(compext,

"gz"

) == 0

11165

|| strcmp(compext,

"z"

) == 0

11166

|| strcmp(compext,

"Z"

) == 0 )

11168 if

( compression !=

)

11169

*compression = compext;

11174

lastdot = strrchr(filename,

'.'

);

11175 if

( lastslash !=

&& lastdot !=

&& lastdot < lastslash )

11180 if

( lastslash ==

)

11182 if

( name !=

)

11187 if

( path !=

)

11189 if

( name !=

)

11190

*name = lastslash+1;

11191

*lastslash =

'\0'

;

11194 if

( lastdot !=

)

11196 if

( extension !=

)

11197

*extension = lastdot+1;

11226

quot =

MAX3

(1.0, absval1, absval2);

11228 return

(val1-val2)/quot;

11240 if

(

EPSEQ

(primalbound, dualbound,

) )

11247 if

(

EPSZ

(dualbound,

) ||

EPSZ

(primalbound,

) || absprimal >= inf || absdual >= inf ||

11248

primalbound * dualbound < 0.0 )

11251 return REALABS

((primalbound - dualbound)/

(absdual, absprimal));

11266

assert(djset !=

);

11267

assert(blkmem !=

);

11270

assert(ncomponents > 0);

11274

(*djset)->size = ncomponents;

11295

djset->

sizes

[i] = 1;

11306 int

root = element;

11307 int

* parents = djset->

parents

;

11310 while

( root != parents[root] )

11312

root = parents[root];

11316 while

( element != root )

11318

newelement = parents[element];

11319

parents[element] = root;

11320

element = newelement;

11339

assert(djset !=

);

11342

assert(djset->

> p);

11343

assert(djset->

> q);

11352

sizes = djset->

sizes

;

11357

parents[idq] = idp;

11358

sizes[idp] += sizes[idq];

11362 if

( sizes[idp] < sizes[idq] )

11364

parents[idp] = idq;

11365

sizes[idq] += sizes[idp];

11369

parents[idq] = idp;

11370

sizes[idp] += sizes[idq];

11385

assert(djset !=

);

11386

assert(*djset !=

);

11401

assert(djset !=

);

11411

assert(djset !=

);

11413 return

djset->

;

11425

assert(s !=

);

11426

assert(t !=