A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: cons_orbitope.c Source File

129#define CONSHDLR_NAME "orbitope" 130#define CONSHDLR_DESC "symmetry breaking constraint handler relying on (partitioning/packing) orbitopes" 131#define CONSHDLR_SEPAPRIORITY +40100 132#define CONSHDLR_ENFOPRIORITY -1005200 133#define CONSHDLR_CHECKPRIORITY -1005200 134#define CONSHDLR_SEPAFREQ -1 135#define CONSHDLR_PROPFREQ 1 136#define CONSHDLR_EAGERFREQ -1 138#define CONSHDLR_MAXPREROUNDS -1 139#define CONSHDLR_DELAYSEPA FALSE 140#define CONSHDLR_DELAYPROP FALSE 141#define CONSHDLR_NEEDSCONS TRUE 143#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP 144#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_MEDIUM 146#define DEFAULT_PPORBITOPE TRUE 147#define DEFAULT_SEPAFULLORBITOPE FALSE 148#define DEFAULT_FORCECONSCOPY FALSE 155struct

SCIP_ConshdlrData

204

assert( consdata !=

NULL

);

205

assert( *consdata !=

NULL

);

207 if

( (*consdata)->usedynamicprop && (*consdata)->rowindexmap !=

NULL

)

212

p = (*consdata)->nspcons;

213

q = (*consdata)->nblocks;

214 for

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

217 for

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

219

assert( (*consdata)->vars[i] !=

NULL

);

229 if

( (*consdata)->usedynamicprop )

267

assert(consdata !=

NULL

);

269 if

( usedynamicprop )

271

assert( ! mayinteract );

284 if

( usedynamicprop )

290 for

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

296

(*consdata)->roworder[i] = i;

298 if

( usedynamicprop )

300

(*consdata)->rowused[i] =

FALSE

;

303

(*consdata)->nrowsused = 0;

305

(*consdata)->tmpvals =

NULL

;

306

(*consdata)->tmpvars =

NULL

;

307

(*consdata)->nspcons = nspcons;

308

(*consdata)->nblocks = nblocks;

309

(*consdata)->orbitopetype = orbitopetype;

310

(*consdata)->resolveprop = resolveprop;

311

(*consdata)->istrianglefixed =

FALSE

;

312

(*consdata)->ismodelcons = ismodelcons;

313

(*consdata)->mayinteract = mayinteract;

314

(*consdata)->usedynamicprop = usedynamicprop;

322 for

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

327 for

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

331 if

( usedynamicprop )

340 for

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

342 for

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

344

assert( (*consdata)->vars[i][j] !=

NULL

);

370

assert( vars !=

NULL

);

371

assert( vars !=

NULL

);

372

assert( *nrows > 0 );

374

assert( type !=

NULL

);

386 if

( npprows >= 3 && ! mayinteract )

391

assert( pprows !=

NULL

);

397 for

(i =

r

; i < *nrows - 1; ++i)

412 if

( pprows !=

NULL

)

431

assert( consdata !=

NULL

);

432

assert( consdata->nspcons > 0 );

433

assert( consdata->nblocks > 0 );

434

assert( consdata->vars !=

NULL

);

436 for

(j = 0; j < consdata->nblocks; ++j)

440 for

(i = 0; i < consdata->nspcons; ++i)

442 for

(j = 0; j < consdata->nblocks; ++j)

451 for

(j = 0; j < consdata->nblocks; ++j)

477 for

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

480 for

(l = 0; l < q; ++l)

485 for

(l = j; l < q; ++l)

487

assert( M[i][l] == 0 );

496

assert( cases[p1][p2] != -1 );

497

assert( p1 >= 0 && p1 < i );

498

assert( p2 >= 0 && p2 < j );

501 if

( cases[p1][p2] == 1 )

506

assert( cases[p1][p2] == 2 || cases[p1][p2] == 3 );

507

assert( M[p1][p2] == 0 );

509 if

( cases[p1][p2] == 3 )

515

assert( cases[p1][p2] == 3 );

518 for

(l = 0; l < q; ++l)

522 for

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

524 for

(l = 0; l < q; ++l)

542 SCIPerrorMessage

(

"unexpected matrix entry <%d>: should be -1, 0 or +1\n"

, M[k][l]);

550 for

(l = 0; l < q; ++l)

554 for

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

575

assert( consdata !=

NULL

);

576

assert( consdata->nspcons > 0 );

577

assert( consdata->nblocks > 0 );

578

assert( consdata->vars !=

NULL

);

579

assert( consdata->vals !=

NULL

);

581 for

(i = 0; i < consdata->nspcons; ++i)

583 for

(j = 0; j < consdata->nblocks; ++j)

615

assert( weights !=

NULL

);

616

assert( cases !=

NULL

);

617

assert( vals !=

NULL

);

621 for

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

623 for

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

627

weights[i][j] = -1.0;

635

minvalue = vals[0][0];

636

weights[0][0] = minvalue;

641 if

( nspcons < nblocks )

644 for

(j = 1; j < diagsize; ++j)

649

minvalue = vals[j][j];

654

weights[j][j] = minvalue;

658 for

(i = 1; i < nspcons; ++i)

660

weights[i][0] = weights[i-1][0] + vals[i][0];

665 for

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

667 for

(j = 1; j < nblocks && j < i; ++j)

672

assert( cases[i-1][j] != -1 );

673

assert( cases[i-1][j-1] != -1 );

675

weightleft = weights[i-1][j-1];

676

weightright = vals[i][j] + weights[i-1][j];

681

weights[i][j] = weightleft;

686

weights[i][j] = weightright;

714

assert( cons !=

NULL

);

715

assert( infeasible !=

NULL

);

716

assert( nfixedvars !=

NULL

);

719

assert( consdata !=

NULL

);

720

