A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: symmetry_orbitopal.c Source File

114#define SYMHDLR_NAME "orbitopalreduction" 117#define EVENTHDLR_NAME "symmetry_orbitopal_eventhdlr" 118#define EVENTHDLR_DESC "event handler for maintaining the branch-and-bound tree" 119#define DEFAULT_COLUMNORDERING SCIP_COLUMNORDERING_MEDIAN 145struct

SCIP_OrbitopalReductionData

172

assert( orbireddata !=

NULL

);

173

assert( orbireddata->conshdlr_nonlinear_checked );

183

assert( orbireddata->conshdlr_nonlinear_checked );

184 return

orbireddata->conshdlr_nonlinear ==

NULL

?

FALSE

:

235 return

(

unsigned int

) nodeinfo->

nodenumber

;

259

assert( orbidata !=

NULL

);

261

assert( col1 < orbidata->ncols );

263

assert( col2 < orbidata->ncols );

266 for

(i = 0; i < orbidata->

nrows

; ++i)

268

var1 = orbidata->

vars

[i * orbidata->

ncols

+ col1];

269

var2 = orbidata->

vars

[i * orbidata->

ncols

+ col2];

310 int

* origequalcolids;

311 int

norigequalcolids;

312 int

middlecolumn = 0;

313 int

positionorigcolidincolorder;

314 int

positionswaporigcolidincolorder;

324

assert( orbidata !=

NULL

);

325

assert( colorder !=

NULL

);

326

assert( colorderinv !=

NULL

);

327

assert( var !=

NULL

);

328

assert( thiscolswap !=

NULL

);

329

assert( orbidata->

ncols

> 0 );

330

assert( orbidata->

nrows

> 0 );

332

ncols = orbidata->

ncols

;

342

thiscolswap->

from

= 0;

343

thiscolswap->

to

= 0;

349 if

( origcolid == INT_MAX )

351

thiscolswap->

from

= 0;

352

thiscolswap->

to

= 0;

355

assert( origcolid >= 0 );

356

assert( origcolid < ncols );

360

swaporigcolid = origcolid;

366

middlecolumn = ncols / 2;

371 for

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

374 if

( c == origcolid )

384 if

( colorderinv[c] >= colorderinv[swaporigcolid] )

389 if

( colorderinv[c] <= colorderinv[swaporigcolid] )

394 if

(

ABS

(colorderinv[c] - middlecolumn) >=

395 ABS

(colorderinv[swaporigcolid] - middlecolumn) )

415

norigequalcolids = 0;

419#ifdef SCIP_MORE_DEBUG 420 SCIPdebugMessage

(

"Detect columns identical to original column %d: "

, origcolid);

422 for

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

425 if

( c == origcolid )

427

origequalcolids[norigequalcolids++] = c;

428#ifdef SCIP_MORE_DEBUG 431

assert( norigequalcolids <= ncols );

440

origequalcolids[norigequalcolids++] = c;

441#ifdef SCIP_MORE_DEBUG 444

assert( norigequalcolids <= ncols );

446#ifdef SCIP_MORE_DEBUG 451

assert( norigequalcolids >= 1 );

458 SCIPsortInd

(origequalcolids, SCIPsortArgsortInt, colorderinv, norigequalcolids);

460

swaporigcolid = origequalcolids[norigequalcolids / 2];

474

thiscolswap->

from

= swaporigcolid;

475

thiscolswap->

to

= origcolid;

478 if

( swaporigcolid == origcolid )

483 for

(i = 0; i <

nrows

; ++i)

485

var1 = orbidata->

vars

[i * ncols + swaporigcolid];

486

var2 = orbidata->

vars

[i * ncols + origcolid];

495

positionorigcolidincolorder = colorderinv[origcolid];

496

assert( positionorigcolidincolorder >= 0 );

497

assert( positionorigcolidincolorder < ncols );

498

assert( colorder[positionorigcolidincolorder] == origcolid );

501

positionswaporigcolidincolorder = colorderinv[swaporigcolid];

502

assert( positionswaporigcolidincolorder >= 0 );

503

assert( positionswaporigcolidincolorder < ncols );

504

assert( colorder[positionswaporigcolidincolorder] == swaporigcolid );

506 SCIPdebugMessage

(

"Orbitope %p: Swapping column %d (at position %d) with column %d (at position %d)\n"

,

507

(

void

*) orbidata, origcolid, positionorigcolidincolorder, swaporigcolid, positionswaporigcolidincolorder);

