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

SCIP Doxygen Documentation: cons_and.c Source File

85#define CONSHDLR_NAME "and" 86#define CONSHDLR_DESC "constraint handler for AND-constraints: r = and(x1, ..., xn)" 87#define CONSHDLR_SEPAPRIORITY +850100 88#define CONSHDLR_ENFOPRIORITY -850100 89#define CONSHDLR_CHECKPRIORITY -850100 90#define CONSHDLR_SEPAFREQ 1 91#define CONSHDLR_PROPFREQ 1 92#define CONSHDLR_EAGERFREQ 100 94#define CONSHDLR_MAXPREROUNDS -1 95#define CONSHDLR_DELAYSEPA FALSE 96#define CONSHDLR_DELAYPROP FALSE 97#define CONSHDLR_NEEDSCONS TRUE 99#define CONSHDLR_PRESOLTIMING (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_EXHAUSTIVE) 100#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP 102#define EVENTHDLR_NAME "and" 103#define EVENTHDLR_DESC "bound change event handler for AND-constraints" 105#define DEFAULT_PRESOLPAIRWISE TRUE 106#define DEFAULT_LINEARIZE FALSE 107#define DEFAULT_ENFORCECUTS TRUE 108#define DEFAULT_AGGRLINEARIZATION FALSE 109#define DEFAULT_UPGRRESULTANT TRUE 110#define DEFAULT_DUALPRESOLVING TRUE 112#define HASHSIZE_ANDCONS 500 113#define DEFAULT_PRESOLUSEHASHING TRUE 114#define NMINCOMPARISONS 200000 115#define MINGAINPERNMINCOMPARISONS 1e-06 138 unsigned int

propagated:1;

139 unsigned int

nofixedzero:1;

140 unsigned int

impladded:1;

141 unsigned int

opimpladded:1;

142 unsigned int

sorted:1;

143 unsigned int

changed:1;

144 unsigned int

merged:1;

145 unsigned int

checkwhenupgr:1;

148 unsigned int

notremovablewhenupgr:1;

154struct

SCIP_ConshdlrData

223

assert(conshdlrdata !=

NULL

);

224

assert(eventhdlr !=

NULL

);

229

(*conshdlrdata)->eventhdlr = eventhdlr;

241

assert(conshdlrdata !=

NULL

);

242

assert(*conshdlrdata !=

NULL

);

257

assert(consdata !=

NULL

);

258

assert(consdata->vars !=

NULL

);

259

assert(eventhdlr !=

NULL

);

260

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

261

assert(filterpos !=

NULL

);

281

assert(consdata !=

NULL

);

282

assert(consdata->vars !=

NULL

);

283

assert(eventhdlr !=

NULL

);

284

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

285

assert(filterpos >= 0);

304

assert(consdata !=

NULL

);

311 for

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

330

assert(consdata !=

NULL

);

337 for

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

356

assert(consdata !=

NULL

);

357

assert(watchedvar1 == -1 || watchedvar1 != watchedvar2);

358

assert(watchedvar1 != -1 || watchedvar2 == -1);

359

assert(watchedvar1 == -1 || (0 <= watchedvar1 && watchedvar1 < consdata->nvars));

360

assert(watchedvar2 == -1 || (0 <= watchedvar2 && watchedvar2 < consdata->nvars));

363 if

( watchedvar1 == consdata->watchedvar2 || watchedvar2 == consdata->watchedvar1 )

367

tmp = consdata->watchedvar1;

368

consdata->watchedvar1 = consdata->watchedvar2;

369

consdata->watchedvar2 = tmp;

370

tmp = consdata->filterpos1;

371

consdata->filterpos1 = consdata->filterpos2;

372

consdata->filterpos2 = tmp;

374

assert(watchedvar1 == -1 || watchedvar1 != consdata->watchedvar2);

375

assert(watchedvar2 == -1 || watchedvar2 != consdata->watchedvar1);

378 if

( consdata->watchedvar1 != -1 && consdata->watchedvar1 != watchedvar1 )

380

assert(consdata->filterpos1 != -1);

383 if

( consdata->watchedvar2 != -1 && consdata->watchedvar2 != watchedvar2 )

385

assert(consdata->filterpos2 != -1);

390 if

( watchedvar1 != -1 && watchedvar1 != consdata->watchedvar1 )

394 if

( watchedvar2 != -1 && watchedvar2 != consdata->watchedvar2 )

400

consdata->watchedvar1 = watchedvar1;

401

consdata->watchedvar2 = watchedvar2;

414

assert(consdata !=

NULL

);

415

assert(consdata->nvars <= consdata->varssize);

417 if

( num > consdata->varssize )

423

consdata->varssize = newsize;

425

assert(num <= consdata->varssize);

449

assert(consdata !=

NULL

);

450

assert(nvars == 0 || vars !=

NULL

);

451

assert(resvar !=

NULL

);

455

(*consdata)->resvar = resvar;

456

(*consdata)->rows =

NULL

;

457

(*consdata)->aggrrow =

NULL

;

458

(*consdata)->nlrow =

NULL

;

459

(*consdata)->nvars = nvars;

460

(*consdata)->varssize = nvars;

461

(*consdata)->nrows = 0;

462

(*consdata)->watchedvar1 = -1;

463

(*consdata)->watchedvar2 = -1;

464

(*consdata)->filterpos1 = -1;

465

(*consdata)->filterpos2 = -1;

466

(*consdata)->propagated =

FALSE

;

467

(*consdata)->nofixedzero =

FALSE

;

468

(*consdata)->impladded =

FALSE

;

469

(*consdata)->opimpladded =

FALSE

;

470

(*consdata)->sorted =

FALSE

;

471

(*consdata)->changed =

TRUE

;

472

(*consdata)->merged =

FALSE

;

473

(*consdata)->checkwhenupgr = checkwhenupgr;

474

(*consdata)->notremovablewhenupgr = notremovablewhenupgr;

493 for

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

495

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

NULL

);

503 for

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

505

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

NULL

);

522

assert(consdata !=

NULL

);

524 if

( consdata->rows !=

NULL

)

526 for

(

r

= 0;

r

< consdata->nrows; ++

r

)

535 if

( consdata->aggrrow !=

NULL

)

538

consdata->aggrrow =

NULL

;

554

assert(consdata !=

NULL

);

555

assert(*consdata !=

NULL

);

567

assert((*consdata)->watchedvar1 == -1);

568

assert((*consdata)->watchedvar2 == -1);

575 if

( (*consdata)->nlrow !=

NULL

)

581 for

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

583

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

NULL

);

602

assert(consdata !=

NULL

);

631

assert(var !=

NULL

);

634

assert(consdata !=

NULL

);

635

assert(consdata->rows ==

NULL

);

645

assert(var !=

NULL

);

649

consdata->vars[consdata->nvars] = var;

651

consdata->sorted = (consdata->nvars == 1);

652

consdata->changed =

TRUE

;

653

consdata->merged =

FALSE

;

670 if

( consdata->rows !=

NULL

)

672 SCIPerrorMessage

(

"cannot add coefficients to AND-constraint after LP relaxation was created\n"

);

690

assert(eventhdlr !=

NULL

);

693

assert(consdata !=

NULL

);

694

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

710 if

( consdata->watchedvar1 == pos )

714 if

( consdata->watchedvar2 == pos )

719

assert(pos != consdata->watchedvar1);

720

assert(pos != consdata->watchedvar2);

726

consdata->vars[pos] = consdata->vars[consdata->nvars-1];

730 if

( consdata->watchedvar1 == consdata->nvars )

731

consdata->watchedvar1 = pos;

732 if

( consdata->watchedvar2 == consdata->nvars )

733

consdata->watchedvar2 = pos;

735

consdata->propagated =

FALSE

;

736

consdata->sorted =

FALSE

;

737

consdata->changed =

TRUE

;

748

assert(consdata !=

NULL

);

750 if

( !consdata->sorted )

752 if

( consdata->nvars <= 1 )

753

consdata->sorted =

TRUE

;

760 if

( consdata->watchedvar1 != -1 )

762

var1 = consdata->vars[consdata->watchedvar1];

763

assert(var1 !=

NULL

);

764

consdata->watchedvar1 = -1;

765 if

( consdata->watchedvar2 != -1 )

767

var2 = consdata->vars[consdata->watchedvar2];

768

assert(var2 !=

NULL

);

769

consdata->watchedvar2 = -1;

772

assert(consdata->watchedvar1 == -1);

773

assert(consdata->watchedvar2 == -1);

774

assert(var1 !=

NULL

|| var2 ==

NULL

);

777 SCIPsortPtr

((

void

**)consdata->vars, SCIPvarComp, consdata->nvars);

778

consdata->sorted =

TRUE

;

787

found =

SCIPsortedvecFindPtr

((

void

**)consdata->vars, SCIPvarComp, (

void

*)var1, consdata->nvars, &pos);

790

(void)

SCIPsortedvecFindPtr

((

void

**)consdata->vars, SCIPvarComp, (

void

*)var1, consdata->nvars, &pos);

792

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

793

consdata->watchedvar1 = pos;

798

found =

SCIPsortedvecFindPtr

((

void

**)consdata->vars, SCIPvarComp, (

void

*)var2, consdata->nvars, &pos);

801

(void)

SCIPsortedvecFindPtr

((

void

**)consdata->vars, SCIPvarComp, (

void

*)var2, consdata->nvars, &pos);

803

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

804

consdata->watchedvar2 = pos;

815 for

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

817

assert(v == consdata->nvars-1 ||

SCIPvarCompare

(consdata->vars[v], consdata->vars[v+1]) <= 0);

837

assert(cons !=

NULL

);

838

assert(eventhdlr !=

NULL

);

839

assert(nchgcoefs !=

NULL

);

842

assert(consdata !=

NULL

);

843

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

NULL

);

846 while

( v < consdata->nvars )

848

var = consdata->vars[v];

879#ifdef SCIP_DISABLED_CODE 891 if

( repvar != consdata->resvar )

910

consdata->resvar = repvar;

911

consdata->changed =

TRUE

;

936

assert(consdata !=

NULL

);

937

assert(consdata->rows ==

NULL

);

939

nvars = consdata->nvars;

942

consdata->nrows = nvars + 1;

958 for

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

990

assert(consdata !=

NULL

);

993 if

( consdata->aggrrow ==

NULL

)

1010 if

( !(*infeasible) )

1012 if

( consdata->rows ==

NULL

)

1018

assert(consdata->rows !=

NULL

);

1046

assert(consdata !=

NULL

);

1047

assert(consdata->resvar !=

NULL

);

1049 if

( consdata->nlrow ==

NULL

)

1057 for

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

1065

assert(consdata->nlrow !=

NULL

);

1068 for

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

1098

assert(violated !=

NULL

);

1101

assert(consdata !=

NULL

);

1106

mustcheck = checklprows;

1107

mustcheck = mustcheck || (consdata->rows ==

NULL

);

1110

assert(consdata->rows !=

NULL

);

1112 for

(

r

= 0;

r

< consdata->nrows; ++

r

)

1139 for

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

1143 if

( minsolval > solval )

1149

sumsolval += solval;

1156

viol =

MAX3

(0.0, solval - minsolval, sumsolval - (consdata->nvars - 1.0 + solval));

1209

assert(separated !=

NULL

);

1210

assert(cutoff !=

NULL

);

1212

*separated =

FALSE

;

1216

assert(consdata !=

NULL

);

1219 if

( consdata->rows ==

NULL

)

1223

assert(consdata->rows !=

NULL

);

1226 for

(

r

= 0;

r

< consdata->nrows; ++

r

)

1259

assert(consdata !=

NULL

);

1261

assert(0 <= falsepos && falsepos < consdata->nvars);

1293

assert(consdata !=

NULL

);

1300 for

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

1326 SCIPdebugMsg

(

scip

,

"constraint <%s>: operator %d fixed to 0.0 -> fix resultant <%s> to 0.0\n"

,

1366 for

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

1368 SCIPdebugMsg

(

scip

,

"constraint <%s>: resultant fixed to 1.0 -> fix operator var <%s> to 1.0\n"

,

1380 else if

( tightened )

1422

assert(consdata !=

NULL

);

1427

nvars = consdata->nvars;

1428

conscreated =

FALSE

;

1452 else if

( tightened )

1461 else if

( tightened )

1473

conscreated =

TRUE

;

1481 for

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

1493

conscreated =

TRUE

;

1530

assert(consdata !=

NULL

);

1533 if

( watchedvar2 == -1 )

1538

assert(watchedvar1 != -1);

1545 for

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

1546 if

( v != watchedvar1 )

1551 SCIPdebugMsg

(

scip

,

"constraint <%s>: resultant <%s> fixed to 0.0, only one unfixed operand -> fix operand <%s> to 0.0\n"

,

1583 unsigned char

** entries,

1604

assert(cons !=

NULL

);

1605

assert(eventhdlr !=

NULL

);

1606

assert(*entries !=

NULL

);

1607

assert(nentries !=

NULL

);

1608

assert(nfixedvars !=

NULL

);

1609

assert(nchgcoefs !=

NULL

);

1610

assert(ndelconss !=

NULL

);

1613

assert(consdata !=

NULL

);

1615 if

( consdata->merged )

1619 if

( consdata->nvars <= 1 )

1621

consdata->merged =

TRUE

;

1625

vars = consdata->vars;

1626

nvars = consdata->nvars;

1628

assert(vars !=

NULL

);

1635

assert(*nentries >= nbinvars + nintvars + nimplvars);

1639 for

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

1642

assert(var !=

NULL

);

1646

assert(probvar !=

NULL

);

1649

assert(0 <= probidx);

1655

(probidx >= nbinvars + nintvars && probidx < nbinvars + nintvars + nimplvars &&

1659

(*entries)[probidx] = 0;

1666 for

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

1669

assert(var !=

NULL

);

1673

assert(probvar !=

NULL

);

1676

assert(0 <= probidx && probidx < *nentries);

1679 if

( (*entries)[probidx] == 0 )

1697 SCIPdebugMsg

(

scip

,

"AND-constraint <%s> is redundant: variable <%s> and its negation are present -> fix resultant <%s> = 0\n"

,

1711

assert(!infeasible);

1720

consdata->merged =

TRUE

;

1755

assert(cutoff !=

NULL

);

1756

assert(nfixedvars !=

NULL

);

1759

assert(consdata !=

NULL

);

1761

resvar = consdata->resvar;

1762

vars = consdata->vars;

1763

nvars = consdata->nvars;

1768 if

( consdata->propagated )

1770

assert(consdata->nofixedzero);

1782 if

( !consdata->nofixedzero )

1792

consdata->nofixedzero =

TRUE

;

1833

watchedvar1 = consdata->watchedvar1;

1834

watchedvar2 = consdata->watchedvar2;

1837 if

( watchedvar1 != -1 )

1843 if

( watchedvar2 != -1 )

1851 if

( watchedvar1 == -1 )

1853

watchedvar1 = watchedvar2;

1856

assert(watchedvar1 != -1 || watchedvar2 == -1);

1859 if

( watchedvar2 == -1 )

1861 for

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

1866 if

( watchedvar1 == -1 )

1868

assert(watchedvar2 == -1);

1871 else if

( watchedvar1 != i )

1879

assert(watchedvar1 != -1 || watchedvar2 == -1);

1882 if

( watchedvar1 == -1 )

1884

assert(watchedvar2 == -1);

1886 SCIPdebugMsg

(

scip

,

"constraint <%s>: all operator vars fixed to 1.0 -> fix resultant <%s> to 1.0\n"

,

1915

assert(watchedvar1 != -1);

1955

assert(result !=

NULL

);

1958

assert(consdata !=

NULL

);

1959

vars = consdata->vars;

1960

nvars = consdata->nvars;

1967

assert(infervar == consdata->resvar);

1968 for

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

1991

assert(infervar == consdata->resvar);

1992 for

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

2005 for

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

2007 if

( vars[i] != infervar )

2032 unsigned char

** entries,

2058

assert(conss !=

NULL

|| nconss == 0);

2059

assert(eventhdlr !=

NULL

);

2060

assert(*entries !=

NULL

);

2061

assert(nentries !=

NULL

);

2062

assert(cutoff !=

NULL

);

2063

assert(nfixedvars !=

NULL

);

2064

assert(naggrvars !=

NULL

);

2065

assert(nchgcoefs !=

NULL

);

2066

assert(ndelconss !=

NULL

);

2067

assert(nupgdconss !=

NULL

);

2068

assert(naddconss !=

NULL

);

2073

assert(conss !=

NULL

);

2079 for

( c = nconss - 1; c >= 0 && !(*cutoff); --c )

2082

assert(cons !=

NULL

);

2105

assert(consdata !=

NULL

);

2107

vars = consdata->vars;

2108

nvars = consdata->nvars;

2109

assert(vars !=

NULL

|| nvars == 0);

2114

assert(vars !=

NULL

);

2116

resvar = consdata->resvar;

2117

assert(resvar !=

NULL

);

2131 int

oldnfixedvars = *nfixedvars;

2132 int

oldnaggrvars = *naggrvars;

2137 for

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

2140

assert(var !=

NULL

);

2147

impoperands[nimpoperands] = var;

2160

maxpos = nimpoperands - 1;

2165

assert(nimpoperands >= 0 && nimpoperands <= nvars);

2168 if

( nimpoperands == 0 )

2182 if

( nimpoperands == nvars && poscontissmall )

2188

*cutoff = *cutoff || infeasible;

2192 for

( v = nvars - 1; v >= 0 && !(*cutoff); --v )

2196

*cutoff = *cutoff || infeasible;

2211

assert(nimpoperands > 0);

2213 SCIPdebugMsg

(

scip

,

"dual-fixing all variables in constraint <%s> with positive contribution (when together exceeding the negative contribution of the resultant) to 0 and with negative contribution to 1\n"

,

SCIPconsGetName

(cons));

2215 for

( v = nimpoperands - 1; v >= 0 && !(*cutoff); --v )

2224

*cutoff = *cutoff || infeasible;

2228 else if

( !poscontissmall )

2231

assert(!infeasible);

2244

&infeasible, &redundant, &aggregated) );

2245

assert(!infeasible);

2252

aggregationperformed =

TRUE

;

2258

assert(*nfixedvars - oldnfixedvars + *naggrvars - oldnaggrvars <= nimpoperands);

2263 if

( aggregationperformed || zerofix )

2278 if

( fixval < 0.5 || *nfixedvars - oldnfixedvars + *naggrvars - oldnaggrvars == nvars )

2283

assert(!infeasible);

2303

assert(nimpoperands > 0);

2304

assert(maxpos >= 0 && maxpos <= consdata->nvars);

2313 if

( nimpoperands == nvars &&

SCIPisLE

(

scip

, maxobj, 0.0) )

2317 SCIPdebugMsg

(

scip

,

"dual-fixing variable <%s> in constraint <%s> to %g, because the contribution is%s "

\

2318 "enough to nullify/exceed the contribution of the resultant \n"

,

2322

zerofix = (fixval < 0.5);

2324

*cutoff = *cutoff || infeasible;

2329 SCIPdebugMsg

(

scip

,

"dual-fixing all variables, except the variable with the highest contribution to "

\

2330 "the objective, in constraint <%s> with positive contribution to 0 and with negative contribution to 1\n"

,

2333 for

( v = nimpoperands - 1; v >= 0 && !(*cutoff); --v )

2351

*cutoff = *cutoff || infeasible;

2355

assert(*nfixedvars - oldnfixedvars <= nimpoperands);

2357

assert((*nfixedvars - oldnfixedvars == nvars) == (nimpoperands == nvars));

2359 if

( *nfixedvars - oldnfixedvars == nvars )

2365

*cutoff = *cutoff || infeasible;

2388 int

oldnchgcoefs = *nchgcoefs;

2389 int

oldnfixedvars = *nfixedvars;

2402 for

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

2405

assert(var !=

NULL

);

2435 "dual aggregating operand <%s> with 1 up- and downlock to the resultant <%s> in constraint <%s>\n"

,

2439

*cutoff = *cutoff || infeasible;

2442

goodvarsfound =

TRUE

;

2445

assert(*nchgcoefs - oldnchgcoefs <= nvars);

2457 if

( !*cutoff && goodvarsfound && linearize )

2460 for

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

2463

assert(var !=

NULL

);

2474 "dual-fixing variable <%s> in constraint <%s> to 1, because the contribution is negative\n"

,

2479

assert(!infeasible);

2484

assert(*nfixedvars - oldnfixedvars <= consdata->nvars);

2486

assert(*nchgcoefs - oldnchgcoefs + *nfixedvars - oldnfixedvars <= nvars);

2496 for

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

2499

assert(var !=

NULL

);

2528

*cutoff = *cutoff || infeasible;

2535

assert(*nchgcoefs - oldnchgcoefs <= nvars);

2550

*cutoff = *cutoff || infeasible;

2564

*cutoff = *cutoff || infeasible;

2588

consvars[0] = consdata->resvar;

2593 for

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

2596

consvars[1] = consdata->vars[v];

2608

(*naddconss) += consdata->nvars;

2616 else if

( consdata->nvars == 1 )

2622

&infeasible, &redundant, &aggregated) );

2627

*cutoff = *cutoff || infeasible;

2708

assert(cons !=

NULL

);

2709

assert(eventhdlr !=

NULL

);

2710

assert(cutoff !=

NULL

);

2711

assert(nfixedvars !=

NULL

);

2712

assert(naggrvars !=

NULL

);

2713

assert(nchgcoefs !=

NULL

);

2714

assert(ndelconss !=

NULL

);

2715

assert(naddconss !=

NULL

);

2718

assert(consdata !=

NULL

);

2723

vars = consdata->vars;

2724

nvars = consdata->nvars;

2725

assert(vars !=

NULL

|| nvars == 0);

2732 for

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

2734

assert(vars !=

NULL

);

2738 SCIPdebugMsg

(

scip

,

"In constraint <%s> the operand <%s> is fixed to 1 so remove it from the constraint\n"

,

2745

assert(consdata->vars == vars);

2751 SCIPdebugMsg

(

scip

,

"constraint <%s> redundant: because operand <%s> is fixed to zero so we can fix the resultant <%s> to 0\n"

,

2755

*cutoff = *cutoff || infeasible;

2767 if

( consdata->nvars < nvars )

2769

assert(vars == consdata->vars);

2774 if

( consdata->nvars == 0 )

2776 SCIPdebugMsg

(

scip

,

"All operand in constraint <%s> were deleted, so the resultant needs to be fixed to 1\n"

,

2780

*cutoff = *cutoff || infeasible;

2790 else if

( consdata->nvars == 1 )

2797

&infeasible, &redundant, &aggregated) );

2805

*cutoff = *cutoff || infeasible;

2810

nvars = consdata->nvars;

2818 for

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

2820

assert(vars !=

NULL

);

2823

assert(var1 !=

NULL

);

2827

assert(var1 !=

NULL

);

2836 for

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

2839

assert(var2 !=

NULL

);

2843

assert(var2 !=

NULL

);

2865 SCIPdebugMsg

(

scip

,

"constraint <%s> redundant: because variable <%s> and variable <%s> are in a clique, the resultant <%s> can be fixed to 0\n"

,

2869

*cutoff = *cutoff || infeasible;

2909

var1 = consdata->resvar;

2910

assert(var1 !=

NULL

);

2914

assert(var1 !=

NULL

);

2922 SCIPdebugMsg

(

scip

,

"In constraint <%s> the resultant <%s> is fixed to 1 so fix all operands to 1\n"

,

2926 for

( v = nvars - 1; v >= 0 && !(*cutoff); --v )

2928

assert(vars !=

NULL

);

2933

*cutoff = *cutoff || infeasible;

2956 for

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

2958

assert(vars !=

NULL

);

2961

assert(var2 !=

NULL

);

2965

assert(var2 !=

NULL

);

2978 if

( value1 != value2 )

2980 SCIPdebugMsg

(

scip

,

"In constraint <%s> the resultant <%s> can be fixed to 0 because the negation of it is an operand.\n"

,

2984

*cutoff = *cutoff || infeasible;

2998

assert(value1 == value2);

3000

consvars[0] = consdata->resvar;

3002 for

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

3020 if

( value1 == negated )

3022 SCIPdebugMsg

(

scip

,

"In constraint <%s> the resultant <%s> can be fixed to 0 because the negation of it is an operand.\n"

,

3026

*cutoff = *cutoff || infeasible;

3037

assert(consvars[1] !=

NULL

);

3065 if

( var1 == var2 && value1 == value2 )

3073 SCIPdebugMsg

(

scip

,

"in constraint <%s> the resultant <%s> can be fixed to 0 because it is in a clique with operand <%s>\n"

,

3077

*cutoff = *cutoff || infeasible;

3090 for

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

3092

assert(vars !=

NULL

);

3095

assert(var1 !=

NULL

);

3099

assert(var1 !=

NULL

);

3109

allnegoperandsexist =

FALSE

;

3114

allnegoperandsexist =

TRUE

;

3119 else if

( v2 >= 0 && v == -1 )

3133 for

( v = vstart; v >= vend; --v )

3135

assert(vars !=

NULL

);

3138

assert(var1 !=

NULL

);

3142

assert(var1 !=

NULL

);

3149 for

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

3155

assert(var2 !=

NULL

);

3159

assert(var2 !=

NULL

);

3174 if

( var1 == var2 && value1 == value2 )

3176 SCIPdebugMsg

(

scip

,

"in constraint <%s> the resultant <%s> can be fixed to 0 because two operands are negated of each other\n"

,

3180

*cutoff = *cutoff || infeasible;

3190 if

( var1 == var2 && value1 != value2 )

3202 SCIPdebugMsg

(

scip

,

"In constraint <%s> the operand <%s> is in a negated clique with all other operands, so we can aggregated this operand to the resultant <%s>.\n"

,

3206

&infeasible, &redundant, &aggregated) );

3207

*cutoff = *cutoff || infeasible;

3230

var1 = consdata->resvar;

3232

assert(var1 !=

NULL

);

3235

newvars[nvars] = var1;

3238 for

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

3240

assert(vars !=

NULL

);

3244

assert(var1 !=

NULL

);

3250

assert(newvars[v] != newvars[nvars]);

3257 for

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

3259 for

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

3277 if

( negations[nvars] )

3285

assert(newvars[nvars] !=

NULL

);

3287 for

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

3289 if

( !negations[v] )

3297

assert(newvars[v] !=

NULL

);

3307 SCIPdebugMsg

(

scip

,

" -> upgrading AND-constraint <%s> with use of clique information to a set-partitioning constraint: \n"

,

SCIPconsGetName

(cons));

3352 if

( consdata1->nvars != consdata2->nvars )

3358

assert(consdata1->sorted);

3359

assert(consdata2->sorted);

3363 for

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

3366 if

( consdata1->vars[i] != consdata2->vars[i] )

3368

assert(

SCIPvarCompare

(consdata1->vars[i], consdata2->vars[i]) == 1 ||

3370

coefsequal =

FALSE

;

3373

assert(

SCIPvarCompare

(consdata1->vars[i], consdata2->vars[i]) == 0);

3389

assert(consdata !=

NULL

);

3390

assert(consdata->sorted);

3391

assert(consdata->nvars > 0);

3396

assert(minidx >= 0 && minidx <= maxidx);

3398 return SCIPhashFour

(consdata->nvars, minidx, mididx, maxidx);

3420

assert(conss !=

NULL

);

3421

assert(ndelconss !=

NULL

);

3424

hashtablesize = nconss;

3427

hashGetKeyAndcons, hashKeyEqAndcons, hashKeyValAndcons, (

void

*)

scip

) );

3432 for

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

3447

assert(consdata0->sorted);

3452 if

( cons1 !=

NULL

)

3462

assert(consdata1 !=

NULL

);

3463

assert(consdata0->nvars >= 1 && consdata0->nvars == consdata1->nvars);

3465

assert(consdata0->sorted && consdata1->sorted);

3466

assert(consdata0->vars[0] == consdata1->vars[0]);

3470 if

( consdata0->resvar != consdata1->resvar )

3474

assert(

SCIPvarCompare

(consdata0->resvar, consdata1->resvar) != 0);

3478

cutoff, &redundant, &aggregated) );

3497

consdata1->checkwhenupgr = consdata1->checkwhenupgr || consdata0->checkwhenupgr;

3498

consdata1->notremovablewhenupgr = consdata1->notremovablewhenupgr || consdata0->notremovablewhenupgr;

3505 if

( consdata0->changed &&

SCIPconsGetPos

(cons1) < *firstchange )

3541

assert(conshdlrdata !=

NULL

);

3546 for

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

3552 if

( !conshdlrdata->enforcecuts )

3564 else if

( separated )

3598

assert(conss !=

NULL

);

3599

assert(firstchange <= chkind);

3600

assert(cutoff !=

NULL

);

3601

assert(naggrvars !=

NULL

);

3602

assert(nbdchgs !=

NULL

);

3603

assert(ndelconss !=

NULL

);

3606

cons0 = conss[chkind];

3615

assert(consdata0->nvars >= 1);

3616

assert(consdata0->sorted);

3619

cons0changed = consdata0->changed;

3623 for

( c = (cons0changed ? 0 : firstchange); c < chkind && !(*cutoff); ++c )

3642

assert(consdata1 !=

NULL

);

3644#ifdef SCIP_DISABLED_CODE 3645 SCIPdebugMsg

(

scip

,

"preprocess AND-constraint pair <%s>[chg:%d] and <%s>[chg:%d]\n"

,

3650 if

( !cons0changed && !consdata1->changed )

3653

assert(consdata1->nvars >= 1);

3657

assert(consdata1->sorted);

3665

cons0superset =

TRUE

;

3666

cons1superset =

TRUE

;

3667 while

( (v0 < consdata0->nvars || v1 < consdata1->nvars) && (cons0superset || cons1superset) )

3672 if

( v0 < consdata0->nvars && v1 < consdata1->nvars )

3673

varcmp =

SCIPvarCompare

(consdata0->vars[v0], consdata1->vars[v1]);

3674 else if

( v0 < consdata0->nvars )

3683

cons1superset =

FALSE

;

3689

cons0superset =

FALSE

;

3707 if

( cons0superset && cons1superset )

3714 SCIPdebugMsg

(

scip

,

"equivalent AND-constraints <%s> and <%s>: aggregate resultants <%s> == <%s>\n"

,

3720

&infeasible, &redundant, &aggregated) );

3735

consdata0->checkwhenupgr = consdata1->checkwhenupgr || consdata0->checkwhenupgr;

3736

consdata0->notremovablewhenupgr = consdata1->notremovablewhenupgr || consdata0->notremovablewhenupgr;

3743

*cutoff = *cutoff || infeasible;

3745 else if

( cons0superset )

3751 SCIPdebugMsg

(

scip

,

"AND-constraint <%s> is superset of <%s>: add implication <%s> = 1 -> <%s> = 1\n"

,

3757

&infeasible, &nboundchgs) );

3758

*cutoff = *cutoff || infeasible;

3759

(*nbdchgs) += nboundchgs;

3761 else if

( cons1superset )

3767 SCIPdebugMsg

(

scip

,

"AND-constraint <%s> is superset of <%s>: add implication <%s> = 1 -> <%s> = 1\n"

,

3773

&infeasible, &nboundchgs) );

3774

*cutoff = *cutoff || infeasible;

3775

(*nbdchgs) += nboundchgs;

3779

consdata0->changed =

FALSE

;

3805

assert(cons !=

NULL

);

3806

assert(graph !=

NULL

);

3807

assert(success !=

NULL

);

3810

assert(consdata !=

NULL

);

3821

assert(consdata->resvar !=

NULL

);

3822

vars[0] = consdata->resvar;

3833

andvars = consdata->vars;

3834 for

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

3836

assert(andvars[i] !=

NULL

);

3837

vars[0] = andvars[i];

3862

assert(conshdlr !=

NULL

);

3881

assert(conshdlrdata !=

NULL

);

3898

assert( conshdlr !=

NULL

);

3899

assert( nconss == 0 || conss !=

NULL

);

3902

assert(conshdlrdata !=

NULL

);

3904 if

( conshdlrdata->linearize )

3922 for

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

3925

assert( cons !=

NULL

);

3932

assert( consdata !=

NULL

);

3933

assert( consdata->resvar !=

NULL

);

3935

nvars = consdata->nvars;

3937 if

( !conshdlrdata->aggrlinearization )

3939

vars[0] = consdata->resvar;

3944 for

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

3947

vars[1] = consdata->vars[v];

3965 for

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

3967

vars[v] = consdata->vars[v];

3971

vars[nvars] = consdata->resvar;

3973 if

( conshdlrdata->aggrlinearization )

4019#ifdef GMLGATEPRINTING 4061

gmlfile = fopen(fname,

"w"

);

4063 if

( gmlfile ==

NULL

)

4077 for

( c = nconss - 1; c >= 0; --c )

4086

assert(consdata !=

NULL

);

4089 if

( consdata->nvars == 0 )

4092

assert(consdata->vars !=

NULL

);

4093

assert(consdata->resvar !=

NULL

);

4118 for

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

4140#ifdef SCIP_DISABLED_CODE 4141 for

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

4182 for

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

4199 for

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

4202

assert(consdata !=

NULL

);

4206 if

( consdata->nlrow !=

NULL

)

4223

assert(conshdlrdata !=

NULL

);

4240

assert(conshdlrdata !=

NULL

);

4243

assert(sourcedata !=

NULL

);

4247

sourcedata->nvars, sourcedata->vars, sourcedata->resvar, sourcedata->checkwhenupgr,

4248

sourcedata->notremovablewhenupgr) );

4267

*infeasible =

FALSE

;

4269 for

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

4290 for

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

4295 else if

( separated )

4317 for

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

4322 else if

( separated )

4359 for

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

4382 for

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

SCIP_FEASIBLE

|| completely ); ++i )

4403

assert(conshdlrdata !=

NULL

);

4410 for

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

4418 else if

( nfixedvars > 0 || nupgdconss > 0 )

4434 unsigned char

* entries;

4445

assert(result !=

NULL

);

4447

oldnfixedvars = *nfixedvars;

4448

oldnaggrvars = *naggrvars;

4449

oldnchgbds = *nchgbds;

4450

oldndelconss = *ndelconss;

4451

oldnupgdconss = *nupgdconss;

4457

assert(conshdlrdata !=

NULL

);

4461

firstchange = INT_MAX;

4462 for

( c = 0; c < nconss && !cutoff && (c % 1000 != 0 || !

SCIPisStopped

(

scip

)); ++c )

4465

assert(cons !=

NULL

);

4467

assert(consdata !=

NULL

);

4471

consdata->propagated =

FALSE

;

4474 if

( firstchange == INT_MAX && consdata->changed )

4493

assert(consdata->nvars >= 1);

4496 if

( consdata->nvars == 1 )

4503

assert(consdata->vars !=

NULL

);

4509

&cutoff, &redundant, &aggregated) );

4525 else if

( !consdata->impladded )

4530 for

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

4536

(*nchgbds) += nimplbdchgs;

4538

consdata->impladded =

TRUE

;

4542 if

( !cutoff &&

SCIPconsIsActive

(cons) && consdata->nvars == 2 && !consdata->opimpladded

4549

(*nchgbds) += nimplbdchgs;

4550

consdata->opimpladded =

TRUE

;

4558 SCIP_CALL

(

dualPresolve

(

scip

, conss, nconss, conshdlrdata->eventhdlr, &entries, &nentries, &cutoff, nfixedvars, naggrvars, nchgcoefs, ndelconss, nupgdconss, naddconss) );

4567

assert(cons !=

NULL

);

4587 SCIP_CALL

(

cliquePresolve

(

scip

, cons, conshdlrdata->eventhdlr, &cutoff, nfixedvars, naggrvars, nchgcoefs, ndelconss, naddconss) );

4598 if

( *nfixedvars == oldnfixedvars && *naggrvars == oldnaggrvars )

4600 if

( firstchange < nconss )

4604

oldnaggrvars = *naggrvars;

4611 if

( *nfixedvars == oldnfixedvars && *naggrvars == oldnaggrvars )

4614

npaircomparisons = 0;

4615

oldndelconss = *ndelconss;

4630

oldndelconss = *ndelconss;

4631

oldnaggrvars = *naggrvars;

4632

oldnchgbds = *nchgbds;

4634

npaircomparisons = 0;

4646 else if

( *nfixedvars > oldnfixedvars || *naggrvars > oldnaggrvars || *nchgbds > oldnchgbds

4647

|| *ndelconss > oldndelconss || *nupgdconss > oldnupgdconss )

4676

assert(consdata !=

NULL

);

4682 for

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

4708

assert(cons !=

NULL

);

4711

assert(consdata !=

NULL

);

4729

assert( conshdlr !=

NULL

);

4730

assert( cons !=

NULL

);

4745 const char

* consname;

4749

assert(valid !=

NULL

);

4756

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

NULL

);

4772 for

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

4775

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

NULL

);

4789

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

4816 if

( resvar ==

NULL

)

4822 char

* strcopy =

NULL

;

4828

startptr = strchr((

char

*)str,

'('

);

4830 if

( startptr ==

NULL

)

4832 SCIPerrorMessage

(

"missing starting character '(' parsing AND-constraint\n"

);

4840

endptr = strrchr(startptr,

')'

);

4842 if

( endptr ==

NULL

)

4844 SCIPerrorMessage

(

"missing ending character ')' parsing AND-constraint\n"

);

4847

assert(endptr >= startptr);

4849 if

( endptr > startptr )

4853

strcopy[endptr-startptr] =

'\0'

;

4866 if

( varssize < requiredsize )

4869

varssize = requiredsize;

4877

assert(varssize >= requiredsize);

4881

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

4898

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

4914

assert(consdata !=

NULL

);

4916 if

( varssize < consdata->nvars + 1 )

4917

(*success) =

FALSE

;

4921

vars[consdata->nvars] = consdata->resvar;

4934

assert(cons !=

NULL

);

4937

assert(consdata !=

NULL

);

4939

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

4972

assert(eventhdlr !=

NULL

);

4973

assert(eventdata !=

NULL

);

4974

assert(event !=

NULL

);

4977

assert(consdata !=

NULL

);

4981

consdata->nofixedzero =

FALSE

;

4983

consdata->propagated =

FALSE

;

5004

eventExecAnd,

NULL

) );

5012

consEnfolpAnd, consEnfopsAnd, consCheckAnd, consLockAnd,

5015

assert(conshdlr !=

NULL

);

5022#ifdef GMLGATEPRINTING 5048 "should pairwise constraint comparison be performed in presolving?"

,

5051 "constraints/and/presolusehashing"

,

5052 "should hash table be used for detecting redundant constraints in advance"

,

5056 "should the AND-constraint get linearized and removed (in presolving)?"

,

5060 "should cuts be separated during LP enforcing?"

,

5064 "should an aggregated linearization be used?"

,

5068 "should all binary resultant variables be upgraded to implicit binary variables?"

,

5072 "should dual presolving be performed?"

,

5122 if

( conshdlr ==

NULL

)

5136

assert(vars !=

NULL

|| nvars == 0);

5137 for

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

5147

assert(conshdlrdata !=

NULL

);

5168

activeresvar = resvar;

5173 for

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

5178

activevar = vars[v];

5188

assert(!infeasible);

5197 SCIP_CALL

(

SCIPcreateCons

(

scip

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

5198

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

5238

assert(cons !=

NULL

);

5248

assert(consdata !=

NULL

);

5250 return

consdata->nvars;

5262

assert(cons !=

NULL

);

5272

assert(consdata !=

NULL

);

5274 return

consdata->vars;

5286

assert(cons !=

NULL

);

5296

assert(consdata !=

NULL

);

5298 return

consdata->resvar;

5310

assert(cons !=

NULL

);

5320

assert(consdata !=

NULL

);

5322 return

consdata->sorted;

5334

assert(cons !=

NULL

);

5344

assert(consdata !=

NULL

);

5347

assert(consdata->sorted);

5366

assert(cons !=

NULL

);

5376

assert(consdata !=

NULL

);

5378

consdata->checkwhenupgr = flag;

5398

assert(cons !=

NULL

);

5408

assert(consdata !=

NULL

);

5410

consdata->notremovablewhenupgr = flag;

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

static SCIP_DECL_CONSACTIVE(consActiveAnd)

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

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

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

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

#define DEFAULT_DUALPRESOLVING

static SCIP_RETCODE dualPresolve(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_EVENTHDLR *eventhdlr, unsigned char **entries, int *nentries, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *nchgcoefs, int *ndelconss, int *nupgdconss, int *naddconss)

static SCIP_RETCODE consdataSwitchWatchedvars(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int watchedvar1, int watchedvar2)

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_SEPAFREQ

static SCIP_DECL_CONSDELETE(consDeleteAnd)

static SCIP_DECL_HASHKEYEQ(hashKeyEqAndcons)

static SCIP_DECL_EVENTEXEC(eventExecAnd)

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

#define CONSHDLR_CHECKPRIORITY

static SCIP_DECL_CONSFREE(consFreeAnd)

static SCIP_RETCODE consdataFixOperandsOne(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int nvars, SCIP_Bool *cutoff, int *nfixedvars)

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

static SCIP_RETCODE addCoef(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_VAR *var)

static SCIP_DECL_CONSCOPY(consCopyAnd)

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

#define CONSHDLR_PROP_TIMING

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

static SCIP_RETCODE unlockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)

static SCIP_DECL_CONSENFOPS(consEnfopsAnd)

static SCIP_RETCODE analyzeZeroResultant(SCIP *scip, SCIP_CONS *cons, int watchedvar1, int watchedvar2, SCIP_Bool *cutoff, int *nfixedvars)

static SCIP_DECL_CONSINITPRE(consInitpreAnd)

static SCIP_DECL_HASHGETKEY(hashGetKeyAndcons)

static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_EVENTHDLR *eventhdlr, int nvars, SCIP_VAR **vars, SCIP_VAR *resvar, SCIP_Bool checkwhenupgr, SCIP_Bool notremovablewhenupgr)

#define DEFAULT_UPGRRESULTANT

#define CONSHDLR_MAXPREROUNDS

static SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(consGetSignedPermsymGraphAnd)

static SCIP_RETCODE consdataFixResultantZero(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *resvar, int pos, SCIP_Bool *cutoff, int *nfixedvars)

static SCIP_DECL_CONSENFORELAX(consEnforelaxAnd)

#define DEFAULT_PRESOLPAIRWISE

#define CONSHDLR_SEPAPRIORITY

static SCIP_RETCODE analyzeConflictOne(SCIP *scip, SCIP_CONS *cons, int falsepos)

static SCIP_RETCODE detectRedundantConstraints(SCIP *scip, BMS_BLKMEM *blkmem, SCIP_CONS **conss, int nconss, int *firstchange, SCIP_Bool *cutoff, int *naggrvars, int *ndelconss)

static SCIP_DECL_CONSRESPROP(consRespropAnd)

static SCIP_DECL_CONSSEPASOL(consSepasolAnd)

#define DEFAULT_LINEARIZE

static SCIP_RETCODE cliquePresolve(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *nchgcoefs, int *ndelconss, int *naddconss)

static SCIP_RETCODE preprocessConstraintPairs(SCIP *scip, SCIP_CONS **conss, int firstchange, int chkind, SCIP_Bool *cutoff, int *naggrvars, int *nbdchgs, int *ndelconss)

static SCIP_DECL_CONSTRANS(consTransAnd)

static SCIP_RETCODE consdataLinearize(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *nupgdconss)

static SCIP_DECL_CONSLOCK(consLockAnd)

static SCIP_DECL_CONSINITLP(consInitlpAnd)

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

static SCIP_DECL_CONSSEPALP(consSepalpAnd)

static SCIP_RETCODE lockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)

static SCIP_DECL_CONSEXITSOL(consExitsolAnd)

static SCIP_DECL_CONSGETPERMSYMGRAPH(consGetPermsymGraphAnd)

static SCIP_RETCODE consdataEnsureVarsSize(SCIP *scip, SCIP_CONSDATA *consdata, int num)

static SCIP_RETCODE checkCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool *violated)

#define DEFAULT_PRESOLUSEHASHING

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

static SCIP_DECL_CONSPARSE(consParseAnd)

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

#define MINGAINPERNMINCOMPARISONS

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

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopyAnd)

static SCIP_DECL_CONSINITSOL(consInitsolAnd)

#define CONSHDLR_PROPFREQ

static SCIP_DECL_CONSDEACTIVE(consDeactiveAnd)

#define DEFAULT_ENFORCECUTS

#define CONSHDLR_PRESOLTIMING

static SCIP_DECL_CONSGETNVARS(consGetNVarsAnd)

static void consdataSort(SCIP_CONSDATA *consdata)

static SCIP_DECL_CONSPROP(consPropAnd)

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

static SCIP_DECL_CONSPRINT(consPrintAnd)

#define CONSHDLR_EAGERFREQ

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

static SCIP_DECL_HASHKEYVAL(hashKeyValAndcons)

static SCIP_DECL_CONSENFOLP(consEnfolpAnd)

static SCIP_DECL_CONSPRESOL(consPresolAnd)

#define CONSHDLR_ENFOPRIORITY

static SCIP_DECL_CONSCHECK(consCheckAnd)

static SCIP_RETCODE applyFixings(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int *nchgcoefs)

static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, PROPRULE proprule, SCIP_BDCHGIDX *bdchgidx, SCIP_RESULT *result)

#define CONSHDLR_DELAYSEPA

static SCIP_RETCODE mergeMultiples(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, unsigned char **entries, int *nentries, int *nfixedvars, int *nchgcoefs, int *ndelconss)

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

#define DEFAULT_AGGRLINEARIZATION

static SCIP_RETCODE propagateCons(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, int *nfixedvars, int *nupgdconss)

#define CONSHDLR_DELAYPROP

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

static SCIP_DECL_CONSGETVARS(consGetVarsAnd)

Constraint handler for AND constraints, .

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

Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...

constraint handler for pseudoboolean constraints

#define ARTIFICIALVARNAMEPREFIX

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

#define SCIP_CALL_FINALLY(x, y)

product expression handler

variable expression handler

SCIP_RETCODE SCIPcreateConsAnd(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, 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 SCIPchgAndConsCheckFlagWhenUpgr(SCIP *scip, SCIP_CONS *cons, SCIP_Bool flag)

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

int SCIPgetNVarsAnd(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPchgAndConsRemovableFlagWhenUpgr(SCIP *scip, SCIP_CONS *cons, SCIP_Bool flag)

SCIP_RETCODE SCIPcreateConsSetpack(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 SCIPsortAndCons(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPisAndConsSorted(SCIP *scip, SCIP_CONS *cons)

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_VAR ** SCIPgetVarsAnd(SCIP *scip, SCIP_CONS *cons)

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

SCIP_RETCODE SCIPincludeConshdlrAnd(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_RETCODE SCIPcreateExprVar(SCIP *scip, SCIP_EXPR **expr, SCIP_VAR *var, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprProduct(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real coefficient, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

void SCIPgmlWriteNode(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)

void SCIPgmlWriteClosing(FILE *file)

void SCIPgmlWriteOpening(FILE *file, SCIP_Bool directed)

void SCIPgmlWriteArc(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)

SCIP_Bool SCIPisTransformed(SCIP *scip)

SCIP_Bool SCIPisStopped(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

int SCIPgetNIntVars(SCIP *scip)

int SCIPgetNImplVars(SCIP *scip)

int SCIPgetNContVars(SCIP *scip)

SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNBinVars(SCIP *scip)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)

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

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

void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)

#define SCIPhashFour(a, b, c, d)

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

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

SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)

SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)

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

#define SCIPdebugMsgPrint

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 SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)

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

void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)

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 SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))

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)

int SCIPconsGetPos(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_CONSHDLR * SCIPconsGetHdlr(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 SCIPconsIsDeleted(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)

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_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)

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)

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_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)

#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 SCIPduplicateBufferArray(scip, ptr, source, num)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

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

#define SCIPfreeBlockMemory(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 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_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)

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

SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)

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

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

SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)

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

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

SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPinRepropagation(SCIP *scip)

int SCIPgetDepth(SCIP *scip)

SCIP_RETCODE SCIPcutoffNode(SCIP *scip, SCIP_NODE *node)

SCIP_NODE * SCIPgetRootNode(SCIP *scip)

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

void SCIPvarsGetProbvar(SCIP_VAR **vars, int nvars)

SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

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

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_Bool SCIPdoNotAggr(SCIP *scip)

SCIP_RETCODE SCIPvarGetAggregatedObj(SCIP_VAR *var, SCIP_Real *aggrobj)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)

SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)

SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)

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_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)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

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

SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)

SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)

SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)

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)

int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)

SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)

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 SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)

SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)

SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)

int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

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

SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)

SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)

SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)

void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

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

SCIP_RETCODE SCIPaddSymgraphEdge(SCIP *scip, SYM_GRAPH *graph, int first, int second, SCIP_Bool hasval, SCIP_Real val)

SCIP_RETCODE SCIPaddSymgraphOpnode(SCIP *scip, SYM_GRAPH *graph, int op, int *nodeidx)

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

SCIP_RETCODE SCIPaddSymgraphConsnode(SCIP *scip, SYM_GRAPH *graph, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, int *nodeidx)

SCIP_RETCODE SCIPaddSymgraphVarAggregation(SCIP *scip, SYM_GRAPH *graph, int rootidx, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real constant)

memory allocation routines

#define BMScopyMemoryArray(ptr, source, num)

#define BMSclearMemoryArray(ptr, num)

struct BMS_BlkMem BMS_BLKMEM

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

#define SCIPdebugPrintCons(x, y, z)

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 functions to work with algebraic expressions

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

#define SCIP_DECL_CONSEXITPRE(x)

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_EXITPRESOLVE

enum SYM_Symtype SYM_SYMTYPE

#define SCIP_PRESOLTIMING_EXHAUSTIVE

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