assert( consdata->nspcons > 0 );

721

assert( consdata->nblocks > 0 );

722

assert( consdata->vars !=

NULL

);

724

*infeasible =

FALSE

;

727 if

( consdata->istrianglefixed )

730

nspcons = consdata->nspcons;

731

nblocks = consdata->nblocks;

732

vars = consdata->vars;

737 if

( nspcons < nblocks )

741 for

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

743 for

(j = i+1; j < nblocks; ++j)

750 SCIPdebugMsg

(

scip

,

"The problem is infeasible: some variable in the upper right triangle is fixed to 1.\n"

);

758

fixedglobal =

FALSE

;

761 if

( *nfixedvars > 0 )

763 SCIPdebugMsg

(

scip

,

"<%s>: %s fixed upper right triangle to 0 (fixed vars: %d).\n"

,

SCIPconsGetName

(cons), fixedglobal ?

"globally"

:

"locally"

, *nfixedvars);

771

consdata->istrianglefixed =

TRUE

;

802

assert( conshdlr !=

NULL

);

803

assert( cons !=

NULL

);

804

assert( infeasible !=

NULL

);

805

assert( nfixedvars !=

NULL

);

806

assert( ncuts !=

NULL

);

808

assert( consdata !=

NULL

);

809

assert( consdata->nspcons > 0 );

810

assert( consdata->nblocks > 0 );

811

assert( consdata->vars !=

NULL

);

812

assert( consdata->vals !=

NULL

);

813

assert( consdata->tmpvars !=

NULL

);

814

assert( consdata->tmpvals !=

NULL

);

815

assert( consdata->weights !=

NULL

);

816

assert( consdata->cases !=

NULL

);

818

*infeasible =

FALSE

;

822

nspcons = consdata->nspcons;

823

nblocks = consdata->nblocks;

824

vars = consdata->vars;

825

vals = consdata->vals;

826

tmpvars = consdata->tmpvars;

827

tmpvals = consdata->tmpvals;

828

weights = consdata->weights;

829

cases = consdata->cases;

832 if

( ! consdata->istrianglefixed )

837 if

( *nfixedvars > 0 )

845 for

(i = 1; i < nspcons && ! (*infeasible); ++i)

851

lastcolumn = nblocks - 1;

852 if

( lastcolumn > i )

857 for

(j = lastcolumn; j > 0; --j)

880 for

(l = j; l <= lastcolumn; ++l)

882

tmpvars[nvars] = vars[i][l];

883

tmpvals[nvars] = 1.0;

890

assert( cases[p1][p2] != -1 );

891

assert( p1 >= 0 && p1 < i );

892

assert( p2 >= 0 && p2 < j );

895 if

(cases[p1][p2] == 1)

900

assert( cases[p1][p2] == 2 || cases[p1][p2] == 3 );

901

tmpvars[nvars] = vars[p1][p2];

902

tmpvals[nvars] = -1.0;

905

weight += vals[p1][p2];

907 if

( cases[p1][p2] == 3 )

913

assert( cases[p1][p2] == 3 );

929 SCIP_CALL

( printSCI(

scip

, nspcons, nblocks, cases, i, j) );

963

assert( cons !=

NULL

);

964

assert( infeasible !=

NULL

);

965

assert( nfixedvars !=

NULL

);

973

assert( consdata !=

NULL

);

974

assert( consdata->nspcons > 0 );

975

assert( consdata->nblocks > 0 );

976

assert( consdata->vars !=

NULL

);

978

nspcons = consdata->nspcons;

979

nblocks = consdata->nblocks;

980

vars = consdata->vars;

981

orbitopetype = consdata->orbitopetype;

986 if

( ! consdata->istrianglefixed )

990

*nfixedvars += nfixed;

1000

printMatrix(

scip

, consdata);

1012

lastoneprevrow = -1;

1018 for

(i = 1; i < nspcons; ++i)

1021 int

firstnonzeroinrow;

1026

lastcolumn = nblocks - 1;

1027 if

( lastcolumn > i )

1031

firstnonzeroinrow = -1;

1032 for

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

1039

firstnonzeroinrow = j;

1048

firstnonzeroinrow = j;

1056 SCIPdebugMsg

(

scip

,

" -> Infeasible node: all variables in row %d are fixed to 0.\n"

, i);

1057

*infeasible =

TRUE

;

1061

firstnonzeros[i] = firstnonzeroinrow;

1063

assert( -1 <= firstnonzeroinrow && firstnonzeroinrow <= lastcolumn );

1067

assert( lastoneprevrow <= lastcolumn );

1070

infrontier =

FALSE

;

1071

assert( lastoneprevrow + 1 >= 0 );

1072 if

( lastoneprevrow == nblocks-1 ||

SCIPvarGetUbLocal

(vars[i][lastoneprevrow+1]) < 0.5 )

1073

lastoneinrow = lastoneprevrow;

1076

lastoneinrow = lastoneprevrow + 1;

1077

frontiersteps[nsteps++] = i;

1083

assert( lastoneinrow <= lastcolumn );

1084

lastones[i] = lastoneinrow;

1087 if

( firstnonzeroinrow > lastoneinrow )

1094 SCIPdebugMsg

(

scip

,

" -> Infeasible node: row %d, leftmost nonzero at %d, rightmost 1 at %d\n"

,

1095

i, firstnonzeroinrow, lastoneinrow);

1099 SCIPdebugMsg

(

scip

,

" -> Infeasible node: row %d, 1 at %d, rightmost position for 1 at %d\n"

,

1100

i, firstnonzeroinrow, lastoneinrow);

1115 for

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

1128 if

( lastones[0] == -1 )

1140 for

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

1143

l = lastones[k] + 1;

1146 if

( l <= nblocks-1 && l <= k && lastones[k-1] == lastones[k] )

1155

*infeasible =

