RetroSearch Browse

;

161struct

SCIP_Expr_OwnerData

169 int

monotonicitysize;

173 unsigned int

propboundstag;

179 unsigned int

lastenforced;

180 unsigned int

nactivityusesprop;

181 unsigned int

nactivityusessepa;

182 unsigned int

nauxvaruses;

189 unsigned int

violscoretag;

220 unsigned int

ispropagated:1;

221 unsigned int

issimplified:1;

248struct

SCIP_ConshdlrData

260 int

consupgradessize;

273 unsigned int

enforound;

281 unsigned int

curpropboundstag;

294 int

reformbinprodsfac;

304 char

rownotremovable;

307 int

branchauxmindepth;

318 char

branchviolsplit;

321 char

linearizeheursol;

343 int

bilinmaxnauxexprs;

347 char

branchpscostupdatestrategy;

352 int

newsoleventfilterpos;

394

assert(expr !=

);

397

assert(mydata !=

);

399 if

( mydata->auxvar ==

)

411

assert(mydata->auxvar ==

);

432

assert(mydata !=

);

438

assert(mydata->auxvar ==

);

441

mydata->nactivityusesprop = 0;

442

mydata->nactivityusessepa = 0;

443

mydata->nauxvaruses = 0;

447 for

( e = 0; e < mydata->nenfos; ++e )

451

assert(mydata->enfos[e] !=

);

453

nlhdlr = mydata->enfos[e]->nlhdlr;

454

assert(nlhdlr !=

);

456 if

( mydata->enfos[e]->issepainit )

459 SCIP_CALL

( SCIPnlhdlrExitsepa(

, nlhdlr, expr, mydata->enfos[e]->nlhdlrexprdata) );

460

mydata->enfos[e]->issepainit =

;

464 if

( mydata->enfos[e]->nlhdlrexprdata !=

)

466 SCIP_CALL

( SCIPnlhdlrFreeexprdata(

, nlhdlr, expr, &mydata->enfos[e]->nlhdlrexprdata) );

467

assert(mydata->enfos[e]->nlhdlrexprdata ==

);

488

assert(expr !=

);

489

assert(ownerdata !=

);

490

assert(*ownerdata !=

);

493

assert((*ownerdata)->nlockspos == 0);

494

assert((*ownerdata)->nlocksneg == 0);

499

assert((*ownerdata)->nenfos <= 0);

500

assert((*ownerdata)->auxvar ==

);

508

assert((*ownerdata)->nconss == 0);

510

assert((*ownerdata)->filterpos == -1);

516

assert(conshdlrdata !=

);

519

assert(var !=

);

539

assert(ownerdata !=

);

542 if

( ownerdata->nenfos > 0 )

547 for

( i = 0; i < ownerdata->nenfos; ++i )

556 if

( i < ownerdata->nenfos-1 )

564 if

( ownerdata->auxvar !=

)

583

assert(expr !=

);

584

assert(ownerdata !=

);

587

assert(conshdlrdata !=

);

605

assert(expr !=

);

606

assert(ownerdata !=

);

609

(*ownerdata)->nenfos = -1;

617

(*ownerdata)->filterpos = -1;

622

assert(conshdlrdata !=

);

640

(*ownerdata)->filterpos = -2;

643

*ownerfree = exprownerFree;

644

*ownerprint = exprownerPrint;

645

*ownerevalactivity = exprownerEvalactivity;

659

assert(conshdlr !=

);

660

assert(expr !=

);

661

assert(var !=

);

670

assert(*expr !=

);

689

assert(sourcescip !=

);

690

assert(targetscip !=

);

691

assert(sourceexpr !=

);

692

assert(targetexpr !=

);

693

assert(*targetexpr ==

);

694

assert(mapexprdata !=

);

712

assert(sourcescip !=

);

713

assert(targetscip !=

);

714

assert(sourceexpr !=

);

715

assert(targetexpr !=

);

716

assert(*targetexpr ==

);

717

assert(mapexprdata !=

);

724

assert(var !=

);

728

assert(var !=

);

747

assert(consdata !=

);

750 if

( consdata->varexprs !=

)

753

assert(consdata->varexprs ==

);

754

assert(consdata->nvarexprs == 0);

757 if

( consdata->issimplified )

773

assert(varexprssize >= consdata->nvarexprs);

776 if

( varexprssize > consdata->nvarexprs )

782

assert(conshdlrdata !=

);

783

assert(conshdlrdata->var2expr !=

);

788 for

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

808

assert(consdata !=

);

811 if

( consdata->varexprs ==

)

814

assert(consdata->varexprs !=

);

815

assert(consdata->nvarexprs >= 0);

816

assert(!consdata->catchedevents);

819 for

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

821

assert(consdata->varexprs[i] !=

);

823

assert(consdata->varexprs[i] ==

);

828

consdata->varexprs =

;

829

consdata->nvarexprs = 0;

848

assert(var !=

);

851

assert(conshdlrdata !=

);

853 if

( conshdlrdata->globalbounds )

876 switch

( conshdlrdata->varboundrelax )

891

lb =

(bnd, lb - conshdlrdata->varboundrelaxamount);

898

ub =

(bnd, ub + conshdlrdata->varboundrelaxamount);

911

lb -= conshdlrdata->varboundrelaxamount;

914

ub += conshdlrdata->varboundrelaxamount;

932

lb =

(bnd, lb -

(conshdlrdata->varboundrelaxamount *

(1.0,

(lb)), 0.001 *

(ub-lb)));

938

ub =

(bnd, ub +

(conshdlrdata->varboundrelaxamount *

(1.0,

(ub)), 0.001 *

(ub-lb)));

946 SCIPerrorMessage

(

"Unsupported value '%c' for varboundrelax option.\n"

, conshdlrdata->varboundrelax);

972

assert(consdata1 !=

);

973

assert(consdata2 !=

);

975 return

consdata1->consindex - consdata2->consindex;

990

assert(eventdata !=

);

1000

assert(ownerdata !=

);

1002

assert(ownerdata->nconss > 0);

1003

assert(ownerdata->conss !=

);

1006

boundtightened =

;

1015

boundtightened =

;

1025

boundtightened =

;

1032 if

( boundtightened )

1037 for

( c = 0; c < ownerdata->nconss; ++c )

1039

assert(ownerdata->conss[c] !=

);

1047

consdata->ispropagated =

;

1053

consdata->issimplified =

;

1066

assert(conshdlrdata !=

);

1069

++conshdlrdata->curboundstag;

1070

assert(conshdlrdata->curboundstag > 0);

1074

conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;

1079 SCIP_CALL

( SCIPcallExprInteval(

, expr, &activity, conshdlrdata->intevalvar, conshdlrdata) );

1105

assert(eventhdlr !=

);

1106

assert(expr !=

);

1108

assert(cons !=

);

1111

assert(ownerdata !=

);

1117 for

( i = 0; i < ownerdata->nconss; ++i )

1118

assert(ownerdata->conss[i] != cons);

1124

ownerdata->conss[ownerdata->nconss++] = cons;

1128 if

( ownerdata->nconss <= 1 )

1129

ownerdata->consssorted =

;

1130 else if

( ownerdata->consssorted )

1131

ownerdata->consssorted = compIndexConsNonlinear(ownerdata->conss[ownerdata->nconss-2], ownerdata->conss[ownerdata->nconss-1]) < 0;

1134 if

( ownerdata->filterpos < 0 )

1138

assert(ownerdata->nconss == 1);

1143

assert(ownerdata->filterpos >= 0);

1162

assert(eventhdlr !=

);

1163

assert(cons !=

);

1166

assert(consdata !=

);

1167

assert(consdata->varexprs !=

);

1168

assert(consdata->nvarexprs >= 0);

1171 if

( consdata->catchedevents )

1175

assert(conshdlrdata !=

);

1177

assert(conshdlrdata->intevalvar == intEvalVarBoundTightening);

1182 for

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

1184

expr = consdata->varexprs[i];

1186

assert(expr !=

);

1197 SCIP_CALL

( SCIPcallExprInteval(

, expr, &activity, intEvalVarBoundTightening, conshdlrdata) );

1206

consdata->catchedevents =

;

1227

assert(eventhdlr !=

);

1228

assert(expr !=

);

1230

assert(cons !=

);

1233

assert(ownerdata !=

);

1234

assert(ownerdata->nconss > 0);

1236 if

( ownerdata->conss[ownerdata->nconss-1] == cons )

1238

pos = ownerdata->nconss-1;

1242 if

( !ownerdata->consssorted )

1244 SCIPsortPtr

((

void

**)ownerdata->conss, compIndexConsNonlinear, ownerdata->nconss);

1245

ownerdata->consssorted =

;

1248 if

( !

SCIPsortedvecFindPtr

((

void

**)ownerdata->conss, compIndexConsNonlinear, cons, ownerdata->nconss, &pos) )

1253

assert(pos >= 0 && pos < ownerdata->nconss);

1255

assert(ownerdata->conss[pos] == cons);

1258 if

( pos < ownerdata->nconss-1 )

1260

ownerdata->conss[pos] = ownerdata->conss[ownerdata->nconss-1];

1261

ownerdata->consssorted =

;

1263

--ownerdata->nconss;

1266 if

( ownerdata->nconss == 0 )

1270

assert(ownerdata->filterpos >= 0);

1275

ownerdata->filterpos = -1;

1292

assert(eventhdlr !=

);

1293

assert(cons !=

);

1296

assert(consdata !=

);

1299 if

( !consdata->catchedevents )

1302

assert(consdata->varexprs !=

);

1303

assert(consdata->nvarexprs >= 0);

1307 for

( i = consdata->nvarexprs - 1; i >= 0; --i )

1309

assert(consdata->varexprs[i] !=

);

1314

consdata->catchedevents =

;

1358

assert(conshdlr !=

);

1359

assert(expr !=

);

1362

assert(conshdlrdata !=

);

1366 SCIPerrorMessage

(

"Locally valid nonlinear constraints are not supported, yet.\n"

);

1373 SCIPerrorMessage

(

"Non-initial nonlinear constraints are not supported, yet.\n"

);

1387

consdata->expr = expr;

1390

consdata->lhs = lhs;

1391

consdata->rhs = rhs;

1392

consdata->consindex = conshdlrdata->lastconsindex++;

1396 SCIP_CALL

(

SCIPcreateCons

(

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

1397

local, modifiable, dynamic, removable,

) );

1426

assert(expr !=

);

1429

assert(ownerdata !=

);

1430

assert(ownerdata->auxvar !=

);

1434 if

( violunder !=

)

1436 if

( violover !=

)

1445 if

( violunder !=

)

1446

*violunder =

;

1447 if

( violover !=

)

1454 if

( violunder !=

)

1456 if

( violover !=

)

1461 if

( violunder !=

)

1462

*violunder =

;

1463 if

( violover !=

)

1493

assert(expr !=

);

1496

assert(ownerdata !=

);

1497

assert(ownerdata->auxvar !=

);

1501 if

( violunder !=

)

1503 if

( violover !=

)

1510 if

( ownerdata->nlocksneg > 0 && auxvarvalue > auxvalue )

1512 if

( violunder !=

)

1513

*violunder =

;

1514 if

( violover !=

)

1516 return

auxvarvalue - auxvalue;

1519 if

( ownerdata->nlockspos > 0 && auxvalue > auxvarvalue )

1521 if

( violunder !=

)

1523 if

( violover !=

)

1525 return

auxvalue - auxvarvalue;

1528 if

( violunder !=

)

1529

*violunder =

;

1530 if

( violover !=

)

1549

assert(cons !=

);

1552

assert(consdata !=

);

1583

assert(cons !=

);

1586

assert(consdata !=

);

1588 return MAX3

(0.0, consdata->lhsviol, consdata->rhsviol);

1609

assert(cons !=

);

1610

assert(viol !=

);

1613

assert(conshdlr !=

);

1616

assert(conshdlrdata !=

);

1620 if

( conshdlrdata->violscale ==

'n'

)

1627

assert(consdata !=

);

1629 if

( conshdlrdata->violscale ==

'a'

)

1634 if

( consdata->lhsviol > 0.0 &&

(consdata->lhs) > scale )

1637

scale =

(consdata->lhs);

1639 else if

( consdata->rhsviol > 0.0 &&

(consdata->rhs) > scale )

1642

scale =

(consdata->rhs);

1650

assert(conshdlrdata->violscale ==

'g'

);

1651 if

( soltag == 0L || consdata->gradnormsoltag != soltag )

1657

consdata->gradnorm = 0.0;

1666 for

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

1675

consdata->gradnorm = 0.0;

1679

consdata->gradnorm += deriv*deriv;

1682

consdata->gradnorm = sqrt(consdata->gradnorm);

1683

consdata->gradnormsoltag = soltag;

1686

*viol /=

(1.0, consdata->gradnorm);

1716

assert(cons !=

);

1719

assert(consdata !=

);

1721

consdata->linvarincr =

;

1722

consdata->linvardecr =

;

1723

consdata->linvarincrcoef = 0.0;

1724

consdata->linvardecrcoef = 0.0;

1735

assert(child !=

);

1760 if

( (consdata->linvardecr ==

) ||

1763

consdata->linvardecr = var;

1764

consdata->linvardecrcoef = coef;

1773 if

( (consdata->linvarincr ==

) ||

1776

consdata->linvarincr = var;

1777

consdata->linvarincrcoef = coef;

1783

assert(consdata->linvarincr ==

|| consdata->linvarincrcoef != 0.0);

1784

assert(consdata->linvardecr ==

|| consdata->linvardecrcoef != 0.0);

1786 if

( consdata->linvarincr !=

)

1790 if

( consdata->linvardecr !=

)

1816

assert(conshdlr !=

);

1817

assert(conss !=

|| nconss == 0);

1818

assert(success !=

);

1827

assert(conshdlrdata !=

);

1838 SCIPdebugMsg

(

"attempt to make solution from <%s> feasible by shifting linear variable\n"

1841 for

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

1848

assert(consdata !=

);

1852

viol = consdata->lhsviol;

1854

viol = -consdata->rhsviol;

1858 if

( consdata->linvarincr !=

1859

((viol > 0.0 && consdata->linvarincrcoef > 0.0) || (viol < 0.0 && consdata->linvarincrcoef < 0.0)) )

1861 SCIP_VAR

* var = consdata->linvarincr;

1864

delta = viol / consdata->linvarincrcoef;

1865

assert(delta > 0.0);

1871

delta =

(

(0.0, gap), delta);

1880 SCIPdebugMsg

(

"increase <%s> by %g to %g to remedy lhs-violation %g of cons <%s>\n"

1884

viol -= consdata->linvarincrcoef * delta;

1890

assert(viol != 0.0);

1891 if

( consdata->linvardecr !=

1892

((viol > 0.0 && consdata->linvardecrcoef < 0.0) || (viol < 0.0 && consdata->linvardecrcoef > 0.0)) )

1894 SCIP_VAR

* var = consdata->linvardecr;

1897

delta = viol / consdata->linvardecrcoef;

1898

assert(delta < 0.0);

1904

delta =

(

(0.0, gap), delta);

1913 SCIPdebugMsg

(

"increase <%s> by %g to %g to remedy rhs-violation %g of cons <%s>\n"

1917

viol -= consdata->linvardecrcoef * delta;

1934

assert(conshdlrdata->trysolheur !=

);

1975

assert(conshdlr !=

);

1976

assert(conss !=

|| nconss == 0);

1989 for

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

1997

assert(consdata !=

);

2005 for

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

2022

assert(ownerdata !=

);

2027 if

( ownerdata->auxvar !=

)

2033 for

( e = 0; e < ownerdata->nenfos; ++e )

2036 SCIP_CALL

( SCIPnlhdlrSollinearize(

, conshdlr, conss[c],

2037

ownerdata->enfos[e]->nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, sol, solisbest,

2058

assert(event !=

);

2059

assert(eventdata !=

);

2060

assert(eventhdlr !=

);

2069

assert(sol !=

);

2072

assert(conshdlrdata !=

);

2111

assert(conshdlr !=

);

2112

assert(expr !=

);

2113

assert(cutoff !=

);

2131 if

( ntightenings !=

)

2145 if

( ntightenings !=

)

2182

assert(rootexpr !=

);

2184 if

( infeasible !=

)

2185

*infeasible =

;

2186 if

( ntightenings !=

)

2190

assert(conshdlrdata !=

);

2195 SCIPdebugMsg

(

"stored activity of root expr is empty and valid (activitytag >= lastboundrelax (%" SCIP_LONGINT_FORMAT ")), skip forwardPropExpr -> cutoff\n"

, conshdlrdata->lastboundrelax);

2197 if

( infeasible !=

)

2198

*infeasible =

;

2217

assert(ownerdata !=

);

2224 if

( ownerdata->nenfos >= 0 && ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && !conshdlrdata->indetect)

2227 SCIPdebugMsg

(

"root expr activity is not used but enfo initialized, skip inteval\n"

);

2250

*infeasible =

;

2267

assert(ownerdata !=

);

2275 SCIPexprGetActivityTag

(expr) >= conshdlrdata->lastvaractivitymethodchange && !conshdlrdata->globalbounds )

2280 SCIP_CALL

( SCIPcallExprInteval(

, expr, &exprhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );

2310 if

( infeasible !=

)

2311

*infeasible =

;

2312 SCIPdebugMsg

(

"expr %p already has empty activity -> cutoff\n"

, (

void

*)expr);

2322 if

( ownerdata->nenfos >= 0 && ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && !conshdlrdata->indetect )

2325 SCIPdebugMsg

(

"expr %p activity is not used but enfo initialized, skip inteval\n"

, (

void

*)expr);

2337 if

( ownerdata->nenfos > 0 )

2350

nlhdlr = ownerdata->enfos[e]->nlhdlr;

2351

assert(nlhdlr !=

);

2358

nlhdlrinterval = activity;

2359 SCIP_CALL

( SCIPnlhdlrInteval(

, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata,

2360

&nlhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );

2376 SCIP_CALL

( SCIPcallExprInteval(

, expr, &exprhdlrinterval, conshdlrdata->intevalvar, conshdlrdata) );

2411 SCIPdebugMsg

(

"cut off due to activity [%g,%g] beyond infinity\n"

, activity.

, activity.

);

2420 if

( infeasible !=

)

2421

*infeasible =

;

2423 else if

( tightenauxvars && ownerdata->auxvar !=

)

2428 if

( tighteninfeasible )

2430 if

( infeasible !=

)

2431

*infeasible =

;

2476 if

( subsetsufficient )

2524

assert(infeasible !=

);

2525

assert(ntightenings !=

);

2528

assert(conshdlrdata !=

);

2535 while

( !

SCIPqueueIsEmpty

(conshdlrdata->reversepropqueue) && !(*infeasible) )

2541

assert(expr !=

);

2544

assert(ownerdata !=

);

2546

assert(ownerdata->inpropqueue);

2548

ownerdata->inpropqueue =

;

2553

assert(ownerdata->propboundstag == conshdlrdata->curpropboundstag);

2561#ifdef SCIP_DISABLED_CODE 2565

*infeasible =

;

2569

propbounds = ownerdata->propbounds;

2572 if

( ownerdata->nenfos > 0 )

2575 for

( e = 0; e < ownerdata->nenfos && !*infeasible; ++e )

2584

nlhdlr = ownerdata->enfos[e]->nlhdlr;

2585

assert(nlhdlr !=

);

2595 SCIP_CALL

( SCIPnlhdlrReverseprop(

, conshdlr, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, propbounds, infeasible, &nreds) );

2597

*ntightenings += nreds;

2615

assert(ownerdata->nenfos < 0);

2622 SCIP_CALL

( SCIPcallExprReverseprop(

, expr, propbounds, childrenbounds, infeasible) );

2638

assert(expr !=

);

2641

assert(ownerdata !=

);

2644

ownerdata->inpropqueue =

;

2695

assert(conshdlr !=

);

2696

assert(conss !=

);

2697

assert(nconss >= 0);

2698

assert(result !=

);

2699

assert(nchgbds !=

);

2700

assert(*nchgbds >= 0);

2710

assert(conshdlrdata !=

);

2712

assert(conshdlrdata->intevalvar == intEvalVarBoundTightening);

2714

assert(!conshdlrdata->globalbounds);

2720

conshdlrdata->forceboundtightening = force;

2723

++conshdlrdata->curpropboundstag;

2726 if

( conshdlrdata->propauxvars )

2741 for

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

2744

assert(consdata !=

);

2753 if

( consdata->ispropagated )

2774 if

( !conshdlrdata->propauxvars || ownerdata->auxvar ==

)

2780 if

( ownerdata->auxvar ==

)

2789

conssides = intEvalVarBoundTightening(

, ownerdata->auxvar, (

void

*)conshdlrdata);

2801

assert(revpropcollectit !=

);

2806

assert(ownerdata !=

);

2808 if

( ownerdata->auxvar ==

)

2811 if

( ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 )

2814

conssides = intEvalVarBoundTightening(

, ownerdata->auxvar, (

void

*)conshdlrdata);

2826

assert(ntightenings >= 0);

2827 if

( ntightenings > 0 )

2829

*nchgbds += ntightenings;

2834

consdata->ispropagated =

;

2839

assert(ntightenings >= 0);

2849 if

( ntightenings > 0 )

2851

*nchgbds += ntightenings;

2855 while

( ntightenings > 0 && ++roundnr < conshdlrdata->maxproprounds );

2857 if

( conshdlrdata->propauxvars )

2862

conshdlrdata->forceboundtightening =

;

2865

++conshdlrdata->curpropboundstag;

2897

assert(conshdlr !=

);

2898

assert(conss !=

);

2899

assert(nconss >= 0);

2900

assert(result !=

);

2901

assert(nchgbds !=

);

2902

assert(*nchgbds >= 0);

2915 for

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

2922

assert(consdata !=

);

2927

assert(ownerdata !=

);

2932 for

( e = 0; e < ownerdata->nenfos; ++e )

2935

assert(ownerdata->enfos[e] !=

);

2937

nlhdlr = ownerdata->enfos[e]->nlhdlr;

2938

assert(nlhdlr !=

);

2942 SCIPdebugMsg

(

"propExprDomains calling reverseprop for expression %p [%g,%g]\n"

, (

void

*)expr,

2945 SCIP_CALL

( SCIPnlhdlrReverseprop(

, conshdlr, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata,

2956

assert(ntightenings >= 0);

2957 if

( ntightenings > 0 )

2959

*nchgbds += ntightenings;

2968

assert(ntightenings >= 0);

2975 else if

( ntightenings > 0 )

2977

*nchgbds += ntightenings;

3002

assert(expr !=

);

3005 if

( nlockspos == 0 && nlocksneg == 0 )

3014

ituserdata.

[0] = nlockspos;

3015

ituserdata.

[1] = nlocksneg;

3022

nlockspos = ituserdata.

[0];

3023

nlocksneg = ituserdata.

[1];

3038

ownerdata->nlockspos += nlockspos;

3039

ownerdata->nlocksneg += nlocksneg;

3042 if

( ownerdata->nlockspos == nlockspos && ownerdata->nlocksneg == nlocksneg &&

SCIPexprGetNChildren

(expr) > 0

3047

assert(ownerdata->monotonicity ==

);

3048

assert(ownerdata->monotonicitysize == 0);

3056 SCIP_CALL

( SCIPcallExprMonotonicity(

, expr, i, &ownerdata->monotonicity[i]) );

3065 if

( ownerdata->nlockspos == 0 && ownerdata->nlocksneg == 0 && ownerdata->monotonicity !=

)

3067

assert(ownerdata->monotonicitysize > 0);

3072

ownerdata->monotonicitysize = 0;

3088 switch

( monotonicity )

3091

ituserdata.

[0] = nlockspos;

3092

ituserdata.

[1] = nlocksneg;

3095

ituserdata.

[0] = nlocksneg;

3096

ituserdata.

[1] = nlockspos;

3099

ituserdata.

[0] = nlockspos + nlocksneg;

3100

ituserdata.

[1] = nlockspos + nlocksneg;

3153

assert(cons !=

);

3155 if

( nlockspos == 0 && nlocksneg == 0 )

3159

assert(consdata !=

);

3166

consdata->nlockspos += nlockspos;

3167

consdata->nlocksneg += nlocksneg;

3169

assert(consdata->nlockspos >= 0);

3170

assert(consdata->nlocksneg >= 0);

3200

assert(cons !=

);

3203

assert(consdata !=

);

3204

assert(consdata->expr !=

);

3206 if

( consdata->nlrow !=

)

3271

assert(elem1 !=

);

3272

assert(elem2 !=

);

3277

assert(h1 !=

);

3278

assert(h2 !=

);

3308

assert(expr !=

);

3311

assert(ownerdata !=

);

3314

assert(conshdlrdata !=

);

3315

assert(conshdlrdata->auxvarid >= 0);

3316

assert(!conshdlrdata->indetect);

3319

assert(ownerdata->nenfos < 0);

3320

assert(ownerdata->enfos ==

);

3329 if

( ownerdata->nauxvaruses == 0 )

3333 if

( ownerdata->nlockspos == 0 )

3335 if

( ownerdata->nlocksneg == 0 )

3338 if

( ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 )

3347

ownerdata->nenfos = 0;

3350

conshdlrdata->indetect =

;

3352 SCIPdebugMsg

(

"detecting nlhdlrs for %s expression %p (%s); requiring%s%s%s\n"

3358 for

(

= 0;

< conshdlrdata->nnlhdlrs; ++

)

3362

nlhdlr = conshdlrdata->nlhdlrs[

];

3363

assert(nlhdlr !=

);

3370

nlhdlrexprdata =

;

3371

enforcemethodsnew = enforcemethods;

3373

conshdlrdata->registerusesactivitysepabelow =

;

3374

conshdlrdata->registerusesactivitysepaabove =

;

3376 SCIP_CALL

( SCIPnlhdlrDetect(

, ownerdata->conshdlr, nlhdlr, expr, cons, &enforcemethodsnew, &nlhdlrparticipating, &nlhdlrexprdata) );

3379

nlhdlrparticipating &= enforcemethodsallowed;

3382

assert((enforcemethodsnew & enforcemethods) == enforcemethods);

3387

nlhdlrenforcemethods = (enforcemethodsnew ^ enforcemethods) & enforcemethodsallowed;

3390

assert((nlhdlrparticipating & nlhdlrenforcemethods) == nlhdlrenforcemethods);

3398 if

( nlhdlrexprdata !=

)

3400 SCIP_CALL

( SCIPnlhdlrFreeexprdata(

, nlhdlr, expr, &nlhdlrexprdata) );

3410 SCIPdebugMsg

(

"nlhdlr <%s> detect successful; sepabelow: %s, sepaabove: %s, activity: %s\n"

3419

ownerdata->enfos[ownerdata->nenfos]->nlhdlr = nlhdlr;

3420

ownerdata->enfos[ownerdata->nenfos]->nlhdlrexprdata = nlhdlrexprdata;

3421

ownerdata->enfos[ownerdata->nenfos]->nlhdlrparticipation = nlhdlrparticipating;

3422

ownerdata->enfos[ownerdata->nenfos]->issepainit =

;

3423

ownerdata->enfos[ownerdata->nenfos]->sepabelowusesactivity = conshdlrdata->registerusesactivitysepabelow;

3424

ownerdata->enfos[ownerdata->nenfos]->sepaaboveusesactivity = conshdlrdata->registerusesactivitysepaabove;

3425

ownerdata->nenfos++;

3428

enforcemethods = enforcemethodsnew;

3431

conshdlrdata->indetect =

;

3438 SCIPerrorMessage

(

"no nonlinear handler provided some of the required enforcement methods\n"

);

3442

assert(ownerdata->nenfos > 0);

3445 if

( ownerdata->nenfos > 1 )

3446 SCIPsortDownPtr

((

void

**)ownerdata->enfos, enfodataCmp, ownerdata->nenfos);

3470

assert(conss !=

|| nconss == 0);

3471

assert(nconss >= 0);

3475

assert(conshdlrdata !=

);

3486

conshdlrdata->globalbounds =

;

3487

conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;

3490 for

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

3492

assert(conss !=

&& conss[i] !=

);

3495

assert(consdata !=

);

3496

assert(consdata->expr !=

);

3505

assert(ownerdata !=

);

3512 if

( ownerdata->nenfos > 0 )

3515

assert(ownerdata->nenfos < 0);

3523

conshdlrdata->indetect =

;

3528

conshdlrdata->indetect =

;

3537

assert(ownerdata !=

);

3540 if

( ownerdata->nenfos >= 0 )

3550 if

( ownerdata->nauxvaruses > 0 || ownerdata->nactivityusesprop > 0 || ownerdata->nactivityusessepa > 0 )

3554

assert(ownerdata->nenfos >= 0);

3563

ownerdata->nenfos = 0;

3569

consdata->ispropagated =

;

3578

conshdlrdata->globalbounds =

;

3579

conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;

3615 for

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

3626

assert(consdata !=

);

3627

assert(consdata->expr !=

);

3666 if

( consdata->nlrow ==

)

3669

assert(consdata->nlrow !=

);

3716 for

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

3718

assert(conss !=

);

3719

assert(conss[c] !=

);

3722

assert(consdata !=

);

3723

assert(consdata->expr !=

);

3730 SCIPdebugMsg

(

"exitsepa and free nonlinear handler data for expression %p\n"

, (

void

*)expr);

3738 if

( rootactivityvalid )

3749 if

( consdata->nlrow !=

)

3763

consdata->linvardecr =

;

3764

consdata->linvarincr =

;

3784

assert(expr !=

);

3804

assert(child !=

);

3834

assert(sumexpr !=

);

3836

assert(xs !=

);

3837

assert(ys !=

);

3838

assert(childidxs !=

);

3848

assert(child !=

);

3855

assert(

);

3856

assert(

);

3862

childidxs[*

] = i;

3893

assert(facvar !=

);

3894

assert(vars !=

);

3896

assert(newexpr !=

);

3900 for

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

3902

minact +=

(coefs[i], 0.0);

3903

maxact +=

(coefs[i], 0.0);

3906

assert(minact <= maxact);

3913#ifdef WITH_DEBUG_SOLUTION 3914 if

( SCIPdebugIsMainscip(

) )

3922 for

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

3925

debugsolval += coefs[i] * val;

3944 if

( naddconss !=

)

3955 if

( naddconss !=

)

3969 if

( naddconss !=

)

3982 if

( naddconss !=

)

4015 int

* childidxs =

;

4016 int

* count =

;

4024

assert(sumexpr !=

);

4025

assert(minterms > 1);

4026

assert(newexpr !=

);

4040 if

( nchildren < minterms )

4065 for

( i = 0; i <

; ++i )

4070

assert(xs[i] !=

);

4071

assert(ys[i] !=

);

4074

assert(xidx < ntotalvars);

4076

assert(yidx < ntotalvars);

4094 for

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

4107 for

( j = 0; j <

; ++j )

4109 int

childidx = childidxs[j];

4110

assert(childidx >= 0 && childidx < nchildren);

4112 if

( !isused[childidx] && (xs[j] == facvar || ys[j] == facvar) )

4118

coef = sumcoefs[childidx];

4119

assert(coef != 0.0);

4122

tmpvars[ntmpvars] = (xs[j] == facvar) ? ys[j] : xs[j];

4123

tmpcoefs[ntmpvars] = coef;

4128

assert(xidx < ntotalvars);

4130

assert(yidx < ntotalvars);

4133

assert(count[xidx] >= 0);

4134

assert(count[yidx] >= 0);

4137

isused[childidx] =

;

4140

assert(ntmpvars >= minterms);

4146

exprcoefs[nexprs] = 1.0;

4153 int

nexprsold = nexprs;

4156 for

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

4161

exprcoefs[nexprs] = sumcoefs[i];

4170 for

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

4211

assert(conshdlr !=

);

4212

assert(prodexpr !=

);

4214

assert(newexpr !=

);

4217

assert(nchildren >= 2);

4226

strcpy(name,

"binreform"

);

4227 for

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

4231

assert(vars[i] !=

);

4232

(void) strcat(name,

"_"

);

4241#ifdef WITH_DEBUG_SOLUTION 4242 if

( SCIPdebugIsMainscip(

) )

4249 for

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

4261 if

( nchildren == 2 && !empathy4and )

4266

assert(

);

4267

assert(

);

4291 if

( naddconss !=

)

4303 if

( naddconss !=

)

4336

assert(prodexpr !=

);

4337

assert(newexpr !=

);

4346

assert(conshdlrdata !=

);

4348

assert(nchildren >= 2);

4354

assert(*newexpr !=

);

4361 SCIPdebugMsg

(

" product expression %p has been considered for the first time\n"

, (

void

*)prodexpr);

4363 if

( nchildren == 2 )

4373

assert(

);

4375

assert(

);

4389 if

( nchgcoefs !=

)

4392

found_clique =

;

4401 if

( nchgcoefs !=

)

4404

found_clique =

;

4409 if

( !found_clique )

4421 if

( nchgcoefs !=

)

4424

found_clique =

;

4442 if

( nchgcoefs !=

)

4445

found_clique =

;

4452 if

( !found_clique )

4486

assert(conshdlr !=

);

4487

assert(cons !=

);

4488

assert(exprmap !=

);

4489

assert(it !=

);

4492

assert(conshdlrdata !=

);

4495

assert(consdata !=

);

4496

assert(consdata->expr !=

);

4509

assert(childexpr !=

);

4512 if

( conshdlrdata->reformbinprodsfac > 1 )

4518 if

( newexpr ==

)

4523 if

( newexpr !=

)

4525

assert(naddconss ==

|| *naddconss > 0 || nchgcoefs ==

|| *nchgcoefs > 0);

4534

consdata->issimplified =

;

4590

assert(conshdlr !=

);

4595

assert(conss !=

);

4598

assert(conshdlrdata !=

);

4610 for

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

4615

assert(conss[c] !=

);

4618

assert(consdata !=

);

4621 if

( conshdlrdata->reformbinprodsfac > 1 )

4627 if

( newexpr !=

)

4630

consdata->expr = newexpr;

4633

consdata->issimplified =

;

4665

assert(cons !=

);

4668

assert(consdata !=

);

4682 if

( nchildren == 1 && constant == 0.0 && coefs[0] == -1.0 )

4685

expr = consdata->expr;

4693

consdata->lhs = -consdata->lhs;

4694

consdata->rhs = -consdata->rhs;

4702 for

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

4703

counter += coefs[i] > 0 ? 1 : -1;

4713 for

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

4714

newcoefs[i] = -coefs[i];

4721

consdata->expr = expr;

4723

consdata->lhs = -consdata->lhs;

4724

consdata->rhs = -consdata->rhs;

4751

assert(conshdlr !=

);

4759 for

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

4762

assert(consdata !=

);

4825

assert(conshdlr !=

);

4826

assert(conss !=

);

4828

assert(infeasible !=

);

4831

assert(conshdlrdata !=

);

4834

++(conshdlrdata->ncanonicalizecalls);

4838

*infeasible =

;

4841

havechange = conshdlrdata->ncanonicalizecalls == 1;

4851 for

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

4853

assert(conss[i] !=

);

4856

assert(consdata !=

);

4859

nlockspos[i] = consdata->nlockspos;

4860

nlocksneg[i] = consdata->nlocksneg;

4864

assert(consdata->nlockspos == 0);

4865

assert(consdata->nlocksneg == 0);

4870 for

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

4878

assert(consdata !=

);

4883

assert(expr !=

);

4895 int

tmpnaddconss = 0;

4896 int

tmpnchgcoefs = 0;

4904 if

( naddconss !=

)

4905

*naddconss = tmpnaddconss;

4906 if

( nchgcoefs !=

)

4907

*nchgcoefs = tmpnchgcoefs;

4910 if

( tmpnaddconss + tmpnchgcoefs > 0 )

4914 for

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

4917

assert(consdata !=

);

4920 if

( !consdata->issimplified && consdata->expr !=

)

4927

consdata->issimplified =

;

4935 if

( simplified != consdata->expr )

4943

consdata->expr = simplified;

4971

*infeasible =

;

4978 if

( ndelconss !=

)

4987 if

( havechange && !*infeasible )

4994 for

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

5003 for

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

5016 SCIPsortPtr

((

void

**)consssorted, compIndexConsNonlinear, nconss);

5018 for

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

5020

assert(i == 0 || compIndexConsNonlinear((

void

*)consssorted[i-1], (

void

*)consssorted[i]) < 0);

5027 for

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

5046 for

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

5060 for

( i = 0; i < conshdlrdata->nnlhdlrs; ++i )

5090

assert(success !=

);

5103 for

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

5112

assert(consdata !=

);

5125

assert(idx >= 0 && idx < nconss);

5128

assert(imgconsdata !=

);

5129

assert(imgconsdata->expr == consdata->expr);

5131 SCIPdebugMsg

(

"merge constraint %g <= %s <= %g with %g <= %s <= %g\n"

, consdata->lhs,

5138

nlockspos[idx] = imgconsdata->nlockspos;

5139

nlocksneg[idx] = imgconsdata->nlocksneg;

5141

updatelocks[idx] =

;

5145

imgconsdata->lhs =

(imgconsdata->lhs, consdata->lhs);

5146

imgconsdata->rhs =

(imgconsdata->rhs, consdata->rhs);

5157 for

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

5159 if

( updatelocks[c] )

5188

assert(var !=

);

5191

assert(conshdlrdata !=

);

5193 if

( conshdlrdata->globalbounds )

5260

assert(conshdlr !=

);

5261

assert(conss !=

);

5262

assert(nconss >= 0);

5263

assert(cutoff !=

);

5264

assert(ndelconss !=

);

5265

assert(nchgbds !=

);

5272

assert(conshdlrdata !=

);

5279

++conshdlrdata->curboundstag;

5280

assert(conshdlrdata->curboundstag > 0);

5281

conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;

5282

conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;

5283

conshdlrdata->intevalvar = intEvalVarRedundancyCheck;

5285 SCIPdebugMsg

(

"checking %d constraints for redundancy\n"

, nconss);

5288 for

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

5294

assert(consdata !=

);

5325

assert(var !=

);

5389 SCIPdebugMsg

(

" -> redundant: activity [%g,%g] within sides [%g,%g]\n"

, activity.

, activity.

, consdata->lhs, consdata->rhs);

5397 SCIPdebugMsg

(

" -> not redundant: activity [%g,%g] not within sides [%g,%g]\n"

, activity.

, activity.

, consdata->lhs, consdata->rhs);

5402

++conshdlrdata->curboundstag;

5403

conshdlrdata->lastvaractivitymethodchange = conshdlrdata->curboundstag;

5404

conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;

5405

conshdlrdata->intevalvar = intEvalVarBoundTightening;

5429

assert(conshdlr !=

);

5430

assert(cons !=

);

5432

assert(upgraded !=

);

5433

assert(nupgdconss !=

);

5434

assert(naddconss !=

);

5441

assert(conshdlrdata !=

);

5444 if

( conshdlrdata->nconsupgrades == 0 )

5455

assert(consdata !=

);

5458 for

( i = 0; i < conshdlrdata->nconsupgrades; ++i )

5460 if

( !conshdlrdata->consupgrades[i]->active )

5463

assert(conshdlrdata->consupgrades[i]->consupgd !=

);

5465 SCIP_CALL

( conshdlrdata->consupgrades[i]->consupgd(

, cons, consdata->nvarexprs, &nupgdconss_, upgdconss, upgdconsssize) );

5467 while

( nupgdconss_ < 0 )

5470

assert(-nupgdconss_ > upgdconsssize);

5471

upgdconsssize = -nupgdconss_;

5474 SCIP_CALL

( conshdlrdata->consupgrades[i]->consupgd(

, cons, consdata->nvarexprs, &nupgdconss_, upgdconss, upgdconsssize) );

5476

assert(nupgdconss_ != 0);

5479 if

( nupgdconss_ > 0 )

5487 for

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

5498

*naddconss += nupgdconss_ - 1;

5530

assert(var !=

);

5533

assert(ownerdata !=

);

5593 int

nsinglelocked = 0;

5596

assert(conshdlr !=

);

5597

assert(cons !=

);

5598

assert(nchgvartypes !=

);

5599

assert(naddconss !=

);

5600

assert(infeasible !=

);

5604

*infeasible =

;

5607

assert(conshdlrdata !=

);

5609

assert(consdata !=

);

5628 for

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

5630

assert(consdata->varexprs[i] !=

);

5635

singlelocked[nsinglelocked++] = consdata->varexprs[i];

5640 if

( nsinglelocked > 0 )

5654 for

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

5659

child = children[i];

5660

assert(child !=

);

5695

valid = exponent > 1.0 && fmod(exponent, 2.0) == 0.0;

5697 if

( !valid || !

SCIPisExprVar

(

, grandchild) || (hasrhs && coef > 0.0) || (haslhs && coef < 0.0) )

5719 for

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

5732

assert(var !=

);

5733 SCIPdebugMsg

(

"found single locked variable %s in [%g,%g] that can be fixed to one of its bounds\n"

5793

assert(conshdlr !=

);

5794

assert(conss !=

|| nconss == 0);

5795

assert(nchgvartypes !=

);

5796

assert(infeasible !=

);

5798

*infeasible =

;

5808 for

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

5818

assert(conss !=

&& conss[c] !=

);

5821

assert(consdata !=

);

5824 if

( !

SCIPisEQ

(

, consdata->lhs, consdata->rhs) )

5837 if

( nchildren <= 1 )

5843 for

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

5848

candcoef = coefs[i];

5849

assert(candcoef != 0.0);

5865 for

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

5867 if

( children[i] == cand )

5888 SCIPdebugMsg

(

"make variable <%s> implicit integer due to constraint <%s>\n"

5922

assert(expr !=

);

5925

assert(ownerdata !=

);

5926

assert(ownerdata->nauxvaruses > 0);

5929 if

( ownerdata->auxvar !=

)

5943

assert(conshdlrdata !=

);

5944

assert(conshdlrdata->auxvarid >= 0);

5954

++conshdlrdata->auxvarid;

6004#ifdef WITH_DEBUG_SOLUTION 6005 if

( SCIPdebugIsMainscip(

) )

6047 int

nreductions = 0;

6051

assert(conshdlr !=

);

6052

assert(conss !=

|| nconss == 0);

6053

assert(nconss >= 0);

6054

assert(infeasible !=

);

6057

assert(conshdlrdata !=

);

6060

++conshdlrdata->curpropboundstag;

6066

*infeasible =

;

6067 for

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

6069

assert(conss !=

);

6070

assert(conss[c] !=

);

6073

assert(consdata !=

);

6074

assert(consdata->expr !=

);

6076#ifdef WITH_DEBUG_SOLUTION 6077 if

( SCIPdebugIsMainscip(

) )

6083 if

( debugsol !=

)

6105 if

( auxvar !=

)

6107 SCIPdebugMsg

(

"tighten auxvar <%s> bounds using constraint sides [%g,%g]\n"

6133

*infeasible =

;

6140 for

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

6142

assert(conss !=

);

6143

assert(conss[c] !=

);

6146

assert(consdata !=

);

6147

assert(consdata->expr !=

);

6154

assert(ownerdata !=

);

6156 if

( ownerdata->nauxvaruses == 0 )

6159 for

( e = 0; e < ownerdata->nenfos; ++e )

6164

assert(ownerdata->enfos[e] !=

);

6169 if

( ownerdata->enfos[e]->issepainit )

6176

nlhdlr = ownerdata->enfos[e]->nlhdlr;

6177

assert(nlhdlr !=

);

6184

overestimate = ownerdata->nlocksneg > 0;

6185

underestimate = ownerdata->nlockspos > 0;

6186

assert(underestimate || overestimate);

6188 SCIPdebugMsg

(

"initsepa under=%u over=%u for expression %p\n"

, underestimate, overestimate, (

void

*)expr);

6191 SCIP_CALL

( SCIPnlhdlrInitsepa(

, conshdlr, conss[c], nlhdlr, expr,

6192

ownerdata->enfos[e]->nlhdlrexprdata, overestimate, underestimate, infeasible) );

6193

ownerdata->enfos[e]->issepainit =

;

6222

assert(conshdlr !=

);

6225

assert(conshdlrdata !=

);

6242

assert(conshdlrdata !=

);

6244 switch

( conshdlrdata->branchviolsplit )

6253 return MAX

(0.05, weight);

6262

assert(width > 0.0);

6264 return

10.0*log10(width);

6266 return

0.1/(-log10(width));

6271 SCIPerrorMessage

(

"invalid value for parameter constraints/expr/branching/violsplit"

);

6301

assert(exprs !=

);

6303

assert(success !=

);

6316 for

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

6319

assert(var !=

);

6328 for

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

6331

assert(var !=

);

6333 if

( nunbounded > 0 )

6338 SCIPdebugMsg

(

"add score %g (%g%% of %g) to <%s>[%g,%g]\n"

, violscore / nunbounded,

6339

100.0/nunbounded, violscore,

6346

assert(weightsum > 0.0);

6350 SCIPdebugMsg

(

"add score %g (%g%% of %g) to <%s>[%g,%g]\n"

, violscore * weight / weightsum,

6351

100*weight / weightsum, violscore,

6388

assert(expr !=

);

6389

assert(auxvars !=

);

6390

assert(success !=

);

6393 SCIPsortPtr

((

void

**)auxvars, SCIPvarComp, nauxvars);

6404 if

( auxvar ==

)

6410

assert(auxvars[pos] == auxvar);

6413

exprs[nexprs++] = expr;

6415 if

( nexprs == nauxvars )

6449

assert(conshdlr !=

);

6450

assert(conss !=

|| nconss == 0);

6451

assert(nnotify !=

);

6455 for

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

6457

assert(conss !=

&& conss[c] !=

);

6460

assert(consdata !=

);

6467

assert(consdata->varexprs !=

);

6468 for

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

6471

assert(var !=

);

6498

assert(conshdlr !=

);

6499

assert(success !=

);

6510 for

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

6512

assert(conss !=

&& conss[c] !=

);

6515

assert(consdata !=

);

6516

assert(consdata->varexprs !=

);

6529 for

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

6539 if

( violscore == 0.0 )

6543

assert(var !=

);

6577 if

( violscore == 0.0 )

6584

assert(var !=

);

6641

assert(conshdlr !=

);

6642

assert(cands !=

);

6643

assert(ncands !=

);

6646

assert(conshdlrdata !=

);

6655 for

( attempt = 0; attempt < 2; ++attempt )

6661 for

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

6665

assert(conss !=

&& conss[c] !=

);

6672

assert(consdata !=

);

6673

assert(consdata->varexprs !=

);

6677 if

( attempt == 0 && consviol < conshdlrdata->branchhighviolfactor * maxrelconsviol )

6679 else if

( attempt == 1 && consviol >= conshdlrdata->branchhighviolfactor * maxrelconsviol )

6691 for

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

6701

assert(var !=

);

6714

cands[*ncands].

= consdata->varexprs[i];

6715

cands[*ncands].

= var;

6740

assert(var !=

);

6753

cands[*ncands].

= expr;

6754

cands[*ncands].

= var;

6814

assert(conshdlr !=

);

6815

assert(var !=

);

6826

assert(col !=

);

6841 for

(

= 0;

< nrows; ++

)

6844 const char

* estimategapstr;

6857

estimategapstr = strstr(

SCIProwGetName

(rows[

]),

"_estimategap="

);

6858 if

( estimategapstr ==

)

6860

estimategap = atof(estimategapstr + 13);

6861

assert(estimategap >= 0.0);

6911

assert(conshdlr !=

);

6912

assert(cands !=

);

6916

assert(conshdlrdata !=

);

6921 for

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

6923 if

( conshdlrdata->branchviolweight > 0.0 )

6934

assert(cands[c].expr !=

|| cands[c].fractionality > 0.0);

6936 if

( considerfracnl && cands[c].fractionality == 0.0 )

6955 if

( conshdlrdata->branchdomainweight > 0.0 && cands[c].

)

6961

assert(var !=

);

6970 if

( domainwidth >= 1.0 )

6980 if

( conshdlrdata->branchdualweight > 0.0 && cands[c].

)

6985

assert(var !=

);

6988

maxscore.

(cands[c].dual, maxscore.

);

6991

cands[c].

= 0.0;

6997

var = cands[c].

;

6998

assert(var !=

);

7000 if

( cands[c].expr !=

)

7016

strategy = conshdlrdata->branchpscostupdatestrategy;

7085

cands[c].

= pscostup;

7087

cands[c].

= pscostdown;

7118

cands[c].

= pscostup;

7120

cands[c].

= pscostdown;

7131 if

( conshdlrdata->branchvartypeweight > 0.0 )

7155 for

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

7161

cands[c].weighted = 0.0;

7164 if

( maxscore.

auxviol

> 0.0 )

7167

weightsum += conshdlrdata->branchviolweight;

7175

weightsum += conshdlrdata->branchfracweight;

7180 if

( maxscore.

domain

> 0.0 )

7183

weightsum += conshdlrdata->branchdomainweight;

7188 if

( maxscore.

> 0.0 )

7190

cands[c].

weighted

+= conshdlrdata->branchdualweight * cands[c].

/ maxscore.

;

7191

weightsum += conshdlrdata->branchdualweight;

7196 if

( maxscore.

> 0.0 )

7202

weightsum += conshdlrdata->branchpscostweight;

7213 if

( maxscore.

vartype

> 0.0 )

7216

weightsum += conshdlrdata->branchvartypeweight;

7221

assert(weightsum > 0.0);

7238 if

( cands[ind1].weighted != cands[ind2].weighted )

7241 if

( cands[ind1].var != cands[ind2].var )

7244 return

cands[ind1].

? 1 : -1;

7266

assert(cands !=

);

7267

assert(ncands >= 1);

7268

assert(selected !=

);

7279

assert(conshdlrdata !=

);

7286 SCIPsortDown

(perm, branchcandCompare, (

void

*)cands, ncands);

7290 SCIPvarGetName

(cands[perm[ncands - 1]].var), cands[perm[ncands - 1]].weighted); )

7295

threshold = conshdlrdata->branchhighscorefactor * cands[perm[0]].

weighted

;

7296 while

( left < right )

7298 int

mid = (left + right) / 2;

7299 if

( cands[perm[mid]].weighted >= threshold )

7304

assert(left <= ncands);

7306 if

( left < ncands )

7308 if

( cands[perm[left]].weighted >= threshold )

7310

assert(left + 1 == ncands || cands[perm[left + 1]].weighted < threshold);

7315

assert(cands[perm[left]].weighted < threshold);

7321 ENFOLOG

(

(

, enfologfile,

" %d branching candidates <%s>(%g)...<%s>(%g) after removing low scores\n"

, ncands,

7323 SCIPvarGetName

(cands[perm[ncands - 1]].var), cands[perm[ncands - 1]].weighted); )

7328 if

( conshdlrdata->branchrandnumgen ==

)

7333

*selected = &cands[perm[c]];

7336

*selected = &cands[perm[0]];

7364

assert(conshdlr !=

);

7365

assert(result !=

);

7370

assert(conshdlrdata !=

);

7372 if

( conshdlrdata->branchexternal )

7398

assert(selected !=

);

7406 if

( downchild !=

|| eqchild !=

|| upchild !=

)

7443

assert(result !=

);

7446 SCIP_CALL

( SCIPnlhdlrEnfo(

, conshdlr, cons, nlhdlr, expr, nlhdlrexprdata, sol, auxvalue, overestimate,

7447

allowweakcuts, separated, inenforcement, branchcandonly, result) );

7478

assert(auxvar !=

);

7480 SCIP_CALL

( SCIPnlhdlrEstimate(

, conshdlr, nlhdlr, expr, nlhdlrexprdata, sol, auxvalue, overestimate,

7481 SCIPgetSolVal

(

, sol, auxvar), inenforcement, rowpreps, &sepasuccess, &branchscoresuccess) );

7486

assert((sepasuccess && minidx <= maxidx) || (!sepasuccess && minidx > maxidx));

7494 for

(

= minidx;

<= maxidx; ++

)

7498

assert(rowprep !=

);

7501 if

( !branchcandonly )

7510

auxvalue, allowweakcuts, branchscoresuccess, inenforcement, sol, result) );

7516 if

( branchcandonly && branchscoresuccess )

7558

assert(expr !=

);

7559

assert(result !=

);

7562

assert(ownerdata !=

);

7563

assert(ownerdata->auxvar !=

);

7574

assert(conshdlrdata !=

);

7577 if

( !overestimate && !underestimate )

7583 for

( e = 0; e < ownerdata->nenfos; ++e )

7592 if

( branchcandonly && !ownerdata->enfos[e]->sepaaboveusesactivity && !ownerdata->enfos[e]->sepabelowusesactivity )

7595

nlhdlr = ownerdata->enfos[e]->nlhdlr;

7596

assert(nlhdlr !=

);

7599 SCIP_CALL

( SCIPnlhdlrEvalaux(

, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, &ownerdata->enfos[e]->auxvalue, sol) );

7603 SCIPinfoMessage

(

, enfologfile,

" (%p): evalvalue %.15g auxvarvalue %.15g [%.15g,%.15g], nlhdlr <%s> "

7617

assert(auxviol >= 0.0);

7620 if

( !

SCIPisInfinity

(

SCIP_NLHDLR_METHOD_SEPAABOVE

, auxviol) && auxviol < conshdlrdata->enfoauxviolfactor * origviol )

7623 "auxviolation %g << origviolation %g under:%d over:%d\n"

SCIPnlhdlrGetName

(nlhdlr), (

void

*)expr,

7635

underestimate, overestimate); )

7643

auxviol, origviol, underestimate, overestimate, allowweakcuts); )

7648 if

( overestimate && auxoverestimate && (ownerdata->enfos[e]->nlhdlrparticipation &

) != 0 && (!branchcandonly || ownerdata->enfos[e]->sepaaboveusesactivity) )

7653

ownerdata->enfos[e]->auxvalue,

SCIP_NLHDLR_METHOD_SEPABELOW

, *result ==

SCIP_SEPARATED

, allowweakcuts, inenforcement, branchcandonly, &hdlrresult) );

7659

ownerdata->lastenforced = conshdlrdata->enforound;

7667

ownerdata->lastenforced = conshdlrdata->enforound;

7676

ownerdata->lastenforced = conshdlrdata->enforound;

7683

assert(inenforcement);

7689

ownerdata->lastenforced = conshdlrdata->enforound;

7696 if

( underestimate && auxunderestimate && (ownerdata->enfos[e]->nlhdlrparticipation &

) != 0 && (!branchcandonly || ownerdata->enfos[e]->sepabelowusesactivity) )

7701

ownerdata->enfos[e]->auxvalue,

, *result ==

SCIP_SEPARATED

, allowweakcuts, inenforcement, branchcandonly, &hdlrresult) );

7707

ownerdata->lastenforced = conshdlrdata->enforound;

7715

ownerdata->lastenforced = conshdlrdata->enforound;

7724

ownerdata->lastenforced = conshdlrdata->enforound;

7731

assert(inenforcement);

7737

ownerdata->lastenforced = conshdlrdata->enforound;

7765

assert(conshdlr !=

);

7766

assert(cons !=

);

7767

assert(it !=

);

7768

assert(result !=

);

7769

assert(success !=

);

7772

assert(conshdlrdata !=

);

7775

assert(consdata !=

);

7780 if

( inenforcement && !branchcandonly && !consdata->ispropagated )

7800 if

( ntightenings > 0 )

7810

assert(ownerdata !=

);

7813 if

( ownerdata->auxvar ==

)

7816

assert(ownerdata->lastenforced <= conshdlrdata->enforound);

7817 if

( ownerdata->lastenforced == conshdlrdata->enforound )

7828 SCIP_CALL

(

enforceExpr

(

, conshdlr, cons, expr, sol, soltag, allowweakcuts, inenforcement, branchcandonly, &resultexpr) );

7831

assert((ownerdata->lastenforced == conshdlrdata->enforound) == (resultexpr !=

SCIP_DIDNOTFIND

));

7832 if

( ownerdata->lastenforced == conshdlrdata->enforound )

7885

assert(conshdlr !=

);

7886

assert(conss !=

|| nconss == 0);

7887

assert(result !=

);

7890

assert(conshdlrdata !=

);

7896

++(conshdlrdata->enforound);

7903 for

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

7905

assert(conss !=

&& conss[c] !=

);

7925

assert(consdata !=

);

7929 for

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

7938 SCIP_CALL

(

enforceConstraint

(

, conshdlr, conss[c], sol, soltag, it,

, inenforcement, branchcandonly, result, &consenforced) );

7943 if

( !consenforced && inenforcement && !branchcandonly )

7948 if

( viol > conshdlrdata->weakcutminviolfactor * maxrelconsviol )

7953 SCIP_CALL

(

enforceConstraint

(

, conshdlr, conss[c], sol, soltag, it,

, inenforcement, branchcandonly, result, &consenforced) );

7956

++conshdlrdata->nweaksepa;

7966 ENFOLOG

(

if

( enfologfile !=

) fflush( enfologfile); )

7983 ENFOLOG

(

if

( enfologfile !=

) fflush( enfologfile); )

8019

assert(conshdlr !=

);

8020

assert(conss !=

);

8022

assert(branchintegral !=

);

8023

assert(cutoff !=

);

8025

*branchintegral =

;

8036

*branchintegral =

;

8047 SCIPerrorMessage

(

"Unexpected separation or propagation from enforceConstraints(branchcandonly = TRUE)\n"

);

8059 SCIPerrorMessage

(

"Unexpected return from enforceConstraints(branchcandonly = TRUE)\n"

);

8070 ENFOLOG

(

(

, enfologfile,

" adding %d fractional integer variables to branching candidates\n"

, nlpcands); )

8072 for

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

8077

cands[ncands].

= lpcands[c];

8088

assert(selected !=

);

8094

*branchintegral =

;

8119

assert(conshdlrdata !=

);

8146 for

( i = 0; i < nbinvars + nintvars && !isfractional; ++i )

8148

assert(vars[i] !=

);

8152

isfractional =

;

8155 if

( !isfractional )

8164 if

( conshdlrdata->branchmixfractional == 0.0 )

8204

assert(conss !=

|| nconss == 0);

8205

assert(maxabsconsviol !=

);

8206

assert(maxrelconsviol !=

);

8207

assert(maxauxviol !=

);

8208

assert(maxvarboundviol !=

);

8213

*maxabsconsviol = 0.0;

8214

*maxrelconsviol = 0.0;

8217

*maxvarboundviol = 0.0;

8219 for

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

8221

assert(conss !=

&& conss[c] !=

);

8224

assert(consdata !=

);

8232

*maxabsconsviol =

(*maxabsconsviol, v);

8239

*maxrelconsviol =

(*maxrelconsviol, v);

8254

assert(ownerdata !=

);

8256 if

( ownerdata->auxvar ==

)

8269

origviol = auxvarlb - auxvarvalue;

8271

origviol = auxvarvalue - auxvarub;

8272 if

( origviol <= 0.0 )

8275

*maxvarboundviol =

(*maxvarboundviol, origviol);

8280 SCIPinfoMessage

(

, enfologfile,

" var >= lb violated by %g"

, auxvarlb - auxvarvalue);

8282 SCIPinfoMessage

(

, enfologfile,

" var <= ub violated by %g"

, auxvarvalue - auxvarub);

8295 if

( auxvarlb - auxvarvalue > *maxvarboundviol && !

SCIPisInfinity

(

, -auxvarlb) )

8296

*maxvarboundviol = auxvarlb - auxvarvalue;

8297 else if

( auxvarvalue - auxvarub > *maxvarboundviol && !

SCIPisInfinity

(

, auxvarub) )

8298

*maxvarboundviol = auxvarvalue - auxvarub;

8303 if

( origviol > 0.0 || auxvarlb > auxvarvalue || auxvarub < auxvarvalue )

8310 if

( origviol > 0.0 )

8311 SCIPinfoMessage

(

, enfologfile,

" auxvar %s expr violated by %g"

, violunder ?

">="

"<="

, origviol);

8313 SCIPinfoMessage

(

, enfologfile,

" auxvar >= auxvar's lb violated by %g"

, auxvarlb - auxvarvalue);

8315 SCIPinfoMessage

(

, enfologfile,

" auxvar <= auxvar's ub violated by %g"

, auxvarvalue - auxvarub);

8321 if

( origviol == 0.0 )

8325 for

( e = 0; e < ownerdata->nenfos; ++e )

8333

nlhdlr = ownerdata->enfos[e]->nlhdlr;

8334

assert(nlhdlr !=

);

8337 SCIP_CALL

( SCIPnlhdlrEvalaux(

, nlhdlr, expr, ownerdata->enfos[e]->nlhdlrexprdata, &ownerdata->enfos[e]->auxvalue, sol) );

8343 if

( auxviol > 0.0 )

8345 ENFOLOG

(

(

, enfologfile,

" auxvar %s nlhdlr-expr violated by %g"

, violover ?

"<="

">="

, auxviol); )

8346

*maxauxviol =

(*maxauxviol, auxviol);

8347

*minauxviol =

(*minauxviol, auxviol);

8389

assert(conshdlr !=

);

8394 for

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

8410

&minauxviol, &maxauxviol, &maxvarboundviol) );

8413 "auxviolations in %g..%g, variable bounds violated by at most %g, LP feastol=%e\n"

8430 if

( branchintegral )

8439 if

( conshdlrdata->propinenforce )

8448

*result = propresult;

8460

++conshdlrdata->ntightenlp;

8476

++conshdlrdata->ntightenlp;

8506

++conshdlrdata->ntightenlp;

8528

++conshdlrdata->ndesperatetightenlp;

8538 if

( !conshdlrdata->propinenforce )

8547

*result = propresult;

8560

++conshdlrdata->ndesperatebranch;

8575 ENFOLOG

(

(

, enfologfile,

" enforcement with max. violation %g failed; cutting off node\n"

, maxabsconsviol); )

8580

++conshdlrdata->ndesperatecutoff;

8605 for

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

8607

assert(conss[c] !=

);

8643

assert(conshdlrdata !=

);

8645

idx = ((int)(

size_t

)elem) - 1;

8646

assert(idx >= 0 && idx < conshdlrdata->nbilinterms);

8648 return

(

void

*)&conshdlrdata->bilinterms[idx];

8661

assert(entry1->

&& entry1->

);

8662

assert(entry2->

&& entry2->

);

8666 return

entry1->

== entry2->

&& entry1->

== entry2->

;

8676

assert(entry->

&& entry->

);

8697 if

( compvars != 0 )

8701 for

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

8703 if

( auxexpr1->

[i] != auxexpr2->

[i] )

8704 return

auxexpr1->

[i] < auxexpr2->

[i] ? -1 : 1;

8707 return

auxexpr1->

< auxexpr2->

? -1 : auxexpr1->

== auxexpr2->

? 0 : 1;

8739 if

( term->

nauxexprs

>= conshdlrdata->bilinmaxnauxexprs )

8746 for

( i = term->

nauxexprs

; i > pos; --i )

8750

term->

aux

exprs

[pos] = auxexpr;

8777

assert(conss !=

|| nconss == 0);

8783

assert(conshdlrdata !=

);

8786 if

( conshdlrdata->bilinterms !=

)

8795 for

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

8800

assert(conss !=

&& conss[c] !=

);

8802

assert(consdata !=

);

8855

assert(conshdlr !=

);

8856

assert(

);

8857

assert(

);

8858

assert(nlockspos >= 0);

8859

assert(nlocksneg >= 0);

8862

assert(conshdlrdata !=

);

8876

assert(conshdlrdata->bilinterms[*idx].x ==

);

8877

assert(conshdlrdata->bilinterms[*idx].y ==

);

8880

term = &conshdlrdata->bilinterms[*idx];

8881

assert(existing <= term->existing);

8890

*idx = conshdlrdata->nbilinterms;

8893

term = &conshdlrdata->bilinterms[*idx];

8894

assert(term !=

);

8908

++(conshdlrdata->nbilinterms);

8911 if

( conshdlrdata->bilinhashtable ==

)

8914

bilinearTermsGetHashkey, bilinearTermsIsHashkeyEq, bilinearTermsGetHashkeyVal,

8915

(

void

*)conshdlrdata) );

8917

assert(conshdlrdata->bilinhashtable !=

);

8942

assert(conshdlrdata !=

);

8945 if

( conshdlrdata->bilinterms ==

)

8947

assert(conshdlrdata->bilinterms ==

);

8948

assert(conshdlrdata->nbilinterms == 0);

8949

assert(conshdlrdata->bilintermssize == 0);

8955 for

( i = 0; i < conshdlrdata->nbilinterms; ++i )

8960 for

( j = 0; j < conshdlrdata->bilinterms[i].nauxexprs; ++j )

8962 if

( conshdlrdata->bilinterms[i].aux.exprs[j]->auxvar !=

)

8969 if

( conshdlrdata->bilinterms[i].nauxexprs > 0 )

8978 if

( conshdlrdata->bilinterms[i].aux.var !=

)

8985 if

( conshdlrdata->bilinhashtable !=

)

8992

conshdlrdata->nbilinterms = 0;

8993

conshdlrdata->bilintermssize = 0;

9023

assert(lp !=

);

9027 SCIPdebugMsg

(

"Building LP for computing facets of convex envelope of vertex-polyhedral function\n"

);

9032

nrows = (

unsigned

int)nvars + 1;

9034

nnonz = (ncols * (nrows + 1)) / 2;

9045 for

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

9061 if

( (

& i) != 0 )

9079

ind[k] = (int)nrows - 1;

9081 SCIPdebugMsg

(

" val[%u][%u] = 1 (position %u)\n"

, nrows - 1, i, k);

9088

assert(nrows <= ncols);

9090

(

int

)ncols, obj, lb, ub,

9091

(

int

)nrows, lb, lb,

9092

(

int

)nnonz, beg, ind, val) );

9095

ind[0] = (int)nrows - 1;

9132 unsigned int

ncorners;

9136

assert(funvals !=

);

9137

assert(box !=

);

9138

assert(nonfixedpos !=

);

9139

assert(facetcoefs !=

);

9145

facetval = facetconstant;

9146 for

( i = 0; i < (

unsigned

int) nallvars; ++i )

9147

facetval += facetcoefs[i] * box[2*i];

9150

funval = funvals[0];

9152

error = funval - facetval;

9154

error = facetval - funval;

9157

maxerror =

(error, maxerror);

9160 for

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

9167

gray = i ^ (i >> 1);

9172 while

( (diff >>= 1) != 0 )

9174

assert(pos < (

unsigned int

)nvars);

9176

origpos = nonfixedpos[pos];

9179

facetval += facetcoefs[origpos] * (box[2*origpos+1] - box[2*origpos]);

9181

facetval -= facetcoefs[origpos] * (box[2*origpos+1] - box[2*origpos]);

9184

funval = funvals[gray];

9186

error = funval - facetval;

9188

error = facetval - funval;

9191

maxerror =

(error, maxerror);

9231

assert(conshdlr !=

);

9232

assert(xstar !=

);

9233

assert(box !=

);

9234

assert(nonfixedpos !=

);

9235

assert(funvals !=

);

9238

assert(success !=

);

9239

assert(facetcoefs !=

);

9240

assert(facetconstant !=

);

9245

assert(conshdlrdata !=

);

9247 if

( conshdlrdata->vp_randnumgen ==

&& conshdlrdata->vp_maxperturb > 0.0 )

9253 if

( conshdlrdata->vp_lp[nvars] ==

)

9257

lp = conshdlrdata->vp_lp[nvars];

9258

assert(lp !=

);

9275 for

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

9280 for

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

9289

varpos = nonfixedpos[i];

9290

lb = box[2 * varpos];

9291

ub = box[2 * varpos + 1];

9292

solval = xstar[varpos];

9294 if

( ub - lb < mindomwidth )

9295

mindomwidth = ub - lb;

9300 else if

( solval >= ub )

9303

aux[i] = (solval - lb) / (ub - lb);

9306 if

( conshdlrdata->vp_maxperturb > 0.0 )

9308

assert(conshdlrdata->vp_randnumgen !=

);

9310 if

( aux[i] == 1.0 )

9311

aux[i] -=

SCIPrandomGetReal

(conshdlrdata->vp_randnumgen, 0.0, conshdlrdata->vp_maxperturb);

9312 else if

( aux[i] == 0.0 )

9313

aux[i] +=

SCIPrandomGetReal

(conshdlrdata->vp_randnumgen, 0.0, conshdlrdata->vp_maxperturb);

9318

perturbation =

( aux[i], 1.0 - aux[i] ) / 2.0;

9319

perturbation =

( perturbation, conshdlrdata->vp_maxperturb );

9320

aux[i] +=

SCIPrandomGetReal

(conshdlrdata->vp_randnumgen, -perturbation, perturbation);

9322

assert(0.0 < aux[i] && aux[i] < 1.0);

9355 if

( conshdlrdata->vp_dualsimplex )

9382 for

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

9383

facetcoefs[nonfixedpos[i]] = aux[i];

9385

*facetconstant = aux[nrows - 1];

9389 for

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

9403 for

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

9409

varpos = nonfixedpos[i];

9410

lb = box[2 * varpos];

9411

ub = box[2 * varpos + 1];

9415

facetcoefs[varpos] = facetcoefs[varpos] / (ub - lb);

9418

*facetconstant -= facetcoefs[varpos] * lb;

9421

facetvalue += facetcoefs[varpos] * xstar[varpos];

9428

facetvalue += *facetconstant;

9437 if

( overestimate == (facetvalue > targetvalue) )

9439 SCIPdebugMsg

(

"missed the target, facetvalue %g targetvalue %g, overestimate=%u\n"

, facetvalue, targetvalue, overestimate);

9476

assert(success !=

);

9477

assert(facetcoef !=

);

9478

assert(facetconstant !=

);

9480

*facetcoef = (funright - funleft) / (right - left);

9481

*facetconstant = funleft - *facetcoef * left;

9513

assert(alpha !=

);

9514

assert(beta !=

);

9515

assert(gamma_ !=

);

9516

assert(delta !=

);

9518

*alpha = -b3*c2 + a3*(-b2+c2) + a2*(b3-c3) + b2*c3;

9519

*beta = -(-b3*c1 + a3*(-b1+c1) + a1*(b3-c3) + b1*c3);

9520

*gamma_ = -a2*b1 + a1*b2 + a2*c1 - b2*c1 - a1*c2 + b1*c2;

9521

*delta = -a3*b2*c1 + a2*b3*c1 + a3*b1*c2 - a1*b3*c2 - a2*b1*c3 + a1*b2*c3;

9538 if

( !

(

, *alpha * a1 + *beta * a2 - *delta, -*gamma_ * a3) ||

9539

(

, *alpha * b1 + *beta * b2 - *delta, -*gamma_ * b3) ||

9540

(

, *alpha * c1 + *beta * c2 - *delta, -*gamma_ * c3) )

9568 SCIPdebugMsg

(

"numerical troubles - try to solve the linear system via an LU factorization\n"

);

9581 if

( !success || !

(

, *alpha * a1 + *beta * a2 - *delta, -*gamma_ * a3) ||

9582

(

, *alpha * b1 + *beta * b2 - *delta, -*gamma_ * b3) ||

9583

(

, *alpha * c1 + *beta * c2 - *delta, -*gamma_ * c3) )

9593 if

( *gamma_ < 0.0 )

9629

assert(success !=

);

9634

assert(facetcoefs !=

);

9635

assert(facetconstant !=

);

9640 if

( !overestimate )

9646

targetvalue = -targetvalue;

9649 SCIPdebugMsg

(

"p1 = (%g, %g), f(p1) = %g\n"

, p1[0], p1[1], p1val);

9650 SCIPdebugMsg

(

"p2 = (%g, %g), f(p2) = %g\n"

, p2[0], p2[1], p2val);

9651 SCIPdebugMsg

(

"p3 = (%g, %g), f(p3) = %g\n"

, p3[0], p3[1], p3val);

9652 SCIPdebugMsg

(

"p4 = (%g, %g), f(p4) = %g\n"

, p4[0], p4[1], p4val);

9663 for

( leaveout = 1; leaveout <= 4; ++leaveout )

9669 SCIP_CALL

(

(

, p2[0], p2[1], p2val, p3[0], p3[1], p3val, p4[0], p4[1], p4val,

9670

&alpha, &beta, &gamma_, &delta) );

9672 if

( alpha * p1[0] + beta * p1[1] + gamma_ * p1val - delta > 0.0 )

9678 SCIP_CALL

(

(

, p1[0], p1[1], p1val, p3[0], p3[1], p3val, p4[0], p4[1], p4val,

9679

&alpha, &beta, &gamma_, &delta) );

9681 if

( alpha * p2[0] + beta * p2[1] + gamma_ * p2val - delta > 0.0 )

9687 SCIP_CALL

(

(

, p1[0], p1[1], p1val, p2[0], p2[1], p2val, p4[0], p4[1], p4val,

9688

&alpha, &beta, &gamma_, &delta) );

9690 if

( alpha * p3[0] + beta * p3[1] + gamma_ * p3val - delta > 0.0 )

9696 SCIP_CALL

(

(

, p1[0], p1[1], p1val, p2[0], p2[1], p2val, p3[0], p3[1], p3val,

9697

&alpha, &beta, &gamma_, &delta) );

9699 if

( alpha * p4[0] + beta * p4[1] + gamma_ * p4val - delta > 0.0 )

9721 SCIPdebugMsg

(

"alpha = %g, beta = %g, gamma = %g, delta = %g\n"

, alpha, beta, gamma_, delta);

9724

xstarval = -alpha/gamma_ * xstar[0] -beta/gamma_ * xstar[1] + delta/gamma_;

9727 if

( xstarval <= targetvalue && (!*success || xstarval < candxstarval) )

9730 if

( !overestimate )

9733

facetcoefs[0] = -alpha/gamma_;

9734

facetcoefs[1] = -beta/gamma_;

9735

*facetconstant = delta/gamma_;

9738

candxstarval = xstarval;

9757

assert(openidx !=

);

9758

assert(maxnelems !=

);

9760 if

( nelems > *maxnelems )

9765

assert(newsize >= nelems);

9769

*maxnelems = newsize;

9786

assert(vars !=

);

9787

assert(vals !=

);

9788

assert(maxnelems !=

);

9790 if

( nelems > *maxnelems )

9795

assert(newsize > *maxnelems);

9800

*maxnelems = newsize;

9845

assert(expr !=

);

9847

assert(graph !=

);

9849

assert(consvars !=

);

9850

assert(consvals !=

);

9851

assert(maxnconsvars !=

);

9852

assert(*maxnconsvars > 0);

9853

assert(handledexprs !=

);

9854

assert(success !=

);

9860 if

( nchildren != 2 )

9870 for

( childidx = 0; childidx < 2; ++childidx )

9873

(*consvals)[0] = 1.0;

9888 if

( childidx == 0 )

9890

var1 = (*consvars)[0];

9891

val1 = (*consvals)[0];

9895

var2 = (*consvars)[0];

9896

val2 = (*consvals)[0];

9899

assert(var1 !=

);

9900

assert(var2 !=

);

9907

assert(symdata !=

);

9925

prodval = coef * val1 * val2;

9964

assert(expr !=

);

9965

assert(hasvalue !=

);

9966

assert(value !=

);

9975

assert(symdata !=

);

9998

assert(symdata !=

);

10009

safeexponent = (int) (exponent + 0.5);

10010 if

( safeexponent % 2 != 0 )

10020

*hasvalue =

;

10036

assert(var !=

);

10065 int

* maxnconsvars,

10078

assert(evenopexpr !=

);

10079

assert(child !=

);

10081

assert(cons !=

);

10082

assert(graph !=

);

10083

assert(parentidx >= 0);

10084

assert(consvars !=

);

10085

assert(consvals !=

);

10086

assert(maxnconsvars !=

);

10087

assert(success !=

);

10093

(*consvars)[0] = var;

10094

(*consvals)[0] = 1.0;

10110

var = (*consvars)[0];

10111

edgeweight = (*consvals)[0];

10122 TRUE

, edgeweight) );

10124 TRUE

, edgeweight) );

10150 int

* maxnconsvars,

10165

assert(evenopexpr !=

);

10166

assert(child !=

);

10168

assert(cons !=

);

10169

assert(graph !=

);

10170

assert(parentidx >= 0);

10171

assert(consvars !=

);

10172

assert(consvals !=

);

10173

assert(maxnconsvars !=

);

10174

assert(handledexprs !=

);

10175

assert(success !=

);

10184 for

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

10202

assert(nlocvars > 0);

10204

var = (*consvars)[0];

10208 if

( nlocvars == 2 )

10210

var = (*consvars)[1];

10233 if

( nlocvars == 1 )

10235

var = (*consvars)[0];

10236

weight = (*consvals)[0];

10257 for

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

10259

var = (*consvars)[i];

10260

weight =

ABS

((*consvals)[i]);

10289 int

* maxnconsvars,

10299

assert(expr !=

);

10300

assert(graph !=

);

10302

assert(consvars !=

);

10303

assert(consvals !=

);

10304

assert(maxnconsvars !=

);

10305

assert(*maxnconsvars > 0);

10306

assert(handledexprs !=

);

10307

assert(success !=

);

10329

hasval, val, consvars, consvals, maxnconsvars, success) );

10334

hasval, val, consvars, consvals, maxnconsvars, handledexprs, success) );

10357

assert(var1 !=

);

10358

assert(var2 !=

);

10387 return

(ub + lb) / 2;

10400 int

* maxnconsvars,

10421 int

* powperm =

;

10422 int

* prodperm =

;

10433 int

nprodexprs = 0;

10437

assert(sumexpr !=

);

10438

assert(cons !=

);

10440

assert(consvars !=

);

10441

assert(consvals !=

);

10442

assert(maxnconsvars !=

);

10443

assert(*maxnconsvars > 0);

10444

assert(handledexprs !=

);

10457 for

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

10464 if

( powcoef == 0 )

10480

assert(symdata !=

);

10493

powexprs[npowexprs] = children[i];

10494

powvars[npowexprs++] = var;

10500 if

( powcoef == 0 )

10522

prodexprs[nprodexprs] = children[i];

10523

prodvars[nprodexprs++] = var;

10524

prodexprs[nprodexprs] = children[i];

10525

prodvars[nprodexprs++] = var2;

10530 if

( npowexprs == 0 || nprodexprs != npowexprs )

10537 SCIPsort

(powperm, SCIPsortVarPtr, (

void

*) powvars, npowexprs);

10538 SCIPsort

(prodperm, SCIPsortVarPtr, (

void

*) prodvars, npowexprs);

10540 for

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

10547

assert(npowexprs % 2 == 0);

10553 for

( i = 0; i <

; ++i )

10558

(*consvals)[0] = 1.0;

10559

(*consvars)[0] = prodvars[cnt++];

10566 if

( nlocvars != 1 )

10571

actvar = (*consvars)[0];

10572

val = (*consvals)[0];

10574

(*consvals)[0] = 1.0;

10575

(*consvars)[0] = prodvars[cnt++];

10582 if

( nlocvars != 1 )

10584

actvar2 = (*consvars)[0];

10585

val2 = (*consvals)[0];

10618 for

( j = 0; j < npowexprs && !(var1found && var2found); ++j )

10620 if

( powexprused[j] )

10624 if

( !var1found && powvars[j] == prodvars[cnt - 2] )

10627

powexprused[j] =

;

10630 else if

( !var2found && powvars[j] == prodvars[cnt - 1] )

10633

powexprused[j] =

;

10683

assert(cons !=

);

10684

assert(graph !=

);

10685

assert(success !=

);

10692

assert(rootexpr !=

);

10696

assert(expr !=

);

10752 if

( expr == rootexpr )

10753

parentidx = consnodeidx;

10756

assert(nopenidx >= 1);

10757

parentidx = openidx[nopenidx - 1];

10761

hasparentcoef =

;

10762 if

( expr != rootexpr )

10773

openidx[nopenidx++] = -1;

10775

assert(maxnconsvars > 0);

10776

assert(parentidx > 0);

10779 if

( hasparentcoef )

10784

parentidx = nodeidx;

10804

parentidx = thisidx;

10807

nconsvars, constant) );

10811

assert(parentidx > 0);

10820

openidx[nopenidx++] = -1;

10826

assert(expr == rootexpr || parentidx > 0);

10838

usedefaultgadget =

;

10877

&consvars, &consvals, &maxnconsvars, handledexprs) );

10881

openidx[nopenidx++] = sumidx;

10888

parentcoef, &consvars, &consvals, &maxnconsvars, handledexprs, &succ) );

10892

usedefaultgadget =

;

10902

&consvars, &consvals, &maxnconsvars, handledexprs, &succ) );

10906

usedefaultgadget =

;

10911 if

( usedefaultgadget )

10926

assert(symdata !=

);

10941

openidx[nopenidx++] = opidx;

10970

assert(conshdlr !=

);

10971

assert(valid !=

);

10978

assert(targetconshdlr !=

);

10979

assert(targetconshdlr != conshdlr);

10982

assert(sourceconshdlrdata !=

);

10985 for

( i = 0; i < sourceconshdlrdata->nnlhdlrs; ++i )

10987 SCIP_CALL

( SCIPnlhdlrCopyhdlr(

, targetconshdlr, conshdlr, sourceconshdlrdata->nlhdlrs[i]) );

11003

assert(conshdlrdata !=

);

11006 for

( i = 0; i < conshdlrdata->nnlhdlrs; ++i )

11009

assert(conshdlrdata->nlhdlrs[i] ==

);

11012

conshdlrdata->nlhdlrssize = 0;

11015 for

( i = 0; i < conshdlrdata->nconsupgrades; ++i )

11017

assert(conshdlrdata->consupgrades[i] !=

);

11026 if

( conshdlrdata->vp_randnumgen !=

)

11032 if

( conshdlrdata->vp_lp[i] !=

)

11038

assert(conshdlrdata->branchrandnumgen ==

);

11058

assert(conshdlrdata !=

);

11061

conshdlrdata->lastboundrelax = ++conshdlrdata->curboundstag;

11063

conshdlrdata->enforound = 1;

11065

conshdlrdata->auxvarid = 0;

11067 for

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

11074 if

( conshdlrdata->nnlhdlrs > 1 )

11075 SCIPsortDownPtr

((

void

**)conshdlrdata->nlhdlrs, SCIPnlhdlrComp, conshdlrdata->nnlhdlrs);

11082 for

( i = 0; i < conshdlrdata->nnlhdlrs; ++i )

11084 SCIP_CALL

( SCIPnlhdlrInit(

, conshdlrdata->nlhdlrs[i]) );

11088

conshdlrdata->nweaksepa = 0;

11089

conshdlrdata->ntightenlp = 0;

11090

conshdlrdata->ndesperatebranch = 0;

11091

conshdlrdata->ndesperatecutoff = 0;

11092

conshdlrdata->ndesperatetightenlp = 0;

11093

conshdlrdata->nforcelp = 0;

11095

conshdlrdata->ncanonicalizecalls = 0;

11098 ENFOLOG

( enfologfile = fopen(ENFOLOGFILE,

"w"

); )

11114

assert(conshdlrdata !=

);

11120 SCIPsortDownPtr

((

void

**)consssorted, compIndexConsNonlinear, nconss);

11122 for

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

11131

conshdlrdata->subnlpheur =

;

11132

conshdlrdata->trysolheur =

;

11134 if

( conshdlrdata->vp_randnumgen !=

)

11140 if

( conshdlrdata->vp_lp[i] !=

)

11146 if

( conshdlrdata->branchrandnumgen !=

)

11150 for

( i = 0; i < conshdlrdata->nnlhdlrs; ++i )

11152 SCIP_CALL

( SCIPnlhdlrExit(

, conshdlrdata->nlhdlrs[i]) );

11156 if

( enfologfile !=

)

11158

fclose(enfologfile);

11159

enfologfile =

;

11167#ifdef SCIP_DISABLED_CODE 11171 SCIPerrorMessage

(

"method of nonlinear constraint handler not implemented yet\n"

);

11177#define consInitpreNonlinear NULL 11233

assert(conshdlrdata !=

);

11236 for

( i = 0; i < conshdlrdata->nnlhdlrs; ++i )

11242 if

( conshdlrdata->branchpscostweight > 0.0 )

11245 if

( strchr(

"lds"

, conshdlrdata->branchpscostupdatestrategy) ==

)

11247 SCIPerrorMessage

(

"branching/lpgainnormalize strategy %c unknown\n"

, conshdlrdata->branchpscostupdatestrategy);

11266

assert(conshdlrdata !=

);

11272

conshdlrdata->checkedvarlocks =

;

11275 if

( conshdlrdata->newsoleventfilterpos >= 0 )

11280

assert(eventhdlr !=

);

11283

conshdlrdata->newsoleventfilterpos = -1;

11294

assert(consdata !=

);

11295

assert(*consdata !=

);

11296

assert((*consdata)->expr !=

);

11299

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

11300

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

11308 if

( (*consdata)->nlrow !=

)

11327

assert(sourcedata !=

);

11331

assert(targetexpr !=

);

11335

targetexpr, sourcedata->lhs, sourcedata->rhs,

11362

assert(conshdlrdata !=

);

11365 if

( conshdlrdata->linearizeheursol !=

'o'

&& conshdlrdata->newsoleventfilterpos == -1 )

11370

assert(eventhdlr !=

);

11373

eventhdlr, (

SCIP_EVENTDATA

*)conshdlr, &conshdlrdata->newsoleventfilterpos) );

11440 for

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

11459

*result = propresult;

11467 SCIPdebugMsg

(

"registered %d external branching candidates\n"

, nnotify);

11472 SCIPdebugMsg

(

"could not find branching candidates, forcing to solve LP\n"

);

11492

assert(conshdlr !=

);

11493

assert(conss !=

|| nconss == 0);

11494

assert(result !=

);

11497

assert(conshdlrdata !=

);

11506

maypropfeasible =

;

11509 for

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

11511

assert(conss !=

&& conss[c] !=

);

11520

assert(consdata !=

);

11537 else if

( (conshdlrdata->subnlpheur ==

|| sol ==

) && !maypropfeasible && !completely )

11545

maypropfeasible =

;

11547 if

( maypropfeasible )

11554 if

( !(consdata->linvarincr !=

&& consdata->linvarincrcoef > 0.0) &&

11555

!(consdata->linvardecr !=

&& consdata->linvardecrcoef < 0.0) )

11556

maypropfeasible =

;

11564 if

( !(consdata->linvarincr !=

&& consdata->linvarincrcoef < 0.0) &&

11565

!(consdata->linvardecr !=

&& consdata->linvardecrcoef > 0.0) )

11566

maypropfeasible =

;

11599

assert(nchgbds >= 0);

11624

assert(conshdlrdata !=

);

11672 for

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

11698

&& !conshdlrdata->checkedvarlocks && conshdlrdata->checkvarlocks !=

'd'

)

11703

conshdlrdata->checkedvarlocks =

;

11705 for

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

11707 int

tmpnchgvartypes = 0;

11708 int

tmpnaddconss = 0;

11711 SCIPdebugMsg

(

"presolSingleLockedVars() for %s: nchgvartypes=%d naddconss=%d infeas=%u\n"

11712 SCIPconsGetName

(conss[c]), tmpnchgvartypes, tmpnaddconss, infeasible);

11716 SCIPdebugMsg

(

"presolSingleLockedVars() detected infeasibility\n"

);

11721

(*nchgvartypes) += tmpnchgvartypes;

11722

(*naddconss) += tmpnaddconss;

11726 if

( *ndelconss > 0 || *nchgbds > 0 || *nupgdconss > 0 || *naddconss > 0 || *nchgvartypes > 0 )

11736#ifdef SCIP_DISABLED_CODE 11740 SCIPerrorMessage

(

"method of nonlinear constraint handler not implemented yet\n"

);

11746#define consRespropNonlinear NULL 11758

assert(conshdlr !=

);

11759

assert(cons !=

);

11762

assert(consdata !=

);

11763

assert(consdata->expr !=

);

11771 if

( ownerdata->nenfos >= 0 )

11773 if

( (consdata->nlockspos == 0) != (nlockspos == 0) )

11774

reinitsolve =

;

11775 if

( (consdata->nlocksneg == 0) != (nlocksneg == 0) )

11776

reinitsolve =

;

11804

assert(consdata !=

);

11811 if

( !consdata->issimplified )

11819

assert(simplified !=

);

11820

consdata->expr = simplified;

11821

consdata->issimplified =

;

11826

assert(!replacedroot);

11835

assert(conshdlrdata !=

);

11852 if

( hashmapexpr !=

&& hashmapexpr != child )

11870

assert(consdata->nlockspos == 0);

11871

assert(consdata->nlocksneg == 0);

11882

assert(!infeasible);

11895

assert(conshdlrdata !=

);

11928

assert(conshdlrdata !=

);

11946

assert(conshdlrdata !=

);

11957#ifdef SCIP_DISABLED_CODE 11961 SCIPerrorMessage

(

"method of nonlinear constraint handler not implemented yet\n"

);

11967#define consDelvarsNonlinear NULL 11978

assert(consdata !=

);

11979

assert(consdata->expr !=

);

11991 if

(

SCIPisEQ

(

, consdata->lhs, consdata->rhs) )

12012

assert(cons !=

);

12015

assert(sourcedata !=

);

12018

assert(targetconshdlr !=

);

12020 SCIP_CALL

(

SCIPcopyExpr

(sourcescip,

, sourcedata->expr, &targetexpr, exprownerCreate, (

void

*)targetconshdlr, varmap, consmap, global, valid) );

12022 if

( targetexpr ==

)

12030

targetexpr, sourcedata->lhs, sourcedata->rhs,

12031

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

12034 if

( targetexpr !=

)

12056

assert(success !=

);

12057

assert(str !=

);

12058

assert(name !=

);

12059

assert(cons !=

);

12067

endptr = (

char

*)str;

12076 if

( isdigit((

unsigned char

)str[0]) || ((str[0] ==

'-'

|| str[0] ==

'+'

) && isdigit((

unsigned char

)str[1])) )

12088 if

( endptr[0] !=

'<'

|| endptr[1] !=

'='

)

12103 SCIPdebugMsg

(

"str should start at beginning of expr: %s\n"

, str);

12112 if

( strncmp(str,

"[free]"

, 6) == 0 )

12166

consexprtree, lhs, rhs,

12167

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

12168

assert(*cons !=

);

12186

assert(consdata !=

);

12192 if

( varssize < consdata->nvarexprs )

12198 for

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

12201

assert(vars[i] !=

);

12216

assert(consdata !=

);

12221

*nvars = consdata->nvarexprs;

12228#ifdef SCIP_DISABLED_CODE 12232 SCIPerrorMessage

(

"method of nonlinear constraint handler not implemented yet\n"

);

12238#define consGetDiveBdChgsNonlinear NULL 12267

assert(conshdlr !=

);

12270

assert(conshdlrdata !=

);

12273 SCIPinfoMessage

(

, file,

"Nonlinear Conshdlr : %10s %10s %10s %10s %10s %10s %10s\n"

"WeakSepa"

"TightenLP"

"DespTghtLP"

"DespBranch"

"DespCutoff"

"ForceLP"

"CanonTime"

);

12297

assert(conshdlr !=

);

12304

assert(conshdlrdata !=

);

12324

assert(conshdlr !=

);

12327

assert(conshdlrdata !=

);

12333 for

( i = 0; i < conshdlrdata->nnlhdlrs; ++i )

12336

assert(nlhdlr !=

);

12367

conshdlrdata->intevalvar = intEvalVarBoundTightening;

12368

conshdlrdata->curboundstag = 1;

12369

conshdlrdata->lastboundrelax = 1;

12370

conshdlrdata->curpropboundstag = 1;

12371

conshdlrdata->newsoleventfilterpos = -1;

12382

conshdlrCopyNonlinear,

12383

consFreeNonlinear, consInitNonlinear, consExitNonlinear,

12385

consDeleteNonlinear, consTransNonlinear, consInitlpNonlinear,

12386

consSepalpNonlinear, consSepasolNonlinear, consEnfolpNonlinear, consEnforelaxNonlinear, consEnfopsNonlinear, consCheckNonlinear,

12388

consActiveNonlinear, consDeactiveNonlinear,

12390

consPrintNonlinear, consCopyNonlinear, consParseNonlinear,

12392

consGetSignedPermsymGraphNonlinear, conshdlrdata) );

12397 "limit on number of propagation rounds for a set of constraints within one round of SCIP propagation"

12398

&conshdlrdata->maxproprounds,

, 10, 0, INT_MAX,

) );

12401 "whether to check bounds of all auxiliary variable to seed reverse propagation"

12405 "strategy on how to relax variable bounds during bound tightening: relax (n)ot, relax by (a)bsolute value, relax always by a(b)solute value, relax by (r)relative value"

12406

&conshdlrdata->varboundrelax,

'r'

"nabr"

) );

12409 "by how much to relax variable bounds during bound tightening if strategy 'a', 'b', or 'r'"

12413 "by how much to relax constraint sides during bound tightening"

12417 "maximal relative perturbation of reference point when computing facet of envelope of vertex-polyhedral function (dim>2)"

12421 "adjust computed facet of envelope of vertex-polyhedral function up to a violation of this value times LP feasibility tolerance"

12425 "whether to use dual simplex instead of primal simplex for LP that computes facet of vertex-polyhedral function"

12429 "maximal number of auxiliary expressions per bilinear term"

12433 "whether to reformulate products of binary variables during presolving"

12437 "whether to use the AND constraint handler for reformulating binary products"

12441 "minimum number of terms to reformulate bilinear binary products by factorizing variables (<= 1: disabled)"

12442

&conshdlrdata->reformbinprodsfac,

, 50, 1, INT_MAX,

) );

12445 "whether to forbid multiaggregation of nonlinear variables"

12449 "whether to tighten LP feasibility tolerance during enforcement, if it seems useful"

12453 "whether to (re)run propagation in enforcement"

12457 "threshold for when to regard a cut from an estimator as weak (lower values allow more weak cuts)"

12458

&conshdlrdata->weakcutthreshold,

, 0.2, 0.0, 1.0,

) );

12461 "\"strong\" cuts will be scaled to have their maximal coef in [1/strongcutmaxcoef,strongcutmaxcoef]"

12465 "consider efficacy requirement when deciding whether a cut is \"strong\""

12469 "whether to force \"strong\" cuts in enforcement"

12473 "an expression will be enforced if the \"auxiliary\" violation is at least this factor times the \"original\" violation"

12474

&conshdlrdata->enfoauxviolfactor,

, 0.01, 0.0, 1.0,

) );

12477 "retry enfo of constraint with weak cuts if violation is least this factor of maximal violated constraints"

12478

&conshdlrdata->weakcutminviolfactor,

, 0.5, 0.0, 2.0,

) );

12481 "whether to make rows to be non-removable in the node where they are added (can prevent some cycling): 'o'ff, in 'e'nforcement only, 'a'lways"

12482

&conshdlrdata->rownotremovable,

'o'

"oea"

) );

12485 "method how to scale violations to make them comparable (not used for feasibility check): (n)one, (a)ctivity and side, norm of (g)radient"

12486

&conshdlrdata->violscale,

'n'

"nag"

) );

12489 "whether variables contained in a single constraint should be forced to be at their lower or upper bounds ('d'isable, change 't'ype, add 'b'ound disjunction)"

12490

&conshdlrdata->checkvarlocks,

't'

"bdt"

) );

12493 "from which depth on in the tree to allow branching on auxiliary variables (variables added for extended formulation)"

12494

&conshdlrdata->branchauxmindepth,

, INT_MAX, 0, INT_MAX,

) );

12497 "whether to use external branching candidates and branching rules for branching"

12501 "consider a constraint highly violated if its violation is >= this factor * maximal violation among all constraints"

12502

&conshdlrdata->branchhighviolfactor,

, 0.0, 0.0, 1.0,

) );

12505 "consider a variable branching score high if its branching score >= this factor * maximal branching score among all variables"

12506

&conshdlrdata->branchhighscorefactor,

, 0.9, 0.0, 1.0,

) );

12509 "weight by how much to consider the violation assigned to a variable for its branching score"

12513 "weight by how much to consider fractionality of integer variables in branching score for spatial branching"

12517 "weight by how much to consider the dual values of rows that contain a variable for its branching score"

12521 "weight by how much to consider the pseudo cost of a variable for its branching score"

12525 "weight by how much to consider the domain width in branching score"

12529 "weight by how much to consider variable type (continuous: 0, binary: 1, integer: 0.1, impl-integer: 0.01) in branching score"

12533 "how to aggregate several branching scores given for the same expression: 'a'verage, 'm'aximum, 's'um"

12534

&conshdlrdata->branchscoreagg,

's'

"ams"

) );

12537 "method used to split violation in expression onto variables: 'u'niform, 'm'idness of solution, 'd'omain width, 'l'ogarithmic domain width"

12538

&conshdlrdata->branchviolsplit,

'm'

"umdl"

) );

12541 "minimum pseudo-cost update count required to consider pseudo-costs reliable"

12545 "minimal average pseudo cost count for discrete variables at which to start considering spatial branching before branching on fractional integer variables"

12549 "whether tight linearizations of nonlinear constraints should be added to cutpool when some heuristics finds a new solution ('o'ff, on new 'i'ncumbents, on 'e'very solution)"

12550

&conshdlrdata->linearizeheursol,

'o'

"oie"

) );

12553 "whether to assume that any constraint is convex"

12558 "signals a bound change to a nonlinear constraint"

, processVarEvent,

) );

12559

assert(conshdlrdata->eventhdlr !=

);

12577

assert(parentdialog !=

);

12588

processNewSolutionEvent,

) );

12599 const char

* conshdlrname

12609

assert(conshdlrname !=

);

12610

assert(nlconsupgd !=

);

12614 if

( conshdlr ==

)

12621

assert(conshdlrdata !=

);

12624 for

( i = conshdlrdata->nconsupgrades - 1; i >= 0; --i )

12626 if

( conshdlrdata->consupgrades[i]->consupgd == nlconsupgd )

12629 SCIPwarningMessage

(

"Try to add already known upgrade method for constraint handler <%s>.\n"

, conshdlrname);

12637

consupgrade->consupgd = nlconsupgd;

12638

consupgrade->

priority

= priority;

12643

assert(conshdlrdata->nconsupgrades+1 <= conshdlrdata->consupgradessize);

12645 for

( i = conshdlrdata->nconsupgrades; i > 0 && conshdlrdata->consupgrades[i-1]->priority < consupgrade->

priority

; --i )

12646

conshdlrdata->consupgrades[i] = conshdlrdata->consupgrades[i-1];

12647

assert(0 <= i && i <= conshdlrdata->nconsupgrades);

12648

conshdlrdata->consupgrades[i] = consupgrade;

12649

conshdlrdata->nconsupgrades++;

12699 if

( conshdlr ==

)

12707

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

12777

assert(nlinvars == 0 || (linvars !=

&& lincoefs !=

));

12778

assert(nquadterms == 0 || (quadvars1 !=

&& quadvars2 !=

&& quadcoefs !=

));

12782 if

( conshdlr ==

)

12789 SCIP_CALL

(

SCIPcreateExprQuadratic

(

, &expr, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, exprownerCreate, (

void

*)conshdlr) );

12790

assert(expr !=

SCIPcreateConsQuadraticNonlinear

);

12794

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

12825 SCIP_CALL

(

(

, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs,

12857

assert(vars !=

|| nvars == 0);

12860 for

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

12866 if

( offsets !=

&& offsets[i] != 0.0 )

12885

termcoefs[0] = 1.0;

12888

termcoefs[1] = -rhscoeff;

12926

assert(

);

12927

assert(z !=

);

12930 if

( xoffset != 0.0 )

12965

assert(conshdlr !=

);

12968 return

conshdlrdata->curboundstag;

12978

assert(conshdlr !=

);

12981 return

conshdlrdata->lastboundrelax;

12998

assert(conshdlrdata !=

);

13000

++conshdlrdata->curboundstag;

13001

assert(conshdlrdata->curboundstag > 0);

13004

conshdlrdata->lastboundrelax = conshdlrdata->curboundstag;

13012

assert(conshdlr !=

);

13041

assert(nlhdlr !=

);

13042

assert(cons !=

);

13043

assert(expr !=

);

13044

assert(rowprep !=

);

13045

assert(auxvar !=

);

13046

assert(result !=

);

13055

assert(conshdlrdata !=

);

13057

sepasuccess =

;

13060 if

( cutviol > 0.0 )

13081 if

( (!overestimate && ( cutviol <= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) ||

13082

( overestimate && (-cutviol >= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) )

13085 "weak: auxvarvalue %g estimateval %g auxvalue %g (over %d)\n"

13087

auxvarvalue + (overestimate ? -cutviol : cutviol), auxvalue, overestimate); )

13088

sepasuccess =

;

13093

estimateval = auxvarvalue + (!overestimate ? cutviol : -cutviol);

13097

sepasuccess =

;

13106 "estimateval %g auxvalue %g (over %d)\n "

SCIPnlhdlrGetName

(nlhdlr), auxvarvalue,

13107

auxvarvalue + (overestimate ? -cutviol : cutviol), auxvalue, overestimate);

13113 if

( !allowweakcuts )

13117 if

( !sepasuccess )

13125 "min requ viol = %g\n"

, cutviol, sepasuccess ?

""

"not "

, mincutviolation); )

13127

sepasuccess = cutviol > mincutviolation;

13151 if

( auxvarcoef == 0.0 ||

13152

(!overestimate && ( cutviol / auxvarcoef <= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) ||

13153

( overestimate && (-cutviol / auxvarcoef >= conshdlrdata->weakcutthreshold * (auxvalue - auxvarvalue))) )

13155 ENFOLOG

(

(

, enfologfile,

" cut is too weak after cleanup: auxvarvalue %g estimateval %g auxvalue %g (over %d)\n"

13156

auxvarvalue, auxvarvalue + (overestimate ? -cutviol : cutviol) / auxvarcoef, auxvalue, overestimate); )

13157

sepasuccess =

;

13168 if

( !branchscoresuccess )

13173 if

( !sepasuccess )

13186#ifdef BRSCORE_ABSVIOL 13211 if

( conshdlrdata->branchdualweight > 0.0 )

13218 else if

( !

SCIPisEQ

(

, auxvalue, estimateval) )

13222

(void) sprintf(gap,

"_estimategap=%g"

(auxvalue - estimateval));

13248 SCIP_CALL

(

SCIPaddRow

(

, row, conshdlrdata->forcestrongcut && !allowweakcuts && inenforcement, &infeasible) );

13251 if

( conshdlrdata->rownotremovable ==

'a'

|| (conshdlrdata->rownotremovable ==

'e'

&& inenforcement) )

13268 else if

( branchscoresuccess )

13281 "branching candidates%s\n"

SCIPnlhdlrGetName

(nlhdlr), (allowweakcuts && inenforcement) ?

13295

assert(conshdlr !=

);

13298

assert(conshdlrdata !=

);

13300 return

conshdlrdata->assumeconvex;

13315

assert(conshdlr !=

);

13316

assert(conss !=

|| nconss == 0);

13333

assert(conshdlr !=

);

13336

assert(conshdlrdata !=

);

13338 return

conshdlrdata->nbilinterms;

13352

assert(conshdlr !=

);

13355

assert(conshdlrdata !=

);

13357 return

conshdlrdata->bilinterms;

13375

assert(conshdlr !=

);

13376

assert(

);

13377

assert(

);

13380

assert(conshdlrdata !=

);

13382 if

( conshdlrdata->bilinhashtable ==

)

13398

assert(idx >= -1 && idx < conshdlrdata->nbilinterms);

13399

assert(idx < 0 || conshdlrdata->bilinterms[idx].

);

13400

assert(idx < 0 || conshdlrdata->bilinterms[idx].

);

13419

assert(conshdlr !=

);

13420

assert(

);

13421

assert(

);

13424

assert(conshdlrdata !=

);

13427

assert(idx >= -1 && idx < conshdlrdata->nbilinterms);

13431 return

&conshdlrdata->bilinterms[idx];

13447

assert(

);

13448

assert(

);

13449

assert(auxexpr !=

);

13471

assert(conshdlr !=

);

13474

assert(conshdlrdata !=

);

13478

term = &conshdlrdata->bilinterms[idx];

13479

assert(term !=

);

13484 if

( auxvar !=

)

13486

term->

aux

= auxvar;

13515

assert(conshdlr !=

);

13518

assert(conshdlrdata !=

);

13520

nlockspos = overestimate ? 1 : 0;

13521

nlocksneg = overestimate ? 0 : 1;

13525

term = &conshdlrdata->bilinterms[idx];

13526

assert(term !=

);

13536 if

( conshdlrdata->bilinmaxnauxexprs <= 1 )

13540

auxvarexpr->

= 0.0;

13541

auxvarexpr->

[0] = 1.0;

13542

auxvarexpr->

[1] = 0.0;

13543

auxvarexpr->

[2] = 0.0;

13561

auxexpr->

auxvar

= auxvar;

13562

auxexpr->

[0] = coefaux;

13563 if

( term->

)

13565

assert(term->

);

13566

auxexpr->

[1] = coefx;

13567

auxexpr->

[2] = coefy;

13571

assert(term->

);

13572

assert(term->

);

13573

auxexpr->

[1] = coefy;

13574

auxexpr->

[2] = coefx;

13576

auxexpr->

= cst;

13583 else if

( auxvar !=

)

13612 unsigned int

ncorners;

13617

assert(conshdlr !=

);

13618

assert(function !=

);

13619

assert(xstar !=

);

13620

assert(box !=

);

13621

assert(success !=

);

13622

assert(facetcoefs !=

);

13623

assert(facetconstant !=

);

13630 for

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

13634

nonfixedpos[nvars] = j;

13652 for

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

13655

corner[j] = (box[2 * j] + box[2 * j + 1]) / 2.0;

13657 for

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

13660 for

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

13662 int

varpos = nonfixedpos[j];

13666 if

( (i >> j) & 0x1 )

13667

corner[varpos] = box[2 * varpos + 1];

13669

corner[varpos] = box[2 * varpos ];

13674

funvals[i] = function(corner, nallvars, fundata);

13680 SCIPdebugMsg

(

"cannot compute underestimator; function value at corner is too large %g\n"

, funvals[i]);

13693 if

( *success && overestimate == (*facetconstant + facetcoefs[nonfixedpos[0]] * xstar[nonfixedpos[0]] > targetvalue) )

13695 SCIPdebugMsg

(

computeVertexPolyhedralFacetBivariate

"computed secant, but missed target %g (facetvalue=%g, overestimate=%u)\n"

, targetvalue, *facetconstant + facetcoefs[nonfixedpos[0]] * xstar[nonfixedpos[0]], overestimate);

13701 int

idx1 = nonfixedpos[0];

13702 int

idx2 = nonfixedpos[1];

13703 SCIP_Real

p1[2] = { box[2*idx1], box[2*idx2] };

13704 SCIP_Real

p2[2] = { box[2*idx1+1], box[2*idx2] };

13705 SCIP_Real

p3[2] = { box[2*idx1], box[2*idx2+1] };

13706 SCIP_Real

p4[2] = { box[2*idx1+1], box[2*idx2+1] };

13707 SCIP_Real

xstar2[2] = { xstar[idx1], xstar[idx2] };

13710 SCIP_CALL

(

(

computeVertexPolyhedralFacetLP

, overestimate, p1, p2, p3, p4, funvals[0], funvals[1], funvals[2], funvals[3], xstar2, targetvalue, success, coefs, facetconstant) );

13712

facetcoefs[idx1] = coefs[0];

13713

facetcoefs[idx2] = coefs[1];

13717 SCIP_CALL

(

(

, conshdlr, overestimate, xstar, box, nallvars, nonfixedpos, funvals, nvars, targetvalue, success, facetcoefs, facetconstant) );

13732 if

( maxfaceterror > 0.0 )

13741 for

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

13742

corner[nonfixedpos[j]] = (box[2 * nonfixedpos[j]] + box[2 * nonfixedpos[j] + 1]) / 2.0;

13743

midval = function(corner, nallvars, fundata);

13748

assert(conshdlrdata !=

);

13751 if

( maxfaceterror > conshdlrdata->vp_adjfacetthreshold * feastol * fabs(midval) )

13753 SCIPdebugMsg

(

"ignoring facet due to instability, it cuts off a vertex by %g (midval=%g).\n"

, maxfaceterror, midval);

13758 SCIPdebugMsg

(

"maximum facet error %g (midval=%g), adjust constant to make cut valid!\n"

, maxfaceterror, midval);

13760 if

( overestimate )

13761

*facetconstant += maxfaceterror;

13763

*facetconstant -= maxfaceterror;

13789

assert(cons !=

);

13793

assert(consdata !=

);

13795 return

consdata->expr;

13805

assert(cons !=

);

13809

assert(consdata !=

);

13811 return

consdata->lhs;

13821

assert(cons !=

);

13825

assert(consdata !=

);

13827 return

consdata->rhs;

13839

assert(cons !=

);

13840

assert(nlrow !=

);

13844

assert(consdata !=

);

13846 if

( consdata->nlrow ==

)

13850

assert(consdata->nlrow !=

);

13851

*nlrow = consdata->nlrow;

13866

assert(cons !=

);

13870

assert(consdata !=

);

13872 return

consdata->curv;

13890

assert(cons !=

);

13891

assert(isquadratic !=

);

13895

assert(consdata !=

);

13896

assert(consdata->expr !=

);

13902 if

( *isquadratic )

13921

assert(cons !=

);

13926 SCIPerrorMessage

(

"SCIPchgLhsNonlinear can only be called in problem stage.\n"

);

13934

assert(consdata !=

);

13936 if

( consdata->lhs == lhs )

13939

consdata->lhs = lhs;

13942

consdata->ispropagated =

;

13960

assert(cons !=

);

13965 SCIPerrorMessage

(

"SCIPchgLhsNonlinear can only be called in problem stage.\n"

);

13973

assert(consdata !=

);

13975 if

( consdata->rhs == rhs )

13978

consdata->rhs = rhs;

13981

consdata->ispropagated =

;

14000

assert(cons !=

);

14001

assert(expr !=

);

14005 SCIPerrorMessage

(

"SCIPchgExprNonlinear can only be called in problem stage.\n"

);

14013

assert(conshdlr !=

);

14017

assert(consdata !=

);

14018

assert(consdata->expr !=

);

14023

assert(consdata->nvarexprs == 0);

14024

assert(consdata->varexprs ==

);

14025

assert(!consdata->catchedevents);

14034

consdata->issimplified =

;

14035

consdata->ispropagated =

;

14056

assert(cons !=

);

14060 SCIPerrorMessage

(

"SCIPaddLinearVarNonlinear can only be called in problem stage.\n"

);

14071

assert(conshdlr !=

);

14075

assert(consdata !=

);

14076

assert(consdata->expr !=

);

14081

assert(consdata->nvarexprs == 0);

14082

assert(consdata->varexprs ==

);

14083

assert(!consdata->catchedevents);

14095 SCIP_EXPR

* children[2] = { consdata->expr, varexpr };

14107

consdata->issimplified =

;

14108

consdata->ispropagated =

;

14129

assert(cons !=

);

14133 SCIPerrorMessage

(

"SCIPaddExprNonlinear can only be called in problem stage.\n"

);

14144

assert(conshdlr !=

);

14148

assert(consdata !=

);

14149

assert(consdata->expr !=

);

14170 SCIP_EXPR

* children[2] = { consdata->expr, exprowned };

14182

consdata->issimplified =

;

14183

consdata->ispropagated =

;

14202

assert(cons !=

);

14203

assert(activity !=

);

14206

assert(consdata !=

);

14227

assert(cons !=

);

14228

assert(viol !=

);

14250

assert(cons !=

);

14251

assert(viol !=

);

14269

assert(cons !=

);

14270

assert(var !=

);

14271

assert(coef !=

);

14277

assert(consdata !=

);

14279

*var = consdata->linvardecr;

14280

*coef = consdata->linvardecrcoef;

14293

assert(cons !=

);

14294

assert(var !=

);

14295

assert(coef !=

);

14301

assert(consdata !=

);

14303

*var = consdata->linvarincr;

14304

*coef = consdata->linvarincrcoef;

14317

assert(expr !=

);

14328

assert(expr !=

);

14344

assert(expr !=

);

14347

assert(ownerdata !=

);

14349 return

ownerdata->filterpos >= -1 ?

SCIPgetVarExprVar

(expr) : ownerdata->auxvar;

14357

assert(expr !=

);

14377

assert(expr !=

);

14380

assert(ownerdata !=

);

14382

assert(idx < ownerdata->nenfos);

14383

assert(ownerdata->enfos[idx] !=

);

14384

assert(nlhdlr !=

);

14386

*nlhdlr = ownerdata->enfos[idx]->nlhdlr;

14388 if

( nlhdlrexprdata !=

)

14389

*nlhdlrexprdata = ownerdata->enfos[idx]->nlhdlrexprdata;

14391 if

( nlhdlrparticipation !=

)

14392

*nlhdlrparticipation = ownerdata->enfos[idx]->nlhdlrparticipation;

14394 if

( sepabelowusesactivity !=

)

14395

*sepabelowusesactivity = ownerdata->enfos[idx]->sepabelowusesactivity;

14397 if

( sepaaboveusesactivity !=

)

14398

*sepaaboveusesactivity = ownerdata->enfos[idx]->sepaaboveusesactivity;

14400 if

( auxvalue !=

)

14401

*auxvalue = ownerdata->enfos[idx]->auxvalue;

14413

assert(expr !=

);

14416

assert(ownerdata !=

);

14419

assert(idx < ownerdata->nenfos);

14420

assert(ownerdata->enfos[idx] !=

);

14422

ownerdata->enfos[idx]->auxvalue = auxvalue;

14433

assert(expr !=

);

14447

assert(expr !=

);

14461

assert(expr !=

);

14491

assert(expr !=

);

14494

assert(ownerdata !=

);

14498

useauxvar =

;

14500 if

( ownerdata->nenfos >= 0 &&

14501

( (ownerdata->nactivityusesprop == 0 && ownerdata->nactivityusessepa == 0 && (useactivityforprop || useactivityforsepabelow || useactivityforsepaabove)) ||

14502

(ownerdata->nauxvaruses == 0 && useauxvar)

14514

++ownerdata->nauxvaruses;

14516 if

( useactivityforprop )

14517

++ownerdata->nactivityusesprop;

14519 if

( useactivityforsepabelow || useactivityforsepaabove )

14520

++ownerdata->nactivityusessepa;

14525 if

( useactivityforsepabelow )

14527 if

( useactivityforsepaabove )

14530 if

( useactivityforprop )

14539 if

( (useactivityforsepabelow || useactivityforsepaabove) &&

SCIPexprGetNChildren

(expr) > 0 )

14581

assert(expr !=

);

14582

assert(viol !=

);

14616

assert(expr !=

);

14617

assert(viol !=

);

14648

assert(expr !=

);

14649

assert(viol !=

);

14683

assert(expr !=

);

14686

assert(ownerdata !=

);

14689

assert(conshdlrdata !=

);

14694 if

( ownerdata->propboundstag == conshdlrdata->curpropboundstag )

14696

bounds = ownerdata->propbounds;

14709 if

( ownerdata->auxvar !=

)

14714

auxvarbounds = conshdlrdata->intevalvar(

, ownerdata->auxvar, conshdlrdata);

14741

assert(expr !=

);

14742

assert(cutoff !=

);

14745

assert(ownerdata !=

);

14746

assert(ownerdata->conshdlr !=

);

14749

assert(conshdlrdata !=

);

14790 SCIPdebugMsg

(

" cut off due to new bounds being beyond infinity\n"

);

14797 if

( ownerdata->propboundstag == conshdlrdata->curpropboundstag )

14810 SCIPdebugMsg

(

" applied %s: [%.20g,%.20g]\n"

, ownerdata->propboundstag == conshdlrdata->curpropboundstag ?

"previous propbounds"

"activity"

, newbounds.

, newbounds.

);

14816 SCIPdebugMsg

(

" cut off due to empty intersection with previous propbounds or activity\n"

);

14828

ownerdata->propbounds = newbounds;

14829

ownerdata->propboundstag = conshdlrdata->curpropboundstag;

14843 SCIPdebugMsg

(

" new bounds [%g,%g] for expr %p not sufficiently tighter than activity -- not adding to propqueue or tightening auxvar\n"

, newbounds.

, newbounds.

, (

void

*)expr);

14848 if

(

SCIPexprGetNChildren

(expr) > 0 && !ownerdata->inpropqueue && (ownerdata->nactivityusesprop > 0 || ownerdata->nactivityusessepa > 0 || ownerdata->nenfos < 0) )

14857

ownerdata->inpropqueue =

;

14886

assert(expr !=

);

14889

assert(ownerdata !=

);

14902

assert(ownerdata !=

);

14904 for

( c = 0; c < ownerdata->nconss; ++c )

14907

assert(consdata !=

);

14908

consdata->ispropagated =

;

14938

assert(expr !=

);

14939

assert(violscore >= 0.0);

14942

assert(ownerdata !=

);

14945

assert(conshdlrdata !=

);

14953 if

( ownerdata->violscoretag != conshdlrdata->enforound )

14955

ownerdata->violscoresum = violscore;

14956

ownerdata->violscoremax = violscore;

14957

ownerdata->nviolscores = 1;

14958

ownerdata->violscoretag = conshdlrdata->enforound;

14962

ownerdata->violscoresum += violscore;

14963 if

( violscore > ownerdata->violscoremax )

14964

ownerdata->violscoremax = violscore;

14965

++ownerdata->nviolscores;

14990

assert(exprs !=

|| nexprs == 0);

14991

assert(success !=

);

15014 for

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

15018

assert(e !=

);

15023 if

( varssize == nvars )

15028

assert(varssize > nvars);

15030

varexprs[nvars++] = e;

15052

assert(expr !=

);

15055

assert(ownerdata !=

);

15058

assert(conshdlrdata !=

);

15060 if

( conshdlrdata->enforound != ownerdata->violscoretag )

15063 if

( ownerdata->nviolscores == 0 )

15066 switch

( conshdlrdata->branchscoreagg )

15070 return

ownerdata->violscoresum / ownerdata->nviolscores;

15074 return

ownerdata->violscoremax;

15078 return

ownerdata->violscoresum;

15081 SCIPerrorMessage

(

"Invalid value %c for branchscoreagg parameter\n"

, conshdlrdata->branchscoreagg);

15102

assert(expr !=

);

15103

assert(var !=

);

15117

assert(ownerdata !=

);

15120

assert(conshdlrdata !=

);

15126

assert(varexpr !=

);

15148

assert(expr !=

);

15149

assert(var !=

);

15160

assert(ownerdata !=

);

15163

assert(conshdlrdata !=

);

15172

assert(varexpr !=

);

15198

assert(expr !=

);

15203 for

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

15210 for

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

15222

auxvalue += (lincoef + sqrcoef * solval) * solval;

15226 for

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

15252 int

detectpriority,

15263

assert(nlhdlr !=

);

15264

assert(detect !=

);

15268 if

( conshdlr ==

)

15279

assert(conshdlrdata !=

);

15283

conshdlrdata->nlhdlrs[conshdlrdata->nnlhdlrs] = *nlhdlr;

15284

++conshdlrdata->nnlhdlrs;

15290 SCIPsortDownPtr

((

void

**)conshdlrdata->nlhdlrs, SCIPnlhdlrComp, conshdlrdata->nnlhdlrs);

15302

assert(conshdlr !=

);

15305

assert(conshdlrdata !=

);

15307 return

conshdlrdata->nnlhdlrs;

15317

assert(conshdlr !=

);

15320

assert(conshdlrdata !=

);

15322 return

conshdlrdata->nlhdlrs;

15334

assert(conshdlr !=

);

15335

assert(name !=

);

15338

assert(conshdlrdata !=

);

15340 for

(

= 0;

< conshdlrdata->nnlhdlrs; ++

)

15342 return

conshdlrdata->nlhdlrs[

];

15359

assert(nlhdlr !=

);

15360

assert(expr !=

);

15363

assert(ownerdata !=