RetroSearch Browse

);

456

assert(conshdlrdata->nlinconsupgrades <= conshdlrdata->linconsupgradessize);

458 if

( num > conshdlrdata->linconsupgradessize )

464

conshdlrdata->linconsupgradessize = newsize;

466

assert(num <= conshdlrdata->linconsupgradessize);

480

assert(consdata !=

);

481

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

483 if

( num > consdata->varssize )

490 if

( consdata->eventdata !=

)

494

consdata->varssize = newsize;

496

assert(num <= consdata->varssize);

516

assert(linconsupgrade !=

);

517

assert(linconsupgd !=

);

520

(*linconsupgrade)->linconsupgd = linconsupgd;

521

(*linconsupgrade)->priority = priority;

522

(*linconsupgrade)->active =

;

535

assert(linconsupgrade !=

);

536

assert(*linconsupgrade !=

);

550

assert(conshdlrdata !=

);

551

assert(eventhdlr !=

);

554

(*conshdlrdata)->linconsupgrades =

;

555

(*conshdlrdata)->linconsupgradessize = 0;

556

(*conshdlrdata)->nlinconsupgrades = 0;

557

(*conshdlrdata)->naddconss = 0;

560

(*conshdlrdata)->eventhdlr = eventhdlr;

575

assert(conshdlrdata !=

);

576

assert(*conshdlrdata !=

);

578 for

( i = 0; i < (*conshdlrdata)->nlinconsupgrades; ++i )

593 const char

* conshdlrname

599

assert(conshdlrdata !=

);

600

assert(linconsupgd !=

);

601

assert(conshdlrname !=

);

603 for

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

605 if

( conshdlrdata->linconsupgrades[i]->linconsupgd == linconsupgd )

608 SCIPwarningMessage

(

"Try to add already known upgrade message for constraint handler %s.\n"

, conshdlrname);

628

assert(conshdlrdata !=

);

629

assert(linconsupgrade !=

);

633 for

( i = conshdlrdata->nlinconsupgrades;

634

i > 0 && conshdlrdata->linconsupgrades[i-1]->priority < linconsupgrade->

priority

; --i )

636

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

638

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

639

conshdlrdata->linconsupgrades[i] = linconsupgrade;

640

conshdlrdata->nlinconsupgrades++;

661

assert(cons !=

);

662

assert(var !=

);

665

assert(consdata !=

);

694

assert(cons !=

);

695

assert(var !=

);

698

assert(consdata !=

);

727

assert(cons !=

);

728

assert(eventhdlr !=

);

731

assert(consdata !=

);

733

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

734

assert(consdata->vars !=

);

735

assert(consdata->vars[pos] !=

);

737

assert(consdata->eventdata !=

);

738

assert(consdata->eventdata[pos] ==

);

741

consdata->eventdata[pos]->cons = cons;

742

consdata->eventdata[pos]->varpos = pos;

747

eventhdlr, consdata->eventdata[pos], &consdata->eventdata[pos]->filterpos) );

749

consdata->removedfixings = consdata->removedfixings &&

SCIPvarIsActive

(consdata->vars[pos]);

766

assert(cons !=

);

767

assert(eventhdlr !=

);

770

assert(consdata !=

);

772

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

773

assert(consdata->vars[pos] !=

);

774

assert(consdata->eventdata !=

);

775

assert(consdata->eventdata[pos] !=

);

776

assert(consdata->eventdata[pos]->cons == cons);

777

assert(consdata->eventdata[pos]->varpos == pos);

782

eventhdlr, consdata->eventdata[pos], consdata->eventdata[pos]->filterpos) );

801

assert(cons !=

);

804

assert(consdata !=

);

805

assert(consdata->eventdata ==

);

809

assert(consdata->eventdata !=

);

813 for

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

833

assert(cons !=

);

836

assert(consdata !=

);

837

assert(consdata->eventdata !=

);

840 for

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

847

assert(consdata->eventdata ==

);

868

assert(consdata !=

);

869

assert(nvars == 0 || vars !=

);

870

assert(nvars == 0 || vals !=

);

890

(*consdata)->varssize = 0;

891

(*consdata)->nvars = nvars;

892

(*consdata)->hascontvar =

;

893

(*consdata)->hasnonbinvar =

;

894

(*consdata)->hasnonbinvalid =

;

895

(*consdata)->vars =

;

896

(*consdata)->vals =

;

910 for

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

918

assert(var !=

);

928

varsbuffer[nvars] = var;

929

valsbuffer[nvars] = val;

933 if

( !(*consdata)->hascontvar )

939

(*consdata)->hasnonbinvar =

;

942

(*consdata)->hascontvar =

;

948

(*consdata)->nvars = nvars;

955

(*consdata)->varssize = nvars;

962

(*consdata)->eventdata =

;

974

(*consdata)->row =

;

975

(*consdata)->nlrow =

;

976

(*consdata)->lhs = lhs;

977

(*consdata)->rhs = rhs;

985

(*consdata)->maxactdeltavar =

;

986

(*consdata)->minactivityneginf = -1;

987

(*consdata)->minactivityposinf = -1;

988

(*consdata)->maxactivityneginf = -1;

989

(*consdata)->maxactivityposinf = -1;

990

(*consdata)->minactivityneghuge = -1;

991

(*consdata)->minactivityposhuge = -1;

992

(*consdata)->maxactivityneghuge = -1;

993

(*consdata)->maxactivityposhuge = -1;

998

(*consdata)->glbminactivityneginf = -1;

999

(*consdata)->glbminactivityposinf = -1;

1000

(*consdata)->glbmaxactivityneginf = -1;

1001

(*consdata)->glbmaxactivityposinf = -1;

1002

(*consdata)->glbminactivityneghuge = -1;

1003

(*consdata)->glbminactivityposhuge = -1;

1004

(*consdata)->glbmaxactivityneghuge = -1;

1005

(*consdata)->glbmaxactivityposhuge = -1;

1006

(*consdata)->possignature = 0;

1007

(*consdata)->negsignature = 0;

1008

(*consdata)->validmaxabsval =

;

1009

(*consdata)->validminabsval =

;

1010

(*consdata)->validactivities =

;

1011

(*consdata)->validminact =

;

1012

(*consdata)->validmaxact =

;

1013

(*consdata)->validglbminact =

;

1014

(*consdata)->validglbmaxact =

;

1015

(*consdata)->boundstightened = 0;

1016

(*consdata)->presolved =

;

1017

(*consdata)->removedfixings =

;

1018

(*consdata)->validsignature =

;

1019

(*consdata)->changed =

;

1020

(*consdata)->normalized =

;

1021

(*consdata)->upgradetried =

;

1022

(*consdata)->upgraded =

;

1023

(*consdata)->indexsorted = (nvars <= 1);

1024

(*consdata)->merged = (nvars <= 1);

1025

(*consdata)->cliquesadded =

;

1026

(*consdata)->implsadded =

;

1027

(*consdata)->coefsorted =

;

1028

(*consdata)->nbinvars = -1;

1029

(*consdata)->varsdeleted =

;

1030

(*consdata)->rangedrowpropagated = 0;

1031

(*consdata)->checkabsolute =

;

1040 for

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

1043 if

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

)

1068

assert(consdata !=

);

1069

assert(*consdata !=

);

1070

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

1073 if

( (*consdata)->row !=

)

1079 if

( (*consdata)->nlrow !=

)

1085 for

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

1087

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

);

1108

assert(consdata !=

);

1117 if

( consdata->nvars == 0 )

1150

assert(cons !=

);

1153

assert(consdata !=

);

1164 if

( consdata->nvars == 0 )

1171 for

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

1173 if

( consdata->vals !=

)

1175 if

( consdata->vals[v] == 1.0 )

1180 else if

( consdata->vals[v] == -1.0 )

1185 else if

( consdata->nvars > 0 )

1216

assert(consdata !=

);

1218

consdata->validactivities =

;

1219

consdata->validminact =

;

1220

consdata->validmaxact =

;

1221

consdata->validglbminact =

;

1222

consdata->validglbmaxact =

;

1223

consdata->validmaxabsval =

;

1224

consdata->validminabsval =

;

1225

consdata->hasnonbinvalid =

;

1233

consdata->maxactdeltavar =

;

1234

consdata->minactivityneginf = -1;

1235

consdata->minactivityposinf = -1;

1236

consdata->maxactivityneginf = -1;

1237

consdata->maxactivityposinf = -1;

1238

consdata->minactivityneghuge = -1;

1239

consdata->minactivityposhuge = -1;

1240

consdata->maxactivityneghuge = -1;

1241

consdata->maxactivityposhuge = -1;

1246

consdata->glbminactivityneginf = -1;

1247

consdata->glbminactivityposinf = -1;

1248

consdata->glbmaxactivityneginf = -1;

1249

consdata->glbmaxactivityposinf = -1;

1250

consdata->glbminactivityneghuge = -1;

1251

consdata->glbminactivityposhuge = -1;

1252

consdata->glbmaxactivityneghuge = -1;

1253

consdata->glbmaxactivityposhuge = -1;

1264 int

pseudoactivityposinf;

1265 int

pseudoactivityneginf;

1271

pseudoactivityposinf = 0;

1272

pseudoactivityneginf = 0;

1274 for

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

1276

val = consdata->vals[i];

1281

pseudoactivityposinf++;

1283

pseudoactivityneginf++;

1290

pseudoactivityneginf++;

1292

pseudoactivityposinf++;

1295

pseudoactivity += val *

bound

;

1299 if

( pseudoactivityneginf > 0 && pseudoactivityposinf > 0 )

1301 else if

( pseudoactivityneginf > 0 )

1303 else if

( pseudoactivityposinf > 0 )

1306 return

pseudoactivity;

1321 for

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

1330

consdata->validminact =

;

1333

consdata->lastminactivity =

(consdata->minactivity);

1348 for

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

1357

consdata->validmaxact =

;

1360

consdata->lastmaxactivity =

(consdata->maxactivity);

1375 for

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

1384

consdata->validglbminact =

;

1387

consdata->lastglbminactivity =

(consdata->glbminactivity);

1402 for

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

1411

consdata->validglbmaxact =

;

1414

consdata->lastglbmaxactivity =

(consdata->glbmaxactivity);

1426

assert(consdata !=

);

1427

assert(!consdata->validmaxabsval);

1430

consdata->validmaxabsval =

;

1431

consdata->maxabsval = 0.0;

1432 for

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

1434

absval = consdata->vals[i];

1436 if

( absval > consdata->maxabsval )

1437

consdata->maxabsval = absval;

1450

assert(consdata !=

);

1451

assert(!consdata->validminabsval);

1454

consdata->validminabsval =

;

1456 if

( consdata->nvars > 0 )

1457

consdata->minabsval =

(consdata->vals[0]);

1459

consdata->minabsval = 0.0;

1461 for

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

1463

absval = consdata->vals[i];

1465 if

( absval < consdata->minabsval )

1466

consdata->minabsval = absval;

1478

assert(!consdata->hasnonbinvalid);

1479

consdata->hasnonbinvar =

;

1480

consdata->hascontvar =

;

1482 for

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

1488

consdata->hasnonbinvar =

;

1492

consdata->hascontvar =

;

1497

assert(consdata->hascontvar || v < 0);

1499

consdata->hasnonbinvalid =

;

1503#ifdef CHECKMAXACTDELTA 1520 for

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

1532

delta =

(consdata->vals[v]) * domain;

1534 if

( delta > maxactdelta )

1536

maxactdelta = delta;

1543#define checkMaxActivityDelta(scip, consdata) 1556

consdata->maxactdelta = 0.0;

1558 if

( !consdata->hasnonbinvalid )

1562 if

( !consdata->hasnonbinvar )

1564 for

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

1568

delta =

(consdata->vals[v]);

1570 if

( delta > consdata->maxactdelta )

1572

consdata->maxactdelta = delta;

1573

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

1580 for

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

1592

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

1597

delta =

(consdata->vals[v]) * domain;

1599 if

( delta > consdata->maxactdelta )

1601

consdata->maxactdelta = delta;

1602

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

1625 int

* activityposinf;

1626 int

* activityneginf;

1627 int

* activityposhuge;

1628 int

* activityneghuge;

1636

assert(consdata !=

);

1637

assert(global || (var !=

));

1638

assert(consdata->validactivities);

1643

assert(consdata->minactivityneginf >= 0);

1644

assert(consdata->minactivityposinf >= 0);

1645

assert(consdata->maxactivityneginf >= 0);

1646

assert(consdata->maxactivityposinf >= 0);

1647

assert(consdata->minactivityneghuge >= 0);

1648

assert(consdata->minactivityposhuge >= 0);

1649

assert(consdata->maxactivityneghuge >= 0);

1650

assert(consdata->maxactivityposhuge >= 0);

1655

assert(consdata->glbminactivityneginf >= 0);

1656

assert(consdata->glbminactivityposinf >= 0);

1657

assert(consdata->glbmaxactivityneginf >= 0);

1658

assert(consdata->glbmaxactivityposinf >= 0);

1659

assert(consdata->glbminactivityneghuge >= 0);

1660

assert(consdata->glbminactivityposhuge >= 0);

1661

assert(consdata->glbmaxactivityneghuge >= 0);

1662

assert(consdata->glbmaxactivityposhuge >= 0);

1680

lastactivity = &(consdata->lastglbminactivity);

1681

activityposinf = &(consdata->glbminactivityposinf);

1682

activityneginf = &(consdata->glbminactivityneginf);

1683

activityposhuge = &(consdata->glbminactivityposhuge);

1684

activityneghuge = &(consdata->glbminactivityneghuge);

1685

validact = consdata->validglbminact;

1690

lastactivity = &(consdata->lastglbmaxactivity);

1691

activityposinf = &(consdata->glbmaxactivityneginf);

1692

activityneginf = &(consdata->glbmaxactivityposinf);

1693

activityposhuge = &(consdata->glbmaxactivityposhuge);

1694

activityneghuge = &(consdata->glbmaxactivityneghuge);

1695

validact = consdata->validglbmaxact;

1703

lastactivity = &(consdata->lastglbmaxactivity);

1704

activityposinf = &(consdata->glbmaxactivityposinf);

1705

activityneginf = &(consdata->glbmaxactivityneginf);

1706

activityposhuge = &(consdata->glbmaxactivityposhuge);

1707

activityneghuge = &(consdata->glbmaxactivityneghuge);

1708

validact = consdata->validglbmaxact;

1713

lastactivity = &(consdata->lastglbminactivity);

1714

activityposinf = &(consdata->glbminactivityneginf);

1715

activityneginf = &(consdata->glbminactivityposinf);

1716

activityposhuge = &(consdata->glbminactivityposhuge);

1717

activityneghuge = &(consdata->glbminactivityneghuge);

1718

validact = consdata->validglbminact;

1736

lastactivity = &(consdata->lastminactivity);

1737

activityposinf = &(consdata->minactivityposinf);

1738

activityneginf = &(consdata->minactivityneginf);

1739

activityposhuge = &(consdata->minactivityposhuge);

1740

activityneghuge = &(consdata->minactivityneghuge);

1741

validact = consdata->validminact;

1746

lastactivity = &(consdata->lastmaxactivity);

1747

activityposinf = &(consdata->maxactivityneginf);

1748

activityneginf = &(consdata->maxactivityposinf);

1749

activityposhuge = &(consdata->maxactivityposhuge);

1750

activityneghuge = &(consdata->maxactivityneghuge);

1751

validact = consdata->validmaxact;

1759

lastactivity = &(consdata->lastmaxactivity);

1760

activityposinf = &(consdata->maxactivityposinf);

1761

activityneginf = &(consdata->maxactivityneginf);

1762

activityposhuge = &(consdata->maxactivityposhuge);

1763

activityneghuge = &(consdata->maxactivityneghuge);

1764

validact = consdata->validmaxact;

1769

lastactivity = &(consdata->lastminactivity);

1770

activityposinf = &(consdata->minactivityneginf);

1771

activityneginf = &(consdata->minactivityposinf);

1772

activityposhuge = &(consdata->minactivityposhuge);

1773

activityneghuge = &(consdata->minactivityneghuge);

1774

validact = consdata->validminact;

1779

oldcontribution = val * oldbound;

1780

newcontribution = val * newbound;

1787 if

( oldbound > 0.0 )

1789

assert((*activityposinf) >= 1);

1792 if

( finitenewbound || newbound < 0.0 )

1795

(*activityposinf)--;

1798 if

( !finitenewbound && newbound < 0.0 )

1799

(*activityneginf)++;

1800 else if

( hugevalnewcont )

1803 if

( newcontribution > 0.0 )

1804

(*activityposhuge)++;

1806

(*activityneghuge)++;

1816

assert(oldbound < 0.0);

1817

assert((*activityneginf) >= 1);

1820 if

( finitenewbound || newbound > 0.0 )

1823

(*activityneginf)--;

1826 if

( !finitenewbound && newbound > 0.0 )

1827

(*activityposinf)++;

1828 else if

( hugevalnewcont )

1831 if

( newcontribution > 0.0 )

1832

(*activityposhuge)++;

1834

(*activityneghuge)++;

1845 if

( oldcontribution > 0.0 )

1847

assert((*activityposhuge) >= 1);

1852

(*activityposhuge)--;

1854 if

( !finitenewbound )

1857 if

( newbound > 0.0 )

1858

(*activityposinf)++;

1861

(*activityneginf)++;

1863 else if

( hugevalnewcont )

1866 if

( newcontribution > 0.0 )

1867

(*activityposhuge)++;

1870

(*activityneghuge)++;

1879

assert(oldcontribution < 0.0);

1880

assert((*activityneghuge) >= 1);

1885

(*activityneghuge)--;

1887 if

( !finitenewbound )

1890 if

( newbound > 0.0 )

1891

(*activityposinf)++;

1894

(*activityneginf)++;

1896 else if

( hugevalnewcont )

1899 if

( newcontribution > 0.0 )

1900

(*activityposhuge)++;

1903

(*activityneghuge)++;

1913 if

( !finitenewbound )

1918 if

( newbound > 0.0 )

1920

(*activityposinf)++;

1928

assert(newbound < 0.0 );

1930

(*activityneginf)++;

1935 else if

( hugevalnewcont )

1937 if

( newcontribution > 0.0 )

1939

(*activityposhuge)++;

1944

(*activityneghuge)++;

1971

(*lastactivity) = curractivity;

1977 SCIPdebugMsg

(

"%s activity of linear constraint unreliable after update: %16.9g\n"

1978

(global ?

"global "

""

), curractivity);

1984

consdata->validglbminact =

;

1986

consdata->validglbmaxact =

;

1991

consdata->validminact =

;

1993

consdata->validmaxact =

;

2013

assert(consdata !=

);

2014

assert(var !=

);

2016 if

( consdata->validactivities )

2038

assert(consdata !=

);

2039

assert(var !=

);

2041 if

( consdata->validactivities )

2062

assert(consdata !=

);

2064 if

( consdata->validactivities )

2085

assert(consdata !=

);

2087 if

( consdata->validactivities )

2107

assert(consdata !=

);

2108

assert(var !=

);

2112 if

( consdata->validmaxabsval )

2119

consdata->maxabsval =

(consdata->maxabsval, absval);

2123 if

( consdata->validminabsval )

2130

consdata->minabsval =

(consdata->minabsval, absval);

2134 if

( consdata->validactivities )

2156

consdata->maxactdeltavar = var;

2158 else if

( consdata->maxactdeltavar !=

)

2163 if

( delta > consdata->maxactdelta )

2165

consdata->maxactdelta = delta;

2166

consdata->maxactdeltavar = var;

2183

assert(consdata !=

);

2184

assert(var !=

);

2188 if

( consdata->validmaxabsval )

2196

consdata->validmaxabsval =

;

2202 if

( consdata->validminabsval )

2210

consdata->validminabsval =

;

2216 if

( consdata->validactivities )

2230 if

( consdata->maxactdeltavar == var )

2233

consdata->maxactdeltavar =

;

2259

assert(consdata !=

);

2261 if

( !consdata->validmaxabsval )

2263

assert(consdata->validmaxabsval);

2266 return

consdata->maxabsval;

2275

assert(consdata !=

);

2277 if

( !consdata->validminabsval )

2279

assert(consdata->validminabsval);

2282 return

consdata->minabsval;

2297

assert(consdata !=

);

2298

assert(!consdata->validactivities);

2304

consdata->validmaxabsval =

;

2305

consdata->validminabsval =

;

2306

consdata->validactivities =

;

2307

consdata->validminact =

;

2308

consdata->validmaxact =

;

2309

consdata->validglbminact =

;

2310

consdata->validglbmaxact =

;

2311

consdata->maxabsval = 0.0;

2312

consdata->minabsval = (consdata->nvars == 0 ? 0.0 :

(consdata->vals[0]));

2315

consdata->lastminactivity = 0.0;

2316

consdata->lastmaxactivity = 0.0;

2317

consdata->minactivityneginf = 0;

2318

consdata->minactivityposinf = 0;

2319

consdata->maxactivityneginf = 0;

2320

consdata->maxactivityposinf = 0;

2321

consdata->minactivityneghuge = 0;

2322

consdata->minactivityposhuge = 0;

2323

consdata->maxactivityneghuge = 0;

2324

consdata->maxactivityposhuge = 0;

2327

consdata->lastglbminactivity = 0.0;

2328

consdata->lastglbmaxactivity = 0.0;

2329

consdata->glbminactivityneginf = 0;

2330

consdata->glbminactivityposinf = 0;

2331

consdata->glbmaxactivityneginf = 0;

2332

consdata->glbmaxactivityposinf = 0;

2333

consdata->glbminactivityneghuge = 0;

2334

consdata->glbminactivityposhuge = 0;

2335

consdata->glbmaxactivityneghuge = 0;

2336

consdata->glbmaxactivityposhuge = 0;

2338 for

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

2341

consdata->lastminactivity =

(consdata->minactivity);

2342

consdata->lastmaxactivity =

(consdata->maxactivity);

2343

consdata->lastglbminactivity =

(consdata->glbminactivity);

2344

consdata->lastglbmaxactivity =

(consdata->glbmaxactivity);

2369

assert(consdata !=

);

2370

assert(posinf >= 0);

2371

assert(neginf >= 0);

2372

assert(poshuge >= 0);

2373

assert(neghuge >= 0);

2374

assert(minactivity !=

);

2375

assert(istight !=

);

2376

assert(issettoinfinity !=

);

2382

*issettoinfinity =

;

2383

*istight = posinf == 0;

2386 else if

( posinf > 0 )

2389

*issettoinfinity =

;

2393 else if

( neghuge > 0 || ( poshuge > 0 && !goodrelax ) )

2396

*issettoinfinity =

;

2406 if

( !consdata->validglbminact )

2408

assert(consdata->validglbminact);

2414 if

( !consdata->validminact )

2416

assert(consdata->validminact);

2438

*issettoinfinity =

;

2464

assert(consdata !=

);

2465

assert(posinf >= 0);

2466

assert(neginf >= 0);

2467

assert(poshuge >= 0);

2468

assert(neghuge >= 0);

2469

assert(maxactivity !=

);

2470

assert(istight !=

);

2471

assert(issettoinfinity !=

);

2477

*issettoinfinity =

;

2478

*istight = neginf == 0;

2481 else if

( neginf > 0 )

2484

*issettoinfinity =

;

2488 else if

( poshuge > 0 || ( neghuge > 0 && !goodrelax ) )

2491

*issettoinfinity =

;

2501 if

( !consdata->validglbmaxact )

2503

assert(consdata->validglbmaxact);

2509 if

( !consdata->validmaxact )

2511

assert(consdata->validmaxact);

2533

*issettoinfinity =

;

2556

assert(consdata !=

);

2557

assert(minactivity !=

);

2558

assert(maxactivity !=

);

2559

assert(isminsettoinfinity !=

);

2560

assert(ismaxsettoinfinity !=

);

2562 if

( !consdata->validactivities )

2565

assert(consdata->validminact);

2566

assert(consdata->validmaxact);

2570

assert(consdata->minactivityneginf >= 0);

2571

assert(consdata->minactivityposinf >= 0);

2572

assert(consdata->maxactivityneginf >= 0);

2573

assert(consdata->maxactivityposinf >= 0);

2575 getMinActivity

(

, consdata, consdata->minactivityposinf, consdata->minactivityneginf,

2576

consdata->minactivityposhuge, consdata->minactivityneghuge, 0.0,

, goodrelax,

2577

minactivity, ismintight, isminsettoinfinity);

2579 getMaxActivity

(

, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,

2580

consdata->maxactivityposhuge, consdata->maxactivityneghuge, 0.0,

, goodrelax,

2581

maxactivity, ismaxtight, ismaxsettoinfinity);

2602

assert(consdata !=

);

2603

assert(cancelvar !=

);

2604

assert(resactivity !=

);

2608 for

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

2610

var = consdata->vars[v];

2611

assert(var !=

);

2612 if

( var == cancelvar )

2615

val = consdata->vals[v];

2617 if

( useglobalbounds )

2637

*resactivity += val*lb;

2643

*resactivity += val*ub;

2652

*resactivity += val*ub;

2658

*resactivity += val*lb;

2689

assert(consdata !=

);

2690

assert(var !=

);

2691

assert(minresactivity !=

);

2692

assert(maxresactivity !=

);

2693

assert(ismintight !=

);

2694

assert(ismaxtight !=

);

2695

assert(isminsettoinfinity !=

);

2696

assert(ismaxsettoinfinity !=

);

2699 if

( !consdata->validactivities )

2702

assert(consdata->validminact);

2703

assert(consdata->validmaxact);

2707

assert(consdata->minactivityneginf >= 0);

2708

assert(consdata->minactivityposinf >= 0);

2709

assert(consdata->maxactivityneginf >= 0);

2710

assert(consdata->maxactivityposinf >= 0);

2711

assert(consdata->minactivityneghuge >= 0);

2712

assert(consdata->minactivityposhuge >= 0);

2713

assert(consdata->maxactivityneghuge >= 0);

2714

assert(consdata->maxactivityposhuge >= 0);

2734

assert(consdata->minactivityposinf >= 1);

2736 getMinActivity

(

, consdata, consdata->minactivityposinf - 1, consdata->minactivityneginf,

2737

consdata->minactivityposhuge, consdata->minactivityneghuge, 0.0,

, goodrelax,

2738

minresactivity, ismintight, isminsettoinfinity);

2742

assert(consdata->minactivityneginf >= 1);

2744 getMinActivity

(

, consdata, consdata->minactivityposinf, consdata->minactivityneginf - 1,

2745

consdata->minactivityposhuge, consdata->minactivityneghuge, 0.0,

, goodrelax,

2746

minresactivity, ismintight, isminsettoinfinity);

2750

assert(consdata->minactivityposhuge >= 1);

2752 getMinActivity

(

, consdata, consdata->minactivityposinf, consdata->minactivityneginf,

2753

consdata->minactivityposhuge - 1, consdata->minactivityneghuge, 0.0,

, goodrelax,

2754

minresactivity, ismintight, isminsettoinfinity);

2758

assert(consdata->minactivityneghuge >= 1);

2760 getMinActivity

(

, consdata, consdata->minactivityposinf, consdata->minactivityneginf,

2761

consdata->minactivityposhuge, consdata->minactivityneghuge - 1, 0.0,

, goodrelax,

2762

minresactivity, ismintight, isminsettoinfinity);

2766 getMinActivity

(

, consdata, consdata->minactivityposinf, consdata->minactivityneginf,

2767

consdata->minactivityposhuge, consdata->minactivityneghuge, absval * minactbound,

, goodrelax,

2768

minresactivity, ismintight, isminsettoinfinity);

2776

assert(consdata->maxactivityneginf >= 1);

2778 getMaxActivity

(

, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf - 1,

2779

consdata->maxactivityposhuge, consdata->maxactivityneghuge, 0.0,

, goodrelax,

2780

maxresactivity, ismaxtight, ismaxsettoinfinity);

2784

assert(consdata->maxactivityposinf >= 1);

2786 getMaxActivity

(

, consdata, consdata->maxactivityposinf - 1, consdata->maxactivityneginf,

2787

consdata->maxactivityposhuge, consdata->maxactivityneghuge, 0.0,

, goodrelax,

2788

maxresactivity, ismaxtight, ismaxsettoinfinity);

2792

assert(consdata->maxactivityposhuge >= 1);

2794 getMaxActivity

(

, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,

2795

consdata->maxactivityposhuge - 1, consdata->maxactivityneghuge, 0.0,

, goodrelax,

2796

maxresactivity, ismaxtight, ismaxsettoinfinity);

2800

assert(consdata->maxactivityneghuge >= 1);

2802 getMaxActivity

(

, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,

2803

consdata->maxactivityposhuge, consdata->maxactivityneghuge - 1, 0.0,

, goodrelax,

2804

maxresactivity, ismaxtight, ismaxsettoinfinity);

2808 getMaxActivity

(

, consdata, consdata->maxactivityposinf, consdata->maxactivityneginf,

2809

consdata->maxactivityposhuge, consdata->maxactivityneghuge, absval * maxactbound,

, goodrelax,

2810

maxresactivity, ismaxtight, ismaxsettoinfinity);

2832

assert(consdata !=

);

2833

assert((glbminactivity !=

&& ismintight !=

&& isminsettoinfinity !=

)

2834

|| (glbmaxactivity !=

&& ismaxtight !=

&& ismaxsettoinfinity !=

));

2836 if

( !consdata->validactivities )

2839

assert(consdata->validglbminact);

2840

assert(consdata->validglbmaxact);

2844

assert(consdata->glbminactivityneginf >= 0);

2845

assert(consdata->glbminactivityposinf >= 0);

2846

assert(consdata->glbmaxactivityneginf >= 0);

2847

assert(consdata->glbmaxactivityposinf >= 0);

2848

assert(consdata->glbminactivityneghuge >= 0);

2849

assert(consdata->glbminactivityposhuge >= 0);

2850

assert(consdata->glbmaxactivityneghuge >= 0);

2851

assert(consdata->glbmaxactivityposhuge >= 0);

2853 if

( glbminactivity !=

)

2855

assert(isminsettoinfinity !=

);

2856

assert(ismintight !=

);

2858 getMinActivity

(

, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,

2859

consdata->glbminactivityposhuge, consdata->glbminactivityneghuge, 0.0,

, goodrelax,

2860

glbminactivity, ismintight, isminsettoinfinity);

2863 if

( glbmaxactivity !=

)

2865

assert(ismaxsettoinfinity !=

);

2866

assert(ismaxtight !=

);

2868 getMaxActivity

(

, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,

2869

consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge, 0.0,

, goodrelax,

2870

glbmaxactivity, ismaxtight, ismaxsettoinfinity);

2898

assert(consdata !=

);

2899

assert(var !=

);

2900

assert((minresactivity !=

&& ismintight !=

&& isminsettoinfinity !=

)

2901

|| (maxresactivity !=

&& ismaxtight !=

&& ismaxsettoinfinity !=

));

2904 if

( !consdata->validactivities )

2909

assert(consdata->glbminactivityneginf >= 0);

2910

assert(consdata->glbminactivityposinf >= 0);

2911

assert(consdata->glbmaxactivityneginf >= 0);

2912

assert(consdata->glbmaxactivityposinf >= 0);

2927 if

( minresactivity !=

)

2929

assert(isminsettoinfinity !=

);

2930

assert(ismintight !=

);

2937

assert(consdata->glbminactivityposinf >= 1);

2939 getMinActivity

(

, consdata, consdata->glbminactivityposinf - 1, consdata->glbminactivityneginf,

2940

consdata->glbminactivityposhuge, consdata->glbminactivityneghuge, 0.0,

, goodrelax,

2941

minresactivity, ismintight, isminsettoinfinity);

2945

assert(consdata->glbminactivityneginf >= 1);

2947 getMinActivity

(

, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf - 1,

2948

consdata->glbminactivityposhuge, consdata->glbminactivityneghuge, 0.0,

, goodrelax,

2949

minresactivity, ismintight, isminsettoinfinity);

2953

assert(consdata->glbminactivityposhuge >= 1);

2955 getMinActivity

(

, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,

2956

consdata->glbminactivityposhuge - 1, consdata->glbminactivityneghuge, 0.0,

, goodrelax,

2957

minresactivity, ismintight, isminsettoinfinity);

2961

assert(consdata->glbminactivityneghuge >= 1);

2963 getMinActivity

(

, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,

2964

consdata->glbminactivityposhuge, consdata->glbminactivityneghuge - 1, 0.0,

, goodrelax,

2965

minresactivity, ismintight, isminsettoinfinity);

2969 getMinActivity

(

, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf,

2970

consdata->glbminactivityposhuge, consdata->glbminactivityneghuge, absval * minactbound,

2971

goodrelax, minresactivity, ismintight, isminsettoinfinity);

2975 if

( maxresactivity !=

)

2977

assert(ismaxsettoinfinity !=

);

2978

assert(ismaxtight !=

);

2985

assert(consdata->glbmaxactivityneginf >= 1);

2987 getMaxActivity

(

, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf - 1,

2988

consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge, 0.0,

, goodrelax,

2989

maxresactivity, ismaxtight, ismaxsettoinfinity);

2993

assert(consdata->glbmaxactivityposinf >= 1);

2995 getMaxActivity

(

, consdata, consdata->glbmaxactivityposinf - 1, consdata->glbmaxactivityneginf,

2996

consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge, 0.0,

, goodrelax,

2997

maxresactivity, ismaxtight, ismaxsettoinfinity);

3001

assert(consdata->glbmaxactivityposhuge >= 1);

3003 getMaxActivity

(

, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,

3004

consdata->glbmaxactivityposhuge - 1, consdata->glbmaxactivityneghuge, 0.0,

, goodrelax,

3005

maxresactivity, ismaxtight, ismaxsettoinfinity);

3009

assert(consdata->glbmaxactivityneghuge >= 1);

3011 getMaxActivity

(

, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,

3012

consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge - 1, 0.0,

, goodrelax,

3013

maxresactivity, ismaxtight, ismaxsettoinfinity);

3017 getMaxActivity

(

, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf,

3018

consdata->glbmaxactivityposhuge, consdata->glbmaxactivityneghuge, absval * maxactbound,

3019

goodrelax, maxresactivity, ismaxtight, ismaxsettoinfinity);

3035

assert(consdata !=

);

3051 for

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

3055 if

( consdata->vals[v] < 0 )

3065

activity += consdata->vals[v] * solval;

3067

assert(nneginf >= 0 && nposinf >= 0);

3069 SCIPdebugMsg

(

"activity of linear constraint: %.15g, %d positive infinity values, %d negative infinity values \n"

, activity, nposinf, nneginf);

3072 if

( nposinf > 0 && nneginf > 0 )

3073

activity = (consdata->rhs + consdata->lhs) / 2;

3074 else if

( nposinf > 0 )

3076 else if

( nneginf > 0 )

3079 SCIPdebugMsg

(

"corrected activity of linear constraint: %.15g\n"

, activity);

3084 else if

( activity < 0 )

3103

assert(consdata !=

);

3110 return MIN

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

3120

uint64_t varsignature;

3125

assert(consdata !=

);

3126

assert(consdata->validsignature);

3131

val = consdata->vals[pos];

3132 if

( (val > 0.0 && ub > 0.0) || (val < 0.0 && lb < 0.0) )

3133

consdata->possignature |= varsignature;

3134 if

( (val > 0.0 && lb < 0.0) || (val < 0.0 && ub > 0.0) )

3135

consdata->negsignature |= varsignature;

3144

assert(consdata !=

);

3146 if

( !consdata->validsignature )

3150

consdata->validsignature =

;

3151

consdata->possignature = 0;

3152

consdata->negsignature = 0;

3153 for

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

3166

assert(consdata !=

);

3167

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

3168

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

3170

var1 = consdata->vars[ind1];

3171

var2 = consdata->vars[ind2];

3188 if

( vartype1 < vartype2 )

3190 else if

( vartype1 > vartype2 )

3205

assert(consdata !=

);

3206

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

3207

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

3209

var1 = consdata->vars[ind1];

3210

var2 = consdata->vars[ind2];

3223 if

(

(abscoef1, abscoef2, 1e-9) )

3225 else if

(

(abscoef2, abscoef1, 1e-9) )

3235 if

( vartype1 < vartype2 )

3239 else if

( vartype1 > vartype2 )

3256 if

(

(abscont1, abscont2, 1e-9) )

3258 else if

(

(abscont2, abscont1, 1e-9) )

3282

assert(perm !=

);

3283

assert(consdata !=

);

3287 for

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

3291

varv = consdata->vars[v];

3292

valv = consdata->vals[v];

3293 if

( consdata->eventdata !=

)

3294

eventdatav = consdata->eventdata[v];

3298

assert(0 <= perm[i] && perm[i] < nvars);

3299

assert(perm[i] != i);

3300

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

3301

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

3302 if

( consdata->eventdata !=

)

3304

consdata->eventdata[i] = consdata->eventdata[perm[i]];

3305

consdata->eventdata[i]->varpos = i;

3311 while

( perm[i] != v );

3312

consdata->vars[i] = varv;

3313

consdata->vals[i] = valv;

3314 if

( consdata->eventdata !=

)

3316

consdata->eventdata[i] = eventdatav;

3317

consdata->eventdata[i]->varpos = i;

3324 for

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

3326

assert(perm[v] == v);

3327

assert(consdata->eventdata ==

|| consdata->eventdata[v]->varpos == v);

3351

assert(consdata !=

);

3354 if

( consdata->nvars <= 1 )

3356

consdata->indexsorted =

;

3357

consdata->coefsorted =

;

3358

consdata->nbinvars = (consdata->nvars == 1 ? (int)

SCIPvarIsBinary

(consdata->vars[0]) : 0);

3371 SCIPsort

(perm, consdataCompVar, (

void

*)consdata, consdata->nvars);

3373 SCIPsort

(perm, consdataCompVarProp, (

void

*)consdata, consdata->nvars);

3382

consdata->indexsorted =

;

3383

consdata->coefsorted =

;

3386

consdata->nbinvars = 0;

3387 for

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

3390

++consdata->nbinvars;

3397

consdata->indexsorted =

;

3398

consdata->coefsorted =

;

3423

assert(cons !=

);

3432

assert(consdata !=

);

3433

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

&& consdata->vals !=

));

3444

consdata->rhs = lhs;

3445

assert(consdata->row ==

);

3449 for

( i = 0; i <

NLOCKTYPES

&& !locked; i++ )

3462

vars = consdata->vars;

3463

vals = consdata->vals;

3465 for

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

3467

assert(vars[v] !=

);

3487

vars = consdata->vars;

3488

vals = consdata->vals;

3490 for

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

3492

assert(vars[v] !=

);

3510

consdata->boundstightened = 0;

3511

consdata->presolved =

;

3512

consdata->cliquesadded =

;

3513

consdata->implsadded =

;

3523

consdata->lhs = lhs;

3524

consdata->changed =

;

3525

consdata->normalized =

;

3526

consdata->upgradetried =

;

3527

consdata->rangedrowpropagated = 0;

3530 if

( consdata->row !=

)

3551

assert(cons !=

);

3560

assert(consdata !=

);

3561

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

&& consdata->vals !=

));

3572

consdata->lhs = rhs;

3573

assert(consdata->row ==

);

3577 for

( i = 0; i <

NLOCKTYPES

&& !locked; i++ )

3592

vars = consdata->vars;

3593

vals = consdata->vals;

3595 for

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

3597

assert(vars[v] !=

);

3617

vars = consdata->vars;

3618

vals = consdata->vals;

3620 for

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

3622

assert(vars[v] !=

);

3640

consdata->boundstightened = 0;

3641

consdata->presolved =

;

3642

consdata->cliquesadded =

;

3643

consdata->implsadded =

;

3653

consdata->rhs = rhs;

3654

consdata->changed =

;

3655

consdata->normalized =

;

3656

consdata->upgradetried =

;

3657

consdata->rangedrowpropagated = 0;

3660 if

( consdata->row !=

)

3681

assert(cons !=

);

3682

assert(var !=

);

3687

assert(consdata !=

);

3697

assert(var !=

);

3701

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

3702

consdata->vals[consdata->nvars] = val;

3711 if

( consdata->eventdata !=

)

3719

assert(conshdlrdata !=

);

3720

assert(conshdlrdata->eventhdlr !=

);

3723

consdata->eventdata[consdata->nvars-1] =

;

3746

consdata->boundstightened = 0;

3747

consdata->presolved =

;

3748

consdata->removedfixings = consdata->removedfixings &&

SCIPvarIsActive

(var);

3750 if

( consdata->validsignature )

3753

consdata->changed =

;

3754

consdata->normalized =

;

3755

consdata->upgradetried =

;

3756

consdata->cliquesadded =

;

3757

consdata->implsadded =

;

3758

consdata->rangedrowpropagated = 0;

3759

consdata->merged =

;

3761 if

( consdata->nvars == 1 )

3763

consdata->indexsorted =

;

3764

consdata->coefsorted =

;

3770

consdata->indexsorted = consdata->indexsorted && (consdataCompVar((

void

*)consdata, consdata->nvars-2, consdata->nvars-1) <= 0);

3771

consdata->coefsorted =

;

3775

consdata->indexsorted =

;

3776

consdata->coefsorted = consdata->coefsorted && (consdataCompVarProp((

void

*)consdata, consdata->nvars-2, consdata->nvars-1) <= 0);

3781 if

( consdata->hasnonbinvalid && !consdata->hascontvar )

3787

consdata->hasnonbinvar =

;

3790

consdata->hascontvar =

;

3795 if

( consdata->row !=

)

3816

assert(cons !=

);

3819

assert(consdata !=

);

3820

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

3822

var = consdata->vars[pos];

3823

val = consdata->vals[pos];

3824

assert(var !=

);

3841

assert(conshdlrdata !=

);

3842

assert(conshdlrdata->eventhdlr !=

);

3845 if

( consdata->eventdata !=

)

3848

assert(consdata->eventdata[pos] ==

);

3853 if

( pos != consdata->nvars - 1 )

3855

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

3856

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

3858 if

( consdata->eventdata !=

)

3860

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

3861

assert(consdata->eventdata[pos] !=

);

3862

consdata->eventdata[pos]->varpos = pos;

3865

consdata->indexsorted = consdata->indexsorted && (pos + 2 >= consdata->nvars);

3866

consdata->coefsorted = consdata->coefsorted && (pos + 2 >= consdata->nvars);

3873 if

( consdata->nvars <= 1 )

3888

consdata->boundstightened = 0;

3889

consdata->presolved =

;

3890

consdata->validsignature =

;

3891

consdata->changed =

;

3892

consdata->normalized =

;

3893

consdata->upgradetried =

;

3894

consdata->cliquesadded =

;

3895

consdata->implsadded =

;

3896

consdata->rangedrowpropagated = 0;

3901

consdata->hasnonbinvalid =

;

3905 if

( consdata->row !=

)

3932

assert(cons !=

);

3934

assert(consdata !=

);

3935

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

3936

var = consdata->vars[pos];

3937

assert(var !=

);

3939

val = consdata->vals[pos];

3943 for

( i = 0; i <

NLOCKTYPES

&& !locked; i++ )

3966

consdata->vals[pos] = newval;

3968 if

( consdata->coefsorted )

3971

consdata->coefsorted = (consdataCompVarProp((

void

*)consdata, pos - 1, pos) <= 0);

3972 if

( consdata->coefsorted && pos < consdata->nvars - 1 )

3973

consdata->coefsorted = (consdataCompVarProp((

void

*)consdata, pos, pos + 1) <= 0);

3993

consdata->boundstightened = 0;

3994

consdata->presolved =

;

3995

consdata->validsignature = consdata->validsignature && (newval * val > 0.0);

3996

consdata->changed =

;

3997

consdata->normalized =

;

3998

consdata->upgradetried =

;

3999

consdata->cliquesadded =

;

4000

consdata->implsadded =

;

4001

consdata->rangedrowpropagated = 0;

4020

assert(cons !=

);

4023

assert(consdata !=

);

4024

assert(consdata->row ==

);

4025

assert(scalar != 1.0);

4030 SCIPwarningMessage

(

"skipped scaling for linear constraint <%s> to avoid numerical troubles (scalar: %.15g)\n"

4037 for

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

4039

newval = scalar * consdata->vals[i];

4049 SCIPwarningMessage

(

"coefficient %.15g of variable <%s> in linear constraint <%s> scaled to zero (scalar: %.15g)\n"

4054

consdata->vals[i] = newval;

4062

lhs = consdata->lhs;

4063

consdata->lhs = -consdata->rhs;

4064

consdata->rhs = -lhs;

4069

newval = absscalar * consdata->lhs;

4077

consdata->lhs = newval;

4081

newval = absscalar * consdata->rhs;

4089

consdata->rhs = newval;

4093

consdata->cliquesadded =

;

4094

consdata->implsadded =

;

4113

assert(conshdlr !=

);

4114

assert(conss !=

);

4115

assert(nconss >= 0);

4119 for

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

4124 if

( consdata->varsdeleted )

4127 for

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

4134

consdata->varsdeleted =

;

4186

assert(cons !=

);

4187

assert(infeasible !=

);

4189

*infeasible =

;

4197

assert(consdata !=

);

4200 if

( consdata->normalized )

4204

vals = consdata->vals;

4205

nvars = consdata->nvars;

4206

assert(nvars == 0 || vals !=

);

4210

consdata->normalized =

;

4214

assert(vals !=

);

4236

scalar = 2.0 / (minabsval + maxabsval);

4243 SCIPdebugMsg

(

"divide linear constraint with %g, because all coefficients are in absolute value the same\n"

, maxabsval);

4248

vals = consdata->vals;

4249

nvars = consdata->nvars;

4251

assert(nvars == 0 || vals !=

);

4258

consdata->normalized =

;

4262

assert(vals !=

);

4274 if

( !consdata->hasnonbinvalid )

4281 if

( !consdata->hascontvar )

4320 for

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

4322 if

( vals[i] > 0.0 )

4327 if

( nposcoeffs > nnegcoeffs )

4329 else if

( nposcoeffs < nnegcoeffs )

4339

assert(mult == +1 || mult == -1);

4348

assert(nvars == consdata->nvars);

4358 for

( i = 0; i < nvars && success && scm <= maxmult; ++i )

4363

success =

SCIPrealToRational

(vals[i], -epsilon, epsilon , maxmult, &numerator, &denominator);

4373

onlyintegral =

;

4376 for

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

4380

onlyintegral =

;

4386

success = success && (scm <= maxmult || (scm == 1 && onlyintegral));

4387 if

( success && scm != 1 )

4394 if

( consdata->validmaxabsval )

4399

consdata->validmaxabsval =

;

4405 if

( consdata->validminabsval )

4410

consdata->validminabsval =

;

4417

vals = consdata->vals;

4418

nvars = consdata->nvars;

4419

assert(nvars == 0 || vals !=

);

4425 if

( success && nvars >= 1 )

4431 for

( i = 1; i < nvars && gcd > 1; ++i )

4440 if

( !consdata->hascontvar && onlyintegral )

4444

*infeasible =

;

4458 if

( consdata->validmaxabsval )

4462 if

( consdata->validminabsval )

4470

consdata->normalized =

;

4491

assert(cons !=

);

4494

assert(consdata !=

);

4496 if

( consdata->merged )

4502

v = consdata->nvars - 1;

4510

var = consdata->vars[v];

4511

valsum = consdata->vals[v];

4514 while

( v >= 1 && consdata->vars[v-1] == var )

4518

valsum += consdata->vals[v];

4521

assert(consdata->vars[v] == var);

4528 else if

( valsum != consdata->vals[v] )

4536

consdata->merged =

;

4555

assert(cons !=

);

4557 if

( infeasible !=

)

4558

*infeasible =

;

4561

assert(consdata !=

);

4563 if

( consdata->eventdata ==

)

4569

assert(conshdlr !=

);

4572

assert(conshdlrdata !=

);

4576

assert(consdata->eventdata !=

);

4579 if

( !consdata->removedfixings )

4589

lhssubtrahend = 0.0;

4590

rhssubtrahend = 0.0;

4596 while

( v < consdata->nvars )

4598 SCIP_VAR

* var = consdata->vars[v];

4608 SCIPerrorMessage

(

"original variable in transformed linear constraint\n"

);

4618 if

( var != consdata->vars[v] )

4620

assert(scalar != 0.0);

4626

lhssubtrahend += constant;

4628

rhssubtrahend += constant;

4634 if

( scalar != 0.0 )

4648 for

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

4653

constant += scalar * aggrconstant;

4663 if

( constant < 0.0 )

4667 if

( infeasible !=

)

4669

*infeasible =

;

4679

lhssubtrahend += constant;

4686 if

( constant > 0.0 )

4690 if

( infeasible !=

)

4692

*infeasible =

;

4702

rhssubtrahend += constant;

4723 if

( infeasible !=

)

4725

*infeasible =

;

4755 if

( infeasible !=

)

4757

*infeasible =

;

4778

consdata->removedfixings =

;

4791

assert(consdata->removedfixings);

4795 for

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

4824

assert(cons !=

);

4828

assert(consdata !=

);

4830

vars = consdata->vars;

4831

vals = consdata->vals;

4832

nvars = consdata->nvars;

4834

assert(vars !=

|| nvars == 0);

4835

assert(vals !=

|| nvars == 0);

4837

assert(-1 <= inferpos && inferpos < nvars);

4838

assert((infervar ==

) == (inferpos == -1));

4839

assert(inferpos == -1 || vars[inferpos] == infervar);

4861 if

( infervar !=

)

4863

assert(vals !=

);

4866

&ismintight,

, &isminsettoinfinity,

);

4869 NULL

, &ismaxtight,

, &ismaxsettoinfinity);

4875

&ismintight,

, &isminsettoinfinity,

);

4878 NULL

, &ismaxtight,

, &ismaxsettoinfinity);

4882 if

( (reasonisrhs && !isminsettoinfinity && ismintight) || (!reasonisrhs && !ismaxsettoinfinity && ismaxtight) )

4887

resactisinf =

;

4892 if

( infervar !=

)

4894

assert(vals !=

);

4902

resactisinf =

;

4904

rescap = consdata->rhs - minresactivity;

4912

resactisinf =

;

4914

rescap = consdata->lhs - maxresactivity;

4917 if

( reasonisrhs == (vals[inferpos] > 0.0) )

4923

rescap = (reasonisrhs ? consdata->rhs - minresactivity : consdata->lhs - maxresactivity);

4928 for

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

4930

assert( vars !=

&& vals !=

);

4942 if

( reasonisrhs == (vals[i] > 0.0) )

4961 for

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

4963

assert(vars !=

);

4964

assert(vals !=

);

4970 if

( reasonisrhs == (vals[i] > 0.0) )

5004

assert(cons !=

);

5007

assert(consdata !=

);

5008

vars = consdata->vars;

5009

nvars = consdata->nvars;

5010

assert(vars !=

|| nvars == 0);

5011

assert(-1 <= inferpos && inferpos < nvars);

5012

assert((infervar ==

) == (inferpos == -1));

5013

assert(inferpos == -1 || vars !=

);

5014

assert(inferpos == -1 || vars[inferpos] == infervar);

5017 for

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

5019

assert(vars !=

);

5022 if

( vars[v] == infervar )

5024

assert(vars[v] !=

);

5068 for

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

5070

assert(vars !=

);

5125

assert(cons !=

);

5126

assert(result !=

);

5129

assert(consdata !=

);

5130

vars = consdata->vars;

5131

nvars = consdata->nvars;

5133

vals = consdata->vals;

5134

assert(vars !=

);

5135

assert(vals !=

);

5140 if

( inferpos >= nvars || vars[inferpos] != infervar )

5144 for

( inferpos = 0; inferpos < nvars && vars[inferpos] != infervar; ++inferpos )

5147

assert(inferpos < nvars);

5148

assert(vars[inferpos] == infervar);

5186 SCIPerrorMessage

(

"invalid inference information %d in linear constraint <%s> at position %d for %s bound of variable <%s>\n"

5232

assert(consdata !=

);

5234

infcountmin = consdata->minactivityneginf

5235

+ consdata->minactivityposinf

5236

+ consdata->minactivityneghuge

5237

+ consdata->minactivityposhuge;

5238

infcountmax = consdata->maxactivityneginf

5239

+ consdata->maxactivityposinf

5240

+ consdata->maxactivityneghuge

5241

+ consdata->maxactivityposhuge;

5243 if

( infcountmin > 1 && infcountmax > 1 )

5269

assert(cons !=

);

5273

assert(consdata !=

);

5274

var = consdata->vars[pos];

5275

assert(var !=

);

5284 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newub=%.15g\n"

5286 QUAD_TO_DBL

(consdata->minactivity),

(consdata->maxactivity), consdata->lhs, consdata->rhs, newub);

5295 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n"

5303 else if

( tightened )

5306 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n"

5313

consdata->upgradetried =

;

5339

assert(cons !=

);

5343

assert(consdata !=

);

5344

var = consdata->vars[pos];

5345

assert(var !=

);

5354 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n"

5356 QUAD_TO_DBL

(consdata->minactivity),

(consdata->maxactivity), consdata->lhs, consdata->rhs, newlb);

5365 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n"

5373 else if

( tightened )

5376 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n"

5383

consdata->upgradetried =

;

5409

assert(cons !=

);

5410

assert(cutoff !=

);

5411

assert(nchgbds !=

);

5418

assert(consdata !=

);

5419

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

5423

var = consdata->vars[pos];

5424

assert(var !=

);

5430

val = consdata->vals[pos];

5431

lhs = consdata->lhs;

5432

rhs = consdata->rhs;

5442 if

( !consdata->validactivities )

5444

assert(consdata->validactivities);

5445 if

( !consdata->validminact )

5447

assert(consdata->validminact);

5458

assert(consdata->validminact);

5463 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, minactivity=%.15g > rhs=%.15g\n"

5470

slack = rhs -

(consdata->minactivity);

5478

alpha = val * (ub - lb);

5486

newub = lb + (slack / val);

5492 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n"

5510 if

( !consdata->validmaxact )

5514

assert(consdata->validmaxact);

5519 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, maxactivity=%.15g < lhs=%.15g\n"

5526

slack =

(consdata->maxactivity) - lhs;

5534

alpha = val * (ub - lb);

5542

newlb = ub - (slack / val);

5548 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n"

5565

assert(consdata->validminact);

5570 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, minactivity=%.15g > rhs=%.15g\n"

5577

slack = rhs -

(consdata->minactivity);

5585

alpha = val * (lb - ub);

5593

newlb = ub + slack / val;

5599 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n"

5616 if

( !consdata->validmaxact )

5620

assert(consdata->validmaxact);

5625 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, maxactivity=%.15g < lhs=%.15g\n"

5632

slack =

(consdata->maxactivity) - lhs;

5640

alpha = val * (lb - ub);

5648

newub = lb - (slack / val);

5654 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n"

5681

assert(cons !=

);

5684

assert(consdata !=

);

5764

assert(cons !=

);

5765

assert(cutoff !=

);

5766

assert(nfixedvars !=

);

5767

assert(nchgbds !=

);

5768

assert(naddconss !=

);

5775

assert(consdata !=

);

5778 if

( consdata->rangedrowpropagated == 2 )

5782 if

( consdata->nvars < 3 )

5791

assert(conshdlr !=

);

5793

assert(conshdlrdata !=

);

5799

consdata->rangedrowpropagated = 2;

5806 if

( consdata->rangedrowpropagated > 0 )

5809

consdata->rangedrowpropagated = 1;

5814 for

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

5832

lhs = consdata->lhs - fixedact;

5833

rhs = consdata->rhs - fixedact;

5834

nunfixedvars = consdata->nvars - nfixedconsvars;

5843

possiblegcd =

;

5879

absval =

(consdata->vals[v]);

5881 if

( absminbincoef > absval )

5882

absminbincoef = absval;

5886

possiblegcd =

;

5887

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

5888

infcheckvals[ninfcheckvars] = consdata->vals[v];

5904 if

( v == consdata->nvars )

5908 if

( ncontvars + 2 > nunfixedvars )

5921 for

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

5930

absval =

(consdata->vals[v]);

5932 if

( absminbincoef > absval )

5933

absminbincoef = absval;

5943

possiblegcd =

;

5944

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

5945

infcheckvals[ninfcheckvars] = consdata->vals[v];

5954

assert(

(consdata->vals[v]) > 1.5);

5957

assert(gcdtmp >= 1);

5961

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

5962

infcheckvals[ninfcheckvars] = consdata->vals[v];

5977 if

( ninfcheckvars == 0 )

5982

minactinfvarsinvalid =

;

5983

maxactinfvarsinvalid =

;

5984

maxactinfvars = 0.0;

5985

minactinfvars = 0.0;

5988 for

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

5995 if

( infcheckvals[v] < 0.0 )

5996

maxactinfvarsinvalid =

;

5998

minactinfvarsinvalid =

;

6002 if

( infcheckvals[v] < 0.0 )

6003

maxactinfvars += infcheckvals[v] * lb;

6005

minactinfvars += infcheckvals[v] * lb;

6010 if

( infcheckvals[v] > 0.0 )

6011

maxactinfvarsinvalid =

;

6013

minactinfvarsinvalid =

;

6017 if

( infcheckvals[v] > 0.0 )

6018

maxactinfvars += infcheckvals[v] * ub;

6020

minactinfvars += infcheckvals[v] * ub;

6025

minactinfvarsinvalid =

;

6027

maxactinfvarsinvalid =

;

6029 if

( minactinfvarsinvalid || maxactinfvarsinvalid )

6032

assert(!minactinfvarsinvalid && !maxactinfvarsinvalid);

6034 SCIPdebugMsg

(

"minactinfvarsinvalid = %u, minactinfvars = %g, maxactinfvarsinvalid = %u, maxactinfvars = %g, gcd = %lld, ninfcheckvars = %d, ncontvars = %d\n"

6035

minactinfvarsinvalid, minactinfvars, maxactinfvarsinvalid, maxactinfvars, gcd, ninfcheckvars, ncontvars);

6060 else if

( ncontvars == 0 )

6067

v = ninfcheckvars - 1;

6069

assert(gcdinfvars >= 2);

6071 for

( ; v >= 0 && gcdinfvars >= 2; --v )

6076 else if

( gcdisone )

6079 SCIPdebugMsg

(

"gcdinfvars =%lld, possiblegcd = %u\n"

, gcdinfvars, possiblegcd);

6082 if

( gcdinfvars >= 1 )

6095

value2 = value + gcd * (

(

, (lhs - value) / gcd));

6116

value += gcdinfvars;

6118

assert(nsols < 2 || minvalue <= maxvalue);

6131

value2 = value + gcd * (

(

, (rhs - value) / gcd));

6142

assert(maxvalue > minvalue);

6145

value -= gcdinfvars;

6147

assert(maxvalue > secondsolval);

6150 SCIPdebugMsg

(

"here nsols %s %d, minsolvalue = %g, maxsolvalue = %g, ninfcheckvars = %d, nunfixedvars = %d\n"

6151

nsols > 2 ?

">="

"="

, nsols, minvalue, maxvalue, ninfcheckvars, nunfixedvars);

6156 SCIPdebugMsg

(

"gcdinfvars = %lld, gcd = %lld, correctedlhs = %g, correctedrhs = %g\n"

6157

gcdinfvars, gcd, lhs, rhs);

6168 else if

( nsols == 1 )

6170

assert(minvalue == maxvalue);

6173 if

( ninfcheckvars == 1 )

6179 SCIPdebugMsg

(

"fixing single variable <%s> with bounds [%.15g,%.15g] to %.15g\n"

6200 if

( ninfcheckvars == nunfixedvars - 1 )

6207

assert(ninfcheckvars > 0);

6210 for

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

6214 if

(

>= ninfcheckvars || consdata->vars[v] != infcheckvars[

] )

6220

assert((nfixedconsvars == 0) ? (consdata->nvars - v - 1 == ninfcheckvars -

) :

);

6222 for

( ; v2 < consdata->nvars && w2 < ninfcheckvars; ++v2 )

6227

assert(consdata->vars[v2] == infcheckvars[w2]);

6230

assert(w2 == ninfcheckvars);

6236 if

( consdata->vals[v] < 0 )

6245 SCIPdebugMsg

(

"fixing variable <%s> with bounds [%.15g,%.15g] to %.15g\n"

6258

consdata->vars[v],

bound

) );

6274

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

6277 if

( consdata->vals[v] < 0 )

6286 SCIPdebugMsg

(

"fixing variable <%s> with bounds [%.15g,%.15g] to %.15g\n"

6299

consdata->vars[v],

bound

) );

6306 else if

( addartconss && (

(

, minvalue, minactinfvars) ||

(

, maxvalue, maxactinfvars)) )

6314

++conshdlrdata->naddconss;

6319

maxvalue, maxvalue,

) );

6336 if

( ninfcheckvars == 1 )

6344 if

( infcheckvals[0] < 0 )

6346

newlb = maxvalue/infcheckvals[0];

6347

newub = minvalue/infcheckvals[0];

6351

newlb = minvalue/infcheckvals[0];

6352

newub = maxvalue/infcheckvals[0];

6354

assert(newlb < newub);

6359 SCIPdebugMsg

(

"tightening lower bound of variable <%s> from %g to %g\n"

6380 SCIPdebugMsg

(

"tightening upper bound of variable <%s> from %g to %g\n"

6399 else if

( ninfcheckvars == nunfixedvars - 1 )

6407

assert(ninfcheckvars > 0);

6408

assert(minvalue < maxvalue);

6411 for

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

6415 if

(

>= ninfcheckvars || consdata->vars[v] != infcheckvars[

] )

6421

assert((nfixedconsvars == 0) ? (consdata->nvars - v - 1 == ninfcheckvars -

) :

);

6423 for

( ; v2 < consdata->nvars && w2 < ninfcheckvars; ++v2 )

6428

assert(consdata->vars[v2] == infcheckvars[w2]);

6431

assert(w2 == ninfcheckvars);

6437 if

( consdata->vals[v] < 0 )

6439

newlb =

(

, (rhs - minvalue) / consdata->vals[v]);

6440

newub =

(

, (lhs - maxvalue) / consdata->vals[v]);

6444

newlb =

(

, (lhs - maxvalue) / consdata->vals[v]);

6445

newub =

(

, (rhs - minvalue) / consdata->vals[v]);

6452 SCIPdebugMsg

(

"tightening lower bound of variable <%s> from %g to %g\n"

6464

consdata->vars[v], newlb) );

6474 SCIPdebugMsg

(

"tightening upper bound of variable <%s> from %g to %g\n"

6486

consdata->vars[v], newub) );

6503

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

6506 if

( consdata->vals[v] < 0 )

6508

newlb =

(

, (rhs - minvalue) / consdata->vals[v]);

6509

newub =

(

, (lhs - maxvalue) / consdata->vals[v]);

6513

newlb =

(

, (lhs - maxvalue) / consdata->vals[v]);

6514

newub =

(

, (rhs - minvalue) / consdata->vals[v]);

6521 SCIPdebugMsg

(

"tightening lower bound of variable <%s> from %g to %g\n"

6542 SCIPdebugMsg

(

"tightening upper bound of variable <%s> from %g to %g\n"

6564 else if

( addartconss && (

(

, minvalue, minactinfvars) ||

(

, maxvalue, maxactinfvars)) )

6571

assert(maxvalue > minvalue);

6587

++conshdlrdata->naddconss;

6606 else if

( addartconss && ncontvars < ninfcheckvars )

6613 for

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

6615 if

( w < ninfcheckvars && consdata->vars[v] == infcheckvars[

] )

6625 if

( consdata->vals[v] > 0.0 )

6626

maxact += consdata->vals[v];

6628

minact += consdata->vals[v];

6636 if

( consdata->vals[v] > 0.0 )

6678

assert(maxact > minact);

6679

assert(

== ninfcheckvars);

6681

newlhs = lhs - maxact;

6682

newrhs = rhs - minact;

6683

assert(newlhs < newrhs);

6687

++conshdlrdata->naddconss;

6737

assert(cons !=

);

6738

assert(cutoff !=

);

6739

assert(nchgbds !=

);

6746

assert(consdata !=

);

6747

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

6751

var = consdata->vars[pos];

6757

val = consdata->vals[pos];

6758

lhs = consdata->lhs;

6759

rhs = consdata->rhs;

6761

&ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);

6762

assert(var !=

);

6781

newub = (rhs - minresactivity)/val;

6790 if

( activityunreliable )

6793

newub = (rhs - minresactivity)/val;

6799 if

( !activityunreliable )

6802 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newub=%.15g\n"

6805

&infeasible, &tightened) );

6808 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n"

6823 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n"

6835

newlb = (lhs - maxresactivity)/val;

6843

newlb = (lhs - maxresactivity)/val;

6852 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n"

6855

&infeasible, &tightened) );

6858 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n"

6872 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n"

6888

newlb = (rhs - minresactivity)/val;

6895 if

( activityunreliable )

6898

newlb = (rhs - minresactivity)/val;

6905 if

( !activityunreliable )

6908 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n"

6911

&infeasible, &tightened) );

6914 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n"

6928 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n"

6940

newub = (lhs - maxresactivity)/val;

6948

newub = (lhs - maxresactivity)/val;

6957 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, resactivity=[%.15g,%.15g], sides=[%.15g,%.15g], newub=%.15g\n"

6960

&infeasible, &tightened) );

6963 SCIPdebugMsg

(

"linear constraint <%s>: cutoff <%s>, new bds=[%.15g,%.15g]\n"

6977 SCIPdebugMsg

(

"linear constraint <%s>: tighten <%s>, new bds=[%.15g,%.15g]\n"

6987#define MAXTIGHTENROUNDS 10 7001 unsigned int

tightenmode;

7007 int

oldnchgbdstotal;

7014

assert(cons !=

);

7015

assert(nchgbds !=

);

7016

assert(cutoff !=

);

7037

assert(consdata !=

);

7039

nvars = consdata->nvars;

7049 if

( !force && (consdata->boundstightened >= tightenmode) )

7056

assert(consdata->coefsorted);

7084

&isminsettoinfinity, &ismaxsettoinfinity);

7097

easycase =

(

, consdata->maxactdelta, maxeasyactivitydelta);

7104

oldnchgbdstotal = *nchgbds;

7107 for

( nrounds = 0; (force || consdata->boundstightened < tightenmode) && nrounds <

MAXTIGHTENROUNDS

; ++nrounds )

7116

assert(consdata->coefsorted);

7120

consdata->boundstightened = (

unsigned

int)tightenmode;

7126 while

( v < nvars && v != lastchange && !(*cutoff) )

7128

oldnchgbds = *nchgbds;

7140 if

( *nchgbds > oldnchgbds )

7145 else if

( consdata->coefsorted && v < consdata->nbinvars - 1

7147

v = consdata->nbinvars;

7154

*nchgbds - oldnchgbdstotal, nrounds);

7155

oldnchgbdstotal += oldnchgbds;

7160 if

( force &&

(

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

7187

assert(cons !=

);

7188

assert(violated !=

);

7194

assert(consdata !=

);

7198 if

( consdata->row !=

)

7210 SCIPdebugMsg

(

" consdata activity=%.15g (lhs=%.15g, rhs=%.15g, row=%p, checklprows=%u, rowinlp=%u, sol=%p, hascurrentnodelp=%u)\n"

7211

activity, consdata->lhs, consdata->rhs, (

void

*)consdata->row, checklprows,

7216

lhsviol = consdata->lhs - activity;

7217

rhsviol = activity - consdata->rhs;

7221 if

( (lhsviol > 0) && (lhsviol > rhsviol) )

7226 else if

( rhsviol > 0 )

7237

assert(sol ==

);

7251 if

( !checkrelmaxabs )

7275 for

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

7277 if

( consdata->vals !=

)

7279

coef = consdata->vals[v];

7285

absval =

( coef * solval );

7286

maxabs =

( maxabs, absval );

7293 if

( (consdata->lhs - activity) <= (1e-15 * maxabs) )

7295 SCIPdebugMsg

(

" lhs violated due to random noise: violation=%16.9g, maxabs=%16.9g\n"

7296

consdata->lhs - activity, maxabs);

7310 SCIPdebugMsg

(

" lhs violated absolutely (violation=%16.9g), but feasible when using relative tolerance w.r.t. maximum absolute value (%16.9g)\n"

7311

consdata->lhs - activity, maxabs);

7347 if

( (activity - consdata->rhs) <= (1e-15 * maxabs) )

7349 SCIPdebugMsg

(

" rhs violated due to random noise: violation=%16.9g, maxabs=%16.9g\n"

7350

activity - consdata->rhs, maxabs);

7364 SCIPdebugMsg

(

" rhs violated absolutely (violation=%16.9g), but feasible when using relative tolerance w.r.t. maximum absolute value (%16.9g)\n"

7365

activity - consdata->rhs, maxabs);

7399 else if

( consdata->checkabsolute &&

7437

assert(cons !=

);

7440

assert(consdata !=

);

7441

assert(consdata->row ==

);

7462

assert(cons !=

);

7465

assert(consdata !=

);

7467 if

( consdata->row ==

)

7482

assert(consdata->row !=

);

7484 if

( consdata->nvars == 0 )

7506

assert( pr == 0 || cr == 0 );

7530

assert(consdata !=

);

7532 if

( consdata->nlrow ==

)

7534

assert(consdata->lhs <= consdata->rhs);

7537

0.0, consdata->nvars, consdata->vars, consdata->vals,

, consdata->lhs, consdata->rhs,

SCIP_EXPRCURV_LINEAR

) );

7539

assert(consdata->nlrow !=

);

7569

assert(conshdlrdata !=

);

7570

assert(cons !=

);

7571

assert(cutoff !=

);

7574

assert(ncuts !=

);

7575

assert(consdata !=

);

7591 if

( !separateall && sol ==

)

7604

consdata->vals, +1.0, consdata->rhs, sol, cutoff, ncuts) );

7612

consdata->vals, -1.0, -consdata->lhs, sol, cutoff, ncuts) );

7622

consdata->vals, +1.0, consdata->rhs, sol, cutoff, ncuts) );

7627

consdata->vals, -1.0, -consdata->lhs, sol, cutoff, ncuts) );

7632 if

( *ncuts > oldncuts )

7662

assert(cons !=

);

7663

assert(cutoff !=

);

7664

assert(nchgbds !=

);

7669

assert(consdata !=

);

7671 if

( consdata->eventdata ==

)

7677

assert(conshdlr !=

);

7680

assert(conshdlrdata !=

);

7684

assert(consdata->eventdata !=

);

7699 if

( tightenbounds )

7703

oldnchgbds = *nchgbds;

7707 if

( *nchgbds > oldnchgbds )

7714 if

( rangedrowpropagation && tightenbounds && !(*cutoff) )

7718 SCIPdebug

(

int

oldnchgbds = *nchgbds; )

7734 if

( nfixedvars > 0 )

7735

*nchgbds += 2*nfixedvars;

7742

&isminsettoinfinity, &ismaxsettoinfinity);

7746 SCIPdebugMsg

(

"linear constraint <%s> is infeasible (rhs): activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n"

7747 SCIPconsGetName

(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);

7757 SCIPdebugMsg

(

"linear constraint <%s> is infeasible (lhs): activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n"

7758 SCIPconsGetName

(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);

7768 SCIPdebugMsg

(

"linear constraint <%s> is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n"

7769 SCIPconsGetName

(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);

7772 if

( consdata->nvars > 0 )

7807

assert(cons !=

);

7808

assert(cutoff !=

);

7809

assert(nfixedvars !=

);

7812

assert(consdata !=

);

7814 for

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

7816

assert(consdata->vars !=

);

7817

var = consdata->vars[v];

7829 SCIPdebugMsg

(

"converting variable <%s> with fixed bounds [%.15g,%.15g] into fixed variable fixed at %.15g\n"

7853

assert(consdata->removedfixings);

7858#define MAX_CLIQUE_NONZEROS_PER_CONS 1000000 7950 int

cliquenonzerosadded;

7958

assert(cons !=

);

7959

assert(nfixedvars !=

);

7960

assert(nchgbds !=

);

7961

assert(cutoff !=

);

7965

assert(consdata !=

);

7967 if

( consdata->nvars < 2 )

7976 if

( !consdata->implsadded )

7994

nvars = consdata->nvars;

7995

vars = consdata->vars;

7996

vals = consdata->vals;

7999 if

( !consdata->validactivities )

8001

assert(consdata->validactivities);

8005

finitenegminact = (consdata->glbminactivityneginf == 0 && consdata->glbminactivityneghuge == 0);

8006

finitenegmaxact = (consdata->glbmaxactivityneginf == 0 && consdata->maxactivityneghuge == 0);

8007

finiteposminact = (consdata->glbminactivityposinf == 0 && consdata->glbminactivityposhuge == 0);

8008

finiteposmaxact = (consdata->glbmaxactivityposinf == 0 && consdata->glbmaxactivityposhuge == 0);

8009

finiteminact = (finitenegminact && finiteposminact);

8010

finitemaxact = (finitenegmaxact && finiteposmaxact);

8012 if

( (finiterhs || finitelhs) && (finitenegminact || finiteposminact || finitenegmaxact || finiteposmaxact) )

8017 int

oldnchgbds = *nchgbds;

8023 if

( (finitenegminact || finiteposminact) && !consdata->validglbminact )

8026

assert(consdata->validglbminact);

8029 if

( (finitenegmaxact || finiteposmaxact) && !consdata->validglbmaxact )

8032

assert(consdata->validglbmaxact);

8034

assert(consdata->validglbminact || consdata->validglbmaxact);

8039 for

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

8047 if

( value > maxabscontrib )

8049

maxabscontrib = value;

8060 if

( value > maxabscontrib )

8062

maxabscontrib = value;

8071

assert(0 <= position && position < nvars);

8073 if

( !

(

, maxabscontrib, 1.0) && !allbinary )

8079 if

( finiterhs && finiteminact &&

(

(consdata->glbminactivity), consdata->rhs - maxabscontrib) )

8081 for

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

8086 if

( v != position )

8093

*nchgbds += nbdchgs;

8100

*nchgbds += nbdchgs;

8120 if

( finitelhs && finitemaxact &&

(

(consdata->glbmaxactivity), consdata->lhs - maxabscontrib) )

8122 for

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

8127 if

( v != position )

8134

*nchgbds += nbdchgs;

8141

*nchgbds += nbdchgs;

8160 SCIPdebugMsg

(

"extracted %d implications from constraint %s which led to %d bound changes, %scutoff detetcted\n"

, nimpls,

(cons), *nchgbds - oldnchgbds, *cutoff ?

""

"no "

);

8166 if

( *nchgbds - oldnchgbds > 0 )

8187

consdata->implsadded =

;

8191 if

( consdata->cliquesadded )

8194

consdata->cliquesadded =

;

8195

cliquenonzerosadded = 0;

8201

nvars = consdata->nvars;

8202

vars = consdata->vars;

8203

vals = consdata->vals;

8208 if

( !consdata->validactivities )

8210

assert(consdata->validactivities);

8214

finitenegminact = (consdata->glbminactivityneginf == 0 && consdata->glbminactivityneghuge == 0);

8215

finitenegmaxact = (consdata->glbmaxactivityneginf == 0 && consdata->maxactivityneghuge == 0);

8216

finiteposminact = (consdata->glbminactivityposinf == 0 && consdata->glbminactivityposhuge == 0);

8217

finiteposmaxact = (consdata->glbmaxactivityposinf == 0 && consdata->glbmaxactivityposhuge == 0);

8218

finiteminact = (finitenegminact && finiteposminact);

8219

finitemaxact = (finitenegmaxact && finiteposmaxact);

8224 if

( (finiterhs || finitelhs) && (finitenegminact || finiteposminact || finitenegmaxact || finiteposmaxact) )

8228 int

nposbinvars = 0;

8229 int

nnegbinvars = 0;

8230 int

allonebinary = 0;

8236 for

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

8245

binvars[nposbinvars + nnegbinvars] = vars[i];

8246

binvarvals[nposbinvars + nnegbinvars] = vals[i];

8253

assert(nposbinvars + nnegbinvars <= nvars);

8259

assert(nposbinvars + nnegbinvars <= nvars);

8264 if

( allonebinary < nvars && (nposbinvars >= 2 || nnegbinvars >= 2) )

8267 int

oldnchgbds = *nchgbds;

8273 if

( (finitenegminact || finiteposminact) && !consdata->validglbminact )

8276

assert(consdata->validglbminact);

8279 if

( (finitenegmaxact || finiteposmaxact) && !consdata->validglbmaxact )

8282

assert(consdata->validglbmaxact);

8284

assert(consdata->validglbminact || consdata->validglbmaxact);

8290 if

( finiterhs && finitenegminact && nposbinvars >= 2 )

8293

threshold = consdata->rhs -

(consdata->glbminactivity);

8296#ifdef SCIP_DISABLED_CODE 8305 while

( j < nposbinvars )

8319

*nchgbds += nbdchgs;

8321

cliquenonzerosadded += j;

8326 if

( !stopped && !(*cutoff) && j < nposbinvars )

8329 int

lastfit = j - 2;

8330

assert(lastfit >= 0);

8336 while

( lastfit >= 0 && j < nposbinvars )

8339 if

(

(

, binvarvals[lastfit] + binvarvals[j], threshold) )

8341

clqvars[lastfit + 1] = binvars[j];

8352

*nchgbds += nbdchgs;

8354

cliquenonzerosadded += (lastfit + 2);

8373 if

( !stopped && !*cutoff && *nchgbds - oldnchgbds > 0 )

8394 if

( !consdata->validactivities )

8396

assert(consdata->validactivities);

8398

nvars = consdata->nvars;

8399

vars = consdata->vars;

8400

vals = consdata->vals;

8406 for

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

8415

binvars[nposbinvars + nnegbinvars] = vars[i];

8416

binvarvals[nposbinvars + nnegbinvars] = vals[i];

8423

assert(nposbinvars + nnegbinvars <= nvars);

8429

assert(nposbinvars + nnegbinvars <= nvars);

8434

oldnchgbds = *nchgbds;

8438 if

( !stopped && !(*cutoff) && finitelhs && finiteposmaxact && nnegbinvars >= 2 )

8441

threshold = consdata->lhs -

(consdata->glbmaxactivity);

8443

i = nposbinvars + nnegbinvars - 1;

8445#ifdef SCIP_DISABLED_CODE 8455 while

( j >= nposbinvars )

8470

*nchgbds += nbdchgs;

8472

cliquenonzerosadded += (i - j);

8477 if

( !stopped && !(*cutoff) && jstart >= nposbinvars )

8480 int

lastfit = jstart + 1;

8481

assert(lastfit < i);

8488 while

( lastfit <= i && j >= nposbinvars )

8491 if

(

(

, binvarvals[lastfit] + binvarvals[j], threshold) )

8493

assert(lastfit - jstart - 2 >= 0 && lastfit - jstart - 2 < i);

8494

clqvars[lastfit - jstart - 2] = binvars[j];

8496

assert(i - lastfit + 2 >= 2);

8506

*nchgbds += nbdchgs;

8508

cliquenonzerosadded += (i - lastfit + 2);

8527 if

( !stopped && !*cutoff && *nchgbds - oldnchgbds > 0 )

8548 if

( !consdata->validactivities )

8550

assert(consdata->validactivities);

8552

nvars = consdata->nvars;

8553

vars = consdata->vars;

8554

vals = consdata->vals;

8560 for

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

8569

binvars[nposbinvars + nnegbinvars] = vars[i];

8570

binvarvals[nposbinvars + nnegbinvars] = vals[i];

8577

assert(nposbinvars + nnegbinvars <= nvars);

8583

assert(nposbinvars + nnegbinvars <= nvars);

8588

oldnchgbds = *nchgbds;

8592 if

( !(*cutoff) && finiterhs && finiteminact && nnegbinvars >= 2 )

8601

threshold = consdata->rhs -

(consdata->glbminactivity);

8603

i = nposbinvars + nnegbinvars - 1;

8606#ifdef SCIP_DISABLED_CODE 8616 while

( j >= nposbinvars )

8618 if

( !

(

, -binvarvals[j+1] - binvarvals[j], threshold) )

8631

*nchgbds += nbdchgs;

8633

cliquenonzerosadded += (i - j);

8638 if

( !stopped && !(*cutoff) && jstart >= nposbinvars )

8641 int

lastfit = j + 1;

8642

assert(lastfit < i);

8649 while

( lastfit <= i && j >= nposbinvars )

8652 if

(

(

, -binvarvals[lastfit] - binvarvals[j], threshold) )

8654

assert(lastfit - jstart - 2 >= 0 && lastfit - jstart - 2 < i);

8655

clqvars[lastfit - jstart - 2] = binvars[j];

8657

assert(i - lastfit + 2 >= 2);

8667

*nchgbds += nbdchgs;

8669

cliquenonzerosadded += (i - lastfit + 2);

8690 if

( !stopped && !*cutoff && *nchgbds - oldnchgbds > 0 )

8711 if

( !consdata->validactivities )

8713

assert(consdata->validactivities);

8715

nvars = consdata->nvars;

8716

vars = consdata->vars;

8717

vals = consdata->vals;

8723 for

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

8732

binvars[nposbinvars + nnegbinvars] = vars[i];

8733

binvarvals[nposbinvars + nnegbinvars] = vals[i];

8740

assert(nposbinvars + nnegbinvars <= nvars);

8746

assert(nposbinvars + nnegbinvars <= nvars);

8753 if

( !stopped && !(*cutoff) && finitelhs && finitemaxact && nposbinvars >= 2 )

8762

threshold = consdata->lhs -

(consdata->glbmaxactivity);

8766#ifdef SCIP_DISABLED_CODE 8776 while

( j < nposbinvars )

8778 if

( !

(

, -binvarvals[j-1] - binvarvals[j], threshold) )

8790

*nchgbds += nbdchgs;

8792

cliquenonzerosadded += j;

8797 if

( !stopped && !(*cutoff) && j < nposbinvars )

8800 int

lastfit = j - 2;

8801

assert(lastfit >= 0);

8807 while

( lastfit >= 0 && j < nposbinvars )

8810 if

(

(

, -binvarvals[lastfit] - binvarvals[j], threshold) )

8812

clqvars[lastfit + 1] = binvars[j];

8823

*nchgbds += nbdchgs;

8825

cliquenonzerosadded += lastfit + 2;

8857 for

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

8872 if

( lhsclique || rhsclique )

8877 SCIPdebugMsg

(

"linear constraint <%s>: adding clique with %d vars (%d pos, %d neg)\n"

8881 for

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

8882

values[i] = (rhsclique == (vals[i] > 0.0));

8889

*nchgbds += nbdchgs;

8914

assert(cons !=

);

8915

assert(nchgsides !=

);

8916

assert(infeasible !=

);

8919

assert(consdata !=

);

8921

*infeasible =

;

8931 for

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

8952 SCIPdebugMsg

(

"rounding sides=[%.15g,%.15g] of linear constraint <%s> with integral coefficients and variables only " 8953 "is infeasible\n"

, consdata->lhs, consdata->rhs,

(cons));

8955

*infeasible =

;

8959 SCIPdebugMsg

(

"linear constraint <%s>: make sides integral: sides=[%.15g,%.15g]\n"

8967 if

( !consdata->upgraded )

8975 if

( !consdata->upgraded )

8978 SCIPdebugMsg

(

"linear constraint <%s>: new integral sides: sides=[%.15g,%.15g]\n"

9053

assert(cons !=

);

9054

assert(nchgcoefs !=

);

9055

assert(nchgsides !=

);

9058

assert(consdata !=

);

9065 if

( (consdata->validmaxabsval && consdata->maxabsval >

MAXVALRECOMP

)

9066

|| (consdata->validminabsval && consdata->minabsval <

MINVALRECOMP

) )

9074

&isminsettoinfinity, &ismaxsettoinfinity);

9080

minleftactivity = 0.0;

9081

maxleftactivity = 0.0;

9085 while

( i < consdata->nvars )

9088

var = consdata->vars[i];

9089

val = consdata->vals[i];

9101 if

( isvarrelevant[i] )

9109

lval = consdata->lhs - minactivity;

9110

rval = maxactivity - consdata->rhs;

9113 if

( consdata->nvars == 2 )

9116

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

9120

lval = consdata->lhs - val*lb;

9126

rval = val*ub - consdata->rhs;

9131

newval =

MAX3

(lval, rval, 0.0);

9135

newlhs = consdata->lhs - val * lb;

9136

newlhs += newval * lb;

9137

newrhs = consdata->rhs - val * ub;

9138

newrhs += newval * ub;

9142 SCIPdebugMsg

(

"linear constraint <%s>: change coefficient %+.15g<%s> to %+.15g<%s>, act=[%.15g,%.15g], side=[%.15g,%.15g]\n"

9144

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

9160

&ismaxacttight, &isminsettoinfinity, &ismaxsettoinfinity);

9165

consdata->lhs, newlhs);

9175

consdata->rhs, newrhs);

9192

minleftactivity += val * lb;

9202

maxleftactivity += val * ub;

9212 if

( isvarrelevant[i] )

9220

lval = minactivity - consdata->lhs;

9221

rval = consdata->rhs - maxactivity;

9224 if

( consdata->nvars == 2 )

9227

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

9231

lval = val*ub - consdata->lhs;

9237

rval = consdata->rhs - val*lb;

9242

newval =

MIN3

(lval, rval, 0.0);

9246

newlhs = consdata->lhs - val * ub;

9247

newlhs += newval * ub;

9248

newrhs = consdata->rhs - val * lb;

9249

newrhs += newval * lb;

9253 SCIPdebugMsg

(

"linear constraint <%s>: change coefficient %+.15g<%s> to %+.15g<%s>, act=[%.15g,%.15g], side=[%.15g,%.15g]\n"

9255

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

9271

&ismaxacttight, &isminsettoinfinity, &ismaxsettoinfinity);

9276

consdata->lhs, newlhs);

9286

consdata->rhs, newrhs);

9303

minleftactivity += val * ub;

9313

maxleftactivity += val * lb;

9322

minleftactivity, consdata->rhs);

9324

maxleftactivity, consdata->lhs);

9351

aggrlhs = consdata->lhs - minactivity + minleftactivity;

9352

aggrrhs = consdata->rhs - maxactivity + maxleftactivity;

9369 while

( i < consdata->nvars )

9372 if

( !isvarrelevant[i] )

9375

var = consdata->vars[i];

9376

val = consdata->vals[i];

9381 SCIPdebugMsg

(

"val = %g\tlhs = %g\trhs = %g\n"

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

9382 SCIPdebugMsg

(

"linear constraint <%s>: remove variable <%s> from constraint since it is redundant\n"

9388

minleftactivitypart = val * lb;

9389

maxleftactivitypart = val * ub;

9393

minleftactivitypart = val * ub;

9394

maxleftactivitypart = val * lb;

9398

isvarrelevant[i] = isvarrelevant[consdata->nvars - 1];

9403

newlhs = consdata->lhs - minleftactivitypart;

9404

newrhs = consdata->rhs - maxleftactivitypart;

9409

consdata->lhs, newlhs);

9419

consdata->rhs, newrhs);

9456

assert(cons !=

);

9457

assert(cutoff !=

);

9458

assert(nfixedvars !=

);

9459

assert(ndelconss !=

);

9462

assert(consdata !=

);

9463

assert(consdata->nvars == 1);

9464

assert(

(

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

9467

var = consdata->vars[0];

9468

val = consdata->vals[0];

9488 if

( !consdata->upgraded )

9510

assert(cons !=

);

9511

assert(cutoff !=

);

9512

assert(naggrvars !=

);

9513

assert(ndelconss !=

);

9516

assert(consdata !=

);

9517

assert(consdata->nvars == 2);

9518

assert(

(

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

9520 SCIPdebugMsg

(

"linear constraint <%s>: aggregate %.15g<%s> + %.15g<%s> == %.15g\n"

9522

consdata->vals[1],

(consdata->vars[1]), consdata->rhs);

9526

consdata->rhs, &infeasible, &redundant, &aggregated) );

9545 if

( !consdata->upgraded )

9567

assert(consdata !=

);

9568

assert(newlhs !=

);

9569

assert(newrhs !=

);

9575 if

( slackcoef > 0.0 )

9580

*newrhs = consdata->rhs - slackcoef * slackvarlb;

9584

*newlhs = consdata->lhs - slackcoef * slackvarub;

9591

*newlhs = consdata->rhs - slackcoef * slackvarlb;

9595

*newrhs = consdata->lhs - slackcoef * slackvarub;

9641 int

maxnlocksremove;

9652

assert(cons !=

);

9653

assert(cutoff !=

);

9654

assert(naggrvars !=

);

9657

assert(consdata !=

);

9658

assert(consdata->nvars > 2);

9659

assert(

(

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

9668

lhs = consdata->lhs;

9669

rhs = consdata->rhs;

9671 if

( consdata->nvars == 3 )

9676

maxnlocksremove = 3;

9678 else if

( consdata->nvars == 4 )

9683

maxnlocksremove = 2;

9688

maxnlocksremove = 1;

9707

vars = consdata->vars;

9708

vals = consdata->vals;

9711

bestnlocks = INT_MAX;

9712

bestremovescons =

;

9713

bestslackdomrng = 0.0;

9714

coefszeroone =

;

9715

coefsintegral =

;

9716

varsintegral =

;

9724 for

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

9734

assert(vars !=

);

9735

assert(vals !=

);

9748 if

( absval < minabsval )

9750 if

( absval > maxabsval )

9755 if

( maxabsval / minabsval > conshdlrdata->maxmultaggrquot )

9759

coefszeroone = coefszeroone &&

(

, absval, 1.0);

9787 if

( nlocks > maxnlocksremove )

9791 if

( (iscont || (coefsintegral && varsintegral &&

(

, absval, 1.0))) &&

9805

slackdomrng = (varub - varlb)*absval;

9809

better = (slacktype > bestslacktype) || (bestslackpos == -1);

9810 if

( !better && slacktype == bestslacktype )

9812

better = (nlocks < bestnlocks);

9813 if

( nlocks == bestnlocks && !bestremovescons )

9815

better =

(

, slackdomrng, bestslackdomrng);

9816

equal = !better &&

SCIPisGE

(

, slackdomrng, bestslackdomrng);

9820 if

( better || equal )

9834

&ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);

9839 if

( !ismintight || !ismaxtight )

9859 if

( conshdlrdata->multaggrremove && !removescons )

9863 if

( bestremovescons && !removescons )

9869 if

( !removescons && nlocks > maxnlocksstay )

9872

better = better || (!bestremovescons && removescons);

9876

bestslacktype = slacktype;

9877

bestnlocks = nlocks;

9878

bestslackdomrng = slackdomrng;

9879

bestremovescons = removescons;

9899 for

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

9901 if

( v != bestslackpos )

9933

assert(!samevar || (supinf > 0 && infinf > 0));

9938 if

( (samevar && (supinf > 1 || infinf > 1)) || (!samevar && supinf > 0 && infinf > 0) )

9940 SCIPdebugMsg

(

"do not perform multi-aggregation: infimum and supremum are both infinite\n"

);

9949 if

( bestslackpos >= 0

9951

|| (coefsintegral && varsintegral && nimplvars == 0)) )

9964

assert(bestslackpos < consdata->nvars);

9973

slackvar = vars[bestslackpos];

9974

slackcoef = vals[bestslackpos];

9976

aggrconst = consdata->rhs/slackcoef;

9989 for

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

9991 scalars

[v] = -consdata->vals[v]/slackcoef;

9994 SCIPdebugMsgPrint

(

" %+.15g, bounds of <%s>: [%.15g,%.15g], nlocks=%d, maxnlocks=%d, removescons=%u\n"

9996

bestnlocks, bestremovescons ? maxnlocksremove : maxnlocksstay, bestremovescons);

10000

&infeasible, &aggregated) );

10001

assert(aggregated);

10017 if

( bestremovescons )

10022 if

( !consdata->upgraded )

10026 else if

( ncontvars == 1 )

10030

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

10031

var = vars[contvarpos];

10040 SCIPdebugMsg

(

"linear constraint <%s>: converting continuous variable <%s> to implicit integer variable\n"

10062

absval =

(vals[contvarpos]);

10073#ifdef WITH_DEBUG_SOLUTION 10074 if

( SCIPdebugIsMainscip(

) )

10083 SCIPdebugMsg

(

"linear constraint <%s>: aggregating continuous variable <%s> to newly created implicit integer variable <%s>, aggregation factor = %g\n"

10091 SCIPdebugMsg

(

"infeasible aggregation of variable <%s> to implicit variable <%s>, domain is empty\n"

10113

consdata->boundstightened = 0;

10114

consdata->rangedrowpropagated = 0;

10115

consdata->presolved =

;

10118 else if

( ncontvars == 0 && nimplvars == 0 && nintvars == 1 && !coefszeroone )

10125

assert(varsintegral);

10126

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

10127

var = vars[intvarpos];

10135 SCIPdebugMsg

(

"linear constraint <%s>: converting integer variable <%s> to implicit integer variable\n"

10170

vars = consdata->vars;

10171

nvars = consdata->nvars;

10173

assert(vars !=

);

10175 for

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

10179

assert(var !=

);

10185

assert(var !=

);

10199

val = consdata->vals[v];

10206

(*scale) = val / -objval;

10210 else if

(

(

, -objval * (*scale), val) )

10218

(*scale) = val / objval;

10220 else if

( !

(

, objval * (*scale), val) )

10247

assert(cons !=

);

10248

assert(conshdlrdata !=

);

10251

assert(consdata !=

);

10252

assert(

(

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

10254

nvars = consdata->nvars;

10258 if

( nvars > nobjvars || nvars == 0 )

10262 if

( (nvars < nobjvars && !conshdlrdata->detectpartialobjective) ||

10263

(nvars == nobjvars && (!conshdlrdata->detectcutoffbound || !conshdlrdata->detectlowerbound)) )

10266

offset = consdata->rhs;

10276

vars = consdata->vars;

10277

assert(vars !=

);

10281 SCIPdebugMsg

(

"linear equality constraint <%s> == %g (offset %g) is a subset of the objective function\n"

10289 for

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

10327

assert(consdata !=

);

10363

assert(cons !=

);

10364

assert(conshdlrdata !=

);

10367

assert(consdata !=

);

10370 if

(

(

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

10373

nvars = consdata->nvars;

10388 if

( nobjvars == 0 )

10399

assert(scale != 0.0);

10403 if

( conshdlrdata->detectcutoffbound && rhsfinite )

10407

primalbound = (consdata->rhs - offset) / scale;

10409 SCIPdebugMsg

(

"constraint <%s> is parallel to objective function and provides a cutoff bound <%g>\n"

10415 if

( conshdlrdata->detectlowerbound && lhsfinite )

10419

lowerbound = (consdata->lhs - offset) / scale;

10421 SCIPdebugMsg

(

"constraint <%s> is parallel to objective function and provides a lower bound <%g>\n"

10427 if

( (conshdlrdata->detectcutoffbound && (conshdlrdata->detectlowerbound || !lhsfinite)) ||

10428

(conshdlrdata->detectlowerbound && !rhsfinite) )

10437 if

( conshdlrdata->detectlowerbound && rhsfinite )

10441

lowerbound = (consdata->rhs - offset) / scale;

10443 SCIPdebugMsg

(

"constraint <%s> is parallel to objective function and provides a lower bound <%g>\n"

10449 if

( conshdlrdata->detectcutoffbound && lhsfinite )

10453

primalbound = (consdata->lhs - offset) / scale;

10455 SCIPdebugMsg

(

"constraint <%s> is parallel to objective function and provides a cutoff bound <%g>\n"

10461 if

( (conshdlrdata->detectcutoffbound && (conshdlrdata->detectlowerbound || !rhsfinite)) ||

10462

(conshdlrdata->detectlowerbound && !lhsfinite) )

10490

assert(cons !=

);

10491

assert(conshdlrdata !=

);

10492

assert(cutoff !=

);

10493

assert(nfixedvars !=

);

10494

assert(naggrvars !=

);

10495

assert(ndelconss !=

);

10498

assert(consdata !=

);

10499

assert(consdata->removedfixings);

10502 if

( !

(

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

10506 if

( consdata->nvars == 1 )

10511 else if

( consdata->nvars == 2 )

10542

assert(consdata !=

);

10543

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

10545 for

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

10569

assert(minval !=

);

10570

assert(maxval !=

);

10575

*minval = -maxresactivity;

10577

*minval = (side - maxresactivity)/val;

10580

*maxval = -minresactivity;

10582

*maxval = (side - minresactivity)/val;

10587

*minval = minresactivity;

10589

*minval = (side - minresactivity)/val;

10592

*maxval = maxresactivity;

10594

*maxval = (side - maxresactivity)/val;

10626

assert(cons !=

);

10627

assert(cutoff !=

);

10628

assert(nfixedvars !=

);

10629

assert(naggrvars !=

);

10630

assert(ndelconss !=

);

10640

assert(consdata !=

);

10650

bestislhs =

;

10663 if

( consdata->nvars <= 2 )

10664

maxotherlocks = INT_MAX;

10665 else if

( consdata->nvars == 3 )

10667 else if

( consdata->nvars == 4 )

10673 if

( lhsexists && rhsexists && maxotherlocks < INT_MAX )

10678 for

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

10690

val = consdata->vals[i];

10694 if

( absval < minabsval )

10695

minabsval = absval;

10696 if

( absval > maxabsval )

10697

maxabsval = absval;

10700 if

( maxabsval / minabsval > conshdlrdata->maxdualmultaggrquot )

10703

var = consdata->vars[i];

10707 if

( bestpos >= 0 && isint )

10719

val = consdata->vals[i];

10756 if

( agglhs || aggrhs )

10769

&ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);

10770

assert(

(

, minresactivity, maxresactivity));

10776

assert((ismintight || isminsettoinfinity) && (ismaxtight || ismaxsettoinfinity));

10791

recalculated =

;

10792

oldmaxresactivity = maxresactivity;

10793

oldminresactivity = minresactivity;

10799

recalculated = !

(

, oldminresactivity, minresactivity);

10800

isminsettoinfinity =

;

10807

recalculated = recalculated || !

(

, oldmaxresactivity, maxresactivity);

10808

ismaxsettoinfinity =

;

10812 if

( recalculated )

10814

assert(

(

, minresactivity, maxresactivity));

10851

recalculated =

;

10852

oldmaxresactivity = maxresactivity;

10853

oldminresactivity = minresactivity;

10859

recalculated = !

(

, oldminresactivity, minresactivity);

10866

recalculated = recalculated || !

(

, oldmaxresactivity, maxresactivity);

10870 if

( recalculated )

10886

bestislhs =

;

10894 if

( bestpos >= 0 )

10913

assert(!bestislhs || lhsexists);

10914

assert(bestislhs || rhsexists);

10916

bestvar = consdata->vars[bestpos];

10917

bestval = consdata->vals[bestpos];

10918

assert(bestisint ==

10933 for

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

10935 if

( j != bestpos )

10937

aggrvars[naggrs] = consdata->vars[j];

10938

aggrcoefs[naggrs] = -consdata->vals[j]/consdata->vals[bestpos];

10945 SCIPdebugMsg

(

"do not perform multi-aggregation: too large aggregation coefficients\n"

);

10958

aggrcoefs[naggrs] =

(

, aggrcoefs[naggrs]+0.5);

10993

assert(!samevar || (supinf > 0 && infinf > 0));

10995

aggrconst = (bestislhs ? consdata->lhs/bestval : consdata->rhs/bestval);

10998

assert(naggrs == consdata->nvars-1);

11007

aggregated =

;

11008

infeasible =

;

11011 if

( (samevar && supinf == 1 && infinf == 1) || (!samevar && (supinf == 0 || infinf == 0)) )

11022 for

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

11031

assert(!infeasiblevartypechg);

11040 SCIPdebugMsg

(

"do not perform multi-aggregation: infimum and supremum are both infinite\n"

);

11059 if

( !consdata->upgraded )

11074#define CONTWEIGHT 8 11123

assert( cons !=

);

11126

assert( consdata !=

);

11153

lhs = consdata->lhs;

11154

vars = consdata->vars;

11155

vals = consdata->vals;

11156

nvars = consdata->nvars;

11165 for

( v = 0; v < nvars && noddvars < 3; ++v )

11174 if

( val % 2 != 0 )

11180 if

( noddvars == 0 )

11192 if

( noddvars == 1 )

11194

assert( var1 !=

);

11196 SCIPdebugMsg

(

"linear constraint <%s>: try fixing variable <%s> to <%g>\n"

11216 else if

( noddvars == 2 )

11218

assert( var1 !=

);

11219

assert( var2 !=

);

11225 SCIPdebugMsg

(

"linear constraint <%s>: try aggregation of variables <%s> and <%s>\n"

11229

lhsodd ? 1.0 : 0.0, &infeasible, &redundant, &aggregated) );

11270 while

( success && consdata->nvars >= 1 );

11289

assert(consdata !=

);

11290

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

11291

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

11299 if

( vartype2 != vartype1 )

11309

value =

(consdata->vals[ind2]) -

(consdata->vals[ind1]);

11312 return

(value > 0 ? +1 : (value < 0 ? -1 : 0));

11347

assert(consdata !=

);

11349

nvars = consdata->nvars;

11355

lhs = consdata->lhs;

11356

rhs = consdata->rhs;

11365

vals = consdata->vals;

11366

vars = consdata->vars;

11367

assert(vars !=

);

11368

assert(vals !=

);

11374 for

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

11380

secondminval = minval;

11383 else if

( secondminval > vals[v] || secondminval ==

SCIP_INVALID

)

11384

secondminval = vals[v];

11398 for

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

11402

(*nchgcoefs) += nvars;

11481

assert(cons !=

);

11482

assert(nchgcoefs !=

);

11483

assert(nchgsides !=

);

11485

*infeasible =

;

11495

assert(consdata !=

);

11497

nvars = consdata->nvars;

11521

consdata->normalized =

;

11524

assert(nvars == consdata->nvars);

11529 if

( !consdata->normalized )

11532

lhs = consdata->lhs;

11533

rhs = consdata->rhs;

11547 SCIPdebug

( oldnchgcoefs = *nchgcoefs; )

11548 SCIPdebug

( oldnchgsides = *nchgsides; )

11551 if

( haslhs && hasrhs )

11557

assert(haslhs != hasrhs);

11569 SCIPsort

(perm, consdataCompSim, (

void

*)consdata, nvars);

11573

consdata->indexsorted =

;

11574

consdata->coefsorted =

;

11576

vars = consdata->vars;

11577

vals = consdata->vals;

11578

assert(vars !=

);

11579

assert(vals !=

);

11600

&ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);

11603 if

( isminsettoinfinity || ismaxsettoinfinity )

11606

assert(ismintight);

11607

assert(ismaxtight);

11608

assert(maxact > minact);

11614

side = haslhs ? lhs : rhs;

11615

minactsub = minact;

11616

maxactsub = maxact;

11646 while

( v < nvars &&

(

, side, vals[v]) )

11685 for

(

= 0;

< v; ++

)

11690

assert(vals[

] > 0);

11693

maxactsub -= ub * vals[

];

11694

minactsub -= lb * vals[

];

11695

assert(maxactsub > minactsub);

11726

maxactsub -= ub * vals[0];

11727

minactsub -= lb * vals[0];

11731

maxactsub -= lb * vals[0];

11732

minactsub -= ub * vals[0];

11734

assert(maxactsub > minactsub);

11739

allcoefintegral =

;

11742 for

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

11749

allcoefintegral =

;

11768

maxactsub -= ub * vals[v];

11769

minactsub -= lb * vals[v];

11773

maxactsub -= lb * vals[v];

11774

minactsub -= ub * vals[v];

11791

rredundant = hasrhs && maxactsub <= siderest &&

(

, minactsub, siderest - gcd);

11792

lredundant = haslhs &&

(

, maxactsub, siderest) && minactsub >= siderest - gcd;

11795 if

( offsetv == -1 && (rredundant || lredundant) )

11801

assert(v < nvars || (offsetv >= 0 && gcd > 1));

11821 SCIPdebugMsg

(

"stopped at pos %d (of %d), subactivities [%g, %g], redundant = %u, hasrhs = %u, siderest = %g, gcd = %" SCIP_LONGINT_FORMAT ", offset position for 'side' coefficients = %d\n"

11822

v, nvars, minactsub, maxactsub, redundant, hasrhs, siderest, gcd, offsetv);

11829

rredundant = hasrhs && maxactsub <= siderest &&

(

, minactsub, siderest - gcd);

11830

lredundant = haslhs &&

(

, maxactsub, siderest) && minactsub >= siderest - gcd;

11833 if

( v < nvars && numericsok && (redundant || (offsetv == -1 && (rredundant || lredundant))) )

11843 for

(

= v;

< nvars; ++

)

11852 if

( vals[

] > 0 )

11854

tmpmaxactsub += ub * vals[

];

11855

tmpminactsub += lb * vals[

];

11859

tmpmaxactsub += lb * vals[

];

11860

tmpminactsub += ub * vals[

];

11862

assert(tmpmaxactsub >= tmpminactsub);

11867

assert(offsetv == -1);

11881

assert((hasrhs &&

SCIPisFeasLE

(

, tmpmaxactsub, siderest) && tmpminactsub > siderest - gcd) ||

11882

(haslhs && tmpmaxactsub < siderest &&

SCIPisFeasGE

(

, tmpminactsub, siderest - gcd)));

11885 SCIPdebugMsg

(

"removing %d last variables from constraint <%s>, because they never change anything on the feasibility of this constraint\n"

11889 for

(

= nvars - 1;

>= v; --

)

11893

(*nchgcoefs) += (nvars - v);

11897

oldcoef = vals[

];

11900

assert(vars == consdata->vars);

11901

assert(vals == consdata->vals);

11902

assert(w < consdata->nvars);

11908

gcd = (

)(gcd / (oldcoef/vals[

]) + feastol);

11916

rhs = consdata->rhs;

11923

lhs = consdata->lhs;

11926

assert(offsetv == -1 ||

(

, vals[offsetv], consdata->lhs));

11934

nvars = consdata->nvars;

11937

allcoefintegral =

;

11941 for

(

= offsetv + 1;

< nvars; ++

)

11950 if

( offsetv >= 0 && gcd == 1 )

11960 for

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

11968

allcoefintegral =

;

11994 if

( candpos == -1 )

12004

assert(v > offsetv || candpos > offsetv);

12010

candpos = nvars - 1;

12013 if

( gcd > 1 && allcoefintegral && !redundant )

12016

allcoefintegral =

;

12020 if

( offsetv >= 0 && gcd > 1 && allcoefintegral )

12022

assert(offsetv + 1 < nvars);

12023

assert(0 <= candpos && candpos < nvars);

12031 for

(

= offsetv + 1;

< nvars; ++

)

12046

assert(rest < gcd);

12049

restcoef = ((

)(vals[candpos] + feastol)) % gcd;

12050

assert(restcoef >= 1);

12051

assert(restcoef < gcd);

12056 if

( restcoef > rest )

12057

newcoef = vals[candpos] - restcoef + gcd;

12059

newcoef = vals[candpos] - restcoef;

12064 if

( rest == 0 || restcoef < rest )

12065

newcoef = vals[candpos] - restcoef;

12067

newcoef = vals[candpos] - restcoef + gcd;

12077

notchangable =

;

12118 for

(

= offsetv;

>= 0; --

)

12120

assert(vals[

] > 0);

12124

(*nchgcoefs) += (offsetv + 1);

12127 if

( !notchangable )

12130

assert(vars == consdata->vars);

12131

assert(vals == consdata->vals);

12137

nvars = consdata->nvars;

12138

assert(nvars >= 2);

12142

lhs = consdata->lhs;

12143

rhs = consdata->rhs;

12157

allcoefintegral =

;

12159 for

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

12164

allcoefintegral =

;

12181 if

( allcoefintegral )

12192 for

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

12228 SCIPdebugMsg

(

"rounding all non-integral coefficients and the right hand side down\n"

);

12233 for

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

12270 if

( allcoefintegral )

12285 for

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

12333 SCIPdebugMsg

(

"rounding all non-integral coefficients and the left hand side down\n"

);

12338 for

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

12375

assert(vars == consdata->vars);

12376

assert(vals == consdata->vals);

12381

rhs = consdata->rhs;

12382

lhs = consdata->lhs;

12389

nvars = consdata->nvars;

12393

allcoefintegral =

;

12396 for

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

12403 if

( !allcoefintegral )

12418

assert(nvars >= 2);

12423 SCIPdebug

( oldnchgcoefs = *nchgcoefs; )

12424 SCIPdebug

( oldnchgsides = *nchgsides; )

12439 for

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

12446 if

( foundbin == -1 )

12474

foundbin = nvars - 1;

12477 if

( gcd == 1 || foundbin == -1)

12480

assert((onlybin && gcd == -1) || (!onlybin && gcd > 1));

12488 for

( v = foundbin; v >= 0; --v )

12517 if

( candpos == -1 )

12525 if

( onlybin && v == foundbin - 1 )

12526

candpos2 = foundbin;

12531 if

( onlybin && candpos == v + 1 && candpos2 == v + 2 )

12533

assert(candpos2 == nvars - 1);

12536

candpos = candpos2;

12559

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

12576

assert(rest < gcd);

12579 if

( vals[candpos] < 0 )

12581

restcoef = ((

)(vals[candpos] - feastol)) % gcd;

12582

assert(restcoef <= -1);

12586

restcoef = ((

)(vals[candpos] + feastol)) % gcd;

12587

assert(restcoef >= 1);

12588

assert(restcoef < gcd);

12600 if

( restcoef > rest )

12601

newcoef = vals[candpos] - restcoef + gcd;

12603

newcoef = vals[candpos] - restcoef;

12615 if

( rest == 0 || restcoef < rest )

12616

newcoef = vals[candpos] - restcoef;

12618

newcoef = vals[candpos] - restcoef + gcd;

12622 SCIPdebugMsg

(

"gcd = %" SCIP_LONGINT_FORMAT ", rest = %" SCIP_LONGINT_FORMAT ", restcoef = %" SCIP_LONGINT_FORMAT "; changing coef of variable <%s> to %g and %s by %" SCIP_LONGINT_FORMAT "\n"

, gcd, rest, restcoef,

(vars[candpos]), newcoef, hasrhs ?

"reduced rhs"

"increased lhs"

, hasrhs ? rest : (rest > 0 ? gcd - rest : 0));

12638

assert(vars == consdata->vars);

12639

assert(vals == consdata->vals);

12646

rhs = consdata->rhs;

12647

lhs = consdata->lhs;

12651

nvars = consdata->nvars;

12653 SCIPdebugMsg

(

"we did %d coefficient changes and %d side changes on constraint %s when applying one round of the gcd algorithm\n"

, *nchgcoefs - oldnchgcoefs, *nchgsides - oldnchgsides,

(cons));

12655 while

( nvars >= 2 );

12675 int

* diffidx0minus1,

12676 int

* diffidx1minus0,

12678 int

commonidxweight,

12679 int

diffidx0minus1weight,

12680 int

diffidx1minus0weight,

12705

assert(cons0 !=

);

12706

assert(cons1 !=

);

12707

assert(commonidx0 !=

);

12708

assert(commonidx1 !=

);

12709

assert(diffidx0minus1 !=

);

12710

assert(diffidx1minus0 !=

);

12711

assert(nvarscommon >= 1);

12712

assert(commonidxweight >= nvarscommon);

12713

assert(nchgcoefs !=

);

12714

assert(aggregated !=

);

12719

*infeasible =

;

12725

assert(consdata0 !=

);

12726

assert(consdata0->nvars >= 1);

12727

assert(

(

, consdata0->lhs, consdata0->rhs));

12728

assert(diffidx0minus1weight >= consdata0->nvars - nvarscommon);

12732

assert(consdata1 !=

);

12733

assert(consdata1->nvars >= 1);

12734

assert(

(

, consdata1->lhs, consdata1->rhs));

12735

assert(diffidx1minus0weight >= consdata1->nvars - nvarscommon);

12737

*aggregated =

;

12743

bestvarweight = commonidxweight + diffidx0minus1weight;

12744

bestnvars = consdata0->nvars;

12746

bestscalarsum = 0.0;

12747

commonvarlindependent =

;

12748 for

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

12750

assert(consdata0->vars[commonidx0[v]] == consdata1->vars[commonidx1[v]]);

12751 a

= consdata1->vals[commonidx1[v]];

12752 b

= -consdata0->vals[commonidx0[v]];

12758

varweight = diffidx0minus1weight + diffidx1minus0weight;

12759

nvars = consdata0->nvars + consdata1->nvars - 2*nvarscommon;

12761

betterscalarsum = (scalarsum < bestscalarsum);

12762 for

( i = 0; i < nvarscommon

12763

&& (varweight < bestvarweight || (varweight == bestvarweight && betterscalarsum)); ++i )

12765

aggrcoef =

* consdata0->vals[commonidx0[i]] +

* consdata1->vals[commonidx1[i]];

12768

varweight +=

getVarWeight

(consdata0->vars[commonidx0[i]]);

12772 if

( varweight < bestvarweight || (varweight == bestvarweight && betterscalarsum) )

12775

bestvarweight = varweight;

12777

bestscalarsum = scalarsum;

12784 if

( commonvarlindependent && v > 0 )

12786

consdata1->vals[commonidx1[v]] * consdata0->vals[commonidx0[0]],

12787

consdata1->vals[commonidx1[0]] * consdata0->vals[commonidx0[v]]);

12804 if

( consdata1->vals[commonidx1[bestv]] > 0.0 )

12806 a

= consdata1->vals[commonidx1[bestv]];

12807 b

= -consdata0->vals[commonidx0[bestv]];

12811 a

= -consdata1->vals[commonidx1[bestv]];

12812 b

= consdata0->vals[commonidx0[bestv]];

12821

assert(commonvarlindependent);

12822 if

( consdata1->vals[commonidx1[0]] > 0.0 )

12824 a

= consdata1->vals[commonidx1[0]];

12825 b

= -consdata0->vals[commonidx0[0]];

12829 a

= -consdata1->vals[commonidx1[0]];

12830 b

= consdata0->vals[commonidx0[0]];

12851 SCIPdebug

( bestvarweight = diffidx0minus1weight + diffidx1minus0weight; )

12852

bestnvars = consdata0->nvars + consdata1->nvars - 2*nvarscommon;

12855 SCIPdebugMsg

(

"aggregate linear constraints <%s> := %.15g*<%s> + %.15g*<%s> -> nvars: %d -> %d, weight: %d -> %d\n"

12857

consdata0->nvars, bestnvars, commonidxweight + diffidx0minus1weight, bestvarweight);

12867 if

( !commonvarlindependent )

12869 for

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

12871

assert(0 <= commonidx0[i] && commonidx0[i] < consdata0->nvars);

12872

assert(0 <= commonidx1[i] && commonidx1[i] < consdata1->nvars);

12874

aggrcoef =

* consdata0->vals[commonidx0[i]] +

* consdata1->vals[commonidx1[i]];

12877

assert(newnvars < bestnvars);

12878

newvars[newnvars] = consdata0->vars[commonidx0[i]];

12879

newvals[newnvars] = aggrcoef;

12888 for

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

12890

assert(0 <= commonidx0[i] && commonidx0[i] < consdata0->nvars);

12891

assert(0 <= commonidx1[i] && commonidx1[i] < consdata1->nvars);

12893

aggrcoef =

* consdata0->vals[commonidx0[i]] +

* consdata1->vals[commonidx1[i]];

12900 for

( i = 0; i < consdata0->nvars - nvarscommon; ++i )

12902

assert(0 <= diffidx0minus1[i] && diffidx0minus1[i] < consdata0->nvars);

12904

aggrcoef =

* consdata0->vals[diffidx0minus1[i]];

12906

assert(newnvars < bestnvars);

12907

newvars[newnvars] = consdata0->vars[diffidx0minus1[i]];

12908

newvals[newnvars] = aggrcoef;

12913 for

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

12915

assert(0 <= diffidx1minus0[i] && diffidx1minus0[i] < consdata1->nvars);

12917

aggrcoef =

* consdata1->vals[diffidx1minus0[i]];

12919

assert(newnvars < bestnvars);

12920

newvars[newnvars] = consdata1->vars[diffidx1minus0[i]];

12921

newvals[newnvars] = aggrcoef;

12924

assert(newnvars == bestnvars);

12932

newlhs =

* consdata0->lhs +

* consdata1->lhs;

12936

newrhs =

* consdata0->rhs +

* consdata1->rhs;

12946

assert(newconsdata !=

);

12949

newconsdata->upgraded = consdata0->upgraded;

12965 if

( !consdata0->upgraded )

12966

(*nchgcoefs) += consdata0->nvars + consdata1->nvars - nvarscommon;

12967

*aggregated =

;

13007

assert(key1 !=

);

13008

assert(key2 !=

);

13011

assert(consdata1->indexsorted);

13012

assert(consdata2->indexsorted);

13018 if

( key1 == key2 )

13022 if

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

13026 for

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

13028 if

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

13030

assert(

SCIPvarCompare

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

13034

assert(

SCIPvarCompare

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

13046 for

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

13048 SCIP_Real

scale = consdata2->vals[i] / consdata1->vals[i];

13050 if

( minscale > scale )

13058 if

( maxscale < scale )

13085

assert(key !=

);

13087

assert(consdata !=

);

13088

assert(consdata->nvars > 0);

13090

assert(consdata->indexsorted);

13097 return SCIPhashFour

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

13110

assert(cons !=

);

13113

assert(consdata !=

);

13115 return

(((

unsigned int

)consdata->upgraded)<<31) + (

unsigned

int)

SCIPconsGetPos

(cons);

13129 int

* nparallelconss

13133 unsigned int

querykey;

13135

*nparallelconss = 0;

13142 if

( conskey < querykey )

13144

parallelconss[(*nparallelconss)++] = *querycons;

13145

*querycons = parallelcons;

13146

querykey = conskey;

13150

parallelconss[(*nparallelconss)++] = parallelcons;

13161 if

( *querycons == parallelcons )

13197 int

nparallelconss;

13202

assert(blkmem !=

);

13203

assert(conss !=

);

13204

assert(firstchange !=

);

13205

assert(cutoff !=

);

13206

assert(ndelconss !=

);

13207

assert(nchgsides !=

);

13210

hashtablesize = nconss;

13212

hashGetKeyLinearcons, hashKeyEqLinearcons, hashKeyValLinearcons, (

void

) );

13217 for

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

13237

assert(consdata0 !=

);

13239

assert(consdata0->indexsorted);

13248 if

( nparallelconss != 0 )

13258

lhs = consdata0->lhs;

13259

rhs = consdata0->rhs;

13261 for

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

13267

consdel = parallelconss[i];

13280

assert(consdatadel !=

);

13281

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

13283

assert(consdatadel->indexsorted);

13284

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

13286

scale = consdata0->vals[0] / consdatadel->vals[0];

13287

assert(scale != 0.0);

13294

assert(consdata0->validmaxabsval);

13295

assert(consdatadel->validmaxabsval);

13297 SCIP_Real

scale0 = 1.0 / consdata0->maxabsval;

13300 for

( k = 0; k < consdata0->nvars; ++k )

13302

assert(

(

, scale0 * consdata0->vals[k], scaledel * consdatadel->vals[k]));

13310 SCIPdebugMsg

(

"aggregate linear constraints <%s> and <%s> with equal coefficients into single ranged row\n"

13316

lhs =

(scale * consdatadel->lhs, lhs);

13319

rhs =

(scale * consdatadel->rhs, rhs);

13324 SCIPdebugMsg

(

"aggregate linear constraints <%s> and <%s> with negated coefficients into single ranged row\n"

13330

lhs =

(scale * consdatadel->rhs, lhs);

13333

rhs =

(scale * consdatadel->lhs, rhs);

13340

assert( ! consdata0->upgraded || consdatadel->upgraded );

13342 if

( !consdatadel->upgraded )

13356

rhs = (lhs + rhs)/2;

13365 if

( consdata0->changed &&

SCIPconsGetPos

(cons0) < *firstchange )

13371#ifdef SCIP_MORE_DEBUG 13404 int

* diffidx0minus1;

13405 int

* diffidx1minus0;

13406

uint64_t possignature0;

13407

uint64_t negsignature0;

13410 int

diffidx1minus0size;

13417

assert(conss !=

);

13418

assert(firstchange <= chkind);

13419

assert(cutoff !=

);

13420

assert(ndelconss !=

);

13421

assert(nchgsides !=

);

13422

assert(nchgcoefs !=

);

13425

cons0 = conss[chkind];

13426

assert(cons0 !=

);

13431

assert(consdata0 !=

);

13432

assert(consdata0->nvars >= 1);

13433

cons0isequality =

(

, consdata0->lhs, consdata0->rhs);

13440

possignature0 = consdata0->possignature;

13441

negsignature0 = consdata0->negsignature;

13448

diffidx1minus0size = consdata0->nvars;

13450

cons0lhs = consdata0->lhs;

13451

cons0rhs = consdata0->rhs;

13452

cons0upgraded = consdata0->upgraded;

13455

cons0changed = consdata0->changed;

13456

consdata0->changed =

;

13457 for

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

; ++c )

13461

uint64_t possignature1;

13462

uint64_t negsignature1;

13474 int

commonidxweight;

13475 int

diffidx0minus1weight;

13476 int

diffidx1minus0weight;

13480

assert(cons0lhs == consdata0->lhs);

13481

assert(cons0rhs == consdata0->rhs);

13482

assert(cons0upgraded == consdata0->upgraded);

13487 if

( cons1 ==

)

13494

assert(consdata1 !=

);

13501 if

( !cons0changed && !consdata1->changed )

13506 if

( cons0upgraded && consdata1->upgraded )

13509

assert(consdata1->nvars >= 1);

13516

possignature1 = consdata1->possignature;

13517

negsignature1 = consdata1->negsignature;

13520

coefsequal = (possignature0 == possignature1) && (negsignature0 == negsignature1);

13521

coefsnegated = (possignature0 == negsignature1) && (negsignature0 == possignature1);

13522

cons0dominateslhs =

SCIPisGE

(

, cons0lhs, consdata1->lhs)

13523

&& ((possignature0 | possignature1) == possignature1)

13524

&& ((negsignature0 | negsignature1) == negsignature0);

13525

cons1dominateslhs =

SCIPisGE

(

, consdata1->lhs, cons0lhs)

13526

&& ((possignature0 | possignature1) == possignature0)

13527

&& ((negsignature0 | negsignature1) == negsignature1);

13528

cons0dominatesrhs =

(

, cons0rhs, consdata1->rhs)

13529

&& ((possignature0 | possignature1) == possignature0)

13530

&& ((negsignature0 | negsignature1) == negsignature1);

13531

cons1dominatesrhs =

(

, consdata1->rhs, cons0rhs)

13532

&& ((possignature0 | possignature1) == possignature1)

13533

&& ((negsignature0 | negsignature1) == negsignature0);

13534

cons1isequality =

(

, consdata1->lhs, consdata1->rhs);

13535

tryaggregation = (cons0isequality || cons1isequality) && (maxaggrnormscale > 0.0);

13536 if

( !cons0dominateslhs && !cons1dominateslhs && !cons0dominatesrhs && !cons1dominatesrhs

13537

&& !coefsequal && !coefsnegated && !tryaggregation )

13541 if

( tryaggregation && consdata1->nvars > diffidx1minus0size )

13544

diffidx1minus0size = consdata1->nvars;

13570

commonidxweight = 0;

13572

diffidx0minus1weight = 0;

13574

diffidx1minus0weight = 0;

13577 while

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

13578

&& (cons0dominateslhs || cons1dominateslhs || cons0dominatesrhs || cons1dominatesrhs

13579

|| coefsequal || coefsnegated || tryaggregation) )

13587 if

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

13588

varcmp =

SCIPvarCompare

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

13589 else if

( v0 < consdata0->nvars )

13598

var = consdata0->vars[v0];

13599

val0 = consdata0->vals[v0];

13601 if

( tryaggregation )

13603

diffidx0minus1[nvars0minus1] = v0;

13608

coefsequal =

;

13609

coefsnegated =

;

13614

var = consdata1->vars[v1];

13616

val1 = consdata1->vals[v1];

13617 if

( tryaggregation )

13619

diffidx1minus0[nvars1minus0] = v1;

13624

coefsequal =

;

13625

coefsnegated =

;

13630

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

13631

var = consdata0->vars[v0];

13632

val0 = consdata0->vals[v0];

13633

val1 = consdata1->vals[v1];

13634 if

( tryaggregation )

13636

commonidx0[nvarscommon] = v0;

13637

commonidx1[nvarscommon] = v1;

13643

coefsequal = coefsequal && (

(

, val0, val1));

13644

coefsnegated = coefsnegated && (

(

, val0, -val1));

13654

assert(var !=

);

13661

cons0dominatesrhs =

;

13662

cons1dominateslhs =

;

13666

cons0dominateslhs =

;

13667

cons1dominatesrhs =

;

13674

cons0dominateslhs =

;

13675

cons1dominatesrhs =

;

13679

cons0dominatesrhs =

;

13680

cons1dominateslhs =

;

13686 if

( coefsequal || coefsnegated )

13701 SCIPdebugMsg

(

"aggregate linear constraints <%s> and <%s> with %s coefficients into single ranged row\n"

13709

lhs =

(consdata0->lhs, consdata1->lhs);

13710

rhs =

(consdata0->rhs, consdata1->rhs);

13715

lhs =

(consdata0->lhs, -consdata1->rhs);

13716

rhs =

(consdata0->rhs, -consdata1->lhs);

13727 if

( consdata0->upgraded )

13729

assert(!consdata1->upgraded);

13732

consdatastay = consdata1;

13736

consdatadel = consdata0;

13737

consinddel = chkind;

13743

consdatastay = consdata0;

13747

consdatadel = consdata1;

13754 if

( !consdata0->upgraded )

13756

assert(consstay == cons0);

13757

cons0lhs = consdata0->lhs;

13758

cons0rhs = consdata0->rhs;

13764

assert( !consdatastay->upgraded );

13767

conss[consinddel] =

;

13768 if

( !consdatadel->upgraded )

13776 if

( cons1dominateslhs && (!cons0isequality || cons1dominatesrhs ||

(

, consdata0->rhs) ) )

13779 SCIPdebugMsg

(

"left hand side of linear constraint <%s> is dominated by <%s>:\n"

13796

cons0lhs = consdata0->lhs;

13797

cons0isequality =

;

13798 if

( !consdata0->upgraded )

13807 else if

( cons0dominateslhs && (!cons1isequality || cons0dominatesrhs ||

(

, consdata1->rhs)) )

13810 SCIPdebugMsg

(

"left hand side of linear constraint <%s> is dominated by <%s>:\n"

13827

cons1isequality =

;

13828 if

( !consdata1->upgraded )

13837 if

( cons1dominatesrhs && (!cons0isequality || cons1dominateslhs ||

(

, -consdata0->lhs)) )

13840 SCIPdebugMsg

(

"right hand side of linear constraint <%s> is dominated by <%s>:\n"

13857

cons0rhs = consdata0->rhs;

13858

cons0isequality =

;

13859 if

( !consdata0->upgraded )

13868 else if

( cons0dominatesrhs && (!cons1isequality || cons0dominateslhs ||

(

, -consdata1->lhs)) )

13871 SCIPdebugMsg

(

"right hand side of linear constraint <%s> is dominated by <%s>:\n"

13888

cons1isequality =

;

13889 if

( !consdata1->upgraded )

13905

conss[chkind] =

;

13906 if

( !consdata0->upgraded )

13921 if

( !consdata1->upgraded )

13934 if

( tryaggregation )

13938

assert(consdata0->nvars == nvarscommon + nvars0minus1);

13939

assert(consdata1->nvars == nvarscommon + nvars1minus0);

13941

aggregated =

;

13942 if

( cons1isequality && !consdata0->upgraded && commonidxweight > diffidx1minus0weight )

13946

nvarscommon, commonidxweight, diffidx0minus1weight, diffidx1minus0weight, maxaggrnormscale,

13947

nchgcoefs, &aggregated, cutoff) );

13957

conss[chkind] =

;

13960 if

( !aggregated && cons0isequality && !consdata1->upgraded && commonidxweight > diffidx0minus1weight )

13964

nvarscommon, commonidxweight, diffidx1minus0weight, diffidx0minus1weight, maxaggrnormscale,

13965

nchgcoefs, &aggregated, cutoff) );

14031

assert(cons !=

);

14032

assert(nfixedvars !=

);

14040 if

( singlevarstuffing )

14043

&isminsettoinfinity, &ismaxsettoinfinity);

14049

isminsettoinfinity =

;

14050

ismaxsettoinfinity =

;

14058

rhs = -consdata->lhs;

14060

maxactivity = -minactivity;

14061

ismaxsettoinfinity = isminsettoinfinity;

14066

rhs = consdata->rhs;

14070

nvars = consdata->nvars;

14071

vars = consdata->vars;

14072

vals = consdata->vals;

14075 if

( singletonstuffing )

14077 for

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

14093

assert(singletonstuffing);

14101

mincondactivity = 0.0;

14102

maxcondactivity = 0.0;

14104 for

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

14110

val = factor * vals[v];

14123

tryfixing =

;

14127

maxcondactivity += val * lb;

14128

mincondactivity += val * lb;

14129

swapped[v] =

;

14130

ratios[nsingletons] = obj / val;

14131

varpos[nsingletons] = v;

14139

tryfixing =

;

14146

maxcondactivity += val * ub;

14147

mincondactivity += val * ub;

14148

swapped[v] =

;

14149

ratios[nsingletons] = obj / val;

14150

varpos[nsingletons] = v;

14153 else if

( val > 0 )

14163

tryfixing =

;

14167

maxcondactivity += val * lb;

14168

mincondactivity += val * lb;

14181

tryfixing =

;

14185

maxcondactivity += val * ub;

14186

mincondactivity += val * ub;

14196

tryfixing =

;

14202

maxcondactivity += val * ub;

14203

mincondactivity += val * lb;

14207

maxcondactivity += val * lb;

14208

mincondactivity += val * ub;

14212 if

( tryfixing && nsingletons > 0 && (

(

, rhs, maxcondactivity) ||

(

, rhs, mincondactivity)) )

14217 int

oldnfixedvars = *nfixedvars;

14218 int

oldnchgbds = *nchgbds;

14224 for

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

14228

val = factor * vals[idx];

14233

assert((val < 0) == swapped[idx]);

14247 if

( swapped[idx] )

14248

delta = -(lb - ub) * val;

14250

delta = (ub - lb) * val;

14254 if

(

(

, delta, rhs - maxcondactivity) )

14256 if

( swapped[idx] )

14281 if

( swapped[idx] )

14300

maxcondactivity += delta;

14301

mincondactivity += delta;

14305 if

( *nfixedvars - oldnfixedvars > 0 || *nchgbds - oldnchgbds > 0 )

14307 SCIPdebugMsg

(

"### stuffing fixed %d variables and changed %d bounds\n"

, *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds);

14346 if

( singlevarstuffing && !ismaxsettoinfinity )

14351 int

bestindex = -1;

14352 int

bestuplocks = 0;

14353 int

bestdownlocks = 1;

14356 SCIPdebug

(

int

oldnfixedvars = *nfixedvars; )

14357 SCIPdebug

(

int

oldnchgbds = *nchgbds; )

14360 for

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

14364

val = factor * vals[v];

14392 if

( ratio > bestratio || ((ratio == bestratio) && downlocks == 0 && (bestdownlocks > 0

14397 if

( bestindex != -1 )

14400 if

( bestuplocks > 1 )

14407

secondbestratio = bestratio;

14410

bestdownlocks = downlocks;

14411

bestuplocks = uplocks;

14418 if

( bestdownlocks > 0 && bestuplocks > 1 )

14433 if

( ratio > secondbestratio )

14435

secondbestratio = ratio;

14441 if

( bestindex != -1 && bestdownlocks == 0 )

14446

var = vars[bestindex];

14448

val = factor * vals[bestindex];

14461 SCIP_Real

activitydelta = (maxactivity - rhs) - (bestvarfloor * -val);

14464

tryfixing =

(

, obj, -activitydelta * secondbestratio);

14466

bounddelta =

(

, (maxactivity - rhs)/-val);

14470

bounddelta = (maxactivity - rhs)/-val;

14472

tryfixing = tryfixing &&

(

, bounddelta, ub - lb);

14498 SCIP_Real

activitydelta = (maxactivity - rhs) - (bestvarfloor * val);

14501

tryfixing =

(

, -obj, activitydelta * secondbestratio);

14503

bounddelta =

(

, (maxactivity - rhs)/val);

14507

bounddelta = (maxactivity - rhs)/val;

14509

tryfixing = tryfixing &&

(

, bounddelta, ub - lb);

14538 for

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

14546 SCIPdebugMsg

(

"<= %g\n"

, factor > 0 ? consdata->rhs : -consdata->lhs);

14548 for

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

14550 if

( v == bestindex )

14553 if

( factor * vals[v] < 0 )

14573 SCIPdebug

(

SCIPdebugMsg

(

"### new stuffing fixed %d vars, tightened %d bounds\n"

, *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds); )

14627

assert(nconss == 0 || conss !=

);

14628

assert(nchgbds !=

);

14637 if

( nbinvars == nvars )

14642

nintvars = nvars - ncontvars;

14645

nvars = nvars - nbinvars;

14657 for

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

14669 for

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

14676

var = vars[v + nintvars - nbinvars];

14696 for

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

14714

assert(consdata !=

);

14723 for

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

14727

var = consdata->vars[i];

14732

assert(0 <= contv && contv < ncontvars);

14733

isimplint[contv] =

;

14746

hasimpliedpotential =

;

14749 for

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

14763

var = consdata->vars[i];

14764

assert(var !=

);

14765

val = consdata->vals[i];

14780

isminsettoinfinity =

;

14781

ismaxsettoinfinity =

;

14787

&ismintight, &ismaxtight, &isminsettoinfinity, &ismaxsettoinfinity);

14793

assert((ismintight || isminsettoinfinity) && (ismaxtight || ismaxsettoinfinity));

14806

assert(0 <= arrayindex && arrayindex < nvars);

14808

newredlb = redlb[arrayindex];

14809

newredub = redub[arrayindex];

14815

nlocksdown[arrayindex] += nlockspos;

14816

newredlb = (isminsettoinfinity ?

(

) : (consdata->lhs - minresactivity)/val);

14821

nlocksup[arrayindex] += nlockspos;

14822

newredub = (ismaxsettoinfinity ? -

(

) : (consdata->rhs - maxresactivity)/val);

14830

nlocksup[arrayindex] += nlockspos;

14831

newredub = (isminsettoinfinity ? -

(

) : (consdata->lhs - minresactivity)/val);

14836

nlocksdown[arrayindex] += nlockspos;

14837

newredlb = (ismaxsettoinfinity ?

(

) : (consdata->rhs - maxresactivity)/val);

14851

redlb[arrayindex] =

(redlb[arrayindex], newredlb);

14852

redub[arrayindex] =

(redub[arrayindex], newredub);

14859

assert(nconscontvars < ncontvars);

14861

conscontvars[nconscontvars] = var;

14865

assert(0 <= contv && contv < ncontvars);

14866

hasimpliedpotential = hasimpliedpotential || isimplint[contv];

14871 if

( hasimpliedpotential )

14873 if

( nconscontvars > 1 || !integralcoefs )

14878 for

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

14882

assert(0 <= contv && contv < ncontvars);

14883

isimplint[contv] =

;

14897

assert(nconscontvars == 1);

14898

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

14899

var = consdata->vars[contvarpos];

14900

val = consdata->vals[contvarpos];

14902

assert(0 <= contv && contv < ncontvars);

14903

assert(isimplint[contv]);

14907

isimplint[contv] =

;

14913 if

( obj * val >= 0.0 && lhsexists )

14918 if

( obj * val <= 0.0 && rhsexists )

14930 for

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

14960 SCIPdebugMsg

(

"variable <%s> only locked down in linear constraints: dual presolve <%s>[%.15g,%.15g] <= %.15g\n"

14964

assert(!infeasible);

14967

redub[v] =

(redub[v], ub);

14989 SCIPdebugMsg

(

"variable <%s> only locked up in linear constraints: dual presolve <%s>[%.15g,%.15g] >= %.15g\n"

14993

assert(!infeasible);

14996

redlb[v] =

(redlb[v], lb);

15004 for

( v = nintvars - nbinvars; v < nvars; ++v )

15010

assert(var !=

);

15015

assert(0 <= v - nintvars + nbinvars && v - nintvars + nbinvars < ncontvars);

15018 if

( isimplint[v - nintvars + nbinvars]

15033 SCIPdebugMsg

(

"dual presolve: converting continuous variable <%s>[%g,%g] to implicit integer\n"

15070

assert(conshdlr !=

);

15072

assert(result !=

);

15075

assert(conshdlrdata !=

);

15077

checkrelmaxabs = conshdlrdata->checkrelmaxabs;

15079 SCIPdebugMsg

(

"Enforcement method of linear constraints for %s solution\n"

, sol ==

"LP"

"relaxation"

);

15087 for

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

15103 for

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

SCIP_FEASIBLE

; ++c )

15144

assert(cons !=

);

15145

assert(graph !=

);

15146

assert(success !=

);

15149

assert(consdata !=

);

15153

nlocvars = consdata->nvars;

15158 for

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

15160

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

15161

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

15165

lhs = consdata->lhs - constant;

15166

rhs = consdata->rhs - constant;

15176 for

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

15184

cons, lhs, rhs, success) );

15201

assert(conshdlr !=

);

15219

assert(conshdlr !=

);

15224

assert(conshdlrdata !=

);

15245

assert(conshdlrdata !=

);

15246

assert(conshdlrdata->eventhdlr !=

);

15247

assert(nconss == 0 || conss !=

);

15249

conshdlrdata->naddconss = 0;

15252 for

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

15273

assert(conshdlrdata !=

);

15274

assert(conshdlrdata->eventhdlr !=

);

15277 for

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

15282

assert(consdata !=

);

15284 if

( consdata->eventdata !=

)

15288

assert(consdata->eventdata ==

);

15339

assert(linconsstats !=

);

15341

assert(conshdlr !=

);

15358 for

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

15368

assert(cons !=

);

15376

assert(consdata !=

);

15377

rhs = consdata->rhs;

15378

lhs = consdata->lhs;

15382 for

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

15388 if

( consdata->nvars == 0 )

15408 if

( consdata->nvars == 1 )

15418 if

( consdata->nvars == 2 &&

(

, lhs, rhs) )

15428 if

( consdata->nvars == 2 )

15433 if

(

(

, consdata->vals[0], -consdata->vals[1])

15458

unmatched =

;

15461

scale =

(consdata->vals[0]);

15464 for

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

15471 if

( consdata->vals[i] < 0.0 )

15479 b

= rhs/scale + nnegbinvars;

15500 b

= rhs/scale + nnegbinvars;

15525 b

= lhs/scale + nnegbinvars;

15554

unmatched =

;

15555 for

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

15563 b

-= consdata->vals[i];

15583 for

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

15588 SCIPdebugMsg

(

"classified as %s: "

, matched ?

"BINPACKING"

"KNAPSACK"

);

15606

unmatched =

;

15611 for

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

15637

unmatched =

;

15638 for

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

15671#ifdef SCIP_STATISTIC 15682#ifdef SCIP_STATISTIC 15685

assert(conshdlrdata !=

);

15690 for

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

15698

assert(consdata !=

);

15700 if

( consdata->upgraded )

15707 if

(

(

, consdata->maxactdelta, conshdlrdata->maxeasyactivitydelta) )

15712 SCIPstatisticMessage

(

"below threshold: %d / %d ratio= %g\n"

, ngoodconss, nallconss, (100.0 * ngoodconss / nallconss));

15716 for

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

15724

assert(consdata !=

);

15726 if

( consdata->upgraded )

15751 for

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

15769 for

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

15774

assert(consdata !=

);

15776 if

( consdata->row !=

)

15781 if

( consdata->nlrow !=

)

15797 if

( ncutsadded > 0 )

15800 "(restart) converted %d cuts from the global cut pool into linear constraints\n"

, ncutsadded);

15816

assert(cons !=

);

15833

assert(conshdlr !=

);

15835

assert(cons !=

);

15839

assert(consdata !=

);

15847

assert(conshdlrdata !=

);

15848

assert(conshdlrdata->eventhdlr !=

);

15851 if

( consdata->eventdata !=

)

15856

assert(consdata->eventdata ==

);

15876

assert(conshdlr !=

);

15879 if

( (*consdata)->eventdata !=

)

15884

assert(conshdlrdata !=

);

15888

assert((*consdata)->eventdata ==

);

15908

assert(conshdlr !=

);

15911

assert(sourcecons !=

);

15912

assert(targetcons !=

);

15915

assert(sourcedata !=

);

15916

assert(sourcedata->row ==

);

15919 SCIP_CALL

(

consdataCreate

(

, &targetdata, sourcedata->nvars, sourcedata->vars, sourcedata->vals, sourcedata->lhs, sourcedata->rhs) );

15926 for

(n = targetdata->nvars - 1; n >= 0; --n )

15951

*infeasible =

;

15953 for

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

15981

assert(conshdlr !=

);

15983

assert(result !=

);

15986

assert(conshdlrdata !=

);

15995 if

( (depth == 0 && conshdlrdata->maxroundsroot >= 0 && nrounds >= conshdlrdata->maxroundsroot)

15996

|| (depth > 0 && conshdlrdata->maxrounds >= 0 && nrounds >= conshdlrdata->maxrounds) )

16000

maxsepacuts = (depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);

16006

maxbound = glblowerbound + conshdlrdata->maxcardbounddist * (cutoffbound - glblowerbound);

16007

separatecards =

(

, loclowerbound, maxbound);

16015 for

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

16024 else if

( ncuts > 0 )

16047

assert(conshdlr !=

);

16049

assert(result !=

);

16052

assert(conshdlrdata !=

);

16061 if

( (depth == 0 && conshdlrdata->maxroundsroot >= 0 && nrounds >= conshdlrdata->maxroundsroot)

16062

|| (depth > 0 && conshdlrdata->maxrounds >= 0 && nrounds >= conshdlrdata->maxrounds) )

16066

maxsepacuts = (depth == 0 ? conshdlrdata->maxsepacutsroot : conshdlrdata->maxsepacuts);

16073 for

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

16082 else if

( ncuts > 0 )

16120

assert(conshdlr !=

);

16122

assert(result !=

);

16125

assert(conshdlrdata !=

);

16127

checkrelmaxabs = conshdlrdata->checkrelmaxabs;

16132 if

( objinfeasible )

16134 SCIPdebugMsg

(

"-> pseudo solution is objective infeasible, return.\n"

);

16142 for

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

16167

assert(conshdlr !=

);

16169

assert(result !=

);

16174

assert(conshdlrdata !=

);

16176

checkrelmaxabs = conshdlrdata->checkrelmaxabs;

16181 for

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

SCIP_FEASIBLE

|| completely); ++c )

16196

assert( consdata !=

);

16206 SCIPinfoMessage

(

"violation: left hand side is violated by %.15g\n"

, consdata->lhs - activity);

16208 SCIPinfoMessage

(

"violation: right hand side is violated by %.15g\n"

, activity - consdata->rhs);

16230

assert(conshdlr !=

);

16232

assert(result !=

);

16235

assert(conshdlrdata !=

);

16241

tightenbounds =

;

16246 int

tightenboundsfreq;

16251

tightenboundsfreq = propfreq * conshdlrdata->tightenboundsfreq;

16252

tightenbounds = (conshdlrdata->tightenboundsfreq >= 0)

16253

&& ((tightenboundsfreq == 0 && depth == 0) || (tightenboundsfreq >= 1 && (depth % tightenboundsfreq == 0)));

16256

rangedrowpropagation = conshdlrdata->rangedrowpropagation;

16258

rangedrowpropagation = rangedrowpropagation && (depth <= conshdlrdata->rangedrowmaxdepth);

16259

rangedrowfreq = propfreq * conshdlrdata->rangedrowfreq;

16260

rangedrowpropagation = rangedrowpropagation && (conshdlrdata->rangedrowfreq >= 0)

16261

&& ((rangedrowfreq == 0 && depth == 0) || (rangedrowfreq >= 1 && (depth % rangedrowfreq == 0)));

16268 for

( i = 0; i < nmarkedconss && !cutoff; i++ )

16272

conshdlrdata->maxeasyactivitydelta, conshdlrdata->sortvars, &cutoff, &nchgbds) );

16278 else if

( nchgbds > 0 )

16287#define MAXCONSPRESOLROUNDS 10 16310 int

firstupgradetry;

16314

assert(conshdlr !=

);

16316

assert(result !=

);

16322

oldnfixedvars = *nfixedvars;

16323

oldnaggrvars = *naggrvars;

16324

oldnchgbds = *nchgbds;

16325

oldndelconss = *ndelconss;

16326

oldnupgdconss = *nupgdconss;

16327

oldnchgcoefs = *nchgcoefs;

16328

oldnchgsides = *nchgsides;

16332

assert(conshdlrdata !=

);

16335

firstchange = INT_MAX;

16336

firstupgradetry = INT_MAX;

16342

infeasible =

;

16347

assert(consdata !=

);

16350 if

(

(

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

16352

consdata->lhs = consdata->rhs;

16353

assert(consdata->row ==

);

16356 if

( consdata->eventdata ==

)

16360

assert(consdata->eventdata !=

);

16365

assert(

SCIPgetNRuns

(

) > 0 || nrounds > 0 || consdata->boundstightened == 0);

16366

assert(

SCIPgetNRuns

(

) > 0 || nrounds > 0 || !consdata->presolved);

16379

assert(consdata->removedfixings);

16386 if

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

16390 if

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

16391

firstupgradetry = c;

16394 if

( consdata->presolved )

16412

consdata->presolved =

;

16429 SCIPdebugMsg

(

" -> infeasibility detected during tightening sides\n"

);

16437 SCIPdebugMsg

(

"linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n"

16455

&isminsettoinfinity, &ismaxsettoinfinity);

16458 SCIPdebugMsg

(

"linear constraint <%s> is infeasible: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n"

16459 SCIPconsGetName

(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);

16465 SCIPdebugMsg

(

"linear constraint <%s> is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n"

16466 SCIPconsGetName

(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);

16470 if

( !consdata->upgraded )

16476 SCIPdebugMsg

(

"linear constraint <%s> left hand side is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n"

16477 SCIPconsGetName

(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);

16479 if

( !consdata->upgraded )

16484 SCIPdebugMsg

(

"linear constraint <%s> right hand side is redundant: activitybounds=[%.15g,%.15g], sides=[%.15g,%.15g]\n"

16485 SCIPconsGetName

(cons), minactivity, maxactivity, consdata->lhs, consdata->rhs);

16487 if

( !consdata->upgraded )

16492 if

( consdata->nvars == 0 )

16496 SCIPdebugMsg

(

"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n"

16502 SCIPdebugMsg

(

"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n"

16507 if

( !consdata->upgraded )

16517 if

( conshdlrdata->simplifyinequalities )

16526 if

( conshdlrdata->aggregatevariables )

16537 if

( conshdlrdata->rangedrowpropagation )

16539 int

lastnfixedvars;

16541

lastnfixedvars = *nfixedvars;

16546 if

( lastnfixedvars < *nfixedvars )

16557

nfixedvars, nchgbds, &cutoff) );

16564 SCIPdebugMsg

(

"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n"

16570 SCIPdebugMsg

(

"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n"

16575 if

( !consdata->upgraded )

16600 if

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

16604 if

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

16605

firstupgradetry = c;

16613

conshdlrdata->singlevarstuffing, &cutoff, nfixedvars, nchgbds) );

16616 if

( consdata->nvars == 0 )

16620 SCIPdebugMsg

(

"empty linear constraint <%s> is infeasible: sides=[%.15g,%.15g]\n"

16626 SCIPdebugMsg

(

"empty linear constraint <%s> is redundant: sides=[%.15g,%.15g]\n"

16631 if

( !consdata->upgraded )

16644

assert(firstchange >= 0);

16646 if

( firstchange < nconss && conshdlrdata->presolusehashing )

16650

ndelconss, nchgsides) );

16653 if

( firstchange < nconss && conshdlrdata->presolpairwise )

16657 int

firstchangenew;

16660

npaircomparisons = 0;

16661

oldndelconss = *ndelconss;

16662

oldnchgsides = *nchgsides;

16663

oldnchgcoefs = *nchgcoefs;

16669

firstchangenew = -1;

16670 for

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

16673 if

( c == firstchange )

16674

firstchangenew = nusefulconss;

16680

usefulconss[nusefulconss] = conss[c];

16683

firstchange = firstchangenew;

16684

assert(firstchangenew >= 0 && firstchangenew <= nusefulconss);

16686 for

( c = firstchange; c < nusefulconss && !cutoff && !

SCIPisStopped

(

); ++c )

16689 if

( usefulconss[c] ==

)

16692

npaircomparisons += (

SCIPconsGetData

(conss[c])->changed) ? c : (c - firstchange);

16696

&cutoff, ndelconss, nchgsides, nchgcoefs) );

16698 if

( npaircomparisons > conshdlrdata->nmincomparisons )

16700

assert(npaircomparisons > 0);

16701 if

( ((*ndelconss - oldndelconss) + (*nchgsides - oldnchgsides)/2.0 + (*nchgcoefs - oldnchgcoefs)/10.0) / ((

SCIP_Real

) npaircomparisons) < conshdlrdata->mingainpernmincomp )

16703

oldndelconss = *ndelconss;

16704

oldnchgsides = *nchgsides;

16705

oldnchgcoefs = *nchgcoefs;

16706

npaircomparisons = 0;

16717 if

( !cutoff && firstupgradetry < nconss

16718

&& *nfixedvars == oldnfixedvars && *naggrvars == oldnaggrvars && *nchgbds == oldnchgbds && *ndelconss == oldndelconss

16719

&& *nupgdconss == oldnupgdconss && *nchgcoefs == oldnchgcoefs && *nchgsides == oldnchgsides

16743

assert(consdata !=

);

16746 if

( consdata->upgradetried )

16749 if

( !consdata->presolved )

16752

consdata->upgradetried =

;

16758 if

( upgdcons !=

)

16768

assert(!consdata->upgraded);

16769

consdata->upgraded =

;

16775

|| !conshdlrdata->presolpairwise

16776

|| (conshdlrdata->maxaggrnormscale == 0.0) )

16788 else if

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

16789

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

16803

assert(cons !=

);

16804

assert(result !=

);

16822

assert(cons !=

);

16824

assert(consdata !=

);

16830 for

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

16865

assert(conshdlr !=

);

16866

assert(conss !=

|| nconss == 0);

16881

assert(conshdlr !=

);

16882

assert(cons !=

);

16895 const char

* consname;

16899

assert(sourcescip !=

);

16900

assert(sourcecons !=

);

16907 if

( name !=

)

16914

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

16915

assert(cons !=

|| *valid ==

);

16929 char

** firstoperator,

16930 char

** secondoperator,

16936

assert(str !=

);

16937

assert(firstoperator !=

);

16938

assert(secondoperator !=

);

16940

*firstoperator =

;

16941

*secondoperator =

;

16943

curr = (

char

*)str;

16947 while

( *curr && *success )

16960 if

( curr[1] ==

'='

)

16969 if

( strncmp(curr,

"[free]"

, 6) == 0 )

16984 if

( *firstoperator ==

)

16986

*firstoperator = curr;

16990 if

( *secondoperator !=

)

16995 else if

( strncmp(*firstoperator,

"<="

, 2) != 0 )

16997 SCIPerrorMessage

(

"Two operators in line that is not a ranged row: %s"

, str);

17000 else if

( strncmp(curr,

"<="

, 2) != 0 )

17002 SCIPerrorMessage

(

"Bad second operator, expected ranged row specification: %s"

, str);

17006

*secondoperator = curr;

17016 if

( *firstoperator ==

)

17044

assert(success !=

);

17045

assert(str !=

);

17046

assert(name !=

);

17047

assert(cons !=

);

17053

(*success) =

;

17065 findOperators

(str, &firstop, &secondop, &operatorsuccess);

17068 if

( ! operatorsuccess )

17071

varstrptr = (

char

*)str;

17072

lhsstrptr = rhsstrptr =

;

17073

assert(firstop !=

);

17076 switch

( *firstop )

17079

assert(firstop[1] ==

'='

);

17081 if

( secondop !=

)

17083

assert(secondop[0] ==

'<'

&& secondop[1] ==

'='

);

17084

lhsstrptr = (

char

*)str;

17085

varstrptr = firstop + 2;

17086

rhsstrptr = secondop + 2;

17092

varstrptr = (

char

*)str;

17093

rhsstrptr = firstop + 2;

17097

assert(firstop[1] ==

'='

);

17098

assert(secondop ==

);

17100

lhsstrptr = firstop + 2;

17103

assert(firstop[1] ==

'='

);

17104

assert(secondop ==

);

17106

rhsstrptr = firstop + 2;

17107

lhsstrptr = firstop + 2;

17110

assert(strncmp(firstop,

"[free]"

, 6) == 0);

17111

assert(secondop ==

);

17116 SCIPerrorMessage

(

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

, *firstop);

17121 if

( lhsstrptr !=

)

17125 SCIPerrorMessage

(

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

, lhsstrptr);

17130 if

( rhsstrptr == lhsstrptr )

17135 if

( rhsstrptr !=

&& rhsstrptr != lhsstrptr )

17139 SCIPerrorMessage

(

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

, lhsstrptr);

17149

assert(varstrptr !=

);

17154 if

( *success && requsize > coefssize )

17157

coefssize = requsize;

17162

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

17172

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

17189

assert(consdata !=

);

17191 if

( varssize < consdata->nvars )

17192

(*success) =

;

17195

assert(vars !=

);

17198

(*success) =

;

17212

assert(consdata !=

);

17214

(*nvars) = consdata->nvars;

17215

(*success) =

;

17253

assert(eventhdlr !=

);

17254

assert(eventdata !=

);

17256

assert(event !=

);

17258

cons = eventdata->cons;

17259

assert(cons !=

);

17261

assert(consdata !=

);

17277

varpos = eventdata->varpos;

17278

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

17281

assert(var !=

);

17282

assert(consdata->vars[varpos] == var);

17283

val = consdata->vals[varpos];

17302

consdata->presolved =

;

17303

consdata->rangedrowpropagated = 0;

17311 if

( consdata->maxactdeltavar == var )

17314

consdata->maxactdeltavar =

;

17318 if

( consdata->boundstightened > 0)

17320 switch

( eventtype )

17324

consdata->boundstightened = 0;

17328

consdata->boundstightened = 0;

17350

delta =

(val) * domain;

17352 if

( delta > consdata->maxactdelta )

17354

consdata->maxactdelta = delta;

17355

consdata->maxactdeltavar = var;

17362

consdata->presolved =

;

17363

consdata->removedfixings =

;

17364

consdata->rangedrowpropagated = 0;

17367 if

( consdata->maxactdeltavar == var )

17370

consdata->maxactdeltavar =

;

17378

consdata->presolved =

;

17387

varpos = eventdata->varpos;

17388

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

17391

assert(var !=

);

17392

assert(consdata->vars[varpos] == var);

17393

val = consdata->vals[varpos];

17395

consdata->rangedrowpropagated = 0;

17410

consdata->indexsorted =

;

17412

consdata->coefsorted =

;

17428

consdata->varsdeleted =

;

17449

assert(conflicthdlr !=

);

17451

assert(bdchginfos !=

|| nbdchginfos == 0);

17452

assert(result !=

);

17467 for

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

17469

assert(bdchginfos !=

);

17488 if

( i == nbdchginfos )

17501 if

( upgdcons !=

)

17535

assert(nupgdconss !=

);

17536

assert(upgdconss !=

);

17537

assert(upgdconsssize > 0);

17540

assert(expr !=

);

17563

assert(upgdconss[0] !=

);

17575

consdata->checkabsolute =

;

17603

eventExecLinear,

) );

17607

conflictExecLinear,

) );

17615

consEnfolpLinear, consEnfopsLinear, consCheckLinear, consLockLinear,

17618

assert(conshdlr !=

);

17657 "multiplier on propagation frequency, how often the bounds are tightened (-1: never, 0: only at root)"

17661 "maximal number of separation rounds per node (-1: unlimited)"

17665 "maximal number of separation rounds per node in the root node (-1: unlimited)"

17669 "maximal number of cuts separated per separation round"

17673 "maximal number of cuts separated per separation round in the root node"

17677 "should pairwise constraint comparison be performed in presolving?"

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

17685 "number for minimal pairwise presolve comparisons"

17688 "constraints/" CONSHDLR_NAME "/mingainpernmincomparisons"

17689 "minimal gain per minimal pairwise presolve comparisons to repeat pairwise comparison round"

17693 "maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint aggregation)"

17697 "maximum activity delta to run easy propagation on linear constraint (faster, but numerically less stable)"

17701 "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts"

17705 "should all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value?"

17709 "should presolving search for aggregations in equations"

17713 "should presolving try to simplify inequalities"

17717 "should dual presolving steps be performed?"

17721 "should stuffing of singleton continuous variables be performed?"

17725 "should single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable?"

17728 "constraints/" CONSHDLR_NAME "/sortvars"

"apply binaries sorting in decr. order of coeff abs value?"

17732 "should the violation for a constraint with side 0.0 be checked relative to 1.0 (FALSE) or to the maximum absolute value in the activity (TRUE)?"

17736 "should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP?"

17740 "should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP?"

17744 "should presolving try to detect subsets of constraints parallel to the objective function?"

17748 "should presolving and propagation try to improve bounds, detect infeasibility, and extract sub-constraints from ranged rows and equations?"

17752 "should presolving and propagation extract sub-constraints from ranged rows and equations?"

17756 "maximum depth to apply ranged row propagation"

17760 "frequency for applying ranged row propagation"

17764 "should multi-aggregations only be performed if the constraint can be removed afterwards?"

17768 "maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation"

17772 "maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation"

17776 "should Cliques be extracted?"

17787 const char

* conshdlrname

17797

assert(linconsupgd !=

);

17798

assert(conshdlrname !=

);

17802 if

( conshdlr ==

)

17809

assert(conshdlrdata !=

);

17874

assert(cons !=

);

17878 if

( conshdlr ==

)

17884 for

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

17913 if

( requiredsize > nconsvars )

17919

assert(requiredsize <= nconsvars);

17925 if

( constant < 0.0 )

17932 SCIPerrorMessage

(

"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite left hand side of the constraint\n"

, name);

17942 SCIPerrorMessage

(

"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite right hand side of the constraint\n"

, name);

17958 SCIPerrorMessage

(

"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite left hand side of the constraint\n"

, name);

17968 SCIPerrorMessage

(

"try to generate inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite right hand side of the constraint\n"

, name);

17998

assert(consdata !=

);

18007

assert(consdata !=

);

18012 if

( check || enforce )

18015 for

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

18021 SCIP_CALL

(

SCIPcreateCons

(

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

18022

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

18103

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

18111 if

( sourcecoefs !=

)

18118 for

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

18131 if

( requiredsize > nvars )

18137

assert(requiredsize <= nvars);

18142 for

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

18146

assert(vars[v] !=

);

18152 for

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

18161

assert(!(success) || vars[v] !=

);

18174

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

18195

assert(cons !=

);

18196

assert(var !=

);

18229 if

( requiredsize > nconsvars )

18235

assert(requiredsize <= nconsvars);

18239

assert(consdata !=

);

18241

lhs = consdata->lhs;

18242

rhs = consdata->rhs;

18248 if

( constant < 0.0 )

18255 SCIPerrorMessage

(

"adding variable <%s> leads to inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite left hand side of the constraint\n"

(var),

(cons));

18265 SCIPerrorMessage

(

"adding variable <%s> leads to inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite right hand side of the constraint\n"

(var),

(cons));

18281 SCIPerrorMessage

(

"adding variable <%s> leads to inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite left hand side of the constraint\n"

(var),

(cons));

18291 SCIPerrorMessage

(

"adding variable <%s> leads to inconsistent constraint <%s>, active variables leads to a infinite constant constradict the infinite right hand side of the constraint\n"

(var),

(cons));

18321 for

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

18364

assert(cons !=

);

18365

assert(var !=

);

18375 SCIPerrorMessage

(

"method may only be called during problem creation stage for original constraints and variables\n"

);

18380

assert(consdata !=

);

18382

vars = consdata->vars;

18385 while

( i < consdata->nvars )

18387 if

( vars[i] == var )

18426

assert(cons !=

);

18427

assert(var !=

);

18443

assert(cons !=

);

18453

assert(consdata !=

);

18455 return

consdata->lhs;

18467

assert(cons !=

);

18477

assert(consdata !=

);

18479 return

consdata->rhs;

18490

assert(cons !=

);

18530

assert(cons !=

);

18540

assert(consdata !=

);

18542 return

consdata->nvars;

18554

assert(cons !=

);

18564

assert(consdata !=

);

18566 return

consdata->vars;

18578

assert(cons !=

);

18588

assert(consdata !=

);

18590 return

consdata->vals;

18607

assert(cons !=

);

18617

assert(consdata !=

);

18619 if

( consdata->row !=

)

18635

assert(cons !=

);

18645

assert(consdata !=

);

18647 if

( consdata->row !=

)

18662

assert(cons !=

);

18673

assert(consdata !=

);

18675 if

( consdata->row !=

)

18690

assert(cons !=

);

18701

assert(consdata !=

);

18703 if

( consdata->row !=

)

18720

assert(cons !=

);

18730

assert(consdata !=

);

18732 return

consdata->row;

18773

assert(cons !=

);

18774

assert(upgdcons !=

);

18796

assert(conshdlrdata !=

);

18798

assert(consdata !=

);

18801 if

( consdata->upgraded )

18805 if

( consdata->row !=

)

18809 SCIPerrorMessage

(

"cannot upgrade linear constraint that is already stored as row in the LP\n"

);

18861 for

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

18863

var = consdata->vars[i];

18864

val = consdata->vals[i];

18932

poscoeffsum += val;

18934

negcoeffsum += val;

18941 SCIPdebugMsg

(

"upgrading linear constraint <%s> (%d upgrade methods):\n"

18943 SCIPdebugMsg

(

" +bin=%d -bin=%d +int=%d -int=%d +impl=%d -impl=%d +cont=%d -cont=%d +1=%d -1=%d +I=%d -I=%d +F=%d -F=%d possum=%.15g negsum=%.15g integral=%u\n"

18944

nposbin, nnegbin, nposint, nnegint, nposimpl, nnegimpl, nposcont, nnegcont,

18945

ncoeffspone, ncoeffsnone, ncoeffspint, ncoeffsnint, ncoeffspfrac, ncoeffsnfrac,

18946

poscoeffsum, negcoeffsum, integral);

18949 for

( i = 0; i < conshdlrdata->nlinconsupgrades && *upgdcons ==

; ++i )

18951 if

( conshdlrdata->linconsupgrades[i]->active )

18953 SCIP_CALL

( conshdlrdata->linconsupgrades[i]->linconsupgd(

, cons, consdata->nvars,

18954

consdata->vars, consdata->vals, consdata->lhs, consdata->rhs,

18955

nposbin, nnegbin, nposint, nnegint, nposimpl, nnegimpl, nposimplbin, nnegimplbin, nposcont, nnegcont,

18956

ncoeffspone, ncoeffsnone, ncoeffspint, ncoeffsnint, ncoeffspfrac, ncoeffsnfrac,

18957

poscoeffsum, negcoeffsum, integral,

18963 if

( *upgdcons !=

)

18987 if

( conshdlr ==

)

18990

assert(infeasible !=

);

18991

*infeasible =