RetroSearch Browse

);

290

assert(consanddata2 !=

);

301

consand1 = consanddata1->

;

302

consand2 = consanddata2->

;

306

consand1 = consanddata1->

origcons

;

307

consand2 = consanddata2->

origcons

;

351

assert(cdata1 !=

);

352

assert(cdata2 !=

);

354

assert(cdata1->

> 1);

356

assert(cdata2->

> 1);

360 for

( v = cdata1->

- 1; v > 0; --v )

363 for

( v = cdata2->

- 1; v > 0; --v )

376 for

( v = cdata1->

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

382 if

( cdata1->

[v] != cdata2->

[v] )

405

assert(cdata !=

);

407

assert(cdata->

> 1);

412 for

( v = cdata->

- 1; v > 0; --v )

420

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

434 if

( ((*conshdlrdata)->inithashmapandtable) )

436

assert((*conshdlrdata)->hashtable !=

);

437

assert((*conshdlrdata)->hashmap !=

);

442

assert((*conshdlrdata)->hashtable ==

);

443

assert((*conshdlrdata)->hashmap ==

);

448

hashGetKeyAndConsDatas, hashKeyEqAndConsDatas, hashKeyValAndConsDatas, (

void

) );

454

(*conshdlrdata)->inithashmapandtable =

;

467

assert(conshdlrdata !=

);

471

(*conshdlrdata)->allconsanddatas =

;

472

(*conshdlrdata)->nallconsanddatas = 0;

473

(*conshdlrdata)->sallconsanddatas = 10;

478

(*conshdlrdata)->inithashmapandtable =

;

479

(*conshdlrdata)->hashtable =

;

480

(*conshdlrdata)->hashtablesize = 0;

481

(*conshdlrdata)->hashmap =

;

482

(*conshdlrdata)->hashmapsize = 0;

485

(*conshdlrdata)->nlinconss = 0;

488

(*conshdlrdata)->noriguses = 0;

502

assert(conshdlrdata !=

);

503

assert(*conshdlrdata !=

);

504

assert((*conshdlrdata)->nallconsanddatas == 0);

507 if

( (*conshdlrdata)->inithashmapandtable )

510

(*conshdlrdata)->hashmapsize = 0;

512

(*conshdlrdata)->hashtablesize = 0;

516

assert((*conshdlrdata)->hashmap ==

);

517

assert((*conshdlrdata)->hashtable ==

);

519

(*conshdlrdata)->inithashmapandtable =

;

524

(*conshdlrdata)->allconsanddatas =

;

525

(*conshdlrdata)->nallconsanddatas = 0;

526

(*conshdlrdata)->sallconsanddatas = 0;

543

assert(cons !=

);

544

assert(nvars !=

);

562 case

SCIP_LINEARCONSTYPE_EQKNAPSACK:

563

*nvars = SCIPgetNVarsEQKnapsack(

, cons);

625 case

SCIP_LINEARCONSTYPE_EQKNAPSACK:

626

*lhs = SCIPgetCapacityEQKnapsack(

, cons);

654

assert(cons !=

);

655

assert(vars !=

);

656

assert(nvars !=

);

672 for

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

674

vars[v] = linvars[v];

675

coefs[v] = lincoefs[v];

680 for

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

681

vars[v] = linvars[v];

689

assert( linvars !=

);

693 for

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

695

vars[v] = linvars[v];

701 for

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

702

vars[v] = linvars[v];

712

assert( linvars !=

);

718 for

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

720

vars[v] = linvars[v];

726 for

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

727

vars[v] = linvars[v];

735

assert( linvars !=

);

739 for

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

741

vars[v] = linvars[v];

747 for

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

748

vars[v] = linvars[v];

753 case

SCIP_LINEARCONSTYPE_EQKNAPSACK:

757

*nvars = SCIPgetNVarsEQKnapsack(

, cons);

758

linvars = SCIPgetVarsEQKnapsack(

, cons);

759

assert( linvars !=

);

763

weights = SCIPgetWeightsEQKnapsack(

, cons);

765 for

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

767

vars[v] = linvars[v];

773 for

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

774

vars[v] = linvars[v];

800 int

const

nlinvars,

814

assert(cons !=

);

815

assert(vars !=

);

816

assert((linvars !=

) == (nlinvars !=

));

817

assert((andress ==

) || (nandress !=

));

818

assert((andcoefs !=

) == (andnegs !=

));

819

assert((coefs !=

) == ((lincoefs !=

) || (andcoefs !=

)));

820

assert(linvars !=

|| andress !=

);

822 if

( nlinvars !=

)

824 if

( nandress !=

)

828

assert(conshdlr !=

);

830

assert(conshdlrdata !=

);

831

assert(conshdlrdata->hashmap !=

);

834 for

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

839

assert(vars[v] !=

);

841

hashmapentryexists =

SCIPhashmapExists

(conshdlrdata->hashmap, (

void

*)(vars[v]));

846

hashmapentryexists =

SCIPhashmapExists

(conshdlrdata->hashmap, (

void

*)(hashmapvar));

849

hashmapvar = vars[v];

854 if

( hashmapentryexists )

859

assert(consanddata !=

);

863 if

( hashmapentryexists )

865

assert(consanddata->

);

871 if

( !hashmapentryexists && linvars !=

&& nlinvars !=

)

873

linvars[*nlinvars] = vars[v];

874 if

( lincoefs !=

)

876

assert(coefs !=

);

877

lincoefs[*nlinvars] = coefs[v];

881 else if

( hashmapentryexists && nandress !=

)

883 if

( andress !=

)

885

andress[*nandress] = hashmapvar;

887 if

( andcoefs !=

)

889

assert(andnegs !=

);

890

assert(coefs !=

);

891

andcoefs[*nandress] = coefs[v];

892

andnegs[*nandress] = (vars[v] != hashmapvar);

903#ifdef CHECK_CONSISTENCY 930

assert(cons !=

);

936

assert(consdata !=

);

939

assert(consdata->lincons !=

);

942

assert(consdata->consanddatas !=

);

943

assert(consdata->nconsanddatas > 0);

944

assert(consdata->nconsanddatas <= consdata->sconsanddatas);

956

assert(nvars == consdata->nlinvars + consdata->nconsanddatas);

970

assert(nvars == 0 || (coefs !=

));

974

andress, andcoefs, andnegs, &nandress) );

975

assert(nlinvars == consdata->nlinvars);

976

assert(nandress == consdata->nconsanddatas);

978 for

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

980 SCIP_VAR

* andresultant = andress[v];

983 for

( c = consdata->nconsanddatas - 1; c >= 0; --c )

985

assert(consdata->consanddatas[c] !=

);

986 if

( consdata->consanddatas[c]->cons !=

)

989

assert(res !=

);

991 if

( res == andresultant && consdata->andnegs[c] == andnegs[v] && consdata->andcoefs[c] == andcoefs[v] )

995

assert(!alreadyfound[c]);

998

alreadyfound[c] =

;

1004

assert(nfound == 1);

1007 for

( c = consdata->nconsanddatas - 1; c >= 0; --c )

1009

assert(alreadyfound[c]);

1023#define checkConsConsistency(scip, cons) 1043

assert(consanddata !=

);

1044

assert(conshdlrdata !=

);

1048

tmpvars = consanddata->

;

1049

ntmpvars = consanddata->

;

1052 for

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

1054

assert(tmpvars[v] !=

);

1062

tmpvars = consanddata->

;

1063

ntmpvars = consanddata->

;

1066 for

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

1068

assert(tmpvars[v] !=

);

1077 if

( !origdata || consanddata->

== 0 )

1082

consanddata->

= 0;

1083

consanddata->

= 0;

1084

consanddata->

= 0;

1099 if

( consanddata->

> 0 )

1110 if

( conshdlrdata->inithashmapandtable )

1112

assert(conshdlrdata->hashmap !=

);

1113

assert(conshdlrdata->hashtable !=

);

1126

assert(consanddata->

== 0);

1127

assert(consanddata->

== 0);

1128

assert(consanddata->

== 0);

1136

assert(consanddata->

> 0);

1137

assert(consanddata->

> 0);

1138

assert(consanddata->

);

1142 if

( conshdlrdata->inithashmapandtable )

1144

assert(conshdlrdata->hashmap !=

);

1145

assert(conshdlrdata->hashtable !=

);

1171 int const

nandconss,

1188

assert(conshdlr !=

);

1189

assert(consdata !=

);

1191

assert(nandconss == 0 || (andconss !=

&& andcoefs !=

));

1209 SCIPerrorMessage

(

"left hand side of pseudo boolean constraint greater than right hand side\n"

);

1220

(*consdata)->issoftcons = issoftcons;

1223

(*consdata)->weight = weight;

1229

(*consdata)->indvar = indvar;

1232

(*consdata)->indvar =

;

1235 if

( intvar !=

)

1242

(*consdata)->intvar = intvar;

1245

(*consdata)->intvar =

;

1248

(*consdata)->lincons = lincons;

1249

(*consdata)->linconstype = linconstype;

1258

assert((*consdata)->lincons !=

);

1261 if

( transforming || transformed )

1271

(*consdata)->nlinvars = nvars - nandconss;

1274 if

( nandconss > 0 )

1282 if

( andnegs !=

)

1290

(*consdata)->nconsanddatas = nandconss;

1291

(*consdata)->sconsanddatas = nandconss;

1297

assert(conshdlrdata !=

);

1298

assert(conshdlrdata->hashmap !=

);

1301 for

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

1303

assert(andconss[c] !=

);

1306

assert(andress[c] !=

);

1309

assert((*consdata)->consanddatas[c] !=

);

1310

assert((*consdata)->consanddatas[c]->origcons == andconss[c] || (*consdata)->consanddatas[c]->cons == andconss[c]);

1315 if

( (*consdata)->consanddatas[c]->origcons !=

&& (*consdata)->consanddatas[c]->cons ==

)

1325

assert((*consdata)->consanddatas[c]->cons !=

);

1326

assert((*consdata)->consanddatas[c]->newvars ==

);

1327

assert((*consdata)->consanddatas[c]->isoriginal);

1329

(*consdata)->consanddatas[c]->istransformed =

;

1331

vars = (*consdata)->consanddatas[c]->vars;

1332

ncvars = (*consdata)->consanddatas[c]->nvars;

1333

assert(vars !=

|| ncvars == 0);

1339 SCIPsortPtr

((

void

**)vars, SCIPvarComp, ncvars);

1342 for

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

1347 else if

( (*consdata)->consanddatas[c]->cons !=

)

1348

assert((*consdata)->consanddatas[c]->istransformed);

1350

++((*consdata)->consanddatas[c]->nuses);

1352 else if

( transformed )

1354

assert((*consdata)->consanddatas[c]->cons == andconss[c]);

1356

assert((*consdata)->consanddatas[c]->istransformed);

1361 SCIPsortPtrPtrRealBool

((

void

**)andress, (

void

**)((*consdata)->consanddatas), (*consdata)->andcoefs, (*consdata)->andnegs, resvarComp, nandconss);

1368

(*consdata)->consanddatas =

;

1369

(*consdata)->andcoefs =

;

1370

(*consdata)->andnegs =

;

1371

(*consdata)->nconsanddatas = 0;

1372

(*consdata)->sconsanddatas = 0;

1376

(*consdata)->lhs = lhs;

1377

(*consdata)->rhs = rhs;

1379

(*consdata)->changed =

;

1380

(*consdata)->propagated =

;

1381

(*consdata)->presolved =

;

1382

(*consdata)->cliquesadded =

;

1383

(*consdata)->upgradetried =

;

1390

assert(conshdlrdata !=

);

1392

conshdlrdata->noriguses += (*consdata)->nconsanddatas;

1412

assert(consdata !=

);

1413

assert(*consdata !=

);

1414

assert((*consdata)->nconsanddatas == 0 || (*consdata)->consanddatas !=

);

1415

assert(conshdlrdata !=

);

1418 if

( (*consdata)->lincons !=

)

1423

nconsanddatas = (*consdata)->nconsanddatas;

1424

consanddatas = (*consdata)->consanddatas;

1427 for

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

1429

assert((consanddatas[c]->origcons ==

) == (consanddatas[c]->noriguses == 0));

1430

assert((consanddatas[c]->cons ==

) == (consanddatas[c]->nuses == 0));

1431

assert(consanddatas[c]->nuses >= 0);

1432

assert(consanddatas[c]->noriguses >= 0);

1433

assert(isorig ? consanddatas[c]->cons ==

);

1436 if

( !isorig && consanddatas[c]->cons !=

)

1440

--(consanddatas[c]->

);

1443 if

( consanddatas[c]->nuses == 0 )

1445 if

( conshdlrdata->inithashmapandtable )

1447

assert(conshdlrdata->hashmap !=

);

1448

assert(conshdlrdata->hashtable !=

);

1451 if

( consanddatas[c]->origcons ==

)

1463 if

( consanddatas[c]->origcons ==

)

1467

assert(conshdlrdata->nallconsanddatas > 0);

1469 for

( d = conshdlrdata->nallconsanddatas - 1; d >= 0; --d )

1471 if

( conshdlrdata->allconsanddatas[d] == consanddatas[c] )

1473

--conshdlrdata->nallconsanddatas;

1477

conshdlrdata->allconsanddatas[d] = conshdlrdata->allconsanddatas[conshdlrdata->nallconsanddatas];

1487 else if

( isorig && consanddatas[c]->origcons !=

)

1490

assert(consanddatas[c]->nuses == 0);

1491

assert(consanddatas[c]->nnewvars == 0);

1492

assert(consanddatas[c]->snewvars == 0);

1493

assert(consanddatas[c]->newvars ==

);

1498 if

( consanddatas[c]->noriguses == 0 )

1502 if

( conshdlrdata->inithashmapandtable )

1504

assert(conshdlrdata->hashmap !=

);

1505

assert(conshdlrdata->hashtable !=

);

1514 if

( consanddatas[c]->vars !=

)

1516

assert(consanddatas[c]->nvars > 0);

1517

assert(consanddatas[c]->svars > 0);

1518

assert(consanddatas[c]->svars >= consanddatas[c]->nvars);

1521

consanddatas[c]->

= 0;

1522

consanddatas[c]->

= 0;

1526

assert(consanddatas[c]->nvars == 0);

1527

assert(consanddatas[c]->svars == 0);

1531

assert(consanddatas[c]->origcons ==

);

1534

assert(conshdlrdata->nallconsanddatas > 0);

1535 for

( d = conshdlrdata->nallconsanddatas - 1; d >= 0; --d )

1537 if

( conshdlrdata->allconsanddatas[d] == consanddatas[c] )

1539

--conshdlrdata->nallconsanddatas;

1543

conshdlrdata->allconsanddatas[d] = conshdlrdata->allconsanddatas[conshdlrdata->nallconsanddatas];

1554

assert(!consanddatas[c]->istransformed);

1555

assert(consanddatas[c]->cons ==

);

1559 if

( consanddatas[c]->nuses == 0 && consanddatas[c]->istransformed )

1564 else if

( consanddatas[c]->nuses == 0 )

1570

assert(consanddatas[c]->nnewvars == 0);

1571

assert(consanddatas[c]->snewvars == 0);

1572

assert(consanddatas[c]->newvars ==

);

1574

tmpvars = consanddatas[c]->

;

1575

ntmpvars = consanddatas[c]->

;

1578 for

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

1580

assert(tmpvars[v] !=

);

1587 if

( !consanddatas[c]->istransformed && consanddatas[c]->noriguses > 0 )

1589

assert(consanddatas[c]->origcons !=

);

1590

assert(consanddatas[c]->nuses == 0);

1591

assert(consanddatas[c]->nnewvars == 0);

1592

assert(consanddatas[c]->snewvars == 0);

1593

assert(consanddatas[c]->newvars ==

);

1594

assert(consanddatas[c]->nvars > 0);

1595

assert(consanddatas[c]->svars > 0);

1596

assert(consanddatas[c]->svars >= consanddatas[c]->nvars);

1597

assert(consanddatas[c]->vars !=

);

1598

assert(consanddatas[c]->isoriginal);

1604 if

( conshdlrdata->inithashmapandtable )

1606

assert(conshdlrdata->hashmap !=

);

1607

assert(conshdlrdata->hashtable !=

);

1635

assert(res !=

);

1666

assert(cons !=

);

1668

assert(consanddata !=

);

1677

vars = consanddata->

;

1682

vars = consanddata->

;

1683

nvars = consanddata->

;

1687

assert(nvars == 0 || (vars !=

&& res !=

));

1698 for

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

1705 for

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

1735

assert(cons !=

);

1737

assert(consanddata !=

);

1743

vars = consanddata->

;

1744

nvars = consanddata->

;

1750

assert(nvars == 0 || vars !=

);

1761 for

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

1768 for

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

1802 int

* monomialnvars;

1808

assert(cons !=

);

1811

assert(consdata !=

);

1812

assert(consdata->intvar ==

);

1813

assert(consdata->lincons !=

);

1822

assert(consdata->nlinvars + consdata->nconsanddatas >= nvars);

1839

assert(nvars == 0 || (coefs !=

));

1843

assert(conshdlr !=

);

1845

assert(conshdlrdata !=

);

1846

assert(conshdlrdata->hashmap !=

);

1850 for

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

1863

assert(!consdata->issoftcons || var != consdata->indvar);

1866 if

( consanddata !=

)

1878 while

( var != vars[v] );

1880 if

( consanddata ==

)

1882

assert(var !=

);

1883

assert(var == vars[v]);

1884

monomialvars[nmonomials] = vars + v;

1885

monomialnvars[nmonomials] = 1;

1892 if

( fixed != negated )

1907

assert(andvars !=

);

1908

monomialvars[nmonomials] = andvars;

1909

assert(nandvars >= 1);

1910

monomialnvars[nmonomials] = nandvars;

1914

monomialcoefs[nmonomials] = coefs[v];

1943 if

( consdata->issoftcons )

1948

assert(consdata->weight ==

SCIPvarGetObj

(consdata->indvar));

1995

assert(conshdlr !=

);

1996

assert(vars !=

);

1998

assert(andcons !=

);

2001

assert(conshdlrdata !=

);

2002

assert(conshdlrdata->hashtable !=

);

2009

newdata->

= nvars;

2010

newdata->

= nvars;

2015

newdata->

= 0;

2028 if

( tmpdata !=

)

2036

*andcons = tmpdata->

;

2038

assert(tmpdata->

> 0);

2040

++(tmpdata->

);

2051

assert(*andcons !=

);

2055

assert(res !=

);

2080#ifdef SCIP_DISABLED_CODE 2081#ifdef WITH_DEBUG_SOLUTION 2082 if

( SCIPdebugIsMainscip(

) )

2088 for

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

2096

val = ((val < 0.5) ? 0.0 : 1.0);

2101 SCIPerrorMessage

(

"computed solution value %g for resultant <%s> violates debug solution value %g\n"

, val,

SCIPvarGetName

(resultant), debugsolval);

2122

initial, separate, enforce, check &&

, propagate,

2123

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

2132

assert(*andcons !=

);

2135 if

( conshdlrdata->nallconsanddatas == conshdlrdata->sallconsanddatas )

2141

conshdlrdata->allconsanddatas[conshdlrdata->nallconsanddatas] = newdata;

2142

++(conshdlrdata->nallconsanddatas);

2148

newdata->

= newcons;

2152

newdata->

= 1;

2155 for

( v = newdata->

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

2207

assert(cons !=

);

2208

assert(nvars == 0 || vars !=

);

2214

assert(consdata !=

);

2217

assert(conshdlr !=

);

2220

assert(conshdlrdata !=

);

2227

assert(andcons !=

);

2230 if

( consdata->nconsanddatas == consdata->sconsanddatas )

2236

assert(res !=

);

2240

++(consdata->nconsanddatas);

2243 switch

( consdata->linconstype )

2266#ifdef WITHEQKNAPSACK 2267 case

SCIP_LINEARCONSTYPE_EQKNAPSACK:

2284

consdata->changed =

;

2285

consdata->propagated =

;

2286

consdata->presolved =

;

2287

consdata->cliquesadded =

;

2288

consdata->upgradetried =

;

2310 SCIPerrorMessage

(

"changing left hand side only allowed on standard lienar constraint \n"

);

2312#ifdef WITHEQKNAPSACK 2313 case

SCIP_LINEARCONSTYPE_EQKNAPSACK:

2341 SCIPerrorMessage

(

"changing left hand side only allowed on standard lienar constraint \n"

);

2343#ifdef WITHEQKNAPSACK 2344 case

SCIP_LINEARCONSTYPE_EQKNAPSACK:

2378

assert(cons !=

);

2387

assert(consdata !=

);

2413

assert(nvars == 0 || (coefs !=

));

2416 SCIP_CALL

(

getLinVarsAndAndRess

(

, cons, vars, coefs, nvars, linvars, lincoefs, &nlinvars, andress, andcoefs, andnegs, &nandress) );

2417

assert(consdata->nconsanddatas == nandress);

2433 for

( c = consdata->nconsanddatas - 1; c >= 0; --c )

2438

consanddata = consdata->consanddatas[c];

2439

assert(consanddata !=

);

2441

andcons = consanddata->

;

2442

assert(andcons !=

);

2446

val = andnegs[c] ? -andcoefs[c] : andcoefs[c];

2451 for

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

2458 for

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

2468 for

( c = consdata->nconsanddatas - 1; c >= 0; --c )

2473

consanddata = consdata->consanddatas[c];

2474

assert(consanddata !=

);

2476

andcons = consanddata->

;

2477

assert(andcons !=

);

2481

val = andnegs[c] ? -andcoefs[c] : andcoefs[c];

2486 for

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

2493 for

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

2505

consdata->propagated =

;

2510

consdata->lhs = lhs;

2511

consdata->presolved =

;

2512

consdata->changed =

;

2549

assert(cons !=

);

2558

assert(consdata !=

);

2584

assert(nvars == 0 || (coefs !=

));

2587 SCIP_CALL

(

getLinVarsAndAndRess

(

, cons, vars, coefs, nvars, linvars, lincoefs, &nlinvars, andress, andcoefs, andnegs, &nandress) );

2588

assert(consdata->nconsanddatas == nandress);

2604 for

( c = consdata->nconsanddatas - 1; c >= 0; --c )

2609

consanddata = consdata->consanddatas[c];

2610

assert(consanddata !=

);

2612

andcons = consanddata->

;

2613

assert(andcons !=

);

2617

val = andnegs[c] ? -andcoefs[c] : andcoefs[c];

2622 for

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

2629 for

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

2639 for

( c = consdata->nconsanddatas - 1; c >= 0; --c )

2644

consanddata = consdata->consanddatas[c];

2645

assert(consanddata !=

);

2647

andcons = consanddata->

;

2648

assert(andcons !=

);

2652

val = andnegs[c] ? -andcoefs[c] : andcoefs[c];

2657 for

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

2664 for

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

2676

consdata->propagated =

;

2681

consdata->rhs = rhs;

2682

consdata->presolved =

;

2683

consdata->changed =

;

2705 int const

const

ntermvars,

2730 int

const

nandconss

2736

assert(conshdlr !=

);

2738

assert(andconss !=

);

2739

assert(andvals !=

);

2740

assert(nandconss !=

);

2748 for

( t = 0; t <

; ++t )

2753

initial, enforce, check, local, modifiable, dynamic, stickingatnode,

2754

&(andconss[*nandconss])) );

2755

assert(andconss[*nandconss] !=

);

2756

andvals[*nandconss] = termcoefs[t];

2757

andnegs[*nandconss] =

;

2826

assert(conshdlr !=

);

2827

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

&& linvals !=

));

2828

assert(nandress == 0 || (andress !=

&& andvals !=

));

2829

assert(lhs !=

);

2830

assert(rhs !=

);

2831

assert(lincons !=

);

2832

assert(linconstype !=

);

2833

assert(nlinvars > 0 || nandress > 0);

2836

assert(conshdlrdata !=

);

2843

++(conshdlrdata->nlinconss);

2859

nvars = nlinvars + nandress;

2862 for

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

2892 for

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

2920 SCIPdebugMsg

(

"While creating the linear constraint of the pseudoboolean constraint we found %d zero coefficients that were removed\n"

, nzero);

2938 if

( upgrconshdlr !=

&& nvars > 2 && ncoeffspone + ncoeffsnone == nvars

2954 for

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

2956 if

( mult * linvals[v] > 0.0 )

2957

transvars[v] = linvars[v];

2962

assert(transvars[v] !=

);

2966 for

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

2968 if

( mult * andvals[v] > 0.0 )

2969

transvars[nlinvars + v] = andress[v];

2975

assert(transvars[nlinvars + v] !=

);

2978

assert(!modifiable);

2981

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

3010 if

( upgrconshdlr !=

&& !created && ncoeffspone + ncoeffsnone == nvars )

3017 SCIPdebugMsg

(

"linear pseudoboolean constraint will be a set partitioning constraint\n"

);

3020

mult =

(

, *lhs, 1.0 - ncoeffsnone) ? +1 : -1;

3026 for

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

3028 if

( mult * linvals[v] > 0.0 )

3029

transvars[v] = linvars[v];

3034

assert(transvars[v] !=

);

3038 for

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

3040 if

( mult * andvals[v] > 0.0 )

3041

transvars[nlinvars + v] = andress[v];

3047

assert(transvars[nlinvars + v] !=

);

3051

assert(!modifiable);

3053

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

3067 SCIPdebugMsg

(

"linear pseudoboolean constraint will be a set packing constraint\n"

);

3076 for

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

3078 if

( mult * linvals[v] > 0.0 )

3079

transvars[v] = linvars[v];

3084

assert(transvars[v] !=

);

3088 for

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

3090 if

( mult * andvals[v] > 0.0 )

3091

transvars[nlinvars + v] = andress[v];

3097

assert(transvars[nlinvars + v] !=

);

3101

assert(!modifiable);

3103

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

3121 SCIPwarningMessage

(

"Does not expect this, because this constraint should be a set packing constraint.\n"

);

3125 SCIPwarningMessage

(

"Does not expect this, because this constraint should be a logicor constraint.\n"

);

3128 SCIPdebugMsg

(

"linear pseudoboolean constraint will be a set covering constraint\n"

);

3137 for

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

3139 if

( mult * linvals[v] > 0.0 )

3140

transvars[v] = linvars[v];

3145

assert(transvars[v] !=

);

3149 for

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

3151 if

( mult * andvals[v] > 0.0 )

3152

transvars[nlinvars + v] = andress[v];

3158

assert(transvars[nlinvars + v] !=

);

3162

assert(!modifiable);

3164

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

3192 SCIPdebugMsg

(

"linear pseudoboolean constraint will be a knapsack constraint\n"

);

3213 for

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

3219

transvars[v] = linvars[v];

3220

weights[v] = weight;

3225

weights[v] = -weight;

3228

assert(transvars[v] !=

);

3231 for

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

3237

transvars[nlinvars + v] = andress[v];

3238

weights[nlinvars + v] = weight;

3244

weights[nlinvars + v] = -weight;

3247

assert(transvars[nlinvars + v] !=

);

3252

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

3264#ifdef WITHEQKNAPSACK 3273 if

( upgrconshdlr !=

&& !created && (ncoeffspone + ncoeffsnone + ncoeffspint + ncoeffsnint == nvars) &&

(

, *lhs, *rhs) )

3283 SCIPdebugMsg

(

"linear pseudoboolean constraint will be a equality-knapsack constraint\n"

);

3301 for

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

3307

transvars[v] = linvars[v];

3308

weights[v] = weight;

3313

weights[v] = -weight;

3316

assert(transvars[v] !=

);

3319 for

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

3325

transvars[nlinvars + v] = andress[v];

3326

weights[nlinvars + v] = weight;

3332

weights[nlinvars + v] = -weight;

3335

assert(transvars[nlinvars + v] !=

);

3339 SCIP_CALL

( SCIPcreateConsEqKnapsack(

, &cons, name, nvars, transvars, weights, capacity,

3340

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

3343

(*linconstype) = SCIP_LINEARCONSTYPE_EQKNAPSACK;

3357

assert(created || upgrconshdlr !=

);

3362

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

3367 for

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

3369

assert(andress[v] !=

);

3423

assert(cons !=

);

3425

assert(violated !=

);

3433

assert(consdata !=

);

3434

assert(consdata->lincons !=

);

3453

assert(nvars == 0 || (coefs !=

));

3459

assert(consdata->nlinvars + consdata->nconsanddatas >= nvars);

3462

assert(conshdlr !=

);

3465

assert(conshdlrdata !=

);

3466

assert(conshdlrdata->hashmap !=

);

3471 for

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

3482 if

( consanddata !=

)

3487 while

( var != vars[v] );

3490 if

( consanddata ==

)

3501 if

( andcons ==

)

3502

andcons = consanddata->

;

3508

assert(nandvars == 0 || andvars !=

);

3512 for

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

3515 if

( var != vars[v] )

3516

solval = 1.0 - solval;

3520

activity += coefs[v] * solval;

3523 SCIPdebugMsg

(

"lhs = %g, activity = %g, rhs = %g\n"

, lhs, activity, rhs);

3526

lhsviol = lhs - activity;

3527

rhsviol = activity - rhs;

3529 if

(lhsviol > rhsviol)

3600

assert(conshdlr !=

);

3601

assert(violated !=

);

3604

assert(conshdlrdata !=

);

3608 for

( c = conshdlrdata->nallconsanddatas - 1; c >= 0; --c )

3615 if

( !conshdlrdata->allconsanddatas[c]->istransformed )

3618

andcons = conshdlrdata->allconsanddatas[c]->cons;

3621 if

( andcons ==

)

3627

assert(nvars == 0 || (vars !=

&& res !=

));

3632 for

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

3636 if

( solval < minsolval )

3639

sumsolval += solval;

3646

viol =

MAX3

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

3659 else if

( sol ==

)

3671 SCIP

const

targetscip,

3673 SCIP

const

sourcescip,

3698

assert(targetscip !=

);

3699

assert(targetcons !=

);

3700

assert(sourcescip !=

);

3701

assert(sourcecons !=

);

3703

assert(valid !=

);

3708

assert(sourceconsdata !=

);

3711

sourcelincons = sourceconsdata->lincons;

3712

assert(sourcelincons !=

);

3721 int

ntargetandconss;

3724

targetlinconstype = sourceconsdata->linconstype;

3726 switch

( targetlinconstype )

3730

assert(conshdlrlinear !=

);

3734

assert(conshdlrlinear !=

);

3738

assert(conshdlrlinear !=

);

3742

assert(conshdlrlinear !=

);

3744#ifdef WITHEQKNAPSACK 3745 case

SCIP_LINEARCONSTYPE_EQKNAPSACK:

3747

assert(conshdlrlinear !=

);

3756 if

( conshdlrlinear ==

)

3762

targetlincons =

;

3772

assert(targetlincons !=

);

3782

targetandconss =

;

3783

targetandcoefs =

;

3784

ntargetandconss = 0;

3790 int

nsourceandconss;

3797

assert(conshdlrand !=

);

3799

nsourceandconss = sourceconsdata->nconsanddatas;

3814

targetlinvars, targetlincoefs, &ntargetlinvars) );

3821

SCIPvarIsHashkeyEq, SCIPvarGetHashkeyVal,

) );

3823 for

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

3832 for

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

3839

consanddata = sourceconsdata->consanddatas[c];

3840

assert(consanddata !=

);

3852

targetandconss[ntargetandconss] =

;

3864

targetandcoefs[ntargetandconss] = sourceconsdata->andcoefs[c];

3870

assert(ntargetandconss <= ntargetlinvars);

3880 const char

* consname;

3883

assert(sourceconsdata->issoftcons == (sourceconsdata->indvar !=

));

3884

indvar = sourceconsdata->indvar;

3885

intvar = sourceconsdata->intvar;

3888 if

( indvar !=

)

3892

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

);

3895 if

( intvar !=

&& *valid )

3898

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

);

3918

targetlincons, targetlinconstype, targetandconss, targetandcoefs, ntargetandconss,

3919

indvar, sourceconsdata->weight, sourceconsdata->issoftcons, intvar, targetlhs, targetrhs,

3920

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

3930 if

( targetlincons !=

)

3936 if

( targetandconss !=

)

3940

assert(ntargetandconss <= sourceconsdata->nconsanddatas);

3942 for

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

3944 if

( targetandconss[c] !=

)

3973

assert(conshdlrdata !=

);

3975

allconsanddatas = conshdlrdata->allconsanddatas;

3976

assert(allconsanddatas !=

);

3977

assert(conshdlrdata->nallconsanddatas >= 0);

3978

assert(conshdlrdata->nallconsanddatas <= conshdlrdata->sallconsanddatas);

3980 for

( c = conshdlrdata->nallconsanddatas - 1; c >= 0; --c )

3989

consanddata = allconsanddatas[c];

3994 if

( consanddata->

== 0 )

3997

vars = consanddata->

;

3998

nvars = consanddata->

;

3999

assert(nvars == 0 || vars !=

);

4012

cons = consanddata->

;

4013

assert(cons !=

);

4030 if

( nnewvars <= 0 )

4035 for

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

4038 for

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

4043 if

( nvars == nnewvars )

4050 for

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

4052 if

( vars[v] != newvars[v] )

4064 if

( nnewvars > consanddata->

)

4074 for

( v = consanddata->

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

4098

assert(cons !=

);

4099

assert(consanddata !=

);

4108

assert(consanddata->

);

4126

assert(cons !=

);

4127

assert(consanddata !=

);

4136

assert(consanddata->

);

4156 int

nnewconsanddatas;

4157 int

snewconsanddatas;

4170

assert(cons !=

);

4171

assert(conshdlrdata !=

);

4172

assert(conshdlrdata->hashmap !=

);

4173

assert(nandress == 0 || (andress !=

&& andcoefs !=

));

4179

assert(consdata !=

);

4182 SCIPsortPtrRealBool

((

void

**)(consdata->consanddatas), consdata->andcoefs, consdata->andnegs, resvarCompWithInactive, consdata->nconsanddatas);

4187

consanddatas = consdata->consanddatas;

4188

oldandcoefs = consdata->andcoefs;

4189

oldandnegs = consdata->andnegs;

4190

nconsanddatas = consdata->nconsanddatas;

4191

assert(nconsanddatas == 0 || (consanddatas !=

&& oldandcoefs !=

));

4193

snewconsanddatas = nconsanddatas + nandress;

4200

nnewconsanddatas = 0;

4203 for

( c = 0, c1 = 0; c < nconsanddatas && c1 < nandress; )

4210

assert(consanddatas[c] !=

);

4213 if

( !consanddatas[c]->istransformed )

4216

consdata->changed =

;

4217

consdata->upgradetried =

;

4221

andcons = consanddatas[c]->

;

4222

assert(andcons !=

);

4224 if

( andcons ==

)

4227

consdata->changed =

;

4228

consdata->upgradetried =

;

4235

oldandnegs[c] ? -oldandcoefs[c] : oldandcoefs[c], consdata->lhs, consdata->rhs) );

4237

consdata->changed =

;

4238

consdata->upgradetried =

;

4241

assert(andcons !=

);

4245

assert(res1 !=

);

4250

assert(res2 !=

);

4254

compval = resvarComp((

void

*)res1, (

void

*)res2);

4257 if

( compval == -1 )

4260

assert(consanddatas[c]->nuses > 0);

4261

--(consanddatas[c]->

);

4265

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

4267

consdata->changed =

;

4268

consdata->upgradetried =

;

4269

consdata->propagated =

;

4270

consdata->presolved =

;

4272 else if

( compval == +1 )

4277

newandcoefs[nnewconsanddatas] = andcoefs[c1];

4278

newandnegs[nnewconsanddatas] = andnegs[c1];

4279

++(newconsanddatas[nnewconsanddatas]->

);

4283

-newandcoefs[nnewconsanddatas] : newandcoefs[nnewconsanddatas], newlhs, newrhs) );

4285

consdata->changed =

;

4286

consdata->upgradetried =

;

4287

consdata->cliquesadded =

;

4288

consdata->propagated =

;

4289

consdata->presolved =

;

4304

newconsanddatas[nnewconsanddatas] = consanddatas[c];

4306

newandcoefs[nnewconsanddatas] = andcoefs[c1];

4307

newandnegs[nnewconsanddatas] = andnegs[c1];

4309 if

( ((oldandnegs[c] == andnegs[c1]) && !

(

, oldandcoefs[c], newandcoefs[c1]))

4310

|| ((oldandnegs[c] != newandnegs[c1]) && !

(

, oldandcoefs[c], -newandcoefs[c1])) )

4311

consdata->upgradetried =

;

4313

coefsignchanged = (oldandnegs[c] == andnegs[c1]) &&

4314

((oldandcoefs[c] < 0 && andcoefs[c1] > 0) || (oldandcoefs[c] > 0 && andcoefs[c1] < 0));

4315

coefsignchanged = coefsignchanged || ((oldandnegs[c] != andnegs[c1]) &&

4316

((oldandcoefs[c] < 0 && andcoefs[c1] < 0) || (oldandcoefs[c] > 0 && andcoefs[c1] > 0)));

4318

|| (consdata->lhs < 0 && newlhs > 0) || (consdata->lhs > 0 && newlhs < 0);

4320

|| (consdata->rhs < 0 && newrhs > 0) || (consdata->rhs > 0 && newrhs < 0);

4323 if

( coefsignchanged || lhschanged || rhschanged || newconsanddatas[nnewconsanddatas]->nnewvars > 0)

4327

-oldandcoefs[c] : oldandcoefs[c], consdata->lhs, consdata->rhs) );

4329

-newandcoefs[nnewconsanddatas] : newandcoefs[nnewconsanddatas], newlhs, newrhs) );

4331

consdata->changed =

;

4332

consdata->upgradetried =

;

4333

consdata->cliquesadded =

;

4334

consdata->propagated =

;

4335

consdata->presolved =

;

4345 if

( c < nconsanddatas )

4347

assert(c1 == nandress);

4349 for

( ; c < nconsanddatas; ++c )

4355

assert(consanddatas[c] !=

);

4357

andcons = consanddatas[c]->

;

4359 if

( andcons !=

)

4362

assert(res1 !=

);

4366 if

( andcons ==

)

4368

consdata->changed =

;

4369

consdata->upgradetried =

;

4373

assert(consanddatas[c]->nuses > 0);

4374

--(consanddatas[c]->

);

4378

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

4379

consdata->changed =

;

4380

consdata->upgradetried =

;

4381

consdata->propagated =

;

4382

consdata->presolved =

;

4385 else if

( c1 < nandress )

4387 for

( ; c1 < nandress; ++c1 )

4392

assert(res2 !=

);

4395

newandcoefs[nnewconsanddatas] = andcoefs[c1];

4396

newandnegs[nnewconsanddatas] = andnegs[c1];

4397

++(newconsanddatas[nnewconsanddatas]->

);

4401

-newandcoefs[nnewconsanddatas] : newandcoefs[nnewconsanddatas], newlhs, newrhs) );

4404

consdata->changed =

;

4405

consdata->upgradetried =

;

4406

consdata->cliquesadded =

;

4407

consdata->propagated =

;

4408

consdata->presolved =

;

4411

assert(c == nconsanddatas && c1 == nandress);

4420

consdata->upgradetried =

;

4421

consdata->lhs = newlhs;

4422

consdata->rhs = newrhs;

4425

consdata->consanddatas = newconsanddatas;

4426

consdata->andcoefs = newandcoefs;

4427

consdata->andnegs = newandnegs;

4428

consdata->nconsanddatas = nnewconsanddatas;

4429

consdata->sconsanddatas = snewconsanddatas;

4431

oldnvars = consdata->nlinvars;

4434

consdata->nlinvars -= nnewconsanddatas;

4436 if

( oldnvars != consdata->nlinvars )

4438

consdata->changed =

;

4439

consdata->upgradetried =

;

4440

consdata->cliquesadded =

;

4441

consdata->propagated =

;

4442

consdata->presolved =

;

4446

consanddatas = consdata->consanddatas;

4447

nconsanddatas = consdata->nconsanddatas;

4448

assert(nconsanddatas == 0 || consanddatas !=

);

4451 for

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

4460

assert(consanddatas[c] !=

);

4461

assert(consanddatas[c]->cons !=

);

4463

assert(res1 !=

);

4464

assert(consanddatas[c - 1] !=

);

4465

assert(consanddatas[c - 1]->cons !=

);

4467

assert(res2 !=

);

4472

assert(res1 !=

);

4478

assert(res2 !=

);

4482 if

( resind1 == -1 && resind2 == -1 )

4488 if

( resind1 <= resind2 )

4490

assert(resind1 == resind2);

4506 int

const

naggrvars,

4524

assert(cons !=

);

4525

assert(cutoff !=

);

4526

assert(naggrvars !=

);

4527

assert(nchgbds !=

);

4533

assert(consdata !=

);

4535

assert(consdata->nconsanddatas > 0);

4538 if

( consdata->cliquesadded )

4541

consdata->cliquesadded =

;

4546

assert(consdata->lincons !=

);

4549

assert(consdata->consanddatas !=

);

4550

assert(consdata->nconsanddatas > 0);

4551

assert(consdata->nconsanddatas <= consdata->sconsanddatas);

4555

assert(nvars == consdata->nlinvars + consdata->nconsanddatas);

4570

assert(nandress == consdata->nconsanddatas);

4571

assert(consdata->consanddatas !=

);

4574 for

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

4580

consanddata = consdata->consanddatas[c];

4581

assert(consanddata !=

);

4588

andvars = consanddata->

;

4589

nandvars = consanddata->

;

4593

andvars = consanddata->

;

4594

nandvars = consanddata->

;

4597 for

( v1 = nandvars - 1; v1 >= 0; --v1 )

4615 for

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

4645 if

( values[0] != values[1] && var1 == var2 )

4651

clqvars[0] = andres;

4653

assert(clqvars[1] !=

);

4662

*nchgbds += nchgbdslocal;

4694

clqvars[0] = andres;

4696

assert(clqvars[1] !=

);

4705

*nchgbds += nchgbdslocal;

4725 for

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

4734

consanddata1 = consdata->consanddatas[c];

4735

assert(consanddata1 !=

);

4736

consanddata2 = consdata->consanddatas[c - 1];

4737

assert(consanddata2 !=

);

4745

andvars1 = consanddata1->

;

4746

nandvars1 = consanddata1->

;

4750

andvars1 = consanddata1->

;

4751

nandvars1 = consanddata1->

;

4757

andvars2 = consanddata2->

;

4758

nandvars2 = consanddata2->

;

4762

andvars2 = consanddata2->

;

4763

nandvars2 = consanddata2->

;

4767 for

( v1 = nandvars1 - 1; v1 >= 0; --v1 )

4772

var1 = andvars1[v1];

4785 for

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

4789

var2 = andvars2[v2];

4815 if

( values[0] != values[1] && var1 == var2 )

4821

clqvars[0] = andres;

4822

clqvars[1] = andres2;

4831

*nchgbds += nchgbdslocal;

4864

clqvars[0] = andres;

4866

assert(clqvars[1] !=

);

4875

*nchgbds += nchgbdslocal;

4908 int

const

ndelconss

4914

assert(cons !=

);

4915

assert(cutoff !=

);

4916

assert(ndelconss !=

);

4921

assert(consdata !=

);

4922

assert(consdata->lincons !=

);

4932 if

( consdata->propagated )

4936

consdata->propagated =

;

4954

assert(cons !=

);

4957

assert(consdata !=

);

4959

consanddatas = consdata->consanddatas;

4960

nconsanddatas = consdata->nconsanddatas;

4961

assert(nconsanddatas == 0 || consanddatas !=

);

4967 for

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

4971

assert(consanddatas[c] !=

);

4973 if

( !consanddatas[c]->istransformed )

4976

andcons = consanddatas[c]->

;

4977

assert(andcons !=

);

4990 int

const

ndelconss

5004

assert(conshdlrdata !=

);

5005

assert(ndelconss !=

);

5007 if

( conshdlrdata->nallconsanddatas == 0 )

5010

allconsanddatas = conshdlrdata->allconsanddatas;

5011

assert(allconsanddatas !=

);

5012

assert(conshdlrdata->nallconsanddatas >= 1);

5013

assert(conshdlrdata->nallconsanddatas <= conshdlrdata->sallconsanddatas);

5015 if

( nfixedvars >= 1 && nvars >= 1 )

5023

activescalars =

;

5026 for

( c = conshdlrdata->nallconsanddatas - 1; c >= 0; --c )

5033

consanddata = allconsanddatas[c];

5035

assert(consanddata->

== 0 || (consanddata->

&& consanddata->

> 0));

5044

assert(consanddata->

== 0);

5045

assert(consanddata->

== 0);

5051 if

( consanddata->

== 0 )

5056

assert(consanddata->

== 0);

5057

assert(consanddata->

> 0);

5058

assert(resvar !=

);

5068

consanddata->

= 0;

5083 if

( consanddata->

== 0 )

5096

assert(consanddata->

== 0);

5097

assert(consanddata->

== 0);

5111 if

( looseorcolumn )

5120 for

(

= 0;

< nfixedvars && del; ++

)

5126

assert(fixedvars !=

);

5127

assert(activevars !=

);

5128

assert(activescalars !=

);

5129

activevars[0] = fixedvars[

];

5130

activescalars[0] = 1.0;

5131

activeconstant = 0.0;

5134

&activeconstant, &requiredsize,

) );

5135

assert(requiredsize <= nvars);

5137 for

( i = 0; i < nactivevars && del; ++i )

5141 if

( activevars[i] == resvar )

5155 if

( !looseorcolumn )

5177

cons = consanddata->

;

5178

assert(cons !=

);

5185

assert(consanddata->

> 0);

5186

assert(resvar !=

);

5192

consanddata->

= 0;

5210

tmpvars = consanddata->

;

5212 for

( v = consanddata->

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

5215

assert(tmpvars[v] !=

);

5220

tmpvars = consanddata->

;

5221

stmpvars = consanddata->

;

5225

consanddata->

= tmpvars;

5231 if

( activevars !=

)

5248 int

const

ndelconss

5257

assert(cons !=

);

5258

assert(conshdlrdata !=

);

5259

assert(ndelconss !=

);

5265

assert(consdata !=

);

5267

consanddatas = consdata->consanddatas;

5268

nconsanddatas = consdata->nconsanddatas;

5269

assert(nconsanddatas > 0 && consanddatas !=

);

5270

assert(consdata->andcoefs !=

);

5273 for

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

5277

consanddata = consanddatas[c];

5278

assert(consanddata !=

);

5287 for

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

5291

consanddata = consanddatas[c];

5292

assert(consanddata !=

);

5293

assert(consanddatas[c]->istransformed);

5295

assert(consanddata->

> 0);

5297 if

( consanddata->

> 0 )

5298

--(consanddata->

);

5301 if

( consanddata->

== 0 )

5310

assert(resvar !=

);

5319 if

( looseorcolumn )

5336 if

( !looseorcolumn )

5357

consdata->nconsanddatas = 0;

5387 int const

nconsanddatas,

5405

assert(vars !=

);

5407

assert(values !=

);

5408

assert(linvars !=

|| nlinvars == 0);

5409

assert(lincoefs !=

|| nlinvars == 0);

5410

assert(nvars >= nlinvars);

5412

assert(consanddatas !=

);

5413

assert(consanddatacoefs !=

);

5414

assert(nconsanddatas > 0);

5415

assert(*xortype >= -1 && *xortype <= 1);

5418 SCIPsortPtr

((

void

**)linvars, SCIPvarCompActiveAndNegated, nlinvars);

5419 SCIPsortPtr

((

void

**)vars, SCIPvarCompActiveAndNegated, nvars);

5422 for

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

5424 if

(

SCIPsortedvecFindPtr

((

void

**)vars, SCIPvarCompActiveAndNegated, linvars[v], nvars, &pos) )

5427

value += lincoefs[v];

5442 for

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

5446

consanddata = consanddatas[c];

5447

assert(consanddata !=

);

5453

termvars = consanddata->

;

5454

ntermvars = consanddata->

;

5458

termvars = consanddata->

;

5459

ntermvars = consanddata->

;

5461

assert(ntermvars > 0 && termvars !=

);

5467 SCIPsortPtrBool

((

void

**)repvars, negated, SCIPvarCompActiveAndNegated, ntermvars);

5469 for

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

5478 if

( (negated[v] && values[pos]) || (!negated[v] && !values[pos]) )

5494 if

( val != consanddatanegs[c] )

5495

value += consanddatacoefs[c];

5501 if

( *xortype == -1 )

5509 else if

( *xortype == 1 && cnt % 2 == 0 )

5511 else if

( *xortype == 0 && cnt % 2 == 1 )

5517 if

( *xortype == -1 )

5525 else if

( *xortype == 1 && cnt % 2 == 1 )

5527 else if

( *xortype == 0 && cnt % 2 == 0 )

5548 int

const

ndelconss,

5549 int

const

naddconss,

5550 int

const

nfixedvars,

5551 int

const

nchgcoefs,

5552 int

const

nchgsides,

5588

assert(cons !=

);

5589

assert(conshdlrdata !=

);

5590

assert(ndelconss !=

);

5591

assert(nfixedvars !=

);

5592

assert(nchgcoefs !=

);

5593

assert(nchgsides !=

);

5594

assert(cutoff !=

);

5598

assert(consdata !=

);

5600

consanddatas = consdata->consanddatas;

5601

andcoefs = consdata->andcoefs;

5602

andnegs = consdata->andnegs;

5603

nconsanddatas = consdata->nconsanddatas;

5604

assert(nconsanddatas > 0 && consanddatas !=

);

5606

assert(consdata->lincons !=

);

5613

assert(consanddatas[0] !=

);

5614

assert(consanddatas[0]->cons !=

);

5616

lincons = consdata->lincons;

5620

assert(nallvars - nconsanddatas == consdata->nlinvars);

5621

nlinvars = consdata->nlinvars;

5638

assert(nallvars > 0);

5643

assert(nlinvars == consdata->nlinvars);

5644

assert(nandress == nallvars-nlinvars);

5655

firstnlinvars = nlinvars;

5658 SCIPsortPtr

((

void

**)linvars, SCIPvarCompActiveAndNegated, nlinvars);

5660 for

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

5662

consanddata = consanddatas[c];

5663

assert(consanddata !=

);

5669

vars = consanddata->

;

5674

vars = consanddata->

;

5675

nvars = consanddata->

;

5677

assert(nvars > 0 && vars !=

);

5686 SCIPsortPtr

((

void

**)repvars, SCIPvarCompActiveAndNegated, nvars);

5688

oldnlinvars = nlinvars;

5691 for

( v = nvars - 1, v1 = nlinvars - 1; v >= 0 && v1 >= 0; )

5711

linvars[nlinvars] = var;

5733 for

( ; v >= 0; --v )

5748

linvars[nlinvars] = var;

5757 if

( nlinvars > oldnlinvars )

5760 SCIPsortPtr

((

void

**)linvars, SCIPvarCompActiveAndNegated, nlinvars);

5768 for

( v = (1 << nlinvars) - 1; v >= 0; --v )

5771 for

( v1 = nlinvars - 1; v1 >= 0; --v1 )

5772 if

( v & (1 << v1) )

5778

values[v1] =

;

5781

assert(cnt <= nlinvars);

5784

consdata->lhs, consanddatas, andcoefs, andnegs, nconsanddatas, cnt, &xortype) );

5785 if

( xortype == -1 )

5791

assert(xortype >= -1 && xortype <= 1);

5839 int

const

ndelconss,

5840 int

const

naddconss,

5841 int

const

nfixedvars,

5842 int

const

nchgcoefs,

5843 int

const

nchgsides,

5859

assert(cons !=

);

5860

assert(conshdlrdata !=

);

5861

assert(ndelconss !=

);

5862

assert(nfixedvars !=

);

5863

assert(nchgcoefs !=

);

5864

assert(nchgsides !=

);

5865

assert(cutoff !=

);

5869

assert(consdata !=

);

5871

consanddatas = consdata->consanddatas;

5872

nconsanddatas = consdata->nconsanddatas;

5873

assert(nconsanddatas > 0 && consanddatas !=

);

5875

assert(consdata->lincons !=

);

5878

assert(consanddatas[0] !=

);

5879

assert(consanddatas[0]->cons !=

);

5881 if

( nconsanddatas == 1 )

5901 if

( consdata->nlinvars == 0 )

5913

lincons = consdata->lincons;

5915

consanddata = consanddatas[0];

5916

assert(consanddata !=

);

5922

vars = consanddata->

;

5927

vars = consanddata->

;

5928

nvars = consanddata->

;

5930

assert(nvars > 0 && vars !=

);

5944

assert(nallvars == consdata->nlinvars + 1);

5946

nlinvars = consdata->nlinvars;

5956

assert(allcoefs !=

);

5961

assert(nlinvars == consdata->nlinvars);

5964 for

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

5970 for

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

6002

c = nconsanddatas - 1;

6003

assert(consanddatas[c]->istransformed);

6006 if

( consanddatas[c]->nnewvars > 0 )

6008

neqvars = consanddatas[c]->

;

6014

neqvars = consanddatas[c]->

;

6020

assert(neqvars > 0 && eqvars !=

);

6024 for

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

6028 for

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

6035

consanddata = consanddatas[c];

6036

assert(consanddata !=

);

6037

assert(consanddatas[c]->istransformed);

6042

vars = consanddata->

;

6047

vars = consanddata->

;

6048

nvars = consanddata->

;

6050

assert(nvars > 0 && vars !=

);

6054 for

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

6059 if

( nvars < nminvars )

6062 else if

( nvars > nmaxvars )

6064

assert(nminvars > 0);

6065

assert(nminvars <= nmaxvars);

6068 for

( v = 0, v2 = 0; v < neqvars && v2 < nvars; )

6073

assert(eqvars[v] !=

);

6074

assert(vars[v2] !=

);

6079 if

( index1 < index2 )

6081 else if

( index1 > index2 )

6085

assert(index1 == index2);

6086

assert(nneweqvars <= v);

6088 if

( nneweqvars < v )

6089

eqvars[nneweqvars] = eqvars[v];

6095

neqvars = nneweqvars;

6100 if

( nminvars > neqvars + 1 )

6142 if

( neqvars > 0 && consdata->nlinvars == 0 )

6148 for

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

6165 if

( nminvars == neqvars )

6177 if

( neqvars > 0 && nminvars == nmaxvars && nminvars == neqvars + 1 )

6188

lincons = consdata->lincons;

6200 for

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

6206

consanddata = consanddatas[c];

6207

assert(consanddata !=

);

6208

assert(consanddatas[c]->istransformed);

6213

vars = consanddata->

;

6218

vars = consanddata->

;

6219

nvars = consanddata->

;

6221

assert(nvars > 0 && vars !=

);

6223 for

( v = 0, v2 = 0; v < neqvars && v2 < nvars; )

6228

assert(eqvars[v] !=

);

6229

assert(vars[v2] !=

);

6234

assert(index1 >= index2);

6236 if

( index1 > index2 )

6243

assert(index1 == index2);

6252

assert(v == neqvars);

6253 for

( ; v2 < nvars; ++v2)

6258

assert(v == neqvars && v2 == nvars);

6265 if

( consdata->nlinvars > 0 )

6275 for

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

6282

assert(nvars == consdata->nlinvars + consdata->nconsanddatas);

6292

assert(nvars == 0 || (coefs !=

));

6296 for

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

6302

assert(nlinvars == consdata->nlinvars);

6305 for

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

6351 int

const

ndelconss,

6352 int

const

naddconss,

6353 int

const

nfixedvars,

6354 int

const

nchgcoefs,

6355 int

const

nchgsides,

6372

assert(cons !=

);

6373

assert(conshdlrdata !=

);

6374

assert(ndelconss !=

);

6375

assert(nfixedvars !=

);

6376

assert(nchgcoefs !=

);

6377

assert(nchgsides !=

);

6378

assert(cutoff !=

);

6382

assert(consdata !=

);

6384

consanddatas = consdata->consanddatas;

6385

nconsanddatas = consdata->nconsanddatas;

6386

assert(nconsanddatas > 0 && consanddatas !=

);

6388

assert(consdata->lincons !=

);

6405

assert(consanddatas[0] !=

);

6406

assert(consanddatas[0]->cons !=

);

6408 if

( nconsanddatas == 1 )

6411 if

( consdata->nlinvars == 0 )

6440 if

( consdata->nlinvars > 0 )

6445

assert(consdata->nlinvars == 0 && nconsanddatas > 1);

6447

c = nconsanddatas - 1;

6448

assert(consanddatas[c]->istransformed);

6451 if

( consanddatas[c]->nnewvars > 0 )

6453

neqvars = consanddatas[c]->

;

6459

neqvars = consanddatas[c]->

;

6465

assert(neqvars > 0 && eqvars !=

);

6469 for

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

6473 for

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

6480

consanddata = consanddatas[c];

6481

assert(consanddata !=

);

6482

assert(consanddatas[c]->istransformed);

6487

vars = consanddata->

;

6492

vars = consanddata->

;

6493

nvars = consanddata->

;

6495

assert(nvars > 0 && vars !=

);

6499 for

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

6504 if

( nvars < nminvars )

6507 else if

( nvars > nmaxvars )

6509

assert(nminvars > 0);

6510

assert(nminvars <= nmaxvars);

6513 for

( v = 0, v2 = 0; v < neqvars && v2 < nvars; )

6518

assert(eqvars[v] !=

);

6519

assert(vars[v2] !=

SCIP_SETPPCTYPE_PARTITIONING

);

6524 if

( index1 < index2 )

6526 else if

( index1 > index2 )

6530

assert(index1 == index2);

6531

assert(nneweqvars <= v);

6533 if

( nneweqvars < v )

6534

eqvars[nneweqvars] = eqvars[v];

6540

neqvars = nneweqvars;

6582 if

( neqvars > 0 && ((nminvars == nmaxvars && nminvars == neqvars + 1) || (nminvars == neqvars) || (type ==

)) )

6612 if

( neqvars == nminvars )

6615

createcons = (

SCIPisLE

(

, lhs, rhs) && ((nminvars == nmaxvars && nminvars == neqvars + 1) || (nminvars == neqvars)));

6620

lincons = consdata->lincons;

6638 for

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

6644

consanddata = consanddatas[c];

6645

assert(consanddata !=

);

6646

assert(consanddatas[c]->istransformed);

6651

vars = consanddata->

;

6656

vars = consanddata->

;

6657

nvars = consanddata->

;

6659

assert(nvars > 0 && vars !=

);

6662 if

( deletecons && neqvars + 1 < nvars )

6681 for

( v = 0, v2 = 0; v < neqvars && v2 < nvars; )

6686

assert(eqvars[v] !=

);

6687

assert(vars[v2] !=

);

6692

assert(index1 >= index2);

6694 if

( index1 > index2 )

6698

assert(newcons !=

);

6701 else if

( deletecons )

6718

assert(index1 == index2);

6728

assert(v == neqvars);

6729 for

( ; v2 < nvars; ++v2)

6735 else if

( deletecons )

6750

assert(v == neqvars && v2 == nvars);

6756 for

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

6782

assert(newcons !=

);

6801

assert(!deletecons);

6827 int

const

ndelconss,

6828 int

const

naddconss,

6829 int

const

nfixedvars,

6830 int

const

nchgcoefs,

6831 int

const

nchgsides,

6842

assert(cons !=

);

6843

assert(conshdlrdata !=

);

6844

assert(ndelconss !=

);

6845

assert(nfixedvars !=

);

6846

assert(nchgcoefs !=

);

6847

assert(nchgsides !=

);

6848

assert(cutoff !=

);

6852

assert(consdata !=

);

6853

assert(consdata->lincons !=

);

6856

consanddatas = consdata->consanddatas;

6857

assert(consdata->nconsanddatas == 0 || consanddatas !=

);

6861 if

( consdata->nconsanddatas == 0 )

6877

assert(consdata->nlinvars + consdata->nconsanddatas == nvars);

6879 switch

( consdata->linconstype )

6896#ifdef WITHEQKNAPSACK 6897 case

SCIP_LINEARCONSTYPE_EQKNAPSACK:

6914

consdata->upgradetried =

;

6925 int

const

ndelconss,

6926 int

const

naggrvars,

6948

assert(cons !=

);

6949

assert(conshdlrdata !=

);

6950

assert(ndelconss !=

);

6951

assert(naggrvars !=

);

6952

assert(cutoff !=

);

6959

assert(consdata !=

);

6960

assert(consdata->lincons !=

);

6962

consanddatas = consdata->consanddatas;

6963

nconsanddatas = consdata->nconsanddatas;

6964

assert(nconsanddatas == 0 || consanddatas !=

);

6970

assert(

(

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

6973 if

( nconsanddatas < 2 || nconsanddatas > 3 )

6979

assert(consdata->nlinvars + nconsanddatas == nvars);

6982 if

( consdata->nlinvars != 1 )

6986 if

( consanddatas[0]->nnewvars > 0 )

6987

nvars = consanddatas[0]->

;

6989

nvars = consanddatas[0]->

;

6991 if

( consanddatas[1]->nnewvars > 0 )

6993 if

( nvars != consanddatas[1]->nnewvars )

6996 else if

( nvars != consanddatas[1]->nvars )

7011 if

( consanddatas[nconsanddatas - 1]->nnewvars > 0 )

7012

vars = consanddatas[nconsanddatas - 1]->

;

7014

vars = consanddatas[nconsanddatas - 1]->

;

7018 SCIPsortPtrBool

((

void

**)repvars, negated, SCIPvarCompActiveAndNegated, nvars);

7022 for

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

7042

assert(var1 != var2);

7047 for

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

7058

++(varcount[negated[v]][v]);

7061 for

( c = nconsanddatas - 2; c >= 0; --c )

7066 if

( consanddatas[nconsanddatas - 1]->nnewvars > 0 )

7067

vars = consanddatas[c]->

;

7069

vars = consanddatas[c]->

;

7076 SCIPsortPtrBool

((

void

**)repvars, negated, SCIPvarCompActiveAndNegated, nvars);

7080 for

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

7100

assert(var1 != var2);

7105 for

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

7115 if

(

SCIPsortedvecFindPtr

((

void

**)allvars, SCIPvarCompActiveAndNegated, repvars[v], nvars, &pos) )

7117

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

7119

++(varcount[negated[v]][pos]);

7132 for

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

7134 for

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

7138 if

( varcount[i][v] == 0 )

7140 else if

( varcount[i][v] == 1 )

7142 else if

( varcount[i][v] == 2 )

7150 if

( othercount == 0 )

7155 if

( nconsanddatas == 2 && twocount == nvars - 1 && onecount == 2 && zerocount == 1 )

7170

assert(nconsvars == consdata->nlinvars + nconsanddatas);

7171

assert(conscoefs !=

);

7175 for

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

7183

assert(nlinvars == 1);

7184

assert(linvar !=

);

7202 for

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

7204 for

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

7207 if

( varcount[i][v] == 2 )

7219

assert(var !=

);

7256 else if

( nvars == 2 && nconsanddatas == 3 && twocount == 2 && onecount == 2 && zerocount == 0)

7275

assert(nconsvars == consdata->nlinvars + nconsanddatas);

7276

assert(conscoefs !=

);

7280 for

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

7288

assert(nlinvars == 1);

7289

assert(linvar !=

);

7294

newandvars[0] =

;

7295

newandvars[1] =

;

7299 for

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

7301 for

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

7304 if

( varcount[i][v] == 1 )

7306 if

( newandvars[0] ==

)

7310

assert(newandvars[1] ==

);

7322

assert(newandvars[0] !=

&& newandvars[1] !=

);

7385

assert(cons !=

);

7386

assert(graph !=

);

7387

assert(success !=

);

7390

assert(consdata !=

);

7404 if

( vars[0] !=

)

7417 if

( consdata->intvar !=

)

7419

vars[0] = consdata->intvar;

7443 for

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

7444

vals[i] = tmpvals[i];

7449 for

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

7455 for

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

7461 for

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

7471

assert(tmpvars !=

);

7472 for

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

7473

vars[i] = tmpvars[i];

7485 for

( c = 0; c < consdata->nconsanddatas; ++c )

7487

assert(consdata->consanddatas[c] !=

);

7492

tmpnvars = consdata->consanddatas[c]->nvars;

7493 for

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

7494

vars[i] = consdata->consanddatas[c]->vars[i];

7495 for

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

7517#ifdef NONLINCONSUPGD_PRIORITY 7523

SCIP_EXPRGRAPH* exprgraph;

7524

SCIP_EXPRGRAPHNODE* node;

7538

assert(nupgdconss !=

);

7539

assert(upgdconss !=

);

7543

node = SCIPgetExprgraphNodeNonlinear(

, cons);

7549 switch

( SCIPexprgraphGetNodeOperator(node) )

7551 case

SCIP_EXPR_VARIDX:

7552 case

SCIP_EXPR_CONST:

7553 case

SCIP_EXPR_PLUS:

7554 case

SCIP_EXPR_MINUS:

7556 case

SCIP_EXPR_LINEAR:

7562 case

SCIP_EXPR_SQUARE:

7563 case

SCIP_EXPR_SQRT:

7564 case

SCIP_EXPR_REALPOWER:

7565 case

SCIP_EXPR_INTPOWER:

7566 case

SCIP_EXPR_SIGNPOWER:

7577 case

SCIP_EXPR_SIGN:

7578 case

SCIP_EXPR_PRODUCT:

7579 case

SCIP_EXPR_USER:

7583 case

SCIP_EXPR_QUADRATIC:

7586 case

SCIP_EXPR_POLYNOMIAL:

7590 case

SCIP_EXPR_PARAM:

7591 case

SCIP_EXPR_LAST:

7601 for

( i = 0; i < SCIPgetNLinearVarsNonlinear(

, cons); ++i )

7603

var = SCIPgetLinearVarsNonlinear(

, cons)[i];

7604

assert(var !=

);

7615 for

( i = 0; i < SCIPexprgraphGetNodeNChildren(node); ++i )

7617

SCIP_EXPRGRAPHNODE* child;

7619

child = SCIPexprgraphGetNodeChildren(node)[i];

7620

assert(child !=

);

7621 if

( SCIPexprgraphGetNodeOperator(child) != SCIP_EXPR_VARIDX )

7623 SCIPdebugMsg

(

"not pseudoboolean because child %d is not a variable\n"

, i);

7627

var = (

SCIP_VAR

*)SCIPexprgraphGetNodeVar(exprgraph, child);

7628

assert(var !=

);

7638 if

( upgdconsssize < 1 )

7648

lhs -= SCIPexprgraphGetNodePolynomialConstant(node);

7650

rhs -= SCIPexprgraphGetNodePolynomialConstant(node);

7653 if

( objvar !=

)

7657 for

( i = 0; i < SCIPgetNLinearVarsNonlinear(

, cons); ++i )

7659

var = SCIPgetLinearVarsNonlinear(

, cons)[i];

7660 if

( var != objvar )

7661

linvars[nlinvars++] = var;

7665

nlinvars = SCIPgetNLinearVarsNonlinear(

, cons);

7668 nterms

= SCIPexprgraphGetNodePolynomialNMonomials(node);

7673 for

( i = 0; i <

; ++i )

7675

SCIP_EXPRDATA_MONOMIAL* monomial;

7677

monomial = SCIPexprgraphGetNodePolynomialMonomials(node)[i];

7678

assert(monomial !=

);

7680

ntermvars[i] = SCIPexprGetMonomialNFactors(monomial);

7683 for

( j = 0; j < SCIPexprGetMonomialNFactors(monomial); ++j )

7685

terms[i][j] = (

SCIP_VAR

*)SCIPexprgraphGetNodeVar(exprgraph, SCIPexprgraphGetNodeChildren(node)[SCIPexprGetMonomialChildIndices(monomial)[j]]);

7686

assert(SCIPexprGetMonomialExponents(monomial)[j] > 0.0);

7689

termvals[i] = SCIPexprGetMonomialCoef(monomial);

7694

objvar !=

? linvars : SCIPgetLinearVarsNonlinear(

, cons), nlinvars, SCIPgetLinearCoefsNonlinear(

, cons),

7701 for

( i =

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

7718

assert(conshdlr !=

);

7736

assert(conshdlr !=

);

7741

assert(conshdlrdata !=

);

7759

assert(conshdlr !=

);

7763

assert(conshdlrdata !=

);

7766 for

( c = conshdlrdata->nallconsanddatas - 1; c >= 0; --c )

7775

assert(conshdlrdata->allconsanddatas[c] !=

);

7776

assert(conshdlrdata->allconsanddatas[c]->newvars ==

);

7778

vars = conshdlrdata->allconsanddatas[c]->vars;

7779

nvars = conshdlrdata->allconsanddatas[c]->nvars;

7780

assert(vars !=

|| nvars == 0);

7783 for

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

7791

andcons = conshdlrdata->allconsanddatas[c]->cons;

7792

assert(andcons !=

);

7802 SCIPconsGetName

(conshdlrdata->allconsanddatas[c]->cons), (

void

*)(conshdlrdata->allconsanddatas[c]),

7803

(

void

*)(conshdlrdata->allconsanddatas[c]->cons));

7817

assert(conshdlr !=

);

7821

assert(conshdlrdata !=

);

7824 for

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

7833

assert(cons !=

);

7840

assert(consdata !=

);

7841

assert(consdata->intvar ==

);

7844 if

( !conshdlrdata->decomposenormalpbcons && !consdata->issoftcons )

7856

assert(nvars == 0 || (coefs !=

));

7859 if

( !consdata->issoftcons )

7880

assert(consdata->weight != 0);

7881

assert(consdata->indvar !=

);

7885

assert(negindvar !=

);

7896

updateandconss =

;

7899 if

( conshdlrdata->decomposeindicatorpbcons )

7921

updateandconss =

;

7934 for

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

7944 if

( !updateandconss )

7968 for

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

8002

updateandconss =

;

8014

ub = lhs - maxact - 1;

8045 if

( !updateandconss )

8061

lb = rhs - minact + 1;

8104

assert(conshdlr !=

);

8105

assert(cons !=

);

8106

assert(consdata !=

);

8107

assert(*consdata !=

);

8111

assert(conshdlrdata !=

);

8122 for

( c = (*consdata)->nconsanddatas - 1; c >= 0; --c )

8124

assert((*consdata)->consanddatas[c]->nuses == 0);

8125

assert((*consdata)->consanddatas[c]->cons ==

);

8126

assert((*consdata)->consanddatas[c]->noriguses == 0 || ((*consdata)->consanddatas[c]->origcons !=

SCIPconsIsOriginal

((*consdata)->consanddatas[c]->origcons)));

8129

conshdlrdata->noriguses -= (*consdata)->nconsanddatas;

8131

assert(conshdlrdata->noriguses >= 0);

8149

assert(conshdlr !=

);

8152

assert(sourcecons !=

);

8153

assert(targetcons !=

);

8156

assert(sourcedata !=

);

8158

assert(sourcedata->nconsanddatas == 0 || sourcedata->consanddatas !=

);

8164 for

( c = sourcedata->nconsanddatas - 1; c >= 0; --c )

8166

assert(sourcedata->consanddatas[c] !=

);

8167

andconss[c] = sourcedata->consanddatas[c]->origcons;

8168

assert(andconss[c] !=

);

8174

andconss, sourcedata->andcoefs, sourcedata->andnegs, sourcedata->nconsanddatas, sourcedata->indvar, sourcedata->weight,

8175

sourcedata->issoftcons, sourcedata->intvar, sourcedata->lhs, sourcedata->rhs,

SCIPconsIsChecked

(sourcecons),

8198

assert(conshdlr !=

);

8200

assert(result !=

);

8223

assert(conshdlr !=

);

8225

assert(result !=

);

8248

assert(conshdlr !=

);

8250

assert(result !=

);

8274

assert(conshdlr !=

);

8275

assert(sol !=

);

8277

assert(result !=

);

8287 for

( c = nconss - 1; c >= 0 && (*result ==

SCIP_FEASIBLE

|| completely); --c )

8290

assert(consdata !=

);

8292 if

( consdata->issoftcons )

8294

assert(consdata->indvar !=

);

8325 int

firstupgradetry;

8336

assert(conshdlr !=

);

8338

assert(result !=

);

8341

oldnfixedvars = *nfixedvars;

8342

oldnaggrvars = *naggrvars;

8343

oldnchgbds = *nchgbds;

8344

oldndelconss = *ndelconss;

8345

oldnupgdconss = *nupgdconss;

8346

oldnchgcoefs = *nchgcoefs;

8347

oldnchgsides = *nchgsides;

8355

firstchange = INT_MAX;

8356

firstupgradetry = INT_MAX;

8377

assert(cons !=

);

8381

assert(consdata !=

);

8382

assert(consdata->lincons !=

);

8404

assert(nvars == 0 || (coefs !=

));

8408

andress, andcoefs, andnegs, &nandress) );

8433 if

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

8446 if

( consdata->changed )

8449 SCIP_CALL

(

tryUpgrading

(

, cons, conshdlrdata, ndelconss, naddconss, nfixedvars, nchgcoefs, nchgsides, &cutoff) );

8459 if

( firstupgradetry == INT_MAX && !consdata->upgradetried )

8460

firstupgradetry = c;

8465

consdata->presolved =

;

8483

consdata->changed =

;

8502 else if

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

8503

|| *nupgdconss > oldnupgdconss || *nchgcoefs > oldnchgcoefs || *nchgsides > oldnchgsides )

8524

assert(cons !=

);

8525

assert(conshdlr !=

);

8530

assert(consdata !=

);

8532

lhs = consdata->lhs;

8533

rhs = consdata->rhs;

8541 SCIPdebugMsg

(

"%socking constraint <%s> by [%d;%d].\n"

, (nlocksneg < 0) || (nlockspos < 0) ?

"Unl"

"L"

SCIPconsGetName

(cons), nlocksneg, nlockspos);

8544 for

( c = consdata->nconsanddatas - 1; c >= 0; --c )

8553

consanddata = consdata->consanddatas[c];

8554

assert( consanddata !=

);

8559

andcons = consanddata->

;

8561 if

( andcons ==

)

8564

assert(consanddata->

== 0);

8565

assert(consanddata->

== 0);

8570

consanddata->

= 0;

8571

consanddata->

= 0;

8578

assert(andcons !=

);

8581

andvars = consanddata->

;

8582

nandvars = consanddata->

;

8586

andvars = consanddata->

;

8587

nandvars = consanddata->

;

8592

assert(nandvars == 0 || andvars !=

);

8593

assert(andres !=

);

8594

val = consdata->andnegs[c] ? -consdata->andcoefs[c] : consdata->andcoefs[c];

8601 for

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

8611 for

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

8628 for

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

8638 for

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

8664

assert(conshdlr !=

);

8666

assert(cons !=

);

8677 const char

* consname;

8680

assert(sourcescip !=

);

8681

assert(sourcecons !=

);

8689

initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, global,

8691

assert(cons !=

|| *valid ==

);

8715 const char

* endptr;

8716 const char

* firstcomp;

8717 const char

* secondcomp;

8718 const char

* lhsstrptr;

8719 const char

* rhsstrptr;

8720 const char

* varstrptr;

8721 char

* polynomialstr;

8722 int

* monomialnvars;

8732

assert(success !=

);

8733

assert(str !=

);

8734

assert(name !=

);

8735

assert(cons !=

);

8760 switch

( endptr[0] )

8766 if

( endptr[1] ==

'='

)

8775 if

( strncmp(endptr,

"[free]"

, 6) == 0 )

8790 if

( firstcomp ==

)

8796 if

( secondcomp !=

)

8801 else if

( strncmp(firstcomp,

"<="

, 2) != 0 )

8806 else if

( strncmp(endptr,

"<="

, 2) != 0 )

8808 SCIPerrorMessage

(

"Bad second comparator, expected ranged specification: %s"

, str);

8812

secondcomp = endptr;

8816

endptr += increment;

8820 if

( firstcomp ==

)

8832 switch

( *firstcomp )

8835

assert(firstcomp[1] ==

'='

);

8837 if

( secondcomp !=

)

8839

assert(secondcomp[0] ==

'<'

&& secondcomp[1] ==

'='

);

8841

rhsstrptr = secondcomp + 2;

8842

varstrptr = firstcomp + 2;

8846

rhsstrptr = firstcomp + 2;

8849

assert(firstcomp[1] ==

'='

);

8850

assert(secondcomp ==

);

8852

lhsstrptr = firstcomp + 2;

8855

assert(firstcomp[1] ==

'='

);

8856

assert(secondcomp ==

);

8858

rhsstrptr = firstcomp + 2;

8859

lhsstrptr = firstcomp + 2;

8862

assert(strncmp(firstcomp,

"[free]"

, 6) == 0);

8863

assert(secondcomp ==

);

8865

endptr = firstcomp + 6;

8869 SCIPerrorMessage

(

"Parsing has wrong comparator character '%c', should be one of <=>["

, *firstcomp);

8878 if

( lhsstrptr !=

)

8882 SCIPerrorMessage

(

"error parsing left hand side number from <%s>\n"

, lhsstrptr);

8887 if

( rhsstrptr == lhsstrptr )

8892 if

( rhsstrptr !=

&& rhsstrptr != lhsstrptr )

8896 SCIPerrorMessage

(

"error parsing right hand side number from <%s>\n"

, lhsstrptr);

8904

issoftcons =

;

8911 if

( *endptr ==

'('

)

8913

endptr = strchr(endptr + 1,

'='

);

8915 if

( endptr ==

)

8924 if

( indvar ==

)

8931

endptr = strchr(endptr,

')'

);

8933 if

( endptr ==

)

8944

polynomialsize = (int)(

MAX

(firstcomp, secondcomp) + 1 - varstrptr);

8946

(void)

SCIPstrncpy

(polynomialstr, varstrptr, polynomialsize);

8952

polynomialsize -= (int)(endptr + 1 - polynomialstr);

8958 SCIPerrorMessage

(

"no luck in parsing pseudoboolean polynomial '%s'\n"

, varstrptr);

8961 else if

( polynomialsize >= 1 )

8963 SCIPerrorMessage

(

"no completion of parsing pseudoboolean polynomial '%s'\n"

, varstrptr);

8980 for

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

8988 for

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

8990 if

( monomialexps[i][j] < 0.0 )

8992 SCIPerrorMessage

(

"invalid exponent '%f' on variable <%s> in pseudoboolean polynomial '%s'\n"

, monomialexps[i][j],

SCIPvarGetName

(monomialvars[i][j]), varstrptr);

8996 if

( monomialexps[i][j] == 0.0 )

8999

monomialvars[i][ntermvars[

]++] = monomialvars[i][j];

9002 if

( ntermvars[

] > 1 )

9004

terms[

] = monomialvars[i];

9005

termvals[

] = monomialcoefs[i];

9008 else if

( ntermvars[

] == 1 )

9010 if

( issoftcons && ( monomialvars[i][0] == indvar ||

SCIPvarGetNegatedVar

(monomialvars[i][0]) == indvar ) )

9016

linvars[nlinvars] = monomialvars[i][0];

9017

linvals[nlinvars] = monomialcoefs[i];

9022

assert(ntermvars[

SCIPcreateConsPseudoboolean

] == 0);

9025

lhs -= monomialcoefs[i];

9028

rhs -= monomialcoefs[i];

9033 SCIP_CALL

(

(

, cons, name, linvars, nlinvars, linvals, terms,

, ntermvars, termvals, indvar, weight, issoftcons,

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

9067

assert(conshdlr !=

);

9068

assert(cons !=

);

9069

assert(vars !=

);

9070

assert(success !=

);

9074

assert(varssize >= 0);

9087

assert(consdata !=

);

9088

assert(consdata->lincons !=

);

9100

assert(nlinconsvars >= 0);

9103 if

( nlinconsvars == 0 )

9110 else if

( varssize < nlinconsvars )

9112

(*success) =

;

9127

andress,

, &nandress) );

9128

assert(nlinconsvars == nlinvars + nandress);

9134

assert(linvars !=

);

9138 if

( nandress == 0 )

9141

assert(andress !=

);

9145

assert(conshdlrdata !=

);

9146

assert(conshdlrdata->hashmap !=

);

9150 for

(

= nandress - 1;

>= 0; --

)

9154

assert(andress[

] !=

);

9158

assert(consanddata !=

);

9162

andcons = consanddata->

;

9166

assert(andcons !=

);

9169 if

( varssize <= nvars )

9171

(*success) =

;

9177

vars[nvars] = andress[

];

9185

assert(noperands >= 0);

9188 if

( varssize < nvars + noperands )

9190

(*success) =

;

9196 if

( noperands > 0 )

9232

assert(conshdlr !=

);

9233

assert(cons !=

);

9234

assert(nvars !=

);

9235

assert(success !=

);

9248

assert(consdata !=

);

9249

assert(consdata->lincons !=

);

9261

assert(nlinconsvars >= 0);

9264 if

( nlinconsvars == 0 )

9281

andress,

, &nandress) );

9282

assert(nlinconsvars == nlinvars + nandress);

9286 if

( nandress == 0 )

9289

assert(andress !=

);

9293

assert(conshdlrdata !=

);

9294

assert(conshdlrdata->hashmap !=

);

9298 for

(

= nandress - 1;

>= 0; --

)

9302

assert(andress[

] !=

);

9306

assert(consanddata !=

);

9310

andcons = consanddata->

;

9314

assert(andcons !=

);

9373

consEnfolpPseudoboolean, consEnfopsPseudoboolean, consCheckPseudoboolean, consLockPseudoboolean,

9375

assert(conshdlr !=

);

9397 "decompose every normal pseudo boolean constraint into a \"linear\" constraint and \"and\" constraints"

9401 "decompose every soft pseudo boolean constraint into \"indicator\" constraints and \"and\" constraints"

9404 "constraints/" CONSHDLR_NAME "/nlcseparate"

"should the nonlinear constraints be separated during LP processing?"

9407 "constraints/" CONSHDLR_NAME "/nlcpropagate"

"should the nonlinear constraints be propagated during node processing?"

9410 "constraints/" CONSHDLR_NAME "/nlcremovable"

"should the nonlinear constraints be removable?"

9413#ifdef NONLINCONSUPGD_PRIORITY 9480

assert(cons !=

);

9481

assert(lincons !=

);

9483

assert(nandconss == 0 || (andconss !=

&& andcoefs !=

));

9484

assert(issoftcons == (indvar !=

));

9486 if

( intvar !=

)

9489 SCIPerrorMessage

(

"intvar currently not supported by pseudo boolean constraint handler\n"

);

9495 if

( conshdlr ==

)

9503

assert(conshdlrdata !=

);

9508

assert(conshdlrdata->hashmap !=

);

9509

assert(conshdlrdata->hashtable !=

);

9510

assert(conshdlrdata->allconsanddatas !=

);

9511

assert(conshdlrdata->nallconsanddatas <= conshdlrdata->sallconsanddatas);

9513

memisinvalid =

;

9519 for

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

9521

assert(andconss[c] !=

);

9525

assert(vars !=

&& nvars > 0);

9526

assert(res !=

);

9538

newdata->

= nvars;

9545

newdata->

= 0;

9551

assert(newdata !=

);

9553 if

( newdata->

< nvars )

9565

newdata->

= nvars;

9573

assert(transformed);

9574

newdata->

= andconss[c];

9577 for

( v = newdata->

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

9585

assert(!transformed);

9593 if

( tmpdata ==

|| (tmpdata->

!= andconss[c] && tmpdata->

origcons

!= andconss[c]))

9597 SCIPwarningMessage

(

"Another and-constraint with the same variables but different and-resultant is added to the global and-constraint hashtable of pseudoboolean constraint handler.\n"

);

9601 if

( conshdlrdata->nallconsanddatas == conshdlrdata->sallconsanddatas )

9606

conshdlrdata->allconsanddatas[conshdlrdata->nallconsanddatas] = newdata;

9607

++(conshdlrdata->nallconsanddatas);

9613

memisinvalid =

;

9629

newdata->noriguses = 1;

9639

memisinvalid =

;

9643

assert(tmpdata->

> 0);

9646

++(tmpdata->

);

9658 if

( !memisinvalid )

9660

assert(newdata !=

);

9683

indvar, weight, issoftcons, intvar, lhs, rhs, check,

) );

9684

assert(consdata !=

);

9687 SCIP_CALL

(

SCIPcreateCons

(

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

9688

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

9759

assert(cons !=

);

9760

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

&& linvals !=

));

9762

assert(issoftcons == (indvar !=

));

9764 if

( intvar !=

)

9767 SCIPerrorMessage

(

"intvar currently not supported by pseudo boolean constraint handler\n"

);

9773 if

( conshdlr ==

)

9779 if

( modifiable && issoftcons )

9787

assert(conshdlrdata !=

);

9801

initial, enforce, check, local, modifiable, dynamic, stickingatnode,

9802

andconss, andcoefs, andnegs, &nandconss) );

9803

assert(

>= nandconss);

9806 for

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

9808

assert(andconss[c] !=

);

9825

&lhs, &rhs, issoftcons, initial, separate, enforce,

, propagate, local, modifiable, dynamic,

9826

removable, stickingatnode, &lincons, &linconstype) );

9827

assert(lincons !=

);

9833

indvar, weight, issoftcons, intvar, lhs, rhs, check,

) );

9834

assert(consdata !=

);

9843 SCIP_CALL

(

SCIPcreateCons

(

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

9844

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

9881

terms,

, ntermvars, termvals, indvar, weight, issoftcons, intvar, lhs, rhs,

9904

assert(cons !=

);

9905

assert(var !=

);

9918

assert(consdata !=

);

9920 switch

( consdata->linconstype )

9943#ifdef WITHEQKNAPSACK 9944 case

SCIP_LINEARCONSTYPE_EQKNAPSACK:

9957

consdata->propagated =

;

9958

consdata->presolved =

;

9959

consdata->cliquesadded =

;

9980

assert(cons !=

);

9981

assert(nvars == 0 || vars !=

);

10004

assert(cons !=

);

10014

assert(consdata !=

);

10016 return

consdata->indvar;

10028

assert(cons !=

);

10038

assert(consdata !=

);

10040 return

consdata->lincons;

10052

assert(cons !=

);

10062

assert(consdata !=

);

10064 return

consdata->linconstype;

10076

assert(cons !=

);

10088

assert(consdata !=

);

10090 return

consdata->nlinvars;

10099 int

const

nlinvars

10109

assert(cons !=

);

10110

assert(nlinvars !=

);

10111

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

);

10112

assert(*nlinvars == 0 || lincoefs !=

);

10122

assert(consdata !=

);

10126 if

( *nlinvars < consdata->nlinvars )

10128

*nlinvars = consdata->nlinvars;

10143 SCIP_CALL

(

getLinVarsAndAndRess

(

, cons, vars, coefs, nvars, linvars, lincoefs, nlinvars,

) );

10159 int

const

nandconss

10168

assert(cons !=

);

10169

assert(nandconss !=

);

10170

assert(*nandconss == 0 || andconss !=

);

10171

assert(*nandconss == 0 || andcoefs !=

);

10181

assert(consdata !=

);

10185 if

( *nandconss < consdata->nconsanddatas )

10187

*nandconss = consdata->nconsanddatas;

10191

*nandconss = consdata->nconsanddatas;

10192

assert(*nandconss == 0 || consdata->consanddatas !=

);

10196 for

( c = *nandconss - 1; c >= 0; --c )

10198

assert(consdata->consanddatas[c] !=

);

10199

assert(consdata->consanddatas[c]->istransformed ? (consdata->consanddatas[c]->cons !=

) :

);

10200

assert(consdata->consanddatas[c]->isoriginal ? (consdata->consanddatas[c]->origcons !=

) :

);

10201

assert(consdata->consanddatas[c]->cons !=

|| consdata->consanddatas[c]->origcons !=

);

10202

assert(isorig ? consdata->consanddatas[c]->origcons !=

: consdata->consanddatas[c]->cons !=

);

10204

andconss[c] = (isorig ? consdata->consanddatas[c]->origcons : consdata->consanddatas[c]->cons);

10205

assert(andconss[c] !=

);

10207

andcoefs[c] = consdata->andcoefs[c];

10222

assert(cons !=

);

10234

assert(consdata !=

);

10236 return

consdata->nconsanddatas;

10255

assert(cons !=

);

10266

assert(consdata !=

);

10268 switch

( consdata->linconstype )

10276#ifdef WITHEQKNAPSACK 10277 case

SCIP_LINEARCONSTYPE_EQKNAPSACK:

10279 SCIPerrorMessage

(

"changing left hand side only allowed on standard linear constraint \n"

);

10314

assert(consdata !=

);

10316 switch

( consdata->linconstype )

10324#ifdef WITHEQKNAPSACK 10325 case

SCIP_LINEARCONSTYPE_EQKNAPSACK:

10327 SCIPerrorMessage

(

"changing right hand side only allowed on standard linear constraint \n"

);

10358

assert(consdata !=

);

10360 return

consdata->lhs;

10383

assert(consdata !=