RetroSearch Browse

);

229

assert(eventhdlr !=

);

234

(*conshdlrdata)->eventhdlr = eventhdlr;

246

assert(conshdlrdata !=

);

247

assert(*conshdlrdata !=

);

262

assert(consdata !=

);

263

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

264

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

265

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

266

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

269 if

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

273

tmp = consdata->watchedvar1;

274

consdata->watchedvar1 = consdata->watchedvar2;

275

consdata->watchedvar2 = tmp;

276

tmp = consdata->filterpos1;

277

consdata->filterpos1 = consdata->filterpos2;

278

consdata->filterpos2 = tmp;

280

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

281

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

284 if

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

286

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

290 if

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

292

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

298 if

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

303 if

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

310

consdata->watchedvar1 = watchedvar1;

311

consdata->watchedvar2 = watchedvar2;

324

assert(consdata !=

);

325

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

327 if

( num > consdata->varssize )

333

consdata->varssize = newsize;

335

assert(num <= consdata->varssize);

353

assert(consdata !=

);

354

assert(nvars == 0 || vars !=

);

359

(*consdata)->rhs = rhs;

360

(*consdata)->intvar = intvar;

362

(*consdata)->rows[

] =

;

363

(*consdata)->nvars = nvars;

364

(*consdata)->varssize = nvars;

365

(*consdata)->watchedvar1 = -1;

366

(*consdata)->watchedvar2 = -1;

367

(*consdata)->filterpos1 = -1;

368

(*consdata)->filterpos2 = -1;

369

(*consdata)->deleteintvar = (intvar ==

);

370

(*consdata)->propagated =

;

371

(*consdata)->sorted =

;

372

(*consdata)->changed =

;

373

(*consdata)->extvars =

;

374

(*consdata)->nextvars = 0;

375

(*consdata)->extvarssize = 0;

382 if

( (*consdata)->intvar !=

)

394

assert(conshdlr !=

);

396

assert(conshdlrdata !=

);

398 for

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

406 if

( (*consdata)->intvar !=

)

424

assert(consdata !=

);

428 if

( consdata->rows[

] !=

)

445

assert(consdata !=

);

446

assert(*consdata !=

);

456 if

( (*consdata)->nextvars > 0 )

458

assert((*consdata)->extvars !=

);

459 for

( j = 0; j < (*consdata)->extvarssize; ++j )

461 if

( (*consdata)->extvars[j] !=

)

468

(*consdata)->nextvars = 0;

469

(*consdata)->extvarssize = 0;

474

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

475

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

482 if

( (*consdata)->intvar !=

)

507

assert(consdata !=

);

519 if

( consdata->intvar !=

)

543

assert(var !=

);

546

assert(consdata !=

);

547

assert(consdata->rows[0] ==

);

557

assert(var !=

);

561 if

( consdata->intvar !=

)

567

consdata->intvar = var;

568

consdata->changed =

;

575 if

( consdata->rows[0] !=

)

577 SCIPerrorMessage

(

"cannot change intvar of xor constraint after LP relaxation was created\n"

);

595

assert(var !=

);

598

assert(consdata !=

);

599

assert(consdata->rows[0] ==

);

609

assert(var !=

);

613

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

615

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

616

consdata->changed =

;

632

assert(conshdlr !=

);

634

assert(conshdlrdata !=

);

641 if

( consdata->rows[0] !=

)

643 SCIPerrorMessage

(

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

);

661

assert(eventhdlr !=

);

664

assert(consdata !=

);

665

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

682 if

( consdata->watchedvar1 == pos )

686 if

( consdata->watchedvar2 == pos )

691

assert(pos != consdata->watchedvar1);

692

assert(pos != consdata->watchedvar2);

695

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

699 if

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

700

consdata->watchedvar1 = pos;

701 if

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

702

consdata->watchedvar2 = pos;

704

consdata->propagated =

;

705

consdata->sorted =

;

706

consdata->changed =

;

717

assert(consdata !=

);

719 if

( !consdata->sorted )

721 if

( consdata->nvars <= 1 )

722

consdata->sorted =

;

729 if

( consdata->watchedvar1 != -1 )

731

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

732

assert(var1 !=

);

733

consdata->watchedvar1 = -1;

734 if

( consdata->watchedvar2 != -1 )

736

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

737

assert(var2 !=

);

738

consdata->watchedvar2 = -1;

741

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

742

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

743

assert(var1 !=

|| var2 ==

);

746 SCIPsortPtr

((

void

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

747

consdata->sorted =

;

757 for

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

759 if

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

761

consdata->watchedvar1 = v;

762 if

( var2 ==

|| consdata->watchedvar2 != -1 )

765 else if

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

767

assert(consdata->vars[v] !=

);

768

consdata->watchedvar2 = v;

769 if

( consdata->watchedvar1 != -1 )

773

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

774

assert(consdata->watchedvar2 != -1 || var2 ==

);

775

assert(consdata->watchedvar1 < consdata->nvars);

776

assert(consdata->watchedvar2 < consdata->nvars);

786 for

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

821 if

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

827

assert(consdata1->sorted);

828

assert(consdata2->sorted);

830 for

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

833 if

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

835

assert(

SCIPvarCompare

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

855

assert(consdata !=

);

856

assert(consdata->sorted);

857

assert(consdata->nvars > 0);

860

assert(consdata->vars[0] !=

);

861

assert(consdata->vars[consdata->nvars / 2] !=

);

862

assert(consdata->vars[consdata->nvars - 1] !=

);

874 return SCIPhashFour

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

893

assert(consdata !=

);

894

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

);

895

assert(nchgcoefs !=

);

901 while

( v < consdata->nvars )

905

var = consdata->vars[v];

918

consdata->rhs = !consdata->rhs;

933 if

( negated && consdata->intvar ==

)

938

consdata->rhs = !consdata->rhs;

957

assert(consdata->sorted);

965

v = consdata->nvars-2;

968 if

( consdata->vars[v] == consdata->vars[v+1] )

973

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

977 SCIPdebugMsg

(

"xor constraint <%s>: deleting pair of equal variables <%s>\n"

982

v =

MIN

(v, consdata->nvars-1);

990 if

( consdata->intvar !=

)

1010

newvars[1] = consdata->intvar;

1032 SCIPdebugMsg

(

"xor constraint <%s>: deleting pair of negated variables <%s> and <%s>\n"

1037

consdata->rhs = !consdata->rhs;

1038

v =

MIN

(v, consdata->nvars-1);

1045 if

( consdata->rhs && consdata->intvar !=

)

1107

newvars[0] = consdata->intvar;

1109

newvars[1] = newvar;

1170

assert(cons !=

);

1171

assert(naddedconss !=

);

1179

assert(consdata !=

);

1182 if

( consdata->extvars !=

)

1186 if

( consdata->nvars <= 3 )

1190

assert(consdata->extvars ==

);

1191

assert(consdata->nextvars == 0);

1192

assert(consdata->extvarssize == 0);

1195

consdata->extvarssize = 4 * (consdata->nvars);

1199 for

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

1217 SCIP_CALL

(

(

, &varnn, name, 0.0, 1.0, 0.0,

(cons),

(cons),

) );

1221 SCIP_CALL

(

(

, &varns, name, 0.0, 1.0, 0.0,

(cons),

(cons),

) );

1230

assert(!infeasible);

1237 if

( i == consdata->nvars-1 )

1239 if

( consdata->rhs )

1243 SCIP_CALL

(

(

, &varns, name, 0.0, 1.0, 0.0,

(cons),

(cons),

) );

1247 SCIP_CALL

(

(

, &varss, name, 0.0, 1.0, 0.0,

(cons),

(cons),

) );

1256

assert(!infeasible);

1265 SCIP_CALL

(

(

, &varnn, name, 0.0, 1.0, 0.0,

(cons),

(cons),

) );

1269 SCIP_CALL

(

(

, &varsn, name, 0.0, 1.0, 0.0,

(cons),

(cons),

) );

1278

assert(!infeasible);

1288 SCIP_CALL

(

(

, &varnn, name, 0.0, 1.0, 0.0,

(cons),

(cons),

) );

1292 SCIP_CALL

(

(

, &varns, name, 0.0, 1.0, 0.0,

(cons),

(cons),

) );

1296 SCIP_CALL

(

(

, &varsn, name, 0.0, 1.0, 0.0,

(cons),

(cons),

) );

1300 SCIP_CALL

(

(

, &varss, name, 0.0, 1.0, 0.0,

(cons),

(cons),

) );

1310 if

( varns !=

)

1315 if

( varsn !=

)

1321

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

1339 if

( varprevss !=

)

1341

vars[cnt] = varprevss;

1344 if

( varprevns !=

)

1346

vars[cnt] = varprevns;

1351 if

( varss !=

)

1356 if

( varsn !=

)

1377 if

( varprevnn !=

)

1379

vars[cnt] = varprevnn;

1382 if

( varprevsn !=

)

1384

vars[cnt] = varprevsn;

1389 if

( varnn !=

)

1394 if

( varns !=

)

1416

consdata->extvars[4*i] = varnn;

1417

consdata->extvars[4*i + 1] = varns;

1418

consdata->extvars[4*i + 2] = varsn;

1419

consdata->extvars[4*i + 3] = varss;

1421 if

( varnn !=

)

1422

++(consdata->nextvars);

1423 if

( varns !=

)

1424

++(consdata->nextvars);

1425 if

( varsn !=

)

1426

++(consdata->nextvars);

1427 if

( varss !=

)

1428

++(consdata->nextvars);

1476

assert(cons !=

);

1477

assert(naddedconss !=

);

1485

assert(consdata !=

);

1488 if

( consdata->extvars !=

)

1492 if

( consdata->nvars <= 3 )

1496

assert(consdata->extvars ==

);

1497

assert(consdata->nextvars == 0);

1500

consdata->extvarssize = consdata->nvars;

1501

consdata->nextvars = consdata->nvars;

1505 for

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

1516 if

( i == consdata->nvars-1 )

1518 if

( consdata->rhs )

1532 SCIP_CALL

(

(

, &artvar, name, lb, ub, 0.0,

(cons),

(cons),

) );

1541

assert(!infeasible);

1555

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

1572

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

1589

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

1606

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

1620

consdata->extvars[i] = artvar;

1651

assert(consdata !=

);

1652

assert(consdata->rows[0] ==

);

1659 if

( consdata->intvar ==

)

1664

ub = consdata->nvars/2;

1670#ifdef WITH_DEBUG_SOLUTION 1671 if

( SCIPdebugIsMainscip(

) )

1677 for

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

1680

count += (solval > 0.5 ? 1 : 0);

1682

assert((count - consdata->rhs) % 2 == 0);

1683

solval = (

) ((count - consdata->rhs) / 2);

1695

rhsval = (consdata->rhs ? 1.0 : 0.0);

1701 else if

( !consdata->rhs )

1707 for

(

= 0;

< 3; ++

)

1714 for

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

1727 if

( consdata->intvar !=

)

1741 for

(

= 0;

< 3; ++

)

1748 for

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

1761 if

( consdata->intvar !=

)

1785

assert(consdata !=

);

1786

assert(infeasible !=

);

1787

assert(!(*infeasible));

1789 if

( consdata->rows[0] ==

)

1793

assert(consdata->rows[0] !=

);

1794 for

(

= 0;

NROWS

&& !(*infeasible); ++

)

1811

assert(consdata !=

);

1813 if

( consdata->rows[0] ==

)

1840

assert(violated !=

);

1843

assert(consdata !=

);

1869 for

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

1877

cenval = 1.0 - solval;

1882 if

( maxcenval < cenval )

1885

sumcenval += cenval;

1886

sumsolval += solval;

1893

viol =

MAX

(0.0, (odd ? 1.0 : 2.0 * maxcenval) - sumcenval);

1896 if

( consdata->intvar !=

)

1900 if

( viol < solval )

1920 if

( consdata->intvar ==

)

1988

assert(separated !=

);

1989

assert(cutoff !=

);

1993

assert(consdata !=

);

1995

*separated =

;

1998 if

( consdata->rows[0] ==

)

2002

assert(consdata->rows[0] !=

);

2021 if

( separateparity && consdata->nvars > 3 )

2036 for

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

2063 if

( (cnt - (

int

) consdata->rhs) % 2 == 1 )

2069 SCIPdebugMsg

(

"found violated parity cut (efficiacy: %f)\n"

, 1.0 - sum);

2076 for

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

2104 SCIPdebugMsg

(

"found violated parity cut (efficiacy: %f, minval: %f)\n"

, 1.0 - (sum - 1.0 + 2.0 * minval), minval);

2112 for

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

2140 SCIPdebugMsg

(

"found violated parity cut (efficiacy: %f, maxval: %f)\n"

, 1.0 - (sum + 1.0 - 2.0 * maxval), maxval);

2148 for

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

2204

assert(

);

2209 for

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

2216 for

( i = 0; i < m && i < n; ++i )

2231 while

( k < m && A[p[k]][j] == 0 )

2253

assert(A[p[k]][j] != 0);

2263

assert(A[pi][s[i]] != 0);

2266 for

( k = i+1; k < m; ++k )

2270 if

( A[pk][s[i]] != 0 )

2272 for

( j = s[i]; j < n; ++j )

2273

A[pk][j] = A[pk][j] ^ A[pi][j];

2274 b

[pk] =

[pk] ^

[pi];

2279 if

( i % 100 == 99 )

2312

assert(

);

2315

assert(

);

2316

assert(

<= m &&

<= n);

2319 for

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

2323 for

( i =

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

2327

assert(i <= s[i] && s[i] <= n);

2331 for

( k = i+1; k <

; ++k )

2333

assert(i <= s[k] && s[k] <= n);

2334 if

( A[p[i]][s[k]] != 0 )

2335

val = val ^

[s[k]];

2378 int

nconssactive = 0;

2387

assert(conss !=

);

2388

assert(result !=

);

2393 SCIPdebugMsg

(

"Checking feasibility via the linear equation system over GF2 using Gauss.\n"

);

2405 for

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

2409

xoractive[i] =

;

2411

assert(conss[i] !=

);

2413

assert(consdata !=

);

2416 for

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

2420

var = consdata->vars[j];

2421

assert(var !=

);

2427

assert(var !=

);

2442

xorvars[nvarsmat++] = var;

2450

xoractive[i] =

;

2453#ifdef SCIP_DISABLED_CODE 2460 for

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

2468 if

( ( cnt - consdata->rhs ) % 2 != 0 )

2477

assert(nvarsmat <= nvars);

2478

assert(nconssactive <= nconss);

2482 SCIPdebugMsg

(

"Skip checking the xor system over GF2 (%d conss, %d vars).\n"

, nconssactive, nvarsmat);

2492 for

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

2505 for

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

2507

assert(0 <= xoridx[j] && xoridx[j] < nvarsmat);

2508

xorbackidx[xoridx[j]] = j;

2514 for

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

2516 if

( !xoractive[i] )

2519

assert(conss[i] !=

);

2521

assert(consdata !=

);

2522

assert(consdata->nvars > 0);

2528 b

[nconssmat] = (

Type

) consdata->rhs;

2529 for

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

2534

var = consdata->vars[j];

2535

assert(var !=

);

2541

assert(var !=

);

2542 b

[nconssmat] = !

[nconssmat];

2559 b

[nconssmat] = !

[nconssmat];

2568 b

[nconssmat] = !

[nconssmat];

2571

assert(var !=

);

2587 b

[nconssmat] = !

[nconssmat];

2599

assert(idx < nvarsmat);

2600

idx = xorbackidx[idx];

2602

assert(idx < nvarsmat);

2603

A[nconssmat][idx] = !A[nconssmat][idx];

2609 SCIPdebugMsg

(

"Found %d non-fixed variables in %d nonempty xor constraints.\n"

, nvarsmat, nconssmat);

2610

assert(nconssmat == nconssactive);

2618 for

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

2620 for

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

2631

assert(rank <= nconssmat && rank <= nvarsmat);

2639 for

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

2641 for

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

2649 for

( i = rank; i < nconssmat; ++i )

2651 if

(

[p[i]] != 0 )

2656 if

( i >= nconssmat )

2658 SCIPdebugMsg

(

"System feasible with rank %d (nconss=%d)\n"

, rank, nconssmat);

2661 if

( rank == nvarsmat && noaggr )

2675 for

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

2681 for

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

2690

assert(!infeasible);

2694

assert(

[j] == 1);

2697

assert(!infeasible);

2712 if

( heurtrysol !=

)

2725 for

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

2734 for

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

2748 for

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

2758 for

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

2761

assert(consdata !=

);

2769 for

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

2775

assert(!noaggr || nones % 2 == (

int

) consdata->rhs);

2776 if

( (

unsigned int

) nones != consdata->rhs )

2778

val = (

) (nones - (

int

) consdata->rhs)/2;

2817 for

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

2820

assert(consdata !=

);

2822 if

( consdata->nvars == 0 )

2825 if

( !xoractive[i] )

2857

assert(cons !=

);

2860

assert(consdata !=

);

2861

vars = consdata->vars;

2862

nvars = consdata->nvars;

2867

assert(infervar ==

|| infervar == consdata->intvar);

2870 for

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

2879 for

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

2896

assert(vars[i] == infervar);

2902

assert(consdata->intvar !=

);

2904 if

( infervar != consdata->intvar )

2910 for

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

2922

assert(consdata->intvar !=

);

2924 if

( infervar != consdata->intvar )

2929 for

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

3006

assert(cons !=

);

3007

assert(eventhdlr !=

);

3008

assert(cutoff !=

);

3009

assert(nfixedvars !=

);

3010

assert(nchgbds !=

);

3017

assert(consdata !=

);

3019

vars = consdata->vars;

3020

nvars = consdata->nvars;

3023 if

( consdata->propagated )

3036

watchedvar1 = consdata->watchedvar1;

3037

watchedvar2 = consdata->watchedvar2;

3040 if

( watchedvar1 != -1 )

3045 if

( watchedvar2 != -1 )

3052 if

( watchedvar1 == -1 )

3054

watchedvar1 = watchedvar2;

3057

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

3060

odd = consdata->rhs;

3064 if

( watchedvar2 == -1 )

3066 for

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

3080 if

( watchedvar1 == -1 )

3082

assert(watchedvar2 == -1);

3085 else if

( watchedvar2 == -1 && watchedvar1 != i )

3093

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

3096 if

( watchedvar1 == -1 )

3098

assert(watchedvar2 == -1);

3114 if

( consdata->intvar !=

)

3119

assert((nfixedones - (

int

) consdata->rhs) % 2 == 0);

3121

fixval = (nfixedones - (int) consdata->rhs)/2;

3129 SCIPdebugMsg

(

"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n"

3140 SCIPdebugMsg

(

"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n"

3154

assert(!infeasible);

3161

assert(!infeasible);

3178 if

( watchedvar2 == -1 )

3180

assert(watchedvar1 != -1);

3183 SCIPdebugMsg

(

"constraint <%s>: only one unfixed variable -> fix <%s> to %u\n"

3187

assert(!infeasible);

3201

assert((nfixedones - (

int

) consdata->rhs) % 2 == 0);

3203

fixval = (nfixedones - (int) consdata->rhs)/2;

3210 SCIPdebugMsg

(

"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n"

3221 SCIPdebugMsg

(

"node infeasible: activity is %d, bounds of integral variable are [%g,%g]\n"

3235

assert(!infeasible);

3242

assert(!infeasible);

3257 if

( consdata->intvar !=

&& !consdata->deleteintvar )

3266

assert(nfixedzeros == 0);

3267

assert(nfixedones == 0);

3269 for

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

3277

assert(nfixedones + nfixedzeros < nvars);

3282

nonesmin = 2 * (int)(

SCIPvarGetLbLocal

(consdata->intvar) + 0.5) + (

int

) consdata->rhs;

3283

nonesmax = 2 * (int)(

SCIPvarGetUbLocal

(consdata->intvar) + 0.5) + (

int

) consdata->rhs;

3286 if

( nvars - nfixedzeros < nonesmin )

3288 SCIPdebugMsg

(

"constraint <%s>: at most %d variables can take value 1, but there should be at least %d.\n"

(cons), nvars - nfixedones, nonesmin);

3299 if

( nfixedones > nonesmax )

3301 SCIPdebugMsg

(

"constraint <%s>: at least %d variables are fixed to 1, but there should be at most %d.\n"

(cons), nfixedones, nonesmax);

3314

newlb = (

)((nfixedones + 1 - (

int

) consdata->rhs) / 2);

3315

newub = (

)((nvars - nfixedzeros - (

int

) consdata->rhs) / 2);

3323

assert(!infeasible);

3327

nonesmin = 2 * (int)(

SCIPvarGetLbLocal

(consdata->intvar) + 0.5) + (

int

) consdata->rhs;

3336

assert(!infeasible);

3340

nonesmax = 2 * (int)(

SCIPvarGetUbLocal

(consdata->intvar) + 0.5) + (

int

) consdata->rhs;

3343

assert(nvars - nfixedzeros >= nonesmin);

3344

assert(nfixedones <= nonesmax);

3347 if

( nvars - nfixedzeros == nonesmin )

3349 SCIPdebugMsg

(

"constraint <%s>: fix %d free variables to 1 to reach lower bound of %d\n"

(cons), nvars - nfixedzeros - nfixedones, nonesmin);

3351 for

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

3356

assert(!infeasible);

3369 if

( nfixedones == nonesmax )

3371 SCIPdebugMsg

(

"constraint <%s>: fix %d free variables to 0 to guarantee upper bound of %d\n"

(cons), nvars - nfixedzeros - nfixedones, nonesmax);

3373 for

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

3378

assert(!infeasible);

3395

consdata->propagated =

;

3413

assert(result !=

);

3415 SCIPdebugMsg

(

"resolving fixations according to rule %d\n"

, (

int

) proprule);

3446

assert(cons !=

);

3447

assert(nfixedvars !=

);

3448

assert(nchgcoefs !=

);

3449

assert(ndelconss !=

);

3450

assert(naddconss !=

);

3451

assert(cutoff !=

);

3458

assert(consdata !=

);

3460

vars = consdata->vars;

3461

nvars = consdata->nvars;

3467 if

( !consdata->deleteintvar )

3470#ifdef SCIP_DISABLED_CODE 3472 if

( !consdata->changed )

3523 if

( posnotinclq1 == v )

3529 for

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

3531 if

( posnotinclq1 == v1 )

3546 if

( posnotinclq1 == -1 )

3554 if

( restart || (posnotinclq2 != v && posnotinclq2 != v1) )

3561

posnotinclq1 = posnotinclq2;

3569

assert(vars[v] != vars[v1]);

3582 if

( posnotinclq1 == -1 )

3586 if

( consdata->rhs )

3611 SCIPdebugMsg

(

"all variables of xor constraints <%s> are in one clique, so fixed all variables to 0\n"

3615 for

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

3620

assert(infeasible || fixed);

3624

*cutoff = infeasible;

3644 if

( !consdata->rhs )

3652 for

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

3654 if

( v == posnotinclq1 )

3659

assert(var !=

);

3688 if

( consdata->intvar !=

)

3700

*cutoff = infeasible;

3737

assert(conss !=

);

3738

assert(ndelconss !=

);

3741

hashtablesize = nconss;

3745

hashGetKeyXorcons, hashKeyEqXorcons, hashKeyValXorcons, (

void

) );

3748 for

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

3764

assert(conshdlrdata !=

);

3778

assert(consdata0 !=

);

3781 if

( consdata0->nvars <= 1 )

3783 if

( consdata0->nvars == 0 )

3786 if

( consdata0->rhs )

3800

assert(!infeasible);

3807 if

( consdata0->intvar !=

)

3813

assert(!infeasible);

3828

assert(consdata0->sorted);

3833 if

( cons1 !=

)

3842

assert(consdata1 !=

);

3843

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

3845

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

3846

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

3848 if

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

3855 if

( consdata0->intvar != consdata1->intvar && consdata0->intvar !=

)

3857 if

( consdata1->intvar !=

)

3893 if

( consdata0->changed &&

SCIPconsGetPos

(cons1) < *firstchange )

3936

assert(conss !=

);

3937

assert(firstchange <= chkind);

3938

assert(cutoff !=

);

3939

assert(nfixedvars !=

);

3940

assert(naggrvars !=

);

3941

assert(ndelconss !=

);

3942

assert(nchgcoefs !=

);

3945

cons0 = conss[chkind];

3950

assert(consdata0 !=

);

3951

assert(consdata0->nvars >= 1);

3956

assert(conshdlrdata !=

);

3970

assert(consdata0->sorted);

3973

cons0changed = consdata0->changed;

3974

consdata0->changed =

;

3999

assert(consdata1 !=

);

4001 if

( !consdata1->deleteintvar )

4015 SCIPdebugMsg

(

"preprocess xor constraint pair <%s>[chg:%u] and <%s>[chg:%u]\n"

4019 if

( !cons0changed && !consdata1->changed )

4023 if

( consdata1->nvars == 0 )

4025 if

( consdata1->rhs )

4033 if

( consdata1->intvar !=

)

4036

assert(!infeasible);

4048 else if

( consdata1->nvars == 1 )

4052

assert(!infeasible);

4058 if

( consdata1->intvar !=

)

4061

assert(!infeasible);

4075

assert(consdata0->sorted);

4079 else if

( consdata1->nvars == 2 )

4081 if

( !(consdata1->rhs) )

4085

&infeasible, &redundant, &aggregated) );

4091

&infeasible, &redundant, &aggregated) );

4093

assert(!infeasible);

4107

assert(consdata0->sorted);

4113 if

( consdata1->intvar !=

)

4117 if

( consdata1->rhs )

4120

assert(!infeasible);

4128

assert(!consdata1->rhs);

4132

&infeasible, &redundant, &aggregated) );

4133

assert(!infeasible);

4152

assert(consdata0->sorted);

4156

assert(consdata1->sorted);

4164

parity = (consdata0->rhs ^ consdata1->rhs);

4165

cons0hastwoothervars =

;

4166

cons1hastwoothervars =

;

4171 while

( (v0 < consdata0->nvars || v1 < consdata1->nvars) && !aborted )

4175

assert(v0 <= consdata0->nvars);

4176

assert(v1 <= consdata1->nvars);

4178 if

( v0 == consdata0->nvars )

4180 else if

( v1 == consdata1->nvars )

4189

assert(v0 < consdata0->nvars);

4190 if

( singlevar0 ==

)

4192

singlevar0 = consdata0->vars[v0];

4193 if

( cons1hastwoothervars )

4198

cons0hastwoothervars =

;

4199 if

( singlevar1 !=

)

4207

assert(v1 < consdata1->nvars);

4208 if

( singlevar1 ==

)

4210

singlevar1 = consdata1->vars[v1];

4211 if

( cons0hastwoothervars )

4216

cons1hastwoothervars =

;

4217 if

( singlevar0 !=

)

4225

assert(v0 < consdata0->nvars);

4226

assert(v1 < consdata1->nvars);

4228 if

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

4245 if

( (cons0hastwoothervars && singlevar1 !=

) || (cons1hastwoothervars && singlevar0 !=

) )

4249 if

( singlevar0 ==

&& singlevar1 ==

)

4255 SCIPdebugMsg

(

"xor constraints <%s> and <%s> are redundant: delete <%s>\n"

4265 if

( consdata1->intvar !=

)

4275 if

( consdata0->intvar ==

)

4283

&infeasible, &redundant, &aggregated) );

4285

*cutoff = *cutoff || infeasible;

4299

newvars[0] = consdata1->intvar;

4301

newvars[1] = consdata0->intvar;

4322 SCIPdebugMsg

(

"xor constraints <%s> and <%s> are contradicting\n"

4329 else if

( singlevar1 ==

)

4332 if

( !cons0hastwoothervars )

4335 SCIPdebugMsg

(

"xor constraints <%s> and <%s> yield sum %u == <%s>\n"

4340

*cutoff = *cutoff || infeasible;

4354 SCIPdebugMsg

(

"xor constraint <%s> is superset of <%s> with parity %u\n"

4358 for

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

4365

assert(consdata0->nvars >= 2);

4372

assert(consdata0->sorted);

4374 else if

( singlevar0 ==

)

4377 if

( !cons1hastwoothervars )

4380 SCIPdebugMsg

(

"xor constraints <%s> and <%s> yield sum %u == <%s>\n"

4385

assert(infeasible || fixed);

4386

*cutoff = *cutoff || infeasible;

4399 SCIPdebugMsg

(

"xor constraint <%s> is subset of <%s> with parity %u\n"

4403 for

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

4409

assert(consdata1->nvars >= 2);

4415

assert(consdata1->sorted);

4420

assert(!cons0hastwoothervars);

4421

assert(!cons1hastwoothervars);

4424 SCIPdebugMsg

(

"xor constraints <%s> and <%s> yield sum %u == xor(<%s>,<%s>)\n"

4431

&infeasible, &redundant, &aggregated) );

4437

&infeasible, &redundant, &aggregated) );

4441

*cutoff = *cutoff || infeasible;

4452 if

( consdata1->intvar !=

)

4454 if

( consdata0->intvar ==

)

4462

&infeasible, &redundant, &aggregated) );

4464

*cutoff = *cutoff || infeasible;

4471 if

( !consdata0->sorted )

4473

assert(consdata0->sorted);

4475#ifdef SCIP_DISABLED_CODE 4537 if

( conshdlr ==

)

4544 if

( intvar !=

)

4556

assert(vars !=

|| nvars == 0);

4557 for

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

4570 SCIP_CALL

(

SCIPcreateCons

(

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

4571

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

4619

assert(upgdcons !=

);

4628 if

( integral && nposcont + nnegcont == 0 && nposbin + nnegbin + nposimplbin + nnegimplbin >= nvars-1 && ncoeffspone + ncoeffsnone == nvars-1 && ncoeffspint + ncoeffsnint == 1 )

4630

assert(ncoeffspfrac + ncoeffsnfrac == 0);

4644 for

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

4648

parityvar = vars[j];

4658

postwo = (vals[j] > 0.0);

4672 if

( vals[j] < 0.0 )

4675

assert(xorvars[cnt] !=

);

4678

xorvars[cnt] = vars[j];

4683 if

( parityvar !=

)

4685

assert(cnt == nvars - 1);

4700

rhsparity = ((

SCIP_Bool

) (intrhs % 2));

4704 if

( (intrhs != 1 && intrhs != 0) || postwo )

4722

intrhshalfed = intrhs / 2;

4761

(

) (postwo ? intrhshalfed : -intrhshalfed), &infeasible, &redundant, &aggregated) );

4762

assert(!infeasible);

4792

assert(intvar !=

);

4805

assert(intvar != parityvar);

4838

assert(cons !=

);

4839

assert(graph !=

);

4840

assert(success !=

);

4843

assert(consdata !=

);

4846

nlocvars =

MAX

(consdata->nvars, 1);

4854 if

( consdata->intvar !=

)

4861

vars[0] = consdata->intvar;

4870

xorvars = consdata->vars;

4871 for

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

4873

assert(xorvars[i] !=

);

4874

vars[i] = xorvars[i];

4878

nlocvars = consdata->nvars;

4899

assert(conshdlr !=

);

4918

assert(conshdlrdata !=

);

4935 for

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

4952

assert(conshdlrdata !=

);

4958 for

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

4979

assert(sourcedata !=

);

4980

assert(sourcedata->nvars >= 1);

4981

assert(sourcedata->vars !=

);

5003

assert(infeasible !=

);

5005

*infeasible =

;

5007 for

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

5029

assert(conshdlrdata !=

);

5032 for

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

5037 else if

( separated )

5060

assert(conshdlrdata !=

);

5063 for

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

5068 else if

( separated )

5089

assert(conshdlrdata !=

);

5092 for

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

5126

assert(conshdlrdata !=

);

5129 for

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

5161 for

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

5184 for

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

SCIP_FEASIBLE

|| completely ); ++i )

5205

assert(conshdlrdata !=

);

5212 for

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

5220 else if

( nfixedvars > 0 || nchgbds > 0 )

5231

freq = conshdlrdata->gausspropfreq;

5232 if

( (depth == 0 && freq == 0) || (freq > 0 && depth % freq == 0) )

5252

assert(conshdlr !=

);

5254

assert(conshdlrdata !=

);

5257 for

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

5260

assert(consdata !=

);

5262 for

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

5281

assert(conshdlr !=

);

5283

assert(conshdlrdata !=

);

5286 for

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

5289

assert(consdata !=

);

5293 for

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

5322

assert(result !=

);

5324

oldnfixedvars = *nfixedvars;

5325

oldnchgbds = *nchgbds;

5326

oldnaggrvars = *naggrvars;

5327

oldndelconss = *ndelconss;

5328

oldnchgcoefs = *nchgcoefs;

5331

assert(conshdlrdata !=

);

5335

firstchange = INT_MAX;

5339

assert(cons !=

);

5341

assert(consdata !=

);

5345

consdata->propagated =

;

5348 if

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

5364

assert(consdata->nvars >= 2);

5367 if

( consdata->nvars == 2 )

5369 SCIPdebugMsg

(

"xor constraint <%s> has only two unfixed variables, rhs=%u\n"

5372

assert(consdata->vars !=

);

5378 if

( !consdata->rhs )

5384

&cutoff, &redundant, &aggregated) );

5392

&cutoff, &redundant, &aggregated) );

5444 if

( firstchange < nconss && conshdlrdata->presolusehashing )

5448

nfixedvars, naggrvars, ndelconss, naddconss, &cutoff) );

5450 if

( conshdlrdata->presolpairwise )

5454

npaircomparisons = 0;

5455

lastndelconss = *ndelconss;

5464

&cutoff, nfixedvars, naggrvars, ndelconss, naddconss, nchgcoefs) );

5470

lastndelconss = *ndelconss;

5471

npaircomparisons = 0;

5481 else if

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

5482

|| *ndelconss > oldndelconss || *nchgcoefs > oldnchgcoefs )

5492 int

naddedconss = 0;

5495

assert(cons !=

);

5497

assert(consdata !=

);

5499 if

( consdata->extvars !=

)

5502 if

( conshdlrdata->addflowextended )

5510

(*naddconss) += naddedconss;

5538

assert(consdata !=

);

5541 for

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

5547 if

( consdata->intvar !=

)

5561

assert(conshdlr !=

);

5562

assert(cons !=

);

5578 const char

* consname;

5583

assert(sourcescip !=

);

5584

assert(sourcecons !=

);

5589

assert(sourceconsdata !=

);

5592

sourcevars = sourceconsdata->vars;

5593

nvars = sourceconsdata->nvars;

5594

intvar = sourceconsdata->intvar;

5595

targetintvar =

;

5604 if

( intvar !=

)

5607

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

);

5609 if

( targetintvar !=

)

5620

targetintvar, initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable,

5631 for

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

5634

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

);

5638 if

( *valid && intvar !=

)

5641

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

);

5652

targetintvar, initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable,

5689 if

( varssize < requiredsize )

5692

varssize = requiredsize;

5700

assert(varssize >= requiredsize);

5705

endptr = strchr(endptr,

'='

);

5708 if

( endptr ==

)

5718

str += *(str+1) ==

'='

? 2 : 1;

5734

str = strchr(str+1,

'='

);

5748 if

( intvar ==

)

5756

endptr = strchr(endptr,

')'

);

5758 if

( endptr ==

)

5766 if

( intvar !=

)

5770

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

5776

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

5802

assert(consdata !=

);

5804 if

( consdata->intvar !=

)

5807 if

( varssize < consdata->nvars + nintvar + consdata->nextvars )

5808

(*success) =

;

5813 if

( consdata->intvar !=

)

5814

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

5816 if

( consdata->nextvars > 0 )

5818

assert(consdata->extvars !=

);

5819

cnt = consdata->nvars + nintvar;

5820 for

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

5822 if

( consdata->extvars[j] !=

)

5823

vars[cnt++] = consdata->extvars[j];

5825

assert(cnt == consdata->nvars + nintvar + consdata->nextvars);

5840

assert(cons !=

);

5843

assert(consdata !=

);

5845 if

( consdata->intvar ==

)

5846

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

5848

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

5882

assert(eventhdlr !=

);

5883

assert(eventdata !=

);

5884

assert(event !=

);

5887

assert(consdata !=

);

5895

consdata->sorted =

;

5898

consdata->propagated =

;

5919

eventExecXor,

) );

5927

consEnfolpXor, consEnfopsXor, consCheckXor, consLockXor,

5929

assert(conshdlr !=

);

5962 "constraints/xor/presolpairwise"

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

5967 "constraints/xor/presolusehashing"

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

5972 "constraints/xor/addextendedform"

5973 "should the extended formulation be added in presolving?"

5977 "constraints/xor/addflowextended"

5978 "should the extended flow formulation be added (nonsymmetric formulation otherwise)?"

5982 "constraints/xor/separateparity"

5983 "should parity inequalities be separated?"

5987 "constraints/xor/gausspropfreq"

5988 "frequency for applying the Gauss propagator"

6036 if

( conshdlr ==

)

6043

assert(vars !=

|| nvars == 0);

6044 for

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

6057 SCIP_CALL

(

SCIPcreateCons

(

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

6058

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

6101

assert(consdata !=

);

6103 return

consdata->nvars;

6124

assert(consdata !=

);

6126 return

consdata->vars;

6147

assert(consdata !=

);

6149 return

consdata->intvar;

6169

assert(consdata !=