510

colorder[positionswaporigcolidincolorder] = origcolid;

511

colorder[positionorigcolidincolorder] = swaporigcolid;

512

colorderinv[origcolid] = positionswaporigcolidincolorder;

513

colorderinv[swaporigcolid] = positionorigcolidincolorder;

542

assert( orbidata !=

NULL

);

543

assert( roworder !=

NULL

);

547

assert( *roworder ==

NULL

);

551

assert( *roworder !=

NULL

);

580

assert( orbidata !=

NULL

);

581

assert( orbidata->

nrows

> 0 );

582

assert( orbidata->

ncols

> 0 );

583

assert( node !=

NULL

);

584

assert( roworder !=

NULL

);

585

assert( nselrows !=

NULL

);

590

*nselrows = orbidata->

nrows

;

603 while

(node !=

NULL

)

608 if

( ancestornodeinfo !=

NULL

)

610

assert( ancestornodeinfo->

nrows

>= 0 );

611 for

(i = ancestornodeinfo->

nrows

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

613

(*roworder)[(*nselrows)++] = ancestornodeinfo->

rows

[i];

617 for

(j = 0; j < (*nselrows) - 1; ++j)

619

assert( ancestornodeinfo->

rows

[i] != (*roworder)[j] );

630 for

(i = 0; i < (*nselrows) / 2; ++i)

634

(*roworder)[i] = (*roworder)[(*nselrows) - 1 - i];

635

(*roworder)[(*nselrows) - 1 - i] = j;

659

assert( orbidata !=

NULL

);

660

assert( node !=

NULL

);

661

assert( rootedpath !=

NULL

);

662

assert( colorder !=

NULL

);

663

assert( colorderinv !=

NULL

);

667 while

( node !=

NULL

)

670

rootedpath[i--] = node;

675 for

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

677

node = rootedpath[i];

686 if

( ancestornodeinfo ==

NULL

)

692 for

(j = 0; j < ancestornodeinfo->

ncolswaps

; ++j)

694 int

positionfromincolorder;

695 int

positiontoincolorder;

697

thiscolswap = &ancestornodeinfo->

colswaps

[j];

698

assert( thiscolswap->

from

!= thiscolswap->

to

);

699

assert( thiscolswap->

from

>= 0 && thiscolswap->

from

< orbidata->

ncols

);

700

assert( thiscolswap->

to

>= 0 && thiscolswap->

to

< orbidata->

ncols

);

703

positionfromincolorder = colorderinv[thiscolswap->

from

];

704

assert( positionfromincolorder >= 0 );

705

assert( positionfromincolorder < orbidata->ncols );

706

assert( colorder[positionfromincolorder] == thiscolswap->

from

);

709

positiontoincolorder = colorderinv[thiscolswap->

to

];

710

assert( positiontoincolorder >= 0 );

711

assert( positiontoincolorder < orbidata->ncols );

712

assert( colorder[positiontoincolorder] == thiscolswap->

to

);

715

colorder[positiontoincolorder] = thiscolswap->

from

;

716

colorder[positionfromincolorder] = thiscolswap->

to

;

717

colorderinv[thiscolswap->

from

] = positiontoincolorder;

718

colorderinv[thiscolswap->

to

] = positionfromincolorder;

749

assert( eventdata !=

NULL

);

756

assert( orbidata !=

NULL

);

757

assert( orbidata->

nrows

> 0 );

758

assert( orbidata->

ncols

> 0 );

772 for

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

774

childnode = children[c];

779 for

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

783

assert( boundchg !=

NULL

);

797 if

( nbranchvars > 0 )

799 for

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

801 if

( branchvars[j] == var )

807 if

( j < nbranchvars )

812 if

( nbranchvars >= maxnbranchvars )

814

assert( nbranchvars == maxnbranchvars );

815

assert( maxnbranchvars > 0 );

819

assert( nbranchvars < maxnbranchvars );

820

branchvars[nbranchvars++] = var;

825 if

( nbranchvars <= 0 )

833

newnodeinfo->

nrows

= 0;

841

assert( orbidata->

nrows

> 0 );

846

assert( roworder !=

NULL

);

849 for

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

855

assert( rowid >= 0 );

856

assert( rowid < orbidata->

nrows

);

861 for

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

863 if

( rowid == roworder[j] )

873

roworder[nselrows++] = rowid;

878

assert( newnodeinfo->

nrows

== 0 );

885

newnodeinfo->

nrows

, newnodeinfo->

nrows

+ 1) );