TRUE

;

1160 for

(j = lastoneinrow+1; j <= lastcolumn; ++j)

1173

inferInfo = i * nblocks + lastoneinrow + 1;

1182 SCIPdebugMsg

(

scip

,

" -> Infeasible node: row %d, 1 in column %d beyond rightmost position %d\n"

, i, j, lastoneinrow);

1205 for

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

1208

l = lastones[k] + 1;

1211 if

( l <= nblocks-1 && l <= k && lastones[k-1] == lastones[k] )

1227

lastoneprevrow = lastoneinrow;

1231 for

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

1236

s = frontiersteps[j];

1237

lastoneinrow = lastones[s];

1239

assert( 0 <= lastoneinrow && lastoneinrow < nblocks );

1245

betaprev = lastoneinrow - 1;

1248 for

(i = s+1; i < nspcons; ++i)

1252

assert( betaprev + 1 >= 0 );

1256

beta = betaprev + 1;

1257

assert( -1 <= beta && beta < nblocks );

1259 if

( firstnonzeros[i] > beta )

1269 SCIPdebugMsg

(

scip

,

" -> Fixing entry (%d,%d) to 1.\n"

, s, lastoneinrow);

1274

inferInfo = nblocks * nspcons + i * nblocks + firstnonzeros[i];

1277

assert( !(*infeasible) );

1316 int

* branchdecisions;

1317 int

nbranchdecision;

1320

assert( rowindexmap !=

NULL

);

1321

assert( roworder !=

NULL

);

1322

assert( nrows > 0 );

1323

assert( maxrowlabel !=

NULL

);

1326

nbranchdecision = 0;

1341

assert( domchg !=

NULL

);

1345 for

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

1349

assert( boundchg !=

NULL

);

1368

branchdecisions[nbranchdecision++] = rowidx;

1379 for

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

1381 if

( ! rowused[branchdecisions[i]] )

1383

roworder[*maxrowlabel] = branchdecisions[i];

1384

rowused[branchdecisions[i]] =

TRUE

;

1400 int

* minfixedrowlexmin,

1412

*infeasible =

FALSE

;

1414

assert( vars !=

NULL

);

1415

assert( lexminfixes !=

NULL

);

1416

assert( !resprop || minfixedrowlexmin !=

NULL

);

1419

assert( nrowsused > 0 );

1420

assert( nrowsused <= m );

1421

assert( infeasible !=

NULL

);

1426 for

(j = n - 2; j >= 0; --j)

1428 int

maxdiscriminating = m;

1432 for

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

1435 if

( minfixed == -1 && lexminfixes[i][j] != 0 && lexminfixes[i][j + 1] != 1 )

1437

assert( lexminfixes[i][j + 1] == 0 );

1439

maxdiscriminating = i;

1443 if

( minfixed == -1 && lexminfixes[i][j] != lexminfixes[i][j + 1] && lexminfixes[i][j] != 2 )

1445

assert( lexminfixes[i][j + 1] != 2 );

1450 if

( maxdiscriminating > minfixed )

1452

*infeasible =

TRUE

;

1460 for

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

1462 if

( lexminfixes[i][j] == 2 )

1464 if

( i < maxdiscriminating || minfixed == -1 )

1465

lexminfixes[i][j] = lexminfixes[i][j + 1];

1466 else if

( i == maxdiscriminating )

1467

lexminfixes[i][j] = 1;

1469

lexminfixes[i][j] = 0;

1475

assert( minfixedrowlexmin !=

NULL

);

1478 if

( minfixed == -1 )

1479

minfixedrowlexmin[j] = nrowsused - 1;

1481

minfixedrowlexmin[j] = minfixed;

1485 if

( minfixedrowlexmin[j + 1] < minfixedrowlexmin[j] )

1486

minfixedrowlexmin[j + 1] = minfixedrowlexmin[j];

1499 int

* minfixedrowlexmax,

1511

*infeasible =

FALSE

;

1513

assert( vars !=

NULL

);

1514

assert( lexmaxfixes !=

NULL

);

1515

assert( !resprop || minfixedrowlexmax !=

NULL

);

1518

assert( nrowsused > 0 );

1519

assert( nrowsused <= m );

1520

assert( infeasible !=

NULL

);

1522 for

(j = 1; j < n; ++j)

1524 int

maxdiscriminating = m;

1528 for

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

1531 if

( minfixed == -1 && lexmaxfixes[i][j - 1] != 0 && lexmaxfixes[i][j] != 1 )

1533

assert( lexmaxfixes[i][j - 1] == 1 );

1535

maxdiscriminating = i;

1539 if

( minfixed == -1 && lexmaxfixes[i][j - 1] != lexmaxfixes[i][j] && lexmaxfixes[i][j] != 2 )

1541

assert( lexmaxfixes[i][j - 1] != 2 );

1546 if

( maxdiscriminating > minfixed )

1548

*infeasible =

TRUE

;

1556 for

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

1558 if

( lexmaxfixes[i][j] == 2 )

1560 if

( i < maxdiscriminating || minfixed == -1 )

1561

lexmaxfixes[i][j] = lexmaxfixes[i][j - 1];

1562 else if

( i == maxdiscriminating )

1563

lexmaxfixes[i][j] = 0;

1565

lexmaxfixes[i][j] = 1;

1571

assert( minfixedrowlexmax !=

NULL

);

1574 if

( minfixed == -1 )

1575

minfixedrowlexmax[j] = nrowsused - 1;

1577

minfixedrowlexmax[j] = minfixed;

1581 if

( minfixedrowlexmax[j - 1] < minfixedrowlexmax[j] )

1582

minfixedrowlexmax[j - 1] = minfixedrowlexmax[j];

1612

assert( cons !=

NULL

);

1613

assert( infeasible !=

NULL

);

1614

