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__symresack_8c_source.php below:

SCIP Doxygen Documentation: cons_symresack.c Source File

86#define CONSHDLR_NAME "symresack" 87#define CONSHDLR_DESC "symmetry breaking constraint handler relying on symresacks" 88#define CONSHDLR_SEPAPRIORITY +40100 89#define CONSHDLR_ENFOPRIORITY -1005200 90#define CONSHDLR_CHECKPRIORITY -1005200 91#define CONSHDLR_SEPAFREQ 5 92#define CONSHDLR_PROPFREQ 5 93#define CONSHDLR_EAGERFREQ -1 95#define CONSHDLR_MAXPREROUNDS -1 96#define CONSHDLR_DELAYSEPA FALSE 97#define CONSHDLR_DELAYPROP FALSE 98#define CONSHDLR_NEEDSCONS TRUE 100#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP 101#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_EXHAUSTIVE 103#define DEFAULT_PPSYMRESACK TRUE 104#define DEFAULT_CHECKMONOTONICITY TRUE 105#define DEFAULT_FORCECONSCOPY FALSE 114#define ISFIXED(x, bdchgidx) (SCIPvarGetUbAtIndex(x, bdchgidx, FALSE) - SCIPvarGetLbAtIndex(x, bdchgidx, FALSE) < 0.5) 123struct

SCIP_ConshdlrData

147 int

** cycledecomposition;

167

assert( consdata !=

NULL

);

168

assert( *consdata !=

NULL

);

170

nvars = (*consdata)->nvars;

174

assert( (*consdata)->vars ==

NULL

);

175

assert( (*consdata)->perm ==

NULL

);

176

assert( (*consdata)->invperm ==

NULL

);

177

assert( (*consdata)->ncycles == 0 );

178

assert( (*consdata)->cycledecomposition ==

NULL

);

185 if

( (*consdata)->ndescentpoints > 0 )

187

assert( (*consdata)->descentpoints !=

NULL

);

192 if

( (*consdata)->ppupgrade )

194 for

(i = 0; i < (*consdata)->ncycles; ++i)

204 for

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

234 int

** cycledecomposition;

235 int

* indicesincycle;

243 int

ndescentpoints = 0;

247

assert( perm !=

NULL

);

248

assert( vars !=

NULL

);

250

assert( upgrade !=

NULL

);

256 for

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

260 for

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

280 else if

( checkmonotonicity )

291

assert( checkmonotonicity );

297

assert( ncycles <= nvars / 2 );

300 for

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

308 for

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

316 for

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

328

descentpoints[c++] = j;

331

cycledecomposition[curcycle][++cyclelength] = j;

336

cycledecomposition[curcycle][0] = cyclelength;

339 if

( maxcyclelength < cyclelength )

340

maxcyclelength = cyclelength;

342

assert( c == ndescentpoints );

346 if

( setppcconshdlr ==

NULL

)

361 for

(i = 0; i < ncycles && *upgrade && ! terminated; ++i)

366 for

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

368

var = vars[cycledecomposition[i][j + 1]];

379

cyclelength = cycledecomposition[i][0];

385 for

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

402 if

( nsetppcvars == 0 )

404

assert( nsetppcvars > 0 );

407

assert( setppcvars !=

NULL

);

410 for

(j = 0; j < nsetppcvars && nfound < cyclelength; ++j)

419 for

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

421 if

( varidx == indicesincycle[k] )

428

assert( nfound <= cyclelength );

430 if

( nfound == cyclelength )

435 if

( c >= nsetppcconss )

441

(*consdata)->ncycles = ncycles;

442

(*consdata)->cycledecomposition = cycledecomposition;

443

(*consdata)->ndescentpoints = ndescentpoints;

444

(*consdata)->descentpoints = descentpoints;

455 for

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

485 int

* indexcorrection;

488 int

naffectedvariables;

492

assert( consdata !=

NULL

);

493

assert( conshdlr !=

NULL

);

499

(*consdata)->debugcnt = 0;

502

(*consdata)->ndescentpoints = 0;

503

(*consdata)->descentpoints =

NULL

;

504

(*consdata)->ismodelcons = ismodelcons;

508

indexcorrection[0] = -1;

509 for

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

514

indexcorrection[i] = 0;

516

indexcorrection[i] = indexcorrection[i - 1] + 1;

521

indexcorrection[i] = indexcorrection[i - 1];

524

naffectedvariables = indexcorrection[inputnvars - 1] + 1;

526

(*consdata)->nvars = naffectedvariables;

529 if

( naffectedvariables == 0 )

533

(*consdata)->vars =

NULL

;

534

(*consdata)->perm =

NULL

;

535

(*consdata)->invperm =

NULL

;

536

(*consdata)->ppupgrade =

FALSE

;

537

(*consdata)->ncycles = 0;

538

(*consdata)->cycledecomposition =

NULL

;

545 for

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

549 if

( indexcorrection[i] > -1 )

551

vars[j] = inputvars[i];

552

perm[j++] = indexcorrection[inputperm[i]];

557 if

( indexcorrection[i] > indexcorrection[i - 1] )

559

vars[j] = inputvars[i];

560

perm[j++] = indexcorrection[inputperm[i]];

566

(*consdata)->vars = vars;

567

(*consdata)->perm = perm;

570 for

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

573

invperm[perm[i]] = i;

575

(*consdata)->invperm = invperm;

580 if

( conshdlrdata->checkppsymresack )

585

(*consdata)->ppupgrade = upgrade;

592 for

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

632

assert( cons !=

NULL

);

633

assert( infeasible !=

NULL

);

635

*infeasible =

FALSE

;

638

assert( consdata !=

NULL

);

640

nvars = consdata->nvars;

646

assert( consdata->vars !=

NULL

);

647

vars = consdata->vars;

650

assert( consdata->invperm[0] != 0 );

667 if

( consdata->ppupgrade && ! *infeasible )

669 if

( checkmonotonicity )

673 int

** cycledecomposition;

677 int

firstelemincycle;

679

ncycles = consdata->ncycles;

680

cycledecomposition = consdata->cycledecomposition;

688 for

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

690

assert( cycledecomposition[i][0] > 0 );

692

nvarsincycle = cycledecomposition[i][0];

693

varsincons[0] = vars[cycledecomposition[i][nvarsincycle]];

694

firstelemincycle = cycledecomposition[i][1];

696

assert( firstelemincycle == consdata->perm[cycledecomposition[i][nvarsincycle]] );

701 for

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

703

nvarsincycle = cycledecomposition[j][0];

704 for

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

706 if

( cycledecomposition[j][k] < firstelemincycle )

708

varsincons[nvarsincons] = vars[cycledecomposition[j][k]];

709

coeffs[nvarsincons++] = -1.0;

738 int

* imgdescentpoints;

743 int

newlastascent = 0;

746

descentpoints = consdata->descentpoints;

747

ndescentpoints = consdata->ndescentpoints;

748

perm = consdata->perm;

750

assert( descentpoints !=

NULL

);

751

assert( ndescentpoints > 0 );

752

assert( perm !=

NULL

);

753

assert( vars !=

NULL

);

759 for

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

760

imgdescentpoints[j] = perm[descentpoints[j]];

771 for

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

773

varsincons[0] = vars[descentpoints[j]];

774 for

(i = lastascent; i < imgdescentpoints[j]; ++i)

778

coeffs[nvarsincons] = -1.0;

779

varsincons[nvarsincons++] = vars[i];

783

lastascent = newlastascent;

824 int

* tempfixentries,

825 int

numfixentriesinit,

827 int

* infeasibleentry

843

assert( vars !=

NULL

);

844

assert( invperm !=

NULL

);

845

assert( tempfixings !=

NULL

);

846

assert( tempfixentries !=

NULL

);

847

assert( infeasible !=

NULL

);

850

numfixentries = numfixentriesinit;

852

*infeasible =

FALSE

;

854 for

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

857

assert( invperm[i] != i );

861

var2 = vars[invperm[i]];

863

assert( var1 !=

NULL

);

864

assert( var2 !=

NULL

);

867

var1fix = tempfixings[i];

880

assert( var1fix !=

NOINIT

);

883

var2fix = tempfixings[invperm[i]];

896

assert( var2fix !=

NOINIT

);

905

*infeasibleentry = i;

911

tempfixings[invperm[i]] =

FIXED0

;

913

tempfixentries[numfixentries++] = invperm[i];

920

tempfixentries[numfixentries++] = i;

926 for

(i = numfixentriesinit; i < numfixentries; ++i)

928

tempfixings[tempfixentries[i]] =

NOINIT

;

929

tempfixentries[i] = 0;

957 int

peekinfeasibleentry;

959 int

* tempfixentries;

962

assert( cons !=

NULL

);

963

assert( infeasible !=

NULL

);

964

assert( ngen !=

NULL

);

969

*infeasible =

FALSE

;

973

assert( consdata !=

NULL

);

974

nvars = consdata->nvars;

980

assert( consdata->vars !=

NULL

);

981

assert( consdata->invperm !=

NULL

);

982

vars = consdata->vars;

983

invperm = consdata->invperm;

986 for

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

989

assert( invperm[i] != i );

993

var2 = vars[invperm[i]];

994

assert( var1 !=

NULL

);

995

assert( var2 !=

NULL

);

1026 SCIPdebugMsg

(

scip

,

" -> node is feasible (could set pair to (1,0) and every earlier pair is constant).\n"

);

1039 SCIPdebugMsg

(

scip

,

" -> First entry is not fixed. Check if 0 is feasible.\n"

);

1040

tempfixings[i] =

FIXED0

;

1041

tempfixentries[0] = i;

1043

&peekinfeasible, &peekinfeasibleentry) );

1045 if

( peekinfeasible )

1048 SCIPdebugMsg

(

scip

,

" -> First entry is not fixed. 0 is not feasible. Fixing to 1.\n"

);

1050 FALSE

, infeasible, &tightened) );

1051

assert( ! *infeasible );

1057

tempfixings[i] =

NOINIT

;

1058

tempfixentries[0] = 0;

1066 SCIPdebugMsg

(

scip

,

" -> Second entry is not fixed. Check if 1 is feasible.\n"

);

1067

tempfixings[invperm[i]] =

FIXED1

;

1068

tempfixentries[0] = invperm[i];

1070

&peekinfeasible, &peekinfeasibleentry) );

1072 if

( peekinfeasible )

1075 SCIPdebugMsg

(

scip

,

" -> Second entry is not fixed. 1 is not feasible. Fixing to 0.\n"

);

1077 FALSE

, infeasible, &tightened) );

1078

assert( ! *infeasible );

1084

tempfixings[invperm[i]] =

NOINIT

;

1085

tempfixentries[0] = 0;

1100 SCIPdebugMsg

(

scip

,

" -> node infeasible (pair was fixed to (0,1) but there was no pair of type (1,0) before) ---> lexicographical order violated, infeasible.\n"

);

1107 for

(

r

= 0;

r

<= i; ++

r

)

1110

assert( invperm[

r

] !=

r

);

1119

*infeasible =

TRUE

;

1133

assert( ! *infeasible );

1149

assert( ! *infeasible );

1181

assert( cons !=

NULL

);

1182

assert( nvars > 0 );

1183

assert( vars !=

NULL

);

1184

assert( coeffs !=

NULL

);

1185

assert( infeasible !=

NULL

);

1187

*infeasible =

FALSE

;

1193

++consdata->debugcnt;

1199 for

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

1201 if

( coeffs[i] == 1 || coeffs[i] == -1 )

1240 int

* componentends;

1244

assert( nvars > 0 );

1245

assert( objective !=

NULL

);

1246

assert( perm !=

NULL

);

1247

assert( invperm !=

NULL

);

1248

assert( maxcrit !=

NULL

);

1249

assert( maxsoluval !=

NULL

);

1261 for

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

1263

componentends[i] = i;

1264

componentobj[i] = objective[i];

1266

helperobj += objective[i];

1270 for

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

1272

critinv = invperm[crit];

1275

assert( crit != critinv );

1278 if

( componentends[crit] == critinv )

1284

tmpobj += componentobj[crit];

1286

tmpobj -= componentobj[critinv];

1289

*maxsoluval = tmpobj;

1294

tmpnewcompobj = componentobj[crit] + componentobj[critinv];

1296

helperobj -= componentobj[crit];

1298

helperobj -= componentobj[critinv];

1300

helperobj += tmpnewcompobj;

1303

componentobj[componentends[crit]] = tmpnewcompobj;

1304

componentobj[componentends[critinv]] = tmpnewcompobj;

1307 if

( componentends[crit] == crit )

1309

componentends[crit] = componentends[critinv];

1310

componentends[componentends[critinv]] = crit;

1314

componentends[componentends[crit]] = componentends[critinv];

1315

componentends[componentends[critinv]] = componentends[crit];

1326

assert( *maxcrit >= 0 );

1350 int

* entrycomponent;

1357

assert( nvars > 0 );

1358

assert( objective !=

NULL

);

1359

assert( perm !=

NULL

);

1360

assert( invperm !=

NULL

);

1361

assert( maxsolu !=

NULL

);

1362

assert( crit >= 0 );

1363

assert( crit <= nvars );

1369 for

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

1371

entrycomponent[i] = i;

1372

componentobjective[i] = objective[i];

1374 for

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

1380 if

( entrycomponent[i] < i )

1394 if

( entrycomponent[c] != c )

1397

entrycomponent[c] = i;

1398

componentobjective[i] += objective[c];

1408 if

( entrycomponent[c] != c )

1411

entrycomponent[c] = i;

1412

componentobjective[i] += objective[c];

1424 for

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

1426 if

( entrycomponent[i] == entrycomponent[crit] )

1428 else if

( entrycomponent[i] == entrycomponent[invperm[crit]] )

1430 else if

(

SCIPisGT

(

scip

, componentobjective[entrycomponent[i]], 0.0) )

1467

*infeasible =

FALSE

;

1471

assert( consdata !=

NULL

);

1474 if

( consdata->nvars < 2 )

1477

assert( consdata->vars !=

NULL

);

1478

assert( consdata->perm !=

NULL

);

1479

assert( consdata->invperm !=

NULL

);

1480

assert( infeasible !=

NULL

);

1481

assert( ngen !=

NULL

);

1483

nvars = consdata->nvars;

1484

perm = consdata->perm;

1485

invperm = consdata->invperm;

1490

constobjective = 1.0;

1491 for

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

1494

sepaobjective[i] = - vals[i];

1497

sepaobjective[i] = 1.0 - vals[i];

1498

constobjective += vals[i] - 1.0;

1507

assert( maxcrit >= 0 );

1508 SCIPdebugMsg

(

scip

,

"Critical row %d found; Computing maximally violated cover.\n"

, maxcrit);

1512

maxsoluobj += constobjective;

1519 for

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

1522

maxsolu[i] = -maxsolu[i];

1525 if

( maxsolu[i] == 0 )

1527

maxsolu[i] = 1 - maxsolu[i];

1534 if

( ! *infeasible )

1561

assert( cons !=

NULL

);

1563

assert( consdata !=

NULL

);

1566 if

( consdata->nvars < 2 )

1569

assert( consdata->vars !=

NULL

);

1570

assert( consdata->invperm !=

NULL

);

1574

nvars = consdata->nvars;

1575

vars = consdata->vars;

1576

invperm = consdata->invperm;

1579 for

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

1586

assert( invperm[i] != i );

1607 else if

( val1 > val2 )

1611

assert( val2 > val1 );

1616 SCIPinfoMessage

(

scip

,

NULL

,

"First non-constant pair (%d, %d) of variables has pattern (0,1).\n"

, i, invperm[i]);

1668

assert( perm !=

NULL

);

1669

assert( nvars > 0 );

1670

assert( inputvars !=

NULL

);

1671

assert( upgrade !=

NULL

);

1677 if

( conshdlr ==

NULL

)

1680 SCIPdebugMsg

(

scip

,

"Cannot check whether symresack constraint can be upgraded to orbisack constraint. "

);

1690 for

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

1696 if

( perm[perm[i]] != i )

1704

vars1[nrows] = inputvars[i];

1705

vars2[nrows++] = inputvars[perm[i]];

1707

assert( nrows <= nvars );

1714 else if

( *upgrade )

1717

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

1768

assert( cons !=

NULL

);

1769

assert( perm !=

NULL

);

1770

assert( vars !=

NULL

);

1771

assert( nvars > 0 );

1774

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

1779

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

1795

assert(conshdlr !=

NULL

);

1812

assert( conshdlr !=

NULL

);

1813

assert( consdata !=

NULL

);

1829

assert( conshdlr !=

NULL

);

1833

assert( conshdlrdata !=

NULL

);

1851

assert( conshdlr !=

NULL

);

1853

assert( sourcecons !=

NULL

);

1854

assert( targetcons !=

NULL

);

1860

assert( sourcedata !=

NULL

);

1863

assert( sourcedata->nvars == 0 || sourcedata->vars !=

NULL

);

1864

assert( sourcedata->nvars == 0 || sourcedata->perm !=

NULL

);

1865

assert( sourcedata->nvars == 0 || sourcedata->invperm !=

NULL

);

1867 if

( sourcedata->ppupgrade )

1869

assert( sourcedata->nvars > 0 );

1870

assert( sourcedata->ncycles != 0 );

1871

assert( sourcedata->cycledecomposition !=

NULL

);

1872 for

(i = 0; i < sourcedata->ncycles; ++i)

1874

assert( sourcedata->cycledecomposition[i] !=

NULL

);

1875

assert( sourcedata->cycledecomposition[i][0] != 0 );

1884

nvars = sourcedata->nvars;

1888

consdata->vars =

NULL

;

1889

consdata->nvars = nvars;

1890

consdata->perm =

NULL

;

1891

consdata->invperm =

NULL

;

1892

consdata->ppupgrade = sourcedata->ppupgrade;

1893

consdata->ismodelcons = sourcedata->ismodelcons;

1895

consdata->debugcnt = 0;

1897

consdata->ncycles = 0;

1898

consdata->cycledecomposition =

NULL

;

1899

consdata->ndescentpoints = 0;

1900

consdata->descentpoints =

NULL

;

1906 for

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

1914 if

( sourcedata->ppupgrade )

1916

consdata->ncycles = sourcedata->ncycles;

1918 for

(i = 0; i < sourcedata->ncycles; ++i)

1923

consdata->ndescentpoints = sourcedata->ndescentpoints;

1933 for

(i = 0; i < sourcedata->nvars; ++i)

1959

assert( infeasible !=

NULL

);

1960

*infeasible =

FALSE

;

1963

assert( conshdlr !=

NULL

);

1967

assert( conshdlrdata !=

NULL

);

1970 for

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

1972

assert( conss[c] !=

NULL

);

1994

assert( conshdlr !=

NULL

);

1999

assert( conshdlrdata !=

NULL

);

2001

conshdlrdata->maxnvars = 0;

2004 for

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

2008

assert( conss[c] !=

NULL

);

2011

assert( consdata !=

NULL

);

2014 if

( consdata->nvars > conshdlrdata->maxnvars )

2015

conshdlrdata->maxnvars = consdata->nvars;

2033

assert( conshdlr !=

NULL

);

2035

assert( result !=

NULL

);

2049

assert( conshdlrdata !=

NULL

);

2051

maxnvars = conshdlrdata->maxnvars;

2052

assert( maxnvars > 0 );

2057 for

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

2065

assert( conss[c] !=

NULL

);

2068 if

( consdata->nvars == 0 )

2072

assert( consdata->nvars <= maxnvars );

2107

assert( conshdlr !=

NULL

);

2109

assert( result !=

NULL

);

2119

assert( conshdlrdata !=

NULL

);

2121

maxnvars = conshdlrdata->maxnvars;

2122

assert( maxnvars > 0 );

2127 for

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

2135

assert( conss[c] !=

NULL

);

2138 if

( consdata->nvars == 0 )

2142

assert( consdata->nvars <= maxnvars );

2179

assert( conshdlr !=

NULL

);

2181

assert( result !=

NULL

);

2183 SCIPdebugMsg

(

scip

,

"Enforcing method for symresack constraints (lp solutions) ...\n"

);

2197

assert( conshdlrdata !=

NULL

);

2199

maxnvars = conshdlrdata->maxnvars;

2200

assert( maxnvars > 0 );

2205 for

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

2213

assert( conss[c] !=

NULL

);

2215

assert( consdata !=

NULL

);

2218 if

( !consdata->ismodelcons )

2221 if

( consdata->nvars == 0 )

2225

assert( consdata->nvars <= maxnvars );

2257

assert( conshdlr !=

NULL

);

2259

assert( result !=

NULL

);

2261 SCIPdebugMsg

(

scip

,

"Enforcing method for symresack constraints (pseudo solutions) ...\n"

);

2265 if

( objinfeasible || solinfeasible )

2269 for

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

2272

assert( consdata !=

NULL

);

2275 if

( !consdata->ismodelcons )

2300

assert( conshdlr !=

NULL

);

2302

assert( result !=

NULL

);

2304 SCIPdebugMsg

(

scip

,

"Enforcing method for symresack constraints (relaxation solutions) ...\n"

);

2318

assert( conshdlrdata !=

NULL

);

2320

maxnvars = conshdlrdata->maxnvars;

2321

assert( maxnvars > 0 );

2326 for

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

2334

assert( conss[c] !=

NULL

);

2336

assert( consdata !=

NULL

);

2339 if

( !consdata->ismodelcons )

2342 if

( consdata->nvars == 0 )

2346

assert( consdata->nvars <= maxnvars );

2376

assert( conshdlr !=

NULL

);

2378

assert( result !=

NULL

);

2383 for

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

2386

assert( consdata !=

NULL

);

2389 if

( !consdata->ismodelcons )

2413

assert( conshdlr !=

NULL

);

2415

assert( result !=

NULL

);

2419 SCIPdebugMsg

(

scip

,

"Propagation method of symresack constraint handler.\n"

);

2422 for

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

2427

assert( conss[c] !=

NULL

);

2437

success = success || ( ngen > 0 );

2461

assert( conshdlr !=

NULL

);

2463

assert( result !=

NULL

);

2465

oldndelconss = *ndelconss;

2467 SCIPdebugMsg

(

scip

,

"Presolving method of symresack constraint handler. Propagating symresack inequalities.\n"

);

2471 for

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

2477

assert( conss[c] !=

NULL

);

2480

assert( consdata !=

NULL

);

2483 if

( consdata->nvars == 0 )

2501

*nfixedvars += ngen;

2508 if

( *ndelconss > oldndelconss || success )

2529

assert( conshdlr !=

NULL

);

2531

assert( cons !=

NULL

);

2532

assert( infervar !=

NULL

);

2533

assert( bdchgidx !=

NULL

);

2534

assert( result !=

NULL

);

2536 SCIPdebugMsg

(

scip

,

"Propagation resolution method of symresack constraint handler.\n"

);

2541

assert( consdata !=

NULL

);

2544 if

( consdata->nvars < 2 )

2547

assert( consdata->vars !=

NULL

);

2548

assert( consdata->invperm !=

NULL

);

2550

vars = consdata->vars;

2551

nvars = consdata->nvars;

2552

perm = consdata->perm;

2553

invperm = consdata->invperm;

2558

varrow = inferinfo % nvars;

2559

infrow = inferinfo / nvars;

2561

assert( varrow >= 0 );

2562

assert( varrow < nvars );

2563

assert( infrow >= 0 );

2564

assert( infrow < nvars );

2565

assert( vars[varrow] == infervar || vars[invperm[varrow]] == infervar );

2568 for

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

2573

assert( i != invperm[i] );

2576

assert(

ISFIXED

(vars[i], bdchgidx) );

2577

assert(

ISFIXED

(vars[invperm[i]], bdchgidx) );

2589

assert( vars[i] != infervar );

2593 if

( invperm[i] > i )

2595

assert( vars[invperm[i]] != infervar );

2611 for

(i = varrow + 1; i <= infrow; ++i)

2616

assert( i != invperm[i] );

2622 if

( ( i < perm[i] || i == invperm[varrow] ) &&

ISFIXED

(vars[i], bdchgidx) )

2624

assert( vars[i] != infervar );

2628 if

( ( invperm[i] > i || invperm[i] == varrow ) &&

ISFIXED

(vars[invperm[i]], bdchgidx) )

2630

assert( vars[invperm[i]] != infervar );

2644

assert( infervar == vars[varrow] );

2645

assert(

ISFIXED

(vars[invperm[varrow]], bdchgidx) );

2647 if

( invperm[varrow] > varrow )

2656

assert( infervar == vars[invperm[varrow]] );

2657

assert(

ISFIXED

(vars[varrow], bdchgidx) );

2659 if

( varrow < perm[varrow] )

2695

assert( conshdlr !=

NULL

);

2697

assert( cons !=

NULL

);

2699 SCIPdebugMsg

(

scip

,

"Locking method for symresack constraint handler.\n"

);

2703

assert( consdata !=

NULL

);

2706 if

( consdata->nvars < 2 )

2709

assert( consdata->vars !=

NULL

);

2710

assert( consdata->perm !=

NULL

);

2712

nvars = consdata->nvars;

2713

vars = consdata->vars;

2714

perm = consdata->perm;

2716 for

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

2719

assert( perm[i] != i );

2747

assert( cons !=

NULL

);

2748

assert( sourcescip !=

NULL

);

2749

assert( sourceconshdlr !=

NULL

);

2751

assert( sourcecons !=

NULL

);

2752

assert( varmap !=

NULL

);

2753

assert( valid !=

NULL

);

2757 SCIPdebugMsg

(

scip

,

"Copying method for symresack constraint handler.\n"

);

2760

assert( sourcedata !=

NULL

);

2761

assert( sourcedata->vars !=

NULL

);

2762

assert( sourcedata->perm !=

NULL

);

2763

assert( sourcedata->nvars > 0 );

2766

assert( conshdlrdata !=

NULL

);

2769 if

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

2776

sourcevars = sourcedata->vars;

2777

nvars = sourcedata->nvars;

2781 for

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

2784

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

NULL

);

2795

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

2816 int

nfoundpermidx = 0;

2819

assert( success !=

NULL

);

2827 if

( strncmp(s,

"symresack("

, 10) != 0 )

2829 SCIPerrorMessage

(

"Syntax error - expected \"symresack(\", but got '%s'"

, s);

2877

endptr = strchr(endptr,

']'

);

2879 if

( endptr ==

NULL

)

2891

assert( s !=

NULL

);

2894 if

( nvars > maxnvars )

2899

assert( nvars <= maxnvars );

2902

vars[nvars-1] = var;

2911 while

( *s !=

']'

);

2929

assert( s !=

NULL

);

2932 if

( nfoundpermidx > nvars )

2939

perm[nfoundpermidx-1] = val;

2948 while

( *s !=

']'

);

2950 if

( nfoundpermidx != nvars )

2952 SCIPerrorMessage

(

"length of permutation is not equal to number of given variables.\n"

);

2964 while

( *s !=

')'

);

2966 if

( *success && cnt < 2 )

2996

assert( conshdlr !=

NULL

);

2998

assert( cons !=

NULL

);

3001

assert( consdata !=

NULL

);

3003 SCIPdebugMsg

(

scip

,

"Printing method for symresack constraint handler\n"

);

3006 if

( consdata->nvars < 2 )

3009

assert( consdata->vars !=

NULL

);

3010

assert( consdata->perm !=

NULL

);

3012

vars = consdata->vars;

3013

nvars = consdata->nvars;

3014

perm = consdata->perm;

3019 for

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

3025 for

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

3039

assert( cons !=

NULL

);

3040

assert( success !=

NULL

);

3041

assert( vars !=

NULL

);

3044

assert( consdata !=

NULL

);

3046 if

( varssize < consdata->nvars )

3047

(*success) =

FALSE

;

3053 for

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

3054

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

3068

assert( cons !=

NULL

);

3069

assert( success !=

NULL

);

3070

assert( nvars !=

NULL

);

3073

assert( consdata !=

NULL

);

3075

(*nvars) = consdata->nvars;

3095

consEnfolpSymresack, consEnfopsSymresack, consCheckSymresack, consLockSymresack,

3097

assert( conshdlr !=

NULL

);

3118 "Upgrade symresack constraints to packing/partioning symresacks?"

,

3123 "Check whether permutation is monotone when upgrading to packing/partioning symresacks?"

,

3127 "Whether symresack constraints should be forced to be copied to sub SCIPs."

,

3181

assert( cons !=

NULL

);

3182

assert( nvars > 0 );

3186 if

( conshdlr ==

NULL

)

3196 SCIP_CALL

(

SCIPcreateCons

(

scip

, cons, name, conshdlr, consdata, initial, separate && (! consdata->ppupgrade), enforce, check, propagate,

3197

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

constraint handler for orbisack constraints

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

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_SEPAFREQ

static SCIP_DECL_CONSTRANS(consTransSymresack)

#define CONSHDLR_CHECKPRIORITY

static SCIP_DECL_CONSDELETE(consDeleteSymresack)

static SCIP_DECL_CONSINITSOL(consInitsolSymresack)

static SCIP_DECL_CONSPROP(consPropSymresack)

static SCIP_DECL_CONSGETVARS(consGetVarsSymresack)

#define CONSHDLR_PROP_TIMING

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopySymresack)

static SCIP_DECL_CONSLOCK(consLockSymresack)

#define DEFAULT_FORCECONSCOPY

#define CONSHDLR_MAXPREROUNDS

#define DEFAULT_CHECKMONOTONICITY

#define ISFIXED(x, bdchgidx)

static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA **consdata, SCIP_VAR *const *inputvars, int inputnvars, int *inputperm, SCIP_Bool ismodelcons)

static SCIP_DECL_CONSENFOPS(consEnfopsSymresack)

static SCIP_RETCODE propVariables(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, int *ngen)

static SCIP_RETCODE initLP(SCIP *scip, SCIP_CONS *cons, SCIP_Bool checkmonotonicity, SCIP_Bool *infeasible)

#define CONSHDLR_SEPAPRIORITY

static SCIP_DECL_CONSENFOLP(consEnfolpSymresack)

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

static SCIP_DECL_CONSCHECK(consCheckSymresack)

static SCIP_DECL_CONSENFORELAX(consEnforelaxSymresack)

static SCIP_RETCODE checkFeasible(SCIP *scip, SCIP_VAR **vars, int *invperm, int nvars, int start, int *tempfixings, int *tempfixentries, int numfixentriesinit, SCIP_Bool *infeasible, int *infeasibleentry)

static SCIP_DECL_CONSPRINT(consPrintSymresack)

static SCIP_RETCODE maximizeObjectiveSymresackCriticalEntry(SCIP *scip, int nvars, SCIP_Real *objective, int *perm, int *invperm, int crit, int *maxsolu)

static SCIP_RETCODE separateSymresackCovers(SCIP *scip, SCIP_CONS *cons, const SCIP_CONSDATA *consdata, SCIP_Real *vals, int *ngen, SCIP_Bool *infeasible)

#define CONSHDLR_PROPFREQ

static SCIP_DECL_CONSPRESOL(consPresolSymresack)

static SCIP_DECL_CONSINITLP(consInitlpSymresack)

static SCIP_RETCODE addSymresackInequality(SCIP *scip, SCIP_CONS *cons, int nvars, SCIP_VAR **vars, int *coeffs, SCIP_Real rhs, SCIP_Bool *infeasible)

#define CONSHDLR_PRESOLTIMING

static SCIP_RETCODE packingUpgrade(SCIP *scip, SCIP_CONSDATA **consdata, int *perm, SCIP_VAR **vars, int nvars, SCIP_Bool checkmonotonicity, SCIP_Bool *upgrade)

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

static SCIP_DECL_CONSSEPALP(consSepalpSymresack)

static SCIP_DECL_CONSPARSE(consParseSymresack)

#define CONSHDLR_EAGERFREQ

static SCIP_DECL_CONSGETNVARS(consGetNVarsSymresack)

#define DEFAULT_PPSYMRESACK

static SCIP_RETCODE maximizeObjectiveSymresackStrict(SCIP *scip, int nvars, SCIP_Real *objective, int *perm, int *invperm, int *maxcrit, SCIP_Real *maxsoluval)

#define CONSHDLR_ENFOPRIORITY

static SCIP_DECL_CONSCOPY(consCopySymresack)

#define CONSHDLR_DELAYSEPA

static SCIP_DECL_CONSSEPASOL(consSepasolSymresack)

static SCIP_DECL_CONSFREE(consFreeSymresack)

static SCIP_DECL_CONSRESPROP(consRespropSymresack)

static SCIP_RETCODE orbisackUpgrade(SCIP *scip, SCIP_CONS **cons, const char *name, int *perm, SCIP_VAR **inputvars, int nvars, SCIP_Bool *upgrade, 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)

#define CONSHDLR_DELAYPROP

constraint handler for symresack constraints

#define SCIP_DEFAULT_INFINITY

SCIP_RETCODE SCIPcreateSymbreakCons(SCIP *scip, SCIP_CONS **cons, const char *name, int *perm, SCIP_VAR **vars, int nvars, 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)

int SCIPgetNVarsSetppc(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR ** SCIPgetVarsSetppc(SCIP *scip, SCIP_CONS *cons)

SCIP_SETPPCTYPE SCIPgetTypeSetppc(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsOrbisack(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, int nrows, SCIP_Bool ispporbisack, SCIP_Bool isparttype, 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 SCIPcreateConsBasicSymresack(SCIP *scip, SCIP_CONS **cons, const char *name, int *perm, SCIP_VAR **vars, int nvars, SCIP_Bool ismodelcons)

SCIP_RETCODE SCIPcreateConsSymresack(SCIP *scip, SCIP_CONS **cons, const char *name, int *perm, SCIP_VAR **vars, int nvars, 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_SETPPCTYPE_PARTITIONING

@ SCIP_SETPPCTYPE_COVERING

@ SCIP_SETPPCTYPE_PACKING

SCIP_RETCODE SCIPincludeConshdlrSymresack(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_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

void SCIPinfoMessage(SCIP *scip, FILE *file, 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)))

int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)

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_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))

SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))

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_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)

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_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 SCIPfreeCleanBufferArray(scip, ptr)

#define SCIPallocCleanBufferArray(scip, ptr, num)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

#define SCIPallocClearBufferArray(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 SCIPfreeBufferArrayNull(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

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

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 SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)

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_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)

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

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisGE(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 SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

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

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

int SCIPvarGetProbindex(SCIP_VAR *var)

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

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)

SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

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

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)

void SCIPsortIntInt(int *intarray1, int *intarray2, int len)

SCIP_Bool SCIPstrToIntValue(const char *str, int *value, char **endptr)

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

SCIP_RETCODE SCIPskipSpace(char **s)

memory allocation routines

public methods for managing constraints

public methods for message output

public data structures and miscellaneous methods

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 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 solutions

public methods for SCIP variables

@ SCIP_CONFTYPE_PROPAGATION

struct SCIP_ConshdlrData SCIP_CONSHDLRDATA

struct SCIP_ConsData SCIP_CONSDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

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