887

newnodeinfo->

rows

[newnodeinfo->

nrows

++] = rowid;

901

assert( orbidata->

ncols

> 0 );

906 for

(i = 0; i < orbidata->

ncols

; ++i)

910 for

(i = 0; i < orbidata->

ncols

; ++i)

924 for

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

927

colorderinv, branchvars[i], &tmpcolswap) );

930 if

( tmpcolswap.

from

== tmpcolswap.

to

)

936

assert( newnodeinfo->

nrows

== 0 );

946

thiscolswap->

from

= tmpcolswap.

from

;

947

thiscolswap->

to

= tmpcolswap.

to

;

979 return

eventExecNodeBranched(

scip

, eventhdlr, event, eventdata);

1002

assert( orbireddata !=

NULL

);

1003

assert( orbidata !=

NULL

);

1004

assert( orbidata->

nrows

> 0 );

1005

assert( orbidata->

ncols

> 0 );

1006

assert( rowid >= 0 );

1007

assert( rowid < orbidata->

nrows

);

1009

assert( orbidata->

vars

[rowid * orbidata->

ncols

] );

1012

var = orbidata->

vars

[rowid * orbidata->

ncols

];

1016 for

(c = 1; c < orbidata->

ncols

; ++c)

1044

assert( orbireddata !=

NULL

);

1045

assert( orbidata !=

NULL

);

1046

assert( *orbidata !=

NULL

);

1047

assert( (*orbidata)->vars !=

NULL

);

1048

assert( (*orbidata)->nrows > 0 );

1049

assert( (*orbidata)->ncols > 0 );

1050

assert( (*orbidata)->nrows * (*orbidata)->ncols > 0 );

1062 for

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

1068 if

( nodeinfo ==

NULL

)

1071

assert( nodeinfo !=

NULL

);

1077

assert( (nodeinfo->

nrows

== 0) != (nodeinfo->

rows

!=

NULL

) );

1090

nelem = (*orbidata)->nrows * (*orbidata)->ncols;

1091

assert( nelem > 0 );

1092 for

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

1125

assert( orbireddata !=

NULL

);

1126

assert( orbireddata->eventhdlr !=

NULL

);

1127

assert( vars !=

NULL

);

1128

assert(

nrows

>= 0 );

1129

assert( ncols >= 0 );

1131

nelem =

nrows

* ncols;

1132

assert( nelem >= 0 );

1146

orbidata->

ncols

= ncols;

1162 SCIPdebugMessage

(

"Orbitope variables for (%dx%d) orbitope with orbidata %p\n"

,

nrows

, ncols, (

void

*) orbidata);

1165 for

(i = 0, rowid = 0, colid = 0; i < nelem; ++i, ++colid)

1167 if

( colid == ncols )

1172

assert(

nrows

> 0 );

1173

assert( ncols > 0 );

1174

assert( rowid == i / ncols );

1175

assert( colid == i % ncols );

1178

assert( var !=

NULL

);

1184

orbidata->

vars

[i] = var;

1199 for

(i = 0; i <

nrows

; ++i)

1221

hashGetKeyBnbnodeinfo, hashKeyEqBnbnodeinfo, hashKeyValBnbnodeinfo,

NULL

) );

1225

assert( orbireddata->norbitopes >= 0 );

1226

assert( (orbireddata->norbitopes == 0) == (orbireddata->orbitopes ==

NULL

) );

1227

assert( orbireddata->norbitopes <= orbireddata->maxnorbitopes );

1228 if

( orbireddata->norbitopes == orbireddata->maxnorbitopes )

1233

assert( newsize >= 0 );

1235 if

( orbireddata->norbitopes == 0 )

1244

orbireddata->maxnorbitopes = newsize;

1246

assert( orbireddata->orbitopes !=

NULL

);

1247

assert( orbireddata->norbitopes < orbireddata->maxnorbitopes );

1250

assert( orbireddata->norbitopes < orbireddata->maxnorbitopes );

1251

orbireddata->orbitopes[orbireddata->norbitopes++] = orbidata;

1270

assert( orbidata !=

NULL

);

1271

assert( colorder !=

NULL

);

1272

assert( colorderinv !=

NULL

);

1276

assert( *colorder ==

NULL

);

1277

assert( *colorderinv ==

NULL

);

1280

assert( *colorder !=

NULL

);

1281

assert( *colorderinv !=

NULL

);

1308

assert( orbidata !=

NULL

);

1309

assert( eventnode !=

NULL

);