assert( nfixedvars !=

NULL

);

1617

*infeasible =

FALSE

;

1628

assert( consdata !=

NULL

);

1629

assert( consdata->nspcons > 0 );

1630

assert( consdata->nblocks > 0 );

1631

assert( consdata->vars !=

NULL

);

1634

m = consdata->nspcons;

1635

n = consdata->nblocks;

1636

vars = consdata->vars;

1642

consdata->roworder, m, n, &(consdata->nrowsused)) );

1645 if

( consdata->nrowsused == 0 )

1648

nrowsused = consdata->nrowsused;

1652

roworder = consdata->roworder;

1658 for

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

1663 for

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

1667

origrow = roworder[i];

1669 for

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

1672

lexminfixes[i][j] = 1;

1674

lexminfixes[i][j] = 0;

1676

lexminfixes[i][j] = 2;

1683 if

( *infeasible ==

TRUE

)

1690 for

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

1695 for

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

1699

origrow = roworder[i];

1701 for

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

1704

lexmaxfixes[i][j] = 0;

1706

lexmaxfixes[i][j] = 1;

1708

lexmaxfixes[i][j] = 2;

1721 for

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

1723 for

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

1727

origrow = roworder[i];

1729 if

( lexminfixes[i][j] != lexmaxfixes[i][j] )

1737

cons, 0, infeasible, &success) );

1746 for

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

1751 for

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

1772

assert( cons !=

NULL

);

1773

assert( infeasible !=

NULL

);

1774

assert( nfixedvars !=

NULL

);

1777

assert( consdata !=

NULL

);

1779

orbitopetype = consdata->orbitopetype;

1784

consdata->usedynamicprop && !consdata->ismodelcons) );

1821 int

* minfixedrowlexmin;

1822 int

* minfixedrowlexmax;

1834

assert( conshdlr !=

NULL

);

1835

assert( cons !=

NULL

);

1836

assert( result !=

NULL

);

1839

assert( consdata !=

NULL

);

1840

assert( consdata->nspcons > 0 );

1841

assert( consdata->nblocks > 0 );

1842

assert( consdata->vars !=

NULL

);

1845

dynamic = consdata->usedynamicprop && !consdata->ismodelcons;

1846

m = consdata->nspcons;

1847

n = consdata->nblocks;

1848

vars = consdata->vars;

1852

assert( consdata->roworder !=

NULL

);

1853

assert( consdata->nrowsused > 0 );

1855

nrowsused = consdata->nrowsused;

1859

roworder = consdata->roworder;

1861

assert( inferinfo <= consdata->nspcons );

1867 for

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

1874

minfixedrowlexmin[n - 1] = -1;

1876 for

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

1880

origrow = roworder[i];

1882 for

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

1885

lexminfixes[i][j] = 1;

1887

lexminfixes[i][j] = 0;

1889

lexminfixes[i][j] = 2;

1903 for

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

1910

minfixedrowlexmax[0] = -1;

1912 for

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

1916

origrow = roworder[i];

1918 for

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

1921

lexmaxfixes[i][j] = 0;

1923

lexmaxfixes[i][j] = 1;

1925

lexmaxfixes[i][j] = 2;

1938 for

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

1940 int

ub =

MAX

(minfixedrowlexmin[j], minfixedrowlexmax[j]);

1942 for

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

1946

origrow = roworder[i];

1959 for

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

1965 for

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

2014

assert( cons !=

NULL

);

2015

assert( result !=

NULL

);

2018

assert( consdata !=

NULL

);

2019

assert( consdata->nspcons > 0 );

2020

assert( consdata->nblocks > 0 );

2021

assert( consdata->vars !=

NULL

);

2022

assert( consdata->vals !=

NULL

);

2023

assert( consdata->weights !=

NULL

);

2024

assert( consdata->cases !=

NULL

);

2025

assert( consdata->istrianglefixed );

2028 if

( ! consdata->resolveprop )

2031

nspcons = consdata->nspcons;

2032

nblocks = consdata->nblocks;

2033

vars = consdata->vars;

2034

vals = consdata->vals;

2035

weights = consdata->weights;

2036

orbitopetype = consdata->orbitopetype;

2037

cases = consdata->cases;

2039 SCIPdebugMsg

(

scip

,

"Propagation resolution method of orbitope constraint using orbitopal fixing\n"

);

2042 for

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

2047

lastcolumn = nblocks - 1;

2048 if

( lastcolumn > i )

2050 for

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

2068

printMatrix(

scip

, consdata);

2072

assert( consdata->istrianglefixed );

2076

assert( inferinfo >= 0 && inferinfo < 2 * nspcons * nblocks );

2077 if

( inferinfo < nspcons * nblocks )

2086

i = (int) (inferinfo / nblocks);

2087

j = inferinfo % nblocks;

2088

assert( 0 <= i && i < nspcons );

2089

assert( 0 <= j && j < nblocks );

2092

assert( weights[i-1][j-1] < 0.5 );

2094 SCIPdebugMsg

(

scip

,

" -> reason for x[%d][%d] = ... = x[%d][%d] = 0 was the following SC:\n"

, i, j, i,

MIN

(i,nblocks));

2103

assert( cases[p1][p2] != -1 );

2104

assert( p1 >= 0 && p1 < i );

2105

assert( p2 >= 0 && p2 < j );

2108 if

( cases[p1][p2] == 1 )

2113

assert( cases[p1][p2] == 2 || cases[p1][p2] == 3 );

2123 if

( cases[p1][p2] == 3 )

2129

assert( cases[p1][p2] == 3 );

2150

inferinfo -= nspcons * nblocks;

2151

i = (int) inferinfo / nblocks;

2152

j = inferinfo % nblocks;

2153

assert( 0 <= i && i < nspcons );

2154

assert( 0 <= j && j < nblocks );

2159 if

( weights[i-1][j-1] > 0.5 && weights[i-1][j-1] < 1.5 )

2161 SCIPdebugMsg

(

scip

,

" -> reason for x[%d][%d] = 1 was the following SC:\n"

, i, j);

2174

assert( cases[p1][p2] != -1 );

2175

assert( p1 >= 0 && p1 < i );

2176

assert( p2 >= 0 && p2 < j );

2179 if

( cases[p1][p2] == 1 )

2184

assert( cases[p1][p2] == 2 || cases[p1][p2] == 3 );

2199

assert( pos1 == -1 && pos2 == -1 );

2204 if

( cases[p1][p2] == 3 )

2210

assert( cases[p1][p2] == 3 );

2211

assert( pos1 >= 0 && pos2 >= 0 );

2222 for

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

2243

lastcolumn = nblocks - 1;

2244 if

( lastcolumn > i )

2248 for

(k = j; k <= lastcolumn; ++k)

2283

assert( cons !=

NULL

);

2288

assert( consdata !=

NULL

);

2289

assert( consdata->nspcons > 0 );

2290

assert( consdata->nblocks > 0 );

2291

assert( consdata->vals !=

NULL

);

2292

assert( consdata->weights !=

NULL

);

2293

assert( consdata->cases !=

NULL

);

2296 if

( ! consdata->istrianglefixed )

2307 if

( nfixedvars > 0 )

2314

nspcons = consdata->nspcons;

2315

nblocks = consdata->nblocks;

2316

vals = consdata->vals;

2317

weights = consdata->weights;

2318

cases = consdata->cases;

2325

assert( consdata->istrianglefixed );

2329 for

(i = 1; i < nspcons; ++i)

2334

lastcolumn = nblocks - 1;

2337 if

( lastcolumn > i )

2341 for

(j = lastcolumn; j > 0; --j)

2381

assert( cons != 0 );

2384

assert( consdata !=

NULL

);

2385

assert( consdata->nspcons > 0 );

2386

assert( consdata->nblocks > 0 );

2387

assert( consdata->vars !=

NULL

);

2388

assert( consdata->vals !=

NULL

);

2389

assert( consdata->weights !=

NULL

);

2390

assert( consdata->cases !=

NULL

);

2392

nspcons = consdata->nspcons;

2393

nblocks = consdata->nblocks;

2394

vars = consdata->vars;

2395

vals = consdata->vals;

2396

weights = consdata->weights;

2397

cases = consdata->cases;

2405 if

( ! consdata->istrianglefixed )

2412 if

( nspcons < nblocks )

2416 for

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

2418 for

(j = i+1; j < nblocks; ++j)

2434 for

(i = 1; i < nspcons; ++i)

2439

lastcolumn = nblocks - 1;

2442 if

( lastcolumn > i )

2446 for

(j = lastcolumn; j > 0; --j)

2466 for

(l = j; l < nblocks; ++l)

2476

assert( cases[p1][p2] != -1 );

2477

assert( p1 >= 0 && p1 < i );

2478

assert( p2 >= 0 && p2 < j );

2481 if

(cases[p1][p2] == 1)

2486

assert( cases[p1][p2] == 2 || cases[p1][p2] == 3 );

2488 if

( cases[p1][p2] == 3 )

2494

assert( cases[p1][p2] == 3 );

2526

assert( cons !=

NULL

);

2527

assert( feasible !=

NULL

);

2531

assert( consdata !=

NULL

);

2532

assert( consdata->vars !=

NULL

);

2533

assert( consdata->nspcons > 0 );

2534

assert( consdata->nblocks > 0 );

2535

assert( ! consdata->ismodelcons );

2537

vars = consdata->vars;

2538

nrows = consdata->nspcons;

2539

ncols = consdata->nblocks;

2547 for

(j = 1; j < ncols && *feasible; ++j)

2549 for

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

2551

vars1[i] = vars[i][j - 1];

2552

vars2[i] = vars[i][j];

2591

assert( cons !=

NULL

);

2592

assert( ngen !=

NULL

);

2593

assert( infeasible !=

NULL

);

2596

*infeasible =

FALSE

;

2600

assert( consdata !=

NULL

);

2602

vars = consdata->vars;

2603

nrows = consdata->nspcons;

2604

ncols = consdata->nblocks;

2605

nrowsused = dynamic ? consdata->nrowsused : nrows;

2606

roworder = consdata->roworder;

2616 for

(j = 0; j < ncols - 1 && ! *infeasible; ++j)

2620 for

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

2622

origrow = roworder[i];

2624

assert( origrow >= 0 );

2625

assert( origrow < nrows );

2643 for

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

2647

origrow2 = roworder[k];

2729

assert( conshdlr !=

NULL

);

2731

assert( result !=

NULL

);

2734 for

(c = 0; c < nconss && ! infeasible; c++)

2738 int

nconsfixedvars = 0;

2742

assert( conss[c] !=

NULL

);

2746

assert( consdata !=

NULL

);

2749 if

( enforce && !consdata->ismodelcons )

2756

orbitopetype = consdata->orbitopetype;

2762

nfixedvars += nconsfixedvars;

2764 else if

( conshdlrdata->sepafullorbitope )

2771 if

( c >= nusefulconss && (ncuts > 0 || nfixedvars > 0) )

2780 else if

( nfixedvars > 0 )

2785 else if

( ncuts > 0 )

2792 SCIPdebugMsg

(

scip

,

"No violated inequality found during separation.\n"

);

2815

assert( cons !=

NULL

);

2816

assert( redundant !=

NULL

);

2818

*redundant =

FALSE

;

2821

assert( consdata !=

NULL

);

2822

assert( consdata->vars !=

NULL

);

2823

assert( consdata->nspcons > 0 );

2824

assert( consdata->nblocks > 0 );

2826

vars = consdata->vars;

2827

nrows = consdata->nspcons;

2828

ncols = consdata->nblocks;

2831 for

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

2833 for

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

2855

assert(conshdlr !=

NULL

);

2872

assert(

scip

!= 0 );

2873

assert( conshdlr != 0 );

2877

assert( conshdlrdata !=

NULL

);

2888

assert(conshdlr !=

NULL

);

2903

assert(conshdlr !=

NULL

);

2906

assert(sourcecons !=

NULL

);

2907

assert(targetcons !=

NULL

);

2910

assert(sourcedata !=

NULL

);

2914

sourcedata->orbitopetype, sourcedata->resolveprop, sourcedata->usedynamicprop, sourcedata->ismodelcons,

2915

sourcedata->mayinteract) );

2932

assert( result !=

NULL

);

2955

assert( result !=

NULL

);

2973

assert( result !=

NULL

);

2993

assert( result !=

NULL

);

3014

assert( conshdlr !=

NULL

);

3016

assert( result !=

NULL

);

3019 if

( objinfeasible || solinfeasible )

3023 for

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

3032

assert( cons != 0 );

3035

assert( consdata !=

NULL

);

3038 if

( !consdata->ismodelcons )

3041

orbitopetype = consdata->orbitopetype;

3073

assert( conshdlr !=

NULL

);

3075

assert( result !=

NULL

);

3080 for

( c = 0; c < nconss && (*result ==

SCIP_FEASIBLE

|| completely); ++c )

3082

assert( conss[c] != 0 );

3085

assert( consdata !=

NULL

);

3088 if

( !consdata->ismodelcons )

3091

orbitopetype = consdata->orbitopetype;

3120

assert( conshdlr !=

NULL

);

3122

assert( result !=

NULL

);

3127 for

(c = 0; c < nusefulconss && !infeasible; ++c)

3129

assert( conss[c] != 0 );

3140 SCIPdebugMsg

(

scip

,

"Propagation via orbitopal fixing proved node to be infeasible.\n"

);

3142 else if

( nfixedvars > 0 )

3145 SCIPdebugMsg

(

scip

,

"Propagated %d variables via orbitopal fixing.\n"

, nfixedvars);

3147 else if

( nusefulconss > 0 )

3150 SCIPdebugMsg

(

scip

,

"Propagation via orbitopal fixing did not find anything.\n"

);

3167

assert( conshdlr !=

NULL

);

3169

assert( result !=

NULL

);

3172

noldfixedvars = *nfixedvars;

3178 for

(c = 0; c < nconss && !infeasible; ++c)

3182

assert( conss[c] != 0 );

3188

*nfixedvars += nfixed;

3196 SCIPdebugMsg

(

scip

,

"Orbitope constraint <%s> is redundant: it does not contain active variables\n"

,

3211 else if

( *nfixedvars > noldfixedvars )

3215 else if

( nconss > 0 )

3218 SCIPdebugMsg

(

scip

,

"Presolving via orbitopal fixing did not find anything.\n"

);

3233

assert( cons !=

NULL

);

3234

assert( infervar !=

NULL

);

3235

assert( bdchgidx !=

NULL

);

3236

assert( result !=

NULL

);

3239

assert( consdata !=

NULL

);

3241

orbitopetype = consdata->orbitopetype;

3269

assert( conshdlr !=

NULL

);

3271

assert( cons !=

NULL

);

3275

assert( consdata !=

NULL

);

3276

assert( consdata->nspcons > 0 );

3277

assert( consdata->nblocks > 0 );

3278

assert( consdata->vars !=

NULL

);

3280 SCIPdebugMsg

(

scip

,

"Locking method for orbitope constraint handler\n"

);

3282

nspcons = consdata->nspcons;

3283

nblocks = consdata->nblocks;

3284

vars = consdata->vars;

3287 for

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

3289 for

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

3310

assert( conshdlr !=

NULL

);

3312

assert( cons !=

NULL

);

3315

assert( consdata !=

NULL

);

3316

assert( consdata->nspcons > 0 );

3317

assert( consdata->nblocks > 0 );

3318

assert( consdata->vars !=

NULL

);

3320

nspcons = consdata->nspcons;

3321

nblocks = consdata->nblocks;

3322

vars = consdata->vars;

3323

orbitopetype = consdata->orbitopetype;

3325 SCIPdebugMsg

(

scip

,

"Printing method for orbitope constraint handler\n"

);

3327 switch

( orbitopetype )

3342 for

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

3344 for

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

3350 if

( i < nspcons-1 )

3374

assert( cons !=

NULL

);

3375

assert( sourcescip !=

NULL

);

3376

assert( sourceconshdlr !=

NULL

);

3378

assert( sourcecons !=

NULL

);

3379

assert( varmap !=

NULL

);

3380

assert( valid !=

NULL

);

3384 SCIPdebugMsg

(

scip

,

"Copying method for orbitope constraint handler.\n"

);

3387

assert( sourcedata !=

NULL

);

3388

assert( sourcedata->nspcons > 0 );

3389

assert( sourcedata->nblocks > 0 );

3390

assert( sourcedata->vars !=

NULL

);

3393

assert( conshdlrdata !=

NULL

);

3396 if

( !sourcedata->ismodelcons && !conshdlrdata->forceconscopy )

3403

nspcons = sourcedata->nspcons;

3404

nblocks = sourcedata->nblocks;

3405

sourcevars = sourcedata->vars;

3408 for

(i = 0; i < nspcons && *valid; ++i)

3412 for

(j = 0; j < nblocks && *valid; ++j)

3415

assert( !(*valid) || vars[i][j] !=

NULL

);

3427

vars, sourcedata->orbitopetype, nspcons, nblocks, sourcedata->usedynamicprop,

3428

sourcedata->resolveprop, sourcedata->ismodelcons, sourcedata->mayinteract,

3429

initial, separate, enforce, check, propagate,

3430

local, modifiable, dynamic, removable, stickingatnode) );

3434

assert( 0 <= i && i <= nspcons );

3435 for

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

3459

assert( success !=

NULL

);

3467 if

( strncmp(s,

"partOrbitope("

, 13) == 0 )

3469 else if

( strncmp(s,

"packOrbitope("

, 13) == 0 )

3473 if

( strncmp(s,

"fullOrbitope("

, 13) != 0 )

3475 SCIPerrorMessage

(

"Syntax error - expected \"fullOrbitope(\", \"partOrbitope\" or \"packOrbitope\": %s\n"

, s);

3499

endptr = strchr(endptr,

')'

);

3501 if

( endptr ==

NULL

|| j > 0 )

3511

assert( s !=

NULL

);

3521 if

( nspcons > maxnspcons )

3525

assert( nspcons <= maxnspcons );

3536 if

( *s ==

'.'

|| *s ==

')'

)

3538 else if

( nblocks > maxnblocks )

3542

assert( nblocks <= maxnblocks );

3545 else if

( ( j < nblocks-1 ) == ( *s ==

'.'

|| *s ==

')'

) )

3552

vars[nspcons-1][j] = var;

3560 if

( *s ==

','

|| *s ==

'.'

)

3563 while

( *s !=

')'

);

3569 SCIP_CALL

(

SCIPcreateConsOrbitope

(

scip

, cons, name, vars, orbitopetype, nspcons, nblocks,

FALSE

,

TRUE

,

TRUE

,

TRUE

,

3570

initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode) );

3572 for

( k = nspcons - 1; k >= 0; --k )

3586

assert( cons !=

NULL

);

3587

assert( success !=

NULL

);

3588

assert( vars !=

NULL

);

3591

assert( consdata !=

NULL

);

3593 if

( varssize < consdata->nblocks * consdata->nspcons )

3594

(*success) =

FALSE

;

3601 for

(i = 0; i < consdata->nspcons; ++i)

3603 for

(j = 0; j < consdata->nblocks; ++j)

3604

vars[cnt++] = consdata->vars[i][j];

3619

assert( cons !=

NULL

);

3622

assert( consdata !=

NULL

);

3624

(*nvars) = consdata->nblocks * consdata->nspcons;

3650

consEnfolpOrbitope, consEnfopsOrbitope, consCheckOrbitope, consLockOrbitope,

3652

assert(conshdlr !=

NULL

);

3672 "Strengthen orbitope constraints to packing/partioning orbitopes?"

,

3676 "Whether we separate inequalities for full orbitopes?"

,

3680 "Whether orbitope constraints should be forced to be copied to sub SCIPs."

,

3740 if

( conshdlr ==

NULL

)

3747 if

( usedynamicprop && mayinteract )

3750 other symmetry handling constraints. Ignore value of <usedynamicprop>.\n"

);

3753

assert( nspcons > 0 );

3754

assert( nblocks > 0 );

3762 for

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

3766 for

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

3772

assert(var !=

NULL

);

3810

resolveprop, usedynamicprop && ! mayinteract, ismodelcons, mayinteract) );

3813 SCIP_CALL

(

SCIPcreateCons

(

scip

, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate,

3814

local, modifiable, dynamic, removable, stickingatnode) );

3840

resolveprop, ismodelcons, mayinteract,

TRUE

,

TRUE

,

TRUE

,

TRUE

,

TRUE

,

FALSE

,

FALSE

,

FALSE

,

FALSE

,

FALSE

) );

constraint handler for orbisack constraints

static SCIP_RETCODE checkRedundantCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *redundant)

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopyOrbitope)

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_SEPAFREQ

static SCIP_DECL_CONSPARSE(consParseOrbitope)

static SCIP_RETCODE propagatePackingPartitioningCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, int *nfixedvars)

static SCIP_RETCODE checkFullOrbitopeSolution(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool *feasible)

#define CONSHDLR_CHECKPRIORITY

static SCIP_DECL_CONSGETNVARS(consGetNVarsOrbitope)

static SCIP_RETCODE enfopsPackingPartitioningOrbitopeSolution(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)

static SCIP_DECL_CONSCOPY(consCopyOrbitope)

static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_CONS *cons, int inferinfo, SCIP_BDCHGIDX *bdchgidx, SCIP_RESULT *result)

static SCIP_RETCODE separateConstraints(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_RESULT *result, SCIP_Bool enforce)

static SCIP_RETCODE checkPackingPartitioningOrbitopeSolution(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result, SCIP_Bool printreason)

#define CONSHDLR_PROP_TIMING

static SCIP_RETCODE separateSCIs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_Bool *infeasible, int *nfixedvars, int *ncuts)

#define DEFAULT_FORCECONSCOPY

#define CONSHDLR_MAXPREROUNDS

static SCIP_DECL_CONSPRINT(consPrintOrbitope)

static SCIP_DECL_CONSFREE(consFreeOrbitope)

static SCIP_DECL_CONSPROP(consPropOrbitope)

#define CONSHDLR_SEPAPRIORITY

static SCIP_DECL_CONSSEPALP(consSepalpOrbitope)

static SCIP_DECL_CONSRESPROP(consRespropOrbitope)

static SCIP_DECL_CONSPRESOL(consPresolOrbitope)

static SCIP_RETCODE propagateCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, int *nfixedvars)

static SCIP_DECL_CONSSEPASOL(consSepasolOrbitope)

static SCIP_RETCODE resolvePropagationFullOrbitope(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, int inferinfo, SCIP_BDCHGIDX *bdchgidx, SCIP_RESULT *result)

static SCIP_DECL_CONSTRANS(consTransOrbitope)

static SCIP_RETCODE findLexMaxFace(SCIP_VAR ***vars, int **lexmaxfixes, int *minfixedrowlexmax, SCIP_Bool *infeasible, int m, int n, int nrowsused, SCIP_Bool resprop)

static SCIP_RETCODE strengthenOrbitopeConstraint(SCIP *scip, SCIP_VAR ***vars, int *nrows, int ncols, SCIP_ORBITOPETYPE *type, SCIP_Bool mayinteract)

static SCIP_DECL_CONSDELETE(consDeleteOrbitope)

static SCIP_DECL_CONSCHECK(consCheckOrbitope)

static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_VAR ***vars, int nspcons, int nblocks, SCIP_ORBITOPETYPE orbitopetype, SCIP_Bool resolveprop, SCIP_Bool usedynamicprop, SCIP_Bool ismodelcons, SCIP_Bool mayinteract)

static SCIP_RETCODE findLexMinFace(SCIP_VAR ***vars, int **lexminfixes, int *minfixedrowlexmin, SCIP_Bool *infeasible, int m, int n, int nrowsused, SCIP_Bool resprop)

#define CONSHDLR_PROPFREQ

static SCIP_RETCODE separateCoversOrbisack(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool dynamic, int *ngen, SCIP_Bool *infeasible)

#define DEFAULT_PPORBITOPE

static SCIP_DECL_CONSGETVARS(consGetVarsOrbitope)

#define CONSHDLR_PRESOLTIMING

static SCIP_RETCODE propagateFullOrbitopeCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, int *nfixedvars, SCIP_Bool dynamic)

#define DEFAULT_SEPAFULLORBITOPE

static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)

static SCIP_DECL_CONSENFORELAX(consEnforelaxOrbitope)

#define CONSHDLR_EAGERFREQ

static SCIP_DECL_CONSENFOLP(consEnfolpOrbitope)

#define CONSHDLR_ENFOPRIORITY

static SCIP_RETCODE fixTriangle(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, int *nfixedvars)

static SCIP_RETCODE computeDynamicRowOrder(SCIP *scip, SCIP_HASHMAP *rowindexmap, SCIP_Bool *rowused, int *roworder, int nrows, int ncols, int *maxrowlabel)

static void computeSCTable(SCIP *scip, int nspcons, int nblocks, SCIP_Real **weights, int **cases, SCIP_Real **vals)

#define CONSHDLR_DELAYSEPA

static void copyValues(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol)

static SCIP_DECL_CONSLOCK(consLockOrbitope)

static SCIP_DECL_CONSENFOPS(consEnfopsOrbitope)

#define CONSHDLR_DELAYPROP

constraint handler for (partitioning/packing/full) orbitope constraints w.r.t. the full symmetric gro...

Constraint handler for the set partitioning / packing / covering constraints .

SCIP_RETCODE SCIPcheckSolutionOrbisack(SCIP *scip, SCIP_SOL *sol, SCIP_VAR **vars1, SCIP_VAR **vars2, int nrows, SCIP_Bool printreason, SCIP_Bool *feasible)

SCIP_RETCODE SCIPcreateConsBasicOrbitope(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR ***vars, SCIP_ORBITOPETYPE orbitopetype, int nspcons, int nblocks, SCIP_Bool usedynamicprop, SCIP_Bool resolveprop, SCIP_Bool ismodelcons, SCIP_Bool mayinteract)

SCIP_RETCODE SCIPcreateConsOrbitope(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR ***vars, SCIP_ORBITOPETYPE orbitopetype, int nspcons, int nblocks, SCIP_Bool usedynamicprop, SCIP_Bool mayinteract, SCIP_Bool resolveprop, SCIP_Bool ismodelcons, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPincludeConshdlrOrbitope(SCIP *scip)

int SCIPgetSubscipDepth(SCIP *scip)

SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)

SCIP_Bool SCIPisTransformed(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)

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

SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)

void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)

void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)

SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

int SCIPgetNLPBranchCands(SCIP *scip)

SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)

SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)

SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)

SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)

SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)

SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))

SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)

SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))

SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)

SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)

SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)

SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))

SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))

SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))

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

SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))

SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))

SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))

SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))

SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)

SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)

#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 SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPallocBlockMemory(scip, ptr)

#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)

SCIP_DOMCHG * SCIPnodeGetDomchg(SCIP_NODE *node)

SCIP_NODE * SCIPnodeGetParent(SCIP_NODE *node)

int SCIPnodeGetDepth(SCIP_NODE *node)

SCIP_Bool SCIPinProbing(SCIP *scip)

SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPcreateEmptyRowConshdlr(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)

SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)

SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)

SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)

SCIP_RETCODE SCIPisPackingPartitioningOrbitope(SCIP *scip, SCIP_VAR ***vars, int nrows, int ncols, SCIP_Bool **pprows, int *npprows, SCIP_ORBITOPETYPE *type)

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)

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

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

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

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

SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)

SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

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_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)

SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

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_Bool SCIPvarIsNegated(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)

SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

SCIP_Real SCIPvarGetLbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)

SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)

SCIP_Real SCIPvarGetUbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)

SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)

int SCIPsnprintf(char *t, int len, const char *s,...)

SCIP_RETCODE SCIPskipSpace(char **s)

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

methods for handling symmetries

@ SCIP_CONFTYPE_PROPAGATION

struct SCIP_ConshdlrData SCIP_CONSHDLRDATA

struct SCIP_ConsData SCIP_CONSDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STAGE_TRANSFORMING

type definitions for symmetry computations

@ SCIP_ORBITOPETYPE_PACKING

@ SCIP_ORBITOPETYPE_PARTITIONING

enum SCIP_OrbitopeType SCIP_ORBITOPETYPE

@ SCIP_BOUNDCHGTYPE_BRANCHING

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