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

SCIP Doxygen Documentation: cons_linking.c Source File

84#define CONSHDLR_NAME "linking" 85#define CONSHDLR_DESC "linking constraint x = sum_{i=1}^{n} c_i*y_i, y1+...+yn = 1, x real, y's binary" 87#define EVENTHDLR_NAME "linking" 88#define EVENTHDLR_DESC "event handler for linking constraints" 90#define CONSHDLR_SEPAPRIORITY 750000 91#define CONSHDLR_ENFOPRIORITY -2050000 92#define CONSHDLR_CHECKPRIORITY -750000 93#define CONSHDLR_SEPAFREQ 1 94#define CONSHDLR_PROPFREQ 1 95#define CONSHDLR_EAGERFREQ 100 96#define CONSHDLR_MAXPREROUNDS -1 97#define CONSHDLR_DELAYSEPA FALSE 98#define CONSHDLR_DELAYPROP FALSE 99#define CONSHDLR_NEEDSCONS TRUE 101#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP 102#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_MEDIUM 105#define HASHSIZE_BINVARSCONS 500 106#define DEFAULT_LINEARIZE FALSE 128 unsigned int

cliqueadded:1;

129 unsigned int

sorted:1;

133struct

SCIP_ConshdlrData

160 if

( consdata->sorted )

164 SCIPsortRealPtr

(consdata->vals, (

void

**)consdata->binvars, consdata->nbinvars);

166

consdata->sorted =

TRUE

;

181 for

(

b

= 0;

b

< nbinvars; ++

b

)

198

assert(conshdlrdata !=

NULL

);

199

assert(eventhdlr !=

NULL

);

204

(*conshdlrdata)->varmap =

NULL

;

207

(*conshdlrdata)->eventhdlr = eventhdlr;

219

assert(conshdlrdata !=

NULL

);

220

assert(*conshdlrdata !=

NULL

);

223 if

( (*conshdlrdata)->varmap !=

NULL

)

243

assert(consdata !=

NULL

);

245

linkvar = consdata->linkvar;

246

binvars = consdata->binvars;

247

nbinvars = consdata->nbinvars;

249

assert(linkvar !=

NULL

);

250

assert(binvars !=

NULL

|| nbinvars == 0);

263

assert(binvars !=

NULL

);

282

assert(consdata !=

NULL

);

283

assert(eventhdlr !=

NULL

);

284

assert(0 <= pos && pos < consdata->nbinvars);

285

assert(consdata->binvars !=

NULL

);

287

var = consdata->binvars[pos];

288

assert(var !=

NULL

);

296

consdata->nfixedzeros++;

298

consdata->nfixedones++;

314

assert(consdata !=

NULL

);

315

assert(eventhdlr !=

NULL

);

316

assert(0 <= pos && pos < consdata->nbinvars);

317

assert(consdata->binvars !=

NULL

);

319

var = consdata->binvars[pos];

320

assert(var !=

NULL

);

327

consdata->nfixedzeros--;

329

consdata->nfixedones--;

344

assert(consdata !=

NULL

);

352 for

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

370

assert(consdata !=

NULL

);

378 for

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

414 for

(

b

= 0;

b

< consdata->nbinvars; ++

b

)

445

assert(consdata !=

NULL

);

446

assert(consdata->nbinvars == 0);

447

assert(consdata->binvars ==

NULL

);

456

linkvar = consdata->linkvar;

460

nbinvars = ub - lb + 1;

461

assert(nbinvars > 0);

467

consdata->sizebinvars = nbinvars;

479

consdata->binvars[0] = binvar;

480

consdata->vals[0] = lb;

484 for

(

b

= 0;

b

< nbinvars; ++

b

)

494

consdata->binvars[

b

] = binvar;

495

consdata->vals[

b

] = lb +

b

;

499

consdata->nbinvars = nbinvars;

501

assert(consdata->nfixedzeros == 0);

502

assert(consdata->nfixedones == 0);

544

assert(consdata !=

NULL

);

545

assert(linkvar !=

NULL

);

546

assert(binvars !=

NULL

|| nbinvars == 0);

552

(*consdata)->linkvar = linkvar;

553

(*consdata)->nbinvars = nbinvars;

554

(*consdata)->sizebinvars = nbinvars;

555

(*consdata)->row1 =

NULL

;

556

(*consdata)->row2 =

NULL

;

557

(*consdata)->nlrow1 =

NULL

;

558

(*consdata)->nlrow2 =

NULL

;

559

(*consdata)->cliqueadded =

FALSE

;

562

(*consdata)->sorted =

FALSE

;

563

(*consdata)->firstnonfixed = 0;

564

(*consdata)->lastnonfixed = nbinvars - 1;

565

(*consdata)->nfixedzeros = 0;

566

(*consdata)->nfixedones = 0;

570

(*consdata)->binvars =

NULL

;

571

(*consdata)->vals =

NULL

;

603 for

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

605

assert((*consdata)->binvars[v] !=

NULL

);

623

assert(consdata !=

NULL

);

624

assert(*consdata !=

NULL

);

625

assert((*consdata)->nbinvars == 0 || (*consdata)->binvars !=

NULL

);

628 if

( (*consdata)->row1 !=

NULL

)

630

assert((*consdata)->row2 !=

NULL

);

637 if

( (*consdata)->nlrow1 !=

NULL

)

639

assert((*consdata)->nlrow2 !=

NULL

);

646 for

( v = 0; v < (*consdata)->nbinvars; ++v )

648

assert((*consdata)->binvars[v] !=

NULL

);

654 if

( (*consdata)->sizebinvars > 0 )

662

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

663

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

696

assert(linkvar !=

NULL

);

702

assert(linkvar !=

NULL

);

706 if

( binvar !=

NULL

)

738

assert(consdata !=

NULL

);

740

linkvar = consdata->linkvar;

741

coef = consdata->vals[pos];

800

assert(cons !=

NULL

);

803

assert(cutoff !=

NULL

);

804

assert(nchgbds !=

NULL

);

805

assert(mustcheck !=

NULL

);

808

assert(consdata !=

NULL

);

813

nbinvars = consdata->nbinvars;

816

assert(nbinvars > 1);

819 if

( consdata->nfixedones > 0 || consdata->nfixedzeros >= nbinvars-1 )

822

linkvar = consdata->linkvar;

823

assert(linkvar !=

NULL

);

825

binvars = consdata->binvars;

826

vals = consdata->vals;

835 for

(

b

= 0;

b

< consdata->firstnonfixed; ++

b

)

839 for

(

b

= consdata->lastnonfixed + 1;

b

< nbinvars; ++

b

)

843 for

(

b

= consdata->firstnonfixed;

b

< nbinvars; ++

b

)

850

assert(var !=

NULL

);

852 SCIPdebugMsg

(

scip

,

"fix variable <%s> to zero due to the lower bound of the linking variable <%s> [%g,%g]\n"

,

868

consdata->firstnonfixed++;

875 for

(

b

= consdata->lastnonfixed;

b

>= 0; --

b

)

882

assert(var !=

NULL

);

884 SCIPdebugMsg

(

scip

,

"fix variable <%s> to zero due to the upper bound of the linking variable <%s> [%g,%g]\n"

,

900

consdata->lastnonfixed--;

906 if

( consdata->firstnonfixed > consdata->lastnonfixed )

912

*mustcheck = (*nchgbds) == 0;

919 if

( consdata->firstnonfixed == consdata->lastnonfixed )

923

var = binvars[consdata->firstnonfixed];

925 SCIPdebugMsg

(

scip

,

"fix variable <%s> to one due to the fixed linking variable <%s> [%g,%g]\n"

,

961

vars = &consdata->binvars[consdata->firstnonfixed];

962

nvars = consdata->lastnonfixed - consdata->firstnonfixed + 1;

992

assert(eventhdlr !=

NULL

);

995

assert(consdata !=

NULL

);

996

assert(0 <= pos && pos < consdata->nbinvars);

998

var = consdata->binvars[pos];

999

assert(var !=

NULL

);

1014

assert(conshdlrdata !=

NULL

);

1015

assert(conshdlrdata->eventhdlr !=

NULL

);

1022 if

( pos != consdata->nbinvars - 1 )

1024

consdata->binvars[pos] = consdata->binvars[consdata->nbinvars-1];

1025

consdata->vals[pos] = consdata->vals[consdata->nbinvars-1];

1026

consdata->sorted =

FALSE

;

1029

consdata->nbinvars--;

1050

assert(consdata !=

NULL

);

1051

assert(consdata->sorted);

1057

nbinvars = consdata->nbinvars;

1059 for

(

b

= nbinvars - 1;

b

> consdata->lastnonfixed; --

b

)

1064 for

(

b

= consdata->firstnonfixed - 1;

b

>= 0; --

b

)

1069 for

(

b

= consdata->nbinvars - 1;

b

>= 0; --

b

)

1078

consdata->firstnonfixed = 0;

1079

consdata->lastnonfixed = consdata->nbinvars - 1;

1104 if

( consdata->nfixedones > 1 || consdata->nfixedzeros >= consdata->nbinvars-1 )

1110

assert(consdata->sorted);

1112

linkvar = consdata->linkvar;

1113

binvars = consdata->binvars;

1114

vals = consdata->vals;

1115

nbinvars = consdata->nbinvars;

1119 for

(

b

= 0;

b

< consdata->firstnonfixed; ++

b

)

1123

assert(consdata->firstnonfixed < nbinvars);

1124

assert(consdata->lastnonfixed < nbinvars);

1127 for

(

b

= consdata->firstnonfixed;

b

< nbinvars; ++

b

)

1132

consdata->firstnonfixed++;

1143 SCIPdebugMsg

(

scip

,

"conflict at <%s> due to bounds and fixed binvars: [lb,ub] = [%g,%g]; b= %d; coef = %g \n"

,

1153 for

(

b

= 0;

b

< consdata->firstnonfixed; ++

b

)

1171 for

(

b

= consdata->lastnonfixed + 1;

b

< nbinvars; ++

b

)

1176 for

(

b

= consdata->lastnonfixed;

b

>= 0; --

b

)

1181

consdata->lastnonfixed--;

1192 SCIPdebugMsg

(

scip

,

"conflict at <%s> due to bounds and fixed binvars: [lb,ub] = [%g,%g]; b = %d; coef = %g,\n"

,

1202 for

(

b

= consdata->lastnonfixed + 1;

b

< nbinvars; ++

b

)

1236

assert(cons !=

NULL

);

1239

assert(cutoff !=

NULL

);

1240

assert(nchgbds !=

NULL

);

1241

assert(addcut !=

NULL

);

1242

assert(mustcheck !=

NULL

);

1245

assert(consdata !=

NULL

);

1246

assert(consdata->nbinvars == 0 || consdata->binvars !=

NULL

);

1247

assert(0 <= consdata->nfixedzeros && consdata->nfixedzeros <= consdata->nbinvars);

1248

assert(0 <= consdata->nfixedones && consdata->nfixedones <= consdata->nbinvars);

1254

assert(consdata->nbinvars > 1);

1259 if

( consdata->nfixedones == 1 )

1265 if

( consdata->nfixedzeros < consdata->nbinvars - 1 ||

1276 SCIPdebugMsg

(

scip

,

" -> fixing all other variables to zero due to the set partitioning condition <%s>\n"

,

1283

vars = consdata->binvars;

1284

nvars = consdata->nbinvars;

1286

fixedonefound =

FALSE

;

1289 for

( v = 0; v < nvars && consdata->nfixedones == 1 && !(*cutoff); ++v )

1305

assert(!infeasible);

1311

fixedonefound =

TRUE

;

1321

assert(consdata->nfixedones >= 1 || fixedonefound);

1337 else if

( consdata->nfixedones >= 2 )

1354

vars = consdata->binvars;

1355

nvars = consdata->nbinvars;

1362 for

( v = 0; v < nvars && n < 2; ++v )

1378 else if

( consdata->nfixedzeros == consdata->nbinvars )

1385

assert(consdata->nfixedones == 0);

1402

vars = consdata->binvars;

1403

nvars = consdata->nbinvars;

1408 for

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

1420 else if

( consdata->nfixedzeros == consdata->nbinvars - 1 )

1427

assert(consdata->nfixedones == 0);

1437

vars = consdata->binvars;

1438

nvars = consdata->nbinvars;

1439 for

( v = 0; v < nvars && !(*cutoff); ++v )

1454

assert(!infeasible);

1465

assert(consdata->nfixedzeros == consdata->nbinvars - 1);

1466

assert(consdata->nfixedones == 1);

1477

*mustcheck = (*nchgbds) == 0;

1479

assert(consdata->nfixedzeros + consdata->nfixedones <= consdata->nbinvars);

1506

assert(cons !=

NULL

);

1511

assert(consdata !=

NULL

);

1512

assert(consdata->binvars !=

NULL

|| consdata->nbinvars == 0);

1515

assert(consdata->nbinvars > 1);

1518

binvars = consdata->binvars;

1519

vals = consdata->vals;

1520

nbinvars = consdata->nbinvars;

1526 for

(

b

= 0;

b

< nbinvars && setpartsum < setpartsumbound; ++

b

)

1533

linksum += vals[

b

] * solval;

1534

setpartsum += solval;

1539

absviol =

REALABS

(linksum - linkvarval);

1545

absviol =

REALABS

(setpartsum - 1.0);

1554#ifdef SCIP_DISABLED_CODE 1587

assert(varmap !=

NULL

);

1589 for

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

1592

assert(consdata !=

NULL

);

1594

linkvar = consdata->linkvar;

1595

assert(linkvar !=

NULL

);

1603 if

( aggrcons !=

NULL

)

1606

assert(aggrconsdata !=

NULL

);

1620

offset = consdata->offset;

1621

binvars = consdata->binvars;

1622

aggroffset = aggrconsdata->offset;

1623

aggrbinvars = aggrconsdata->binvars;

1625

nbinvars =

MIN

(consdata->nbinvars + offset, aggrconsdata->nbinvars + shift + aggroffset);

1627 for

(

b

=

MAX

(offset, aggroffset-shift);

b

< nbinvars; ++

b

)

1629

assert(

b

- offset >= 0);

1630

assert(

b

+ shift - aggroffset >= 0);

1631

assert(b < consdata->nbinvars);

1632

assert(b < aggrconsdata->nbinvars - shift);

1636

&infeasible, &redundant, &aggregated) );

1670

assert( cons !=

NULL

);

1674

assert(consdata !=

NULL

);

1675

assert(consdata->row1 ==

NULL

);

1676

assert(consdata->row2 ==

NULL

);

1677

assert(consdata->nbinvars > 1);

1686

assert(consdata->linkvar !=

NULL

);

1690

assert(consdata->binvars !=

NULL

);

1691 for

(

b

= 0;

b

< consdata->nbinvars; ++

b

)

1698

assert( consdata->nbinvars > 0 );

1719

assert( cutoff !=

NULL

);

1723

assert(consdata !=

NULL

);

1726

assert(consdata->nbinvars > 1);

1728 if

( consdata->row1 ==

NULL

)

1730

assert(consdata->row2 ==

NULL

);

1735

assert(consdata->row1 !=

NULL

);

1736

assert(consdata->row2 !=

NULL

);

1771

assert(consdata !=

NULL

);

1773 if

( consdata->nlrow1 ==

NULL

)

1779

assert(consdata->nlrow2 ==

NULL

);

1794 for

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

1828

assert(cons !=

NULL

);

1831

assert(cutoff !=

NULL

);

1832

assert(separated !=

NULL

);

1833

assert(nchgbds !=

NULL

);

1836

assert(consdata !=

NULL

);

1839

assert(consdata->nbinvars > 1);

1853 if

( mustcheck && !(*cutoff) )

1856 if

( sol ==

NULL

&& consdata->row1 !=

NULL

)

1861

assert(consdata->row2 !=

NULL

);

1873

feasibility =

MIN

(feasibility, tmp);

1880

feasibility =

MIN

(feasibility, tmp);

1921

assert(cons !=

NULL

);

1924

assert(cutoff !=

NULL

);

1925

assert(infeasible !=

NULL

);

1926

assert(nchgbds !=

NULL

);

1927

assert(solvelp !=

NULL

);

1949

*infeasible =

TRUE

;

1981

assert(conshdlr !=

NULL

);

1983

assert(nconss == 0 || conss !=

NULL

);

1984

assert(result !=

NULL

);

1986 SCIPdebugMsg

(

scip

,

"Enforcing %d linking constraints for %s solution\n"

, nconss, sol ==

NULL

?

"LP"

:

"relaxation"

);

1993 for

( c = 0; c < nusefulconss && !cutoff && nchgbds == 0; ++c )

1999 for

( c = nusefulconss; c < nconss && !cutoff && !separated && nchgbds == 0; ++c )

2007 else if

( nchgbds > 0 )

2009 else if

( separated )

2036

assert(cons !=

NULL

);

2037

assert(graph !=

NULL

);

2038

assert(success !=

NULL

);

2041

assert(consdata !=

NULL

);

2045

nlocvars = consdata->nbinvars + 1;

2051 for

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

2053

vars[i] = consdata->binvars[i];

2054

vals[i] = consdata->vals[i];

2058

vars[consdata->nbinvars] = consdata->linkvar;

2059

vals[consdata->nbinvars] = -1.0;

2064

cons, -constant, -constant, success) );

2081

assert(conshdlr !=

NULL

);

2098

assert(conshdlr !=

NULL

);

2104

assert(conshdlrdata !=

NULL

);

2121

assert(conshdlrdata !=

NULL

);

2124 for

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

2127

assert(consdata !=

NULL

);

2133 if

( consdata->nbinvars <= 1 )

2138 else if

( conshdlrdata->linearize )

2156 for

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

2172 for

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

2175

assert(consdata !=

NULL

);

2178 if

( consdata->row1 !=

NULL

)

2180

assert(consdata->row2 !=

NULL

);

2186 if

( consdata->nlrow1 !=

NULL

)

2188

assert(consdata->nlrow2 !=

NULL

);

2205

assert(conshdlr !=

NULL

);

2207

assert(consdata !=

NULL

);

2208

assert(*consdata !=

NULL

);

2211

assert(conshdlrdata !=

NULL

);

2212

assert(conshdlrdata->eventhdlr !=

NULL

);

2215

assert(conshdlrdata->varmap !=

NULL

);

2239

assert(conshdlr !=

NULL

);

2242

assert(sourcecons !=

NULL

);

2243

assert(targetcons !=

NULL

);

2247

assert(conshdlrdata !=

NULL

);

2248

assert(conshdlrdata->eventhdlr !=

NULL

);

2251

assert(sourcedata !=

NULL

);

2252

assert(sourcedata->row1 ==

NULL

);

2253

assert(sourcedata->row2 ==

NULL

);

2259

sourcedata->linkvar, sourcedata->binvars, sourcedata->vals, sourcedata->nbinvars) );

2269

assert(conshdlrdata->varmap !=

NULL

);

2282

*infeasible =

FALSE

;

2284 for

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

2289

assert(consdata !=

NULL

);

2291 if

( consdata->nbinvars <= 1 )

2310

assert(conshdlr !=

NULL

);

2312

assert(nconss == 0 || conss !=

NULL

);

2313

assert(result !=

NULL

);

2315 SCIPdebugMsg

(

scip

,

"separating %d/%d linking constraints\n"

, nusefulconss, nconss);

2322 for

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

2330 else if

( nchgbds > 0 )

2332 else if

( separated )

2350

assert(conshdlr !=

NULL

);

2352

assert(nconss == 0 || conss !=

NULL

);

2353

assert(result !=

NULL

);

2362 for

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

2370 else if

( nchgbds > 0 )

2372 else if

( separated )

2411

assert(conshdlr !=

NULL

);

2413

assert(nconss == 0 || conss !=

NULL

);

2414

assert(result !=

NULL

);

2418 if

( objinfeasible )

2425

infeasible =

FALSE

;

2430 for

( c = 0; c < nconss && !cutoff && !solvelp; ++c )

2437 else if

( nchgbds > 0 )

2441 else if

( infeasible )

2458

assert(conshdlr !=

NULL

);

2460

assert(nconss == 0 || conss !=

NULL

);

2461

assert(result !=

NULL

);

2466 for

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

SCIP_FEASIBLE

|| completely); ++c )

2470

assert(consdata !=

NULL

);

2472 if

( consdata->nbinvars > 1 && (checklprows || consdata->row1 ==

NULL

|| !

SCIProwIsInLP

(consdata->row1)) )

2487 for

(

b

= 0;

b

< consdata->nbinvars; ++

b

)

2489

assert(consdata->binvars[

b

] !=

NULL

);

2498 for

(

b

= 0;

b

< consdata->nbinvars; ++

b

)

2542

assert(conshdlr !=

NULL

);

2544

assert(nconss == 0 || conss !=

NULL

);

2545

assert(result !=

NULL

);

2550 for

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

2562 else if

( nchgbds > 0 )

2589

assert(conshdlr !=

NULL

);

2592

assert(result !=

NULL

);

2598

oldnchgbds = *nchgbds;

2599

oldnaggrvars = *naggrvars;

2600

oldnfixedvars = *nfixedvars;

2601

oldndelconss = *ndelconss;

2605

assert(conshdlrdata !=

NULL

);

2608

firstchange = INT_MAX;

2609

firstclique = INT_MAX;

2621

assert(cons !=

NULL

);

2627

assert(consdata !=

NULL

);

2633

assert(consdata->nbinvars > 1);

2636 if

( consdata->nfixedones >= 2 )

2646 if

( consdata->nfixedones == 1 )

2658 for

( v = 0; v < consdata->nbinvars; ++v )

2660

var = consdata->binvars[v];

2661

assert(var !=

NULL

);

2711 if

( consdata->nfixedzeros == consdata->nbinvars )

2716

assert(consdata->nfixedones == 0);

2723 if

( consdata->nfixedzeros == consdata->nbinvars - 1 )

2734

assert(consdata->nfixedones == 0);

2742 for

( v = 0; v < consdata->nbinvars &&

SCIPvarGetUbGlobal

(consdata->binvars[v]) < 0.5; ++v );

2743

assert(v < consdata->nbinvars);

2744

var = consdata->binvars[v];

2784 if

( consdata->nfixedzeros == consdata->nbinvars - 2 )

2800 for

( v = 0; v < consdata->nbinvars && var2 ==

NULL

; ++v )

2802

var = consdata->binvars[v];

2811

assert(var1 !=

NULL

&& var2 !=

NULL

);

2821 SCIPdebugMsg

(

scip

,

"linking constraint <%s>: infeasible aggregation <%s> + <%s> == 1\n"

,

2840 if

( ! cutoff && consdata->nbinvars == 1 )

2846

linkvar = consdata->linkvar;

2847

binvar = consdata->binvars[0];

2848

val = consdata->vals[0];

2850 SCIPdebugMsg

(

scip

,

"linking constraint <%s>: fix <%s> to %16.9g as only one binary variable remains"

,

2863

cutoff = infeasible;

2876 if

( firstchange == INT_MAX )

2880 if

( !consdata->cliqueadded && consdata->nbinvars >= 2 )

2882 if

( firstclique == INT_MAX )

2897

assert(cons !=

NULL

);

2904

assert(consdata !=

NULL

);

2906 if

( !consdata->cliqueadded && consdata->nbinvars >= 3 )

2912

*nchgbds += ncliquebdchgs;

2920

consdata->cliqueadded =

TRUE

;

2924#ifdef SCIP_DISABLED_CODE 2933 else if

( oldndelconss < *ndelconss || oldnfixedvars < *nfixedvars || oldnchgbds < *nchgbds || oldnaggrvars < *naggrvars)

2951

assert(consdata !=

NULL

);

2953

linkvar = consdata->linkvar;

2954

assert(linkvar !=

NULL

);

2958 if

( inferinfo == -1 )

2972 for

( v = 0; v < consdata->nbinvars; ++v )

2980

assert(v < consdata->nbinvars);

2988 for

( v = 0; v < consdata->nbinvars; ++v )

2990 if

( consdata->binvars[v] != infervar )

2999 else if

( inferinfo == -2 )

3011 else if

( inferinfo == -3 )

3023 else if

( inferinfo == -4 )

3032

assert(infervar == linkvar);

3035

binvars = consdata->binvars;

3036

nbinvars = consdata->nbinvars;

3037

vals = consdata->vals;

3042 for

(

b

= 0;

b

< nbinvars; ++

b

)

3044 if

( vals[

b

] >= lb )

3051 else if

( inferinfo == -5 )

3061

assert(infervar == linkvar);

3064

binvars = consdata->binvars;

3065

nbinvars = consdata->nbinvars;

3066

vals = consdata->vals;

3072 for

(

b

= nbinvars - 1;

b

>= 0; --

b

)

3074 if

( vals[

b

] <= ub )

3080 else if

( inferinfo == -6 )

3098

assert(infervar == linkvar);

3099

assert(inferinfo >= 0);

3100

assert(inferinfo < consdata->nbinvars);

3123

assert(consdata !=

NULL

);

3129 for

(

b

= 0;

b

< consdata->nbinvars; ++

b

)

3141

assert(cons !=

NULL

);

3165

assert(consdata !=

NULL

);

3172

assert(consdata->nlrow2 !=

NULL

);

3184#ifdef SCIP_DISABLED_CODE 3190

assert(conshdlrdata !=

NULL

);

3193

assert(consdata !=

NULL

);

3195 if

( consdata->nbinvars <= 1 )

3200 else if

( conshdlrdata->linearize )

3214

assert(conshdlr !=

NULL

);

3215

assert(cons !=

NULL

);

3231 const char

* consname;

3245

assert(sourceconsdata !=

NULL

);

3248

nbinvars = sourceconsdata->nbinvars;

3249

linkvar = sourceconsdata->linkvar;

3264 for

( v = 0; v < nbinvars && *valid; ++v )

3266

assert(binvars !=

NULL

);

3268

assert(!(*valid) || binvars[v] !=

NULL

);

3275

assert(!(*valid) || linkvar !=

NULL

);

3287

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

3312

assert(success !=

NULL

);

3313

assert(str !=

NULL

);

3314

assert(name !=

NULL

);

3315

assert(cons !=

NULL

);

3322 if

( linkvar ==

NULL

)

3330

endptr = strchr(endptr,

'='

);

3333 if

( endptr ==

NULL

)

3343

str += *(str+1) ==

'='

? 2 : 1;

3354 if

( strncmp(str,

"no binary variables yet"

, 24) != 0 )

3362 if

( *success && requsize > varssize )

3365

varssize = requsize;

3370

assert(!*success || requsize <= varssize);

3377 for

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

3388

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

3404

assert(consdata !=

NULL

);

3406 if

( varssize < consdata->nbinvars + 1)

3407

(*success) =

FALSE

;

3410

assert(vars !=

NULL

);

3413

vars[consdata->nbinvars] = consdata->linkvar;

3427

assert(consdata !=

NULL

);

3429

(*nvars) = consdata->nbinvars + 1;

3464

assert(eventhdlr !=

NULL

);

3465

assert(eventdata !=

NULL

);

3467

assert(event !=

NULL

);

3470

assert(consdata !=

NULL

);

3473 switch

( eventtype )

3476

consdata->nfixedones++;

3479

consdata->nfixedones--;

3480

consdata->firstnonfixed = 0;

3481

consdata->lastnonfixed = consdata->nbinvars - 1;

3484

consdata->nfixedzeros++;

3487

consdata->firstnonfixed = 0;

3488

consdata->lastnonfixed = consdata->nbinvars - 1;

3489

consdata->nfixedzeros--;

3495

assert(0 <= consdata->nfixedzeros && consdata->nfixedzeros <= consdata->nbinvars);

3496

assert(0 <= consdata->nfixedones && consdata->nfixedones <= consdata->nbinvars);

3519

eventExecBinvar,

NULL

) );

3527

consEnfolpLinking, consEnfopsLinking, consCheckLinking, consLockLinking,

3530

assert(conshdlr !=

NULL

);

3563 "constraints/" CONSHDLR_NAME "/linearize"

,

"this constraint will not propagate or separate, linear and setppc are used?"

,

3617 if

( conshdlr ==

NULL

)

3623 SCIPdebugMsg

(

scip

,

"create linking constraint for variable <%s> with %d binary variables (SCIP stage %d)\n"

,

3625 for

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

3632

assert(conshdlrdata !=

NULL

);

3634 if

( conshdlrdata->varmap ==

NULL

)

3638

assert(conshdlrdata->varmap !=

NULL

);

3647

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

3650 if

( nbinvars == 0 )

3698

assert(conshdlr !=

NULL

);

3701

assert(conshdlrdata !=

NULL

);

3716

assert(conshdlr !=

NULL

);

3719

assert(conshdlrdata !=

NULL

);

3721 if

( conshdlrdata->varmap !=

NULL

)

3745

assert(consdata !=

NULL

);

3747 return

consdata->linkvar;

3770

assert(consdata !=

NULL

);

3772 if

( consdata->binvars ==

NULL

)

3778

assert(conshdlr !=

NULL

);

3781

assert(conshdlrdata !=

NULL

);

3786

assert(consdata->binvars !=

NULL

);

3788 if

( binvars !=

NULL

)

3789

(*binvars) = consdata->binvars;

3790 if

( nbinvars !=

NULL

)

3791

(*nbinvars) = consdata->nbinvars;

3814

assert(consdata !=

NULL

);

3816 return

consdata->nbinvars;

3837

assert(consdata !=

NULL

);

3840 return

consdata->vals;

3861

assert(consdata !=

NULL

);

3865 if

( binvars !=

NULL

)

3866

*binvars = consdata->binvars;

3868

*vals = consdata->vals;

3869 if

( nbinvars !=

NULL

)

3870

*nbinvars = consdata->nbinvars;

static SCIP_RETCODE aggregateVariables(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars)

Constraint handler for linear constraints in their most general form, .

static SCIP_DECL_CONSRESPROP(consRespropLinking)

static SCIP_RETCODE consdataLinearize(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata)

static SCIP_RETCODE consdataPrint(SCIP *scip, SCIP_CONSDATA *consdata, FILE *file)

static SCIP_DECL_CONSENFORELAX(consEnforelaxLinking)

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_SEPAFREQ

static SCIP_RETCODE analyzeConflict(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *linkvar, SCIP_VAR *binvar, SCIP_Bool lblinkvar, SCIP_Bool ublinkvar)

static SCIP_RETCODE enforcePseudo(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, SCIP_Bool *infeasible, int *nchgbds, SCIP_Bool *solvelp)

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopyLinking)

#define CONSHDLR_CHECKPRIORITY

static SCIP_DECL_CONSDEACTIVE(consDeactiveLinking)

static SCIP_RETCODE addCuts(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff)

static SCIP_RETCODE catchAllEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr)

static SCIP_RETCODE consFixLinkvar(SCIP *scip, SCIP_CONS *cons, int pos, SCIP_Bool *cutoff)

static SCIP_RETCODE dropEvent(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos)

static SCIP_RETCODE dropAllEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr)

static SCIP_RETCODE removeFixedBinvars(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS *cons)

#define CONSHDLR_PROP_TIMING

static SCIP_DECL_CONSINITSOL(consInitsolLinking)

static SCIP_DECL_CONSTRANS(consTransLinking)

static SCIP_DECL_CONSENFOPS(consEnfopsLinking)

static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)

static SCIP_RETCODE processBinvarFixings(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool *addcut, SCIP_Bool *mustcheck)

static void * getHashmapKey(SCIP_VAR *var)

#define CONSHDLR_MAXPREROUNDS

static SCIP_RETCODE lockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **binvars, int nbinvars)

static SCIP_Bool checkCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)

#define CONSHDLR_SEPAPRIORITY

static SCIP_DECL_CONSPRINT(consPrintLinking)

static SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(consGetSignedPermsymGraphLinking)

static SCIP_DECL_CONSENABLE(consEnableLinking)

#define DEFAULT_LINEARIZE

static SCIP_DECL_CONSACTIVE(consActiveLinking)

static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)

static SCIP_DECL_CONSEXITSOL(consExitsolLinking)

static SCIP_RETCODE catchEvent(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos)

static SCIP_RETCODE processRealBoundChg(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool *mustcheck)

static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONSDATA **consdata, SCIP_VAR *linkvar, SCIP_VAR **binvars, SCIP_Real *vals, int nbinvars)

static SCIP_RETCODE consdataCreateBinvars(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool linearize)

static SCIP_DECL_EVENTEXEC(eventExecBinvar)

static SCIP_DECL_CONSGETVARS(consGetVarsLinking)

static SCIP_DECL_CONSSEPALP(consSepalpLinking)

static SCIP_DECL_CONSCHECK(consCheckLinking)

static SCIP_DECL_CONSPARSE(consParseLinking)

static SCIP_DECL_CONSPRESOL(consPresolLinking)

static SCIP_RETCODE tightenedLinkvar(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_Bool *cutoff, int *nchgbds)

static SCIP_DECL_CONSPROP(consPropLinking)

#define CONSHDLR_PROPFREQ

static SCIP_RETCODE createRows(SCIP *scip, SCIP_CONS *cons)

static SCIP_DECL_CONSINITLP(consInitlpLinking)

static SCIP_DECL_CONSCOPY(consCopyLinking)

#define CONSHDLR_PRESOLTIMING

static SCIP_RETCODE delCoefPos(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS *cons, int pos)

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

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

static void consdataSort(SCIP_CONSDATA *consdata)

static SCIP_RETCODE addNlrow(SCIP *scip, SCIP_CONS *cons)

static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *cutoff, SCIP_Bool *separated, int *nchgbds)

#define CONSHDLR_EAGERFREQ

static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)

#define CONSHDLR_ENFOPRIORITY

static SCIP_DECL_CONSGETPERMSYMGRAPH(consGetPermsymGraphLinking)

#define CONSHDLR_DELAYSEPA

static SCIP_DECL_CONSLOCK(consLockLinking)

static SCIP_DECL_CONSENFOLP(consEnfolpLinking)

#define HASHSIZE_BINVARSCONS

static SCIP_DECL_CONSDELETE(consDeleteLinking)

static SCIP_DECL_CONSINITPRE(consInitpreLinking)

static SCIP_DECL_CONSFREE(consFreeLinking)

static SCIP_DECL_CONSSEPASOL(consSepasolLinking)

static SCIP_DECL_CONSGETNVARS(consGetNVarsLinking)

#define CONSHDLR_DELAYPROP

constraint handler for linking binary variables to a linking (continuous or integer) variable

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

int SCIPgetNBinvarsLinking(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPgetBinvarsLinking(SCIP *scip, SCIP_CONS *cons, SCIP_VAR ***binvars, int *nbinvars)

SCIP_Bool SCIPexistsConsLinking(SCIP *scip, SCIP_VAR *linkvar)

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

SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)

SCIP_CONS * SCIPgetConsLinking(SCIP *scip, SCIP_VAR *linkvar)

SCIP_RETCODE SCIPcreateConsLinking(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *linkvar, SCIP_VAR **binvars, SCIP_Real *vals, int nbinvars, 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 SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, 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 SCIPcreateConsSetpart(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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 SCIPcreateConsBasicLinking(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *linkvar, SCIP_VAR **binvars, SCIP_Real *vals, int nbinvars)

SCIP_Real * SCIPgetValsLinking(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPgetBinvarsDataLinking(SCIP_CONS *cons, SCIP_VAR ***binvars, SCIP_Real **vals, int *nbinvars)

SCIP_RETCODE SCIPincludeConshdlrLinking(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_Bool SCIPisStopped(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

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)

SCIP_RETCODE SCIPhashmapRemove(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)

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

SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)

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)

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 SCIPsetConshdlrEnable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))

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 SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))

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 SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))

SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)))

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_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)))

SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))

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_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))

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_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsTransformed(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)

SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)

SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsAdded(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)

SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)

SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

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

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

const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)

SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)

SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)

SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)

SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

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

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBufferArrayNull(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

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

SCIP_RETCODE SCIPdelNlRow(SCIP *scip, SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)

SCIP_Bool SCIPisNLPConstructed(SCIP *scip)

SCIP_RETCODE SCIPaddLinearCoefToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)

SCIP_Bool SCIPnlrowIsInNLP(SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPcreateNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)

SCIP_Bool SCIPinProbing(SCIP *scip)

SCIP_RETCODE SCIPaddVarsToRowSameCoef(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real val)

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

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

SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)

SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)

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

void SCIPupdateSolLPConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)

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

SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfeastol(SCIP *scip)

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

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

int SCIPconvertRealToInt(SCIP *scip, SCIP_Real real)

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

SCIP_Bool SCIPinRepropagation(SCIP *scip)

int SCIPgetDepth(SCIP *scip)

SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)

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

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)

SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)

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

SCIP_VAR * SCIPvarGetProbvar(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)

int SCIPvarGetIndex(SCIP_VAR *var)

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

SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)

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

const char * SCIPvarGetName(SCIP_VAR *var)

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

SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

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

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 SCIPgetVarLbAtIndex(SCIP *scip, 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 SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)

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

SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)

SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)

void SCIPsortRealPtr(SCIP_Real *realarray, void **ptrarray, int len)

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

SCIP_RETCODE SCIPskipSpace(char **s)

SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)

SCIP_RETCODE SCIPextendPermsymDetectionGraphLinear(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool *success)

memory allocation routines

#define BMScopyMemoryArray(ptr, source, num)

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

public methods for managing constraints

public methods for managing events

public methods for LP management

public methods for message output

public data structures and miscellaneous methods

methods for sorting joint arrays of various types

public methods for problem variables

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 event handler plugins and event handlers

public methods for the LP relaxation, rows and columns

public methods for memory management

public methods for message handling

public methods for nonlinear relaxation

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 the branch-and-bound tree

public methods for SCIP variables

structs for symmetry computations

methods for dealing with symmetry detection graphs

@ SCIP_CONFTYPE_PROPAGATION

struct SCIP_ConshdlrData SCIP_CONSHDLRDATA

struct SCIP_ConsData SCIP_CONSDATA

#define SCIP_EVENTTYPE_BOUNDCHANGED

struct SCIP_EventData SCIP_EVENTDATA

#define SCIP_EVENTTYPE_UBTIGHTENED

#define SCIP_EVENTTYPE_LBRELAXED

#define SCIP_EVENTTYPE_LBTIGHTENED

#define SCIP_EVENTTYPE_UBRELAXED

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STAGE_TRANSFORMING

enum SYM_Symtype SYM_SYMTYPE

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_VARSTATUS_MULTAGGR

@ SCIP_VARSTATUS_AGGREGATED

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