1310

assert( colorder !=

NULL

);

1311

assert( colorderinv !=

NULL

);

1316

*colorderinv =

NULL

;

1319

ncols = orbidata->

ncols

;

1320

assert( ncols > 0 );

1326 for

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

1330 for

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

1331

(*colorderinv)[i] = i;

1361 int

* infinitesimal,

1374

assert( matrix !=

NULL

);

1375

assert( orbidata !=

NULL

);

1377

assert(

nrows

>= 0 );

1378

assert( nrows <= orbidata->

nrows

);

1379

assert( ncols >= 0 );

1380

assert( ncols <= orbidata->ncols );

1381

assert( infinitesimal !=

NULL

);

1384 for

(rowid = 0; rowid <

nrows

; ++rowid)

1387 for

(colid = 0; colid < ncols; ++colid)

1390

idx = rowid * ncols + colid;

1391

origidx = origrowid * ncols + origcolid;

1392

var = orbidata->

vars

[origidx];

1399 for

(colid = 0; colid < ncols - 1; ++colid)

1402 for

(rowid = 0; rowid <

nrows

; ++rowid)

1405

assert(

SCIPsymGE

(

scip

, matrix[rowid * ncols + colid], matrix[rowid * ncols + colid + 1]) );

1407 if

(

SCIPsymGT

(

scip

, matrix[rowid * ncols + colid], matrix[rowid * ncols + colid + 1]) )

1420

assert(

SCIPsymEQ

(

scip

, matrix[rowid * ncols + colid], matrix[rowid * ncols + colid + 1]) );

1421 if

( addinfinitesimals

1422

? (infinitesimal[colid] == rowid)

1423

: (infinitesimal[colid + 1] == rowid)

1444 unsigned int

hash = 0;

1446

assert( array !=

NULL

);

1449 for

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

1451

hash ^= (

unsigned

int) (array[i]);

1452

hash = (hash << 1) ^ (hash >> 1);

1455 return

(

int

) hash;

1459#ifdef SCIP_MORE_DEBUG 1462void

debugPrintMatrix(

1471

assert( matrix !=

NULL

);

1472

assert(

nrows

>= 0 );

1473

assert( ncols >= 0 );

1475 for

(row = 0; row <

nrows

; ++row)

1478 for

(col = 0; col < ncols; ++col)

1502 int

* lexminepsrow =

NULL

;

1504 int

* lexmaxepsrow =

NULL

;

1522

assert( orbidata !=

NULL

);

1524

assert( nselrows >= 0 );

1525

assert( infeasible !=

NULL

);

1526

assert( nfixedvars !=

NULL

);

1528

*infeasible =

FALSE

;

1530

assert( orbidata->

nrows

> 0 );

1531

assert( orbidata->

nrows

>= nselrows );

1532

ncols = orbidata->

ncols

;

1533

assert( ncols > 1 );

1536 if

( nselrows <= 0 )

1539#ifdef SCIP_MORE_DEBUG 1547 for

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

1553 for

(

r

= 0;

r

< nselrows; ++

r

)

1556 for

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

1558

thisvar = orbidata->

vars

[roworder[

r

] * ncols + colorder[k]];

1567

nelem = nselrows * ncols;

1574 for

(colid = 0; colid < ncols; ++colid)

1575

lexminepsrow[colid] = -1;

1580 for

(rowid = 0, i = colid; rowid < nselrows; ++rowid, i += ncols)

1583

origidx = origrowid * ncols + origcolid;

1584

var = orbidata->

vars

[origidx];

1586

assert( i == rowid * ncols + colid );

1587

assert( var !=

NULL

);

1592 for

(colid = ncols - 2; colid >= 0; --colid)

1601 for

(rowid = 0, i = colid; rowid < nselrows; ++rowid, i += ncols)

1604

origidx = origrowid * ncols + origcolid;

1605

assert( i == rowid * ncols + colid );

1608

assert( (i + 1) % ncols > 0 );

1610

var = orbidata->

vars

[origidx];

1611

assert( var !=

NULL

);

1626

( lexminepsrow[colid + 1] == rowid &&

SCIPsymEQ

(

scip

, ub, lexminface[i + 1]) ) )

1632 if

( lastunfixed >= 0 )

1635

assert(

SCIPsymEQ

(

scip

, lexminface[lastunfixed * ncols + colid],

1636

lexminface[lastunfixed * ncols + colid + 1]) );

1646

lexminface[lastunfixed * ncols + colid] += 1.0;

1653

assert( lexminepsrow[colid] == -1 );

1654

lexminepsrow[colid] = lastunfixed;

1661

rowid = lastunfixed;

1662

i = rowid * ncols + colid;

1668

*infeasible =

TRUE

;

1669 SCIPdebugMessage

(

"Cannot repair infeasibility for column %d (original: %d), min\n"

, colid, origcolid);

1678

lexminface[i] =

MAX

(lexminface[i + 1], lb);

1679

assert(

SCIPsymGE

(

scip

, lexminface[i], lexminface[i + 1]) );

1684 else if

( lexminepsrow[colid + 1] == rowid )

1686

assert(

SCIPsymEQ

(

scip

, lexminface[i], lexminface[i + 1]) );

1695

assert( lexminepsrow[colid] == -1 );

1696

lexminepsrow[colid] = rowid;

1710

lastunfixed = rowid;

1717

lastunfixed = rowid;

1742 for

(colid = 0; colid < ncols; ++colid)

1743

lexmaxepsrow[colid] = -1;

1748 for

(rowid = 0, i = colid; rowid < nselrows; ++rowid, i += ncols)

1751

origidx = origrowid * ncols + origcolid;

1752

var = orbidata->

vars

[origidx];

1754

assert( i == rowid * ncols + colid );

1755

assert( var !=

NULL

);

1760 for

(colid = 1; colid < ncols; ++colid)

1769 for

(rowid = 0, i = colid; rowid < nselrows; ++rowid, i += ncols)

1772

origidx = origrowid * ncols + origcolid;

1773

assert( i == rowid * ncols + colid );

1776

assert( i % ncols > 0 );

1778

var = orbidata->

vars

[origidx];

1779

assert( var !=

NULL

);

1794

( lexmaxepsrow[colid - 1] == rowid &&

SCIPsymEQ

(

scip

, lb, lexmaxface[i - 1]) ) )

1800 if

( lastunfixed >= 0 )

1803

assert(

SCIPsymEQ

(

scip

, lexmaxface[lastunfixed * ncols + colid],

1804

lexmaxface[lastunfixed * ncols + colid - 1]) );

1814

lexmaxface[lastunfixed * ncols + colid] -= 1.0;

1823

assert( lexmaxepsrow[colid] == -1 );

1824

lexmaxepsrow[colid] = lastunfixed;

1831

rowid = lastunfixed;

1832

i = rowid * ncols + colid;

1838

*infeasible =

TRUE

;

1839 SCIPdebugMessage

(

"Cannot repair infeasibility for column %d (original: %d), max\n"

, colid, origcolid);

1848

lexmaxface[i] =

MIN

(lexmaxface[i - 1], ub);

1849

assert(

SCIPsymGE

(

scip

, lexmaxface[i - 1], lexmaxface[i]) );

1854 else if

( lexmaxepsrow[colid - 1] == rowid )

1856

assert(

SCIPsymEQ

(

scip

, lexmaxface[i - 1], lexmaxface[i]) );

1865

assert( lexmaxepsrow[colid] == -1 );

1866

lexmaxepsrow[colid] = rowid;

1880

lastunfixed = rowid;

1887

lastunfixed = rowid;

1907#ifdef SCIP_MORE_DEBUG 1910

debugPrintMatrix(lexminface, nselrows, ncols);

1912

debugPrintMatrix(lexmaxface, nselrows, ncols);

1916 for

(colid = 0; colid < ncols; ++colid)

1918 for

(rowid = 0, i = colid; rowid < nselrows; ++rowid, i += ncols)

1920

assert( i == rowid * ncols + colid );

1925

origidx = origrowid * ncols + origcolid;

1926

var = orbidata->

vars

[origidx];

1934 SCIPdebugMessage

(

"Fixing variable LB %12s (%3d,%3d) to %5.2f\n"

, var->

name

, rowid, colid, lexminface[i]);

1939 SCIPdebugMessage

(

"Fixing variable LB %12s (%3d,%3d) to %5.2f (no success)\n"

, var->

name

, rowid, colid,

1944 SCIPdebugMessage

(

"Detected infeasibility fixing variable %12s (%3d,%3d) to %5.2f\n"

,

1945

var->

name

, rowid, colid, lexminface[i]);

1952 SCIPdebugMessage

(

"Fixing variable UB %12s (%3d,%3d) to %5.2f\n"

, var->

name

, rowid, colid, lexminface[i]);

1957 SCIPdebugMessage

(

"Fixing variable UB %12s (%3d,%3d) to %5.2f (no success)\n"

, var->

name

, rowid, colid,

1962 SCIPdebugMessage

(

"Detected infeasibility fixing variable %12s (%3d,%3d) to %5.2f\n"

,

1963

var->

name

, rowid, colid, lexminface[i]);

1976 SCIPdebugMessage

(

"Restricting variable LB %12s (%3d,%3d) to %5.2f\n"

, var->

name

, rowid, colid,

1982 SCIPdebugMessage

(

"Restricting variable LB %12s (%3d,%3d) to %5.2f (no success)\n"

, var->

name

,

1983

rowid, colid, lexminface[i]);

1987 SCIPdebugMessage

(

"Detected infeasibility restricting variable LB %12s (%3d,%3d) to %5.2f\n"

,

1988

var->

name

, rowid, colid, lexminface[i]);

1996 SCIPdebugMessage

(

"Restricting variable UB %12s (%3d,%3d) to %5.2f\n"

, var->

name

, rowid, colid,

2002 SCIPdebugMessage

(

"Restricting variable UB %12s (%3d,%3d) to %5.2f (no success)\n"

, var->

name

,

2003

rowid, colid, lexmaxface[i]);

2007 SCIPdebugMessage

(

"Detected infeasibility restricting variable UB %12s (%3d,%3d) to %5.2f\n"

,

2008

var->

name

, rowid, colid, lexmaxface[i]);

2042

assert( orbidata !=

NULL

);

2043

assert( infeasible !=

NULL

);

2044

assert( nfixedvars !=

NULL

);

2047

*infeasible =

FALSE

;

2049

assert( orbidata->

ncols

> 0 );

2050

assert( orbidata->

nrows

> 0 );

2053

assert( focusnode !=

NULL

);

2057

assert( nselrows >= 0 );

2058

assert( nselrows <= orbidata->

nrows

);

2059 if

( nselrows == 0 )

2071 int

hash = colhash ^ rowhash;

2074 SCIPdebugPrintf

(

"Col hash %32d; Row hash %32d; Hash %32d\n"

, colhash, rowhash, hash);

2078 while

( tmpnode !=

NULL

)

2080 int

nbranchings, nconsprop, nprop;

2083 SCIPdebugPrintf

(

" node %lld: (%d, %d, %d) \n"

, tmpnode->

number

, nbranchings, nconsprop, nprop);

2092

assert( orbidata->

dbghash

== hash );

2105#ifdef SCIP_MORE_DEBUG 2127

assert( orbireddata !=

NULL

);

2128

assert( nred !=

NULL

);

2130

*nred = orbireddata->nred;

2131

*ncutoff = orbireddata->ncutoff;

2146

assert( orbireddata !=

NULL

);

2148 if

( orbireddata->norbitopes == 0 )

2155 " orbitopal reduction: %4d components: "

, orbireddata->norbitopes);

2156 for

(i = 0; i < orbireddata->norbitopes; ++i)

2161 "%dx%d"

, orbireddata->orbitopes[i]->nrows, orbireddata->orbitopes[i]->ncols);

2184

assert( orbireddata !=

NULL

);

2185

assert( (orbireddata->norbitopes == 0) == (orbireddata->orbitopes ==

NULL

) );

2186

assert( infeasible !=

NULL

);

2187

assert( nred !=

NULL

);

2189

*infeasible =

FALSE

;

2204 for

(c = 0; c < orbireddata->norbitopes; ++c)

2206

orbidata = orbireddata->orbitopes[c];

2207

assert( orbidata !=

NULL

);

2210 SCIPdebugMessage

(

"Found %d reductions during orbitopal reduction for orbitope %d\n"

, thisfixedvars, c);

2211

*nred += thisfixedvars;

2219 SCIPdebugMessage

(

"Detected infeasibility during orbitopal reduction for orbitope %d\n"

, c);

2224

orbireddata->nred += *nred;

2226

++orbireddata->ncutoff;

2244

assert( orbireddata !=

NULL

);

2245

assert( vars !=

NULL

);

2246

assert(

nrows

> 0 );

2247

assert( ncols > 0 );

2253 if

( !orbireddata->conshdlr_nonlinear_checked )

2256

orbireddata->conshdlr_nonlinear_checked =

TRUE

;

2273

assert( orbireddata !=

NULL

);

2274

assert( orbireddata->norbitopes >= 0 );

2275

assert( (orbireddata->norbitopes == 0) == (orbireddata->orbitopes ==

NULL

) );

2276

assert( orbireddata->norbitopes <= orbireddata->maxnorbitopes );

2277

assert( orbireddata->eventhdlr !=

NULL

);

2280 while

(orbireddata->norbitopes > 0)

2284

assert( orbireddata->norbitopes == 0 );

2286

orbireddata->orbitopes =

NULL

;

2287

orbireddata->maxnorbitopes = 0;

2300

assert( orbireddata !=

NULL

);

2301

assert( *orbireddata !=

NULL

);

2322

assert( orbireddata !=

NULL

);

2332 "The column ordering variant, respects enum SCIP_ColumnOrdering."

,

2339

assert( eventhdlr !=

NULL

);

2340

(*orbireddata)->eventhdlr = eventhdlr;

2343

(*orbireddata)->orbitopes =

NULL

;

2344

(*orbireddata)->norbitopes = 0;

2345

(*orbireddata)->maxnorbitopes = 0;

2348

(*orbireddata)->conshdlr_nonlinear =

NULL

;

2349

(*orbireddata)->conshdlr_nonlinear_checked =

FALSE

;

2352

(*orbireddata)->nred = 0;

2353

(*orbireddata)->ncutoff = 0;

2364

assert( orbireddata !=

NULL

);

2366 return

orbireddata->defaultcolumnordering;

SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)

SCIP_Bool SCIPisTransformed(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)

SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)

void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)

int SCIPhashtableGetNEntries(SCIP_HASHTABLE *hashtable)

SCIP_RETCODE SCIPhashtableSafeInsert(SCIP_HASHTABLE *hashtable, void *element)

void * SCIPhashtableGetEntry(SCIP_HASHTABLE *hashtable, int entryidx)

SCIP_RETCODE SCIPhashtableCreate(SCIP_HASHTABLE **hashtable, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)

void * SCIPhashtableRetrieve(SCIP_HASHTABLE *hashtable, void *key)

void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)

SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)

int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)

SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)

SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)

SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)

SCIP_NODE * SCIPeventGetNode(SCIP_EVENT *event)

SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPfreeBufferArrayNull(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

void SCIPnodeGetNDomchg(SCIP_NODE *node, int *nbranchings, int *nconsprop, int *nprop)

SCIP_DOMCHG * SCIPnodeGetDomchg(SCIP_NODE *node)

SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)

SCIP_NODE * SCIPnodeGetParent(SCIP_NODE *node)

int SCIPnodeGetDepth(SCIP_NODE *node)

SCIP_Bool SCIPinProbing(SCIP *scip)

SCIP_Longint SCIPgetNNodes(SCIP *scip)

SCIP_Bool SCIPsymGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsymEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsymLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsymGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsymLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)

SCIP_RETCODE SCIPgetChildren(SCIP *scip, SCIP_NODE ***children, int *nchildren)

SCIP_NODE * SCIPgetFocusNode(SCIP *scip)

SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)

SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)

SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)

SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG *boundchg)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)

SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)

SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)

void SCIPsortInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)

memory allocation routines

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

public methods for managing constraints

public methods for message output

public methods for problem variables

public methods for branching rule plugins and branching

public methods for conflict handler plugins and conflict analysis

public methods for constraint handler plugins and constraints

public methods for problem copies

public methods for cuts and aggregation rows

public methods for the LP relaxation, rows and columns

public methods for memory management

public methods for message handling

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for global and local (sub)problems

public methods for the probing mode

public methods for solutions

public methods for SCIP variables

SCIP_HASHMAP * rowindexmap

SCIP_Longint lastnodenumber

SCIP_HASHTABLE * nodeinfos

SCIP_ROWORDERING rowordering

SCIP_HASHMAP * colindexmap

SCIP_COLUMNORDERING columnordering

datastructures for block memory pools and memory buffers

SCIP main data structure.

data structures for branch and bound tree

datastructures for problem variables

methods for handling symmetries

static SCIP_RETCODE propagateStaticOrbitope(SCIP *scip, ORBITOPEDATA *orbidata, int *roworder, int nselrows, int *colorder, SCIP_Bool *infeasible, int *nfixedvars)

static SCIP_RETCODE getRowOrder(SCIP *scip, ORBITOPEDATA *orbidata, SCIP_NODE *node, int **roworder, int *nselrows)

static SCIP_DECL_EVENTEXEC(eventExecNodeBranched)

static SCIP_RETCODE populateRootedPathColumnOrder(ORBITOPEDATA *orbidata, SCIP_NODE *node, SCIP_NODE **rootedpath, int *colorder, int *colorderinv)

static SCIP_RETCODE freeOrbitope(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, ORBITOPEDATA **orbidata)

static int debugGetArrayHash(int *array, int len)

static void freeColumnOrder(SCIP *scip, ORBITOPEDATA *orbidata, int **colorder, int **colorderinv)

SCIP_RETCODE SCIPincludeOrbitopalReduction(SCIP *scip, SCIP_ORBITOPALREDDATA **orbireddata)

static SCIP_DECL_HASHGETKEY(hashGetKeyBnbnodeinfo)

SCIP_RETCODE SCIPorbitopalReductionFree(SCIP *scip, SCIP_ORBITOPALREDDATA **orbireddata)

SCIP_RETCODE SCIPorbitopalReductionReset(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata)

static SCIP_RETCODE propagateOrbitope(SCIP *scip, ORBITOPEDATA *orbidata, SCIP_Bool *infeasible, int *nfixedvars)

SCIP_RETCODE SCIPorbitopalReductionAddOrbitope(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, SCIP_ROWORDERING rowordering, SCIP_COLUMNORDERING colordering, SCIP_VAR **vars, int nrows, int ncols, SCIP_Bool *success)

static SCIP_Bool rowIsBranchRow(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, ORBITOPEDATA *orbidata, int rowid)

SCIP_RETCODE SCIPorbitopalReductionPropagate(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, SCIP_Bool *infeasible, int *nred, SCIP_Bool *didrun)

static void freeRowOrder(SCIP *scip, ORBITOPEDATA *orbidata, int **roworder)

SCIP_RETCODE SCIPorbitopalReductionGetStatistics(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, int *nred, int *ncutoff)

static SCIP_RETCODE updateColumnOrderWhenBranchingOnColumn(SCIP *scip, ORBITOPEDATA *orbidata, int *colorder, int *colorderinv, SCIP_VAR *var, COLSWAP *thiscolswap)

static SCIP_DECL_HASHKEYVAL(hashKeyValBnbnodeinfo)

static SCIP_RETCODE addOrbitope(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, SCIP_ROWORDERING rowordering, SCIP_COLUMNORDERING colordering, SCIP_VAR **vars, int nrows, int ncols, SCIP_Bool *success)

SCIP_RETCODE SCIPorbitopalReductionPrintStatistics(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata)

static SCIP_Bool testColumnsAreSymmetricallyEquivalent(SCIP *scip, ORBITOPEDATA *orbidata, int col1, int col2)

static SCIP_RETCODE getColumnOrder(SCIP *scip, ORBITOPEDATA *orbidata, SCIP_NODE *eventnode, int **colorder, int **colorderinv)

static SCIP_Bool vartypeIsBranchRowType(SCIP *scip, SCIP_ORBITOPALREDDATA *orbireddata, SCIP_VARTYPE vartype)

static SCIP_DECL_HASHKEYEQ(hashKeyEqBnbnodeinfo)

SCIP_COLUMNORDERING SCIPorbitopalReductionGetDefaultColumnOrdering(SCIP_ORBITOPALREDDATA *orbireddata)

static int getArrayEntryOrIndex(int *arr, int idx)

#define DEFAULT_COLUMNORDERING

static void assertIsOrbitopeMatrix(SCIP *scip, ORBITOPEDATA *orbidata, int *roworder, int *colorder, SCIP_Real *matrix, int nrows, int ncols, int *infinitesimal, SCIP_Bool addinfinitesimals)

@ SCIP_COLUMNORDERING_CENTRE

@ SCIP_COLUMNORDERING_FIRST

@ SCIP_COLUMNORDERING_NONE

@ SCIP_COLUMNORDERING_LAST

@ SCIP_COLUMNORDERING_MEDIAN

enum SCIP_ColumnOrdering SCIP_COLUMNORDERING

@ SCIP_ROWORDERING_BRANCHING

struct SCIP_OrbitopalReductionData SCIP_ORBITOPALREDDATA

enum SCIP_RowOrdering SCIP_ROWORDERING

struct SCIP_EventData SCIP_EVENTDATA

#define SCIP_EVENTTYPE_NODEBRANCHED

enum SCIP_Retcode SCIP_RETCODE

type definitions for symmetry computations

type definitions for problem variables

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_BOUNDCHGTYPE_BRANCHING

enum SCIP_Vartype SCIP_VARTYPE

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4