Generated on Tue Feb 11 2025 17:33:26 for Gecode by doxygen 1.12.0
steel-mill.cpp
Go to the documentation of this file.
1/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2/*
3 * Main authors:
4 * Mikael Lagerkvist <lagerkvist@gecode.org>
5 *
6 * Copyright:
7 * Mikael Lagerkvist, 2008
8 *
9 * This file is part of Gecode, the generic constraint
10 * development environment:
11 * http://www.gecode.org
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining
14 * a copy of this software and associated documentation files (the
15 * "Software"), to deal in the Software without restriction, including
16 * without limitation the rights to use, copy, modify, merge, publish,
17 * distribute, sublicense, and/or sell copies of the Software, and to
18 * permit persons to whom the Software is furnished to do so, subject to
19 * the following conditions:
20 *
21 * The above copyright notice and this permission notice shall be
22 * included in all copies or substantial portions of the Software.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
28 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
29 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
30 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 *
32 */
33
34#include <gecode/driver.hh>
35#include <gecode/int.hh>
36#include <gecode/minimodel.hh>
37
38#include <fstream>
39
40using namespace Gecode;
41
48typedef int (*order_t)[2];
49extern const int order_weight;
50extern const int order_color;
52
58extern int csplib_capacities[];
59extern unsigned int csplib_ncapacities;
60extern unsigned int csplib_maxcapacity;
61extern int csplib_loss[];
62extern int csplib_orders[][2];
63extern unsigned int csplib_ncolors;
64extern unsigned int csplib_norders;
66
67
73class SteelMillOptions : public Options {
74private:
75 unsigned int _size;
76 int* _capacities;
77 int _ncapacities;
78 int _maxcapacity;
79 int* _loss;
80 order_t _orders;
81 int _ncolors;
82 unsigned int _norders;
83public:
85 SteelMillOptions(const char* n)
86 : Options(n), _size(csplib_norders),
87 _capacities(csplib_capacities), _ncapacities(csplib_ncapacities),
88 _maxcapacity(csplib_maxcapacity),
89 _loss(csplib_loss), _orders(&(csplib_orders[0])), _ncolors(csplib_ncolors),
90 _norders(csplib_norders) {}
92 virtual void help(void);
94 bool parse(int& argc, char* argv[]);
95
97 unsigned int size(void) const { return _size; }
99 int* capacities(void) const { return _capacities; }
101 int ncapacities(void) const { return _ncapacities; }
103 int maxcapacity(void) const { return _maxcapacity; }
105 int* loss(void) const { return _loss; }
107 order_t orders(void) const { return _orders; }
109 int ncolors(void) const { return _ncolors; }
111 int norders(void) const { return _norders; }
112};
113
116public:
120 SortByWeight(order_t _orders) : orders(_orders) {}
122 bool operator() (int i, int j) {
123 // Order i comes before order j if the weight of i is larger than
124 // the weight of j.
125 return (orders[i][order_weight] > orders[j][order_weight]) ||
126 (orders[i][order_weight] == orders[j][order_weight] && i<j);
127 }
128};
129
159protected:
166 int* loss;
169 unsigned int norders;
170 unsigned int nslabs;
172
181
182public:
184 enum {
188 };
189
192 : // Initialize instance data
195 maxcapacity(opt.maxcapacity()), loss(opt.loss()),
196 ncolors(opt.ncolors()), orders(opt.orders()),
197 norders(opt.size()), nslabs(opt.size()),
198 // Initialize problem variables
199 slab(*this, norders, 0,nslabs-1),
200 slabload(*this, nslabs, 0,45),
201 slabcost(*this, nslabs, 0, Int::Limits::max),
202 total_cost(*this, 0, Int::Limits::max)
203 {
204 // Boolean variables for slab[o]==s
205 BoolVarArgs boolslab(norders*nslabs);
206 for (unsigned int i = 0; i < norders; ++i) {
207 BoolVarArgs tmp(nslabs);
208 for (int j = nslabs; j--; ) {
209 boolslab[j + i*nslabs] = tmp[j] = BoolVar(*this, 0, 1);
210 }
211 channel(*this, tmp, slab[i]);
212 }
213
214 // Packing constraints
215 for (unsigned int s = 0; s < nslabs; ++s) {
216 IntArgs c(norders);
218 for (int i = norders; i--; ) {
219 c[i] = orders[i][order_weight];
220 x[i] = boolslab[s + i*nslabs];
221 }
222 linear(*this, c, x, IRT_EQ, slabload[s]);
223 }
224 // Redundant packing constraint
225 int totalweight = 0;
226 for (unsigned int i = norders; i-- ; )
227 totalweight += orders[i][order_weight] ;
228 linear(*this, slabload, IRT_EQ, totalweight);
229
230
231 // Color constraints
232 IntArgs nofcolor(ncolors);
233 for (int c = ncolors; c--; ) {
234 nofcolor[c] = 0;
235 for (int o = norders; o--; ) {
236 if (orders[o][order_color] == c) nofcolor[c] += 1;
237 }
238 }
239 BoolVar f(*this, 0, 0);
240 for (unsigned int s = 0; s < nslabs; ++s) {
241 BoolVarArgs hascolor(ncolors);
242 for (int c = ncolors; c--; ) {
243 if (nofcolor[c]) {
244 BoolVarArgs hasc(nofcolor[c]);
245 int pos = 0;
246 for (int o = norders; o--; ) {
247 if (orders[o][order_color] == c)
248 hasc[pos++] = boolslab[s + o*nslabs];
249 }
250 assert(pos == nofcolor[c]);
251 hascolor[c] = BoolVar(*this, 0, 1);
252 rel(*this, BOT_OR, hasc, hascolor[c]);
253 } else {
254 hascolor[c] = f;
255 }
256 }
257 linear(*this, hascolor, IRT_LQ, 2);
258 }
259
260 // Compute slabcost
262 for (int s = nslabs; s--; ) {
263 element(*this, l, slabload[s], slabcost[s]);
264 }
266
267 // Add branching
268 if (opt.symmetry() == SYMMETRY_BRANCHING) {
269 // Symmetry breaking branching
271 } else if (opt.symmetry() == SYMMETRY_NONE) {
273 } else { // opt.symmetry() == SYMMETRY_LDSB
274 // There is one symmetry: the values (slabs) are interchangeable.
275 Symmetries syms;
277
278 // For variable order we mimic the custom brancher. We use
279 // min-size domain, breaking ties by maximum weight (preferring
280 // to label larger weights earlier). To do this, we first sort
281 // (stably) by maximum weight, then use min-size domain.
282 SortByWeight sbw(orders);
283 IntArgs indices(norders);
284 for (unsigned int i = 0 ; i < norders ; i++)
285 indices[i] = i;
286 Support::quicksort(&indices[0],norders,sbw);
287 IntVarArgs sorted_orders(norders);
288 for (unsigned int i = 0 ; i < norders ; i++) {
289 sorted_orders[i] = slab[indices[i]];
290 }
291 branch(*this, sorted_orders, INT_VAR_SIZE_MIN(), INT_VAL_MIN(), syms);
292 }
293 }
294
296 virtual void
297 print(std::ostream& os) const {
298 os << "What slab=" << slab << std::endl;
299 os << "Slab load=" << slabload << std::endl;
300 os << "Slab cost=" << slabcost << std::endl;
301 os << "Total cost=" << total_cost << std::endl;
302 int nslabsused = 0;
303 int nslabscost = 0;
304 bool unassigned = false;
305 for (int i = nslabs; i--; ) {
306 if (!slabload[i].assigned() || !slabcost[i].assigned()) {
307 unassigned = true;
308 break;
309 }
310 if (slabload[i].min()>0) ++nslabsused;
311 if (slabcost[i].min()>0) ++nslabscost;
312 }
313 if (!unassigned)
314 os << "Number of slabs used=" << nslabsused
315 << ", slabs with cost=" << nslabscost
316 << std::endl;
317 os << std::endl;
318 }
319
333 virtual Space*
334 copy(void) {
335 return new SteelMill(*this);
336 }
338 virtual IntVar cost(void) const {
339 return total_cost;
340 }
341
342
352 protected:
354 mutable int start;
356 class Choice : public Gecode::Choice {
357 public:
359 int pos;
361 int val;
365 Choice(const Brancher& b, unsigned int a, int pos0, int val0)
366 : Gecode::Choice(b,a), pos(pos0), val(val0) {}
368 virtual void archive(Archive& e) const {
370 e << alternatives() << pos << val;
371 }
372 };
373
376 : Brancher(home), start(0) {}
379 : Brancher(home, b), start(b.start) {
380 }
381
382 public:
384 virtual bool status(const Space& home) const {
385 const SteelMill& sm = static_cast<const SteelMill&>(home);
386 for (unsigned int i = start; i < sm.norders; ++i)
387 if (!sm.slab[i].assigned()) {
388 start = i;
389 return true;
390 }
391 // No non-assigned orders left
392 return false;
393 }
395 virtual Gecode::Choice* choice(Space& home) {
396 SteelMill& sm = static_cast<SteelMill&>(home);
397 assert(!sm.slab[start].assigned());
398 // Find order with a) minimum size, b) largest weight
399 unsigned int size = sm.norders;
400 int weight = 0;
401 unsigned int pos = start;
402 for (unsigned int i = start; i<sm.norders; ++i) {
403 if (!sm.slab[i].assigned()) {
404 if (sm.slab[i].size() == size &&
405 sm.orders[i][order_weight] > weight) {
406 weight = sm.orders[i][order_weight];
407 pos = i;
408 } else if (sm.slab[i].size() < size) {
409 size = sm.slab[i].size();
410 weight = sm.orders[i][order_weight];
411 pos = i;
412 }
413 }
414 }
415 unsigned int val = sm.slab[pos].min();
416 // Find first still empty slab (all such slabs are symmetric)
417 unsigned int firstzero = 0;
418 while (firstzero < sm.nslabs && sm.slabload[firstzero].min() > 0)
419 ++firstzero;
420 assert(pos < sm.nslabs &&
421 val < sm.norders);
422 return new Choice(*this, (val<firstzero) ? 2 : 1, pos, val);
423 }
424 virtual Choice* choice(const Space&, Archive& e) {
425 unsigned int alt; int pos, val;
426 e >> alt >> pos >> val;
427 return new Choice(*this, alt, pos, val);
428 }
430 virtual ExecStatus commit(Space& home, const Gecode::Choice& _c,
431 unsigned int a) {
432 SteelMill& sm = static_cast<SteelMill&>(home);
433 const Choice& c = static_cast<const Choice&>(_c);
434 if (a)
435 return me_failed(Int::IntView(sm.slab[c.pos]).nq(home, c.val))
436 ? ES_FAILED : ES_OK;
437 else
438 return me_failed(Int::IntView(sm.slab[c.pos]).eq(home, c.val))
439 ? ES_FAILED : ES_OK;
440 }
442 virtual void print(const Space&, const Gecode::Choice& _c,
443 unsigned int a,
444 std::ostream& o) const {
445 const Choice& c = static_cast<const Choice&>(_c);
446 o << "slab[" << c.pos << "] "
447 << ((a == 0) ? "=" : "!=")
448 << " " << c.val;
449 }
451 virtual Actor* copy(Space& home) {
452 return new (home) SteelMillBranch(home, *this);
453 }
455 static void post(Home home) {
456 (void) new (home) SteelMillBranch(home);
457 }
459 virtual size_t dispose(Space&) {
460 return sizeof(*this);
461 }
462 };
463};
464
468int
469main(int argc, char* argv[]) {
470 SteelMillOptions opt("Steel Mill Slab design");
471 opt.symmetry(SteelMill::SYMMETRY_BRANCHING);
472 opt.symmetry(SteelMill::SYMMETRY_NONE,"none");
473 opt.symmetry(SteelMill::SYMMETRY_BRANCHING,"branching");
474 opt.symmetry(SteelMill::SYMMETRY_LDSB,"ldsb");
475 opt.solutions(0);
476 if (!opt.parse(argc,argv))
477 return 1;
479 return 0;
480}
481
482
483void
485 Options::help();
486 std::cerr << "\t(string), optional" << std::endl
487 << "\t\tBenchmark to load." << std::endl
488 << "\t\tIf none is given, the standard CSPLib instance is used."
489 << std::endl;
490 std::cerr << "\t(unsigned int), optional" << std::endl
491 << "\t\tNumber of orders to use, in the interval [0..norders]."
492 << std::endl
493 << "\t\tIf none is given, all orders are used." << std::endl;
494}
495
496bool
497SteelMillOptions::parse(int& argc, char* argv[]) {
498 Options::parse(argc,argv);
499 // Check number of arguments
500 if (argc >= 4) {
501 std::cerr << "Too many arguments given, max two allowed (given={";
502 for (int i = 1; i < argc; ++i) {
503 std::cerr << "\"" << argv[i] << "\"";
504 if (i < argc-1) std::cerr << ",";
505 }
506 std::cerr << "})." << std::endl;
507 return false;
508 }
509 // Parse options
510 while (argc >= 2) {
511 bool issize = true;
512 for (int i = strlen(argv[argc-1]); i-- && issize; )
513 issize &= (isdigit(argv[argc-1][i]) != 0);
514 if (issize) {
515 _size = atoi(argv[argc-1]);
516 } else {
517 std::ifstream instance(argv[argc-1]);
518 if (instance.fail()) {
519 std::cerr << "Argument \"" << argv[argc-1]
520 << "\" is neither an integer nor a readable file"
521 << std::endl;
522 return false;
523 }
524 // Read file instance
525 instance >> _ncapacities;
526 _capacities = new int[_ncapacities];
527 _maxcapacity = -1;
528 for (int i = 0; i < _ncapacities; ++i) {
529 instance >> _capacities[i];
530 _maxcapacity = std::max(_maxcapacity, _capacities[i]);
531 }
532 instance >> _ncolors >> _norders;
533 _orders = new int[_norders][2];
534 for (unsigned int i = 0; i < _norders; ++i) {
535 instance >> _orders[i][order_weight] >> _orders[i][order_color];
536 }
537 }
538
539 --argc;
540 }
541 // Compute loss
542 {
543 _loss = new int[_maxcapacity+1];
544 _loss[0] = 0;
545 int currcap = 0;
546 for (int c = 1; c < _maxcapacity; ++c) {
547 if (c > _capacities[currcap]) ++currcap;
548 _loss[c] = _capacities[currcap] - c;
549 }
550 }
551 // Set size, if none given
552 if (_size == 0) {
553 _size = _norders;
554 }
555 // Check size reasonability
556 if (_size == 0 || _size > _norders) {
557 std::cerr << "Size must be between 1 and " << _norders << std::endl;
558 return false;
559 }
560 return true;
561}
562
563// Positions in order array
564const int order_weight = 0;
565const int order_color = 1;
566
567// CSPLib instance
569 {12, 14, 17, 18, 19,
570 20, 23, 24, 25, 26,
571 27, 28, 29, 30, 32,
572 35, 39, 42, 43, 44};
573unsigned int csplib_ncapacities = 20;
574unsigned int csplib_maxcapacity = 44;
576unsigned int csplib_ncolors = 89;
577unsigned int csplib_norders = 111;
578int csplib_orders[][2] = {
579 {4, 1},
580 {22, 2},
581 {9, 3},
582 {5, 4},
583 {8, 5},
584 {3, 6},
585 {3, 4},
586 {4, 7},
587 {7, 4},
588 {7, 8},
589 {3, 6},
590 {2, 6},
591 {2, 4},
592 {8, 9},
593 {5, 10},
594 {7, 11},
595 {4, 7},
596 {7, 11},
597 {5, 10},
598 {7, 11},
599 {8, 9},
600 {3, 1},
601 {25, 12},
602 {14, 13},
603 {3, 6},
604 {22, 14},
605 {19, 15},
606 {19, 15},
607 {22, 16},
608 {22, 17},
609 {22, 18},
610 {20, 19},
611 {22, 20},
612 {5, 21},
613 {4, 22},
614 {10, 23},
615 {26, 24},
616 {17, 25},
617 {20, 26},
618 {16, 27},
619 {10, 28},
620 {19, 29},
621 {10, 30},
622 {10, 31},
623 {23, 32},
624 {22, 33},
625 {26, 34},
626 {27, 35},
627 {22, 36},
628 {27, 37},
629 {22, 38},
630 {22, 39},
631 {13, 40},
632 {14, 41},
633 {16, 27},
634 {26, 34},
635 {26, 42},
636 {27, 35},
637 {22, 36},
638 {20, 43},
639 {26, 24},
640 {22, 44},
641 {13, 45},
642 {19, 46},
643 {20, 47},
644 {16, 48},
645 {15, 49},
646 {17, 50},
647 {10, 28},
648 {20, 51},
649 {5, 52},
650 {26, 24},
651 {19, 53},
652 {15, 54},
653 {10, 55},
654 {10, 56},
655 {13, 57},
656 {13, 58},
657 {13, 59},
658 {12, 60},
659 {12, 61},
660 {18, 62},
661 {10, 63},
662 {18, 64},
663 {16, 65},
664 {20, 66},
665 {12, 67},
666 {6, 68},
667 {6, 68},
668 {15, 69},
669 {15, 70},
670 {15, 70},
671 {21, 71},
672 {30, 72},
673 {30, 73},
674 {30, 74},
675 {30, 75},
676 {23, 76},
677 {15, 77},
678 {15, 78},
679 {27, 79},
680 {27, 80},
681 {27, 81},
682 {27, 82},
683 {27, 83},
684 {27, 84},
685 {27, 79},
686 {27, 85},
687 {27, 86},
688 {10, 87},
689 {3, 88}
690};
691
692// STATISTICS: example-any
NNF * l
Left subtree.
struct Gecode::@603::NNF::@65::@66 b
For binary nodes (and, or, eqv)
int n
Number of negative literals for node type.
struct Gecode::@603::NNF::@65::@67 a
For atomic nodes.
Base-class for both propagators and branchers.
Definition core.hpp:628
Archive representation
Definition archive.hpp:42
Passing Boolean variables.
Definition int.hh:712
Boolean integer variables.
Definition int.hh:512
Base-class for branchers.
Definition core.hpp:1442
friend class Choice
Definition core.hpp:1445
Choice for performing commit
Definition core.hpp:1412
virtual void archive(Archive &e) const
Archive into e.
Definition core.cpp:891
unsigned int alternatives(void) const
Return number of alternatives.
Definition core.hpp:3770
Parametric base-class for scripts.
Definition driver.hh:729
static void run(const Options &opt, Script *s=NULL)
Definition script.hpp:290
Home class for posting propagators
Definition core.hpp:856
Passing integer arguments.
Definition int.hh:628
static IntArgs create(int n, int start, int inc=1)
Allocate array with n elements such that for all .
Definition array.hpp:76
Passing integer variables.
Definition int.hh:656
Integer variable array.
Definition int.hh:763
Integer variables.
Definition int.hh:371
Integer view for integer variables.
Definition view.hpp:129
ModEvent nq(Space &home, int n)
Restrict domain values to be different from n.
Definition int.hpp:157
ModEvent eq(Space &home, int n)
Restrict domain values to be equal to n.
Definition int.hpp:166
Options for scripts
Definition driver.hh:366
Computation spaces.
Definition core.hpp:1742
Collection of symmetries.
Definition int.hh:5292
bool assigned(void) const
Test if all variables are assigned.
Definition array.hpp:1026
int size(void) const
Return size of array (number of elements)
Definition array.hpp:926
void update(Space &home, VarArray< Var > &a)
Update array to be a clone of array a.
Definition array.hpp:1013
void update(Space &home, VarImpVar< VarImp > &y)
Update this variable to be a clone of variable y.
Definition var.hpp:116
Sort orders by weight.
SortByWeight(order_t _orders)
Initialize orders.
bool operator()(int i, int j)
Sort order.
order_t orders
The orders.
SteelMillOptions for examples with size option and an additional optional file name parameter.
unsigned int size(void) const
Return size.
int ncapacities(void) const
Return number of capacities.
int maxcapacity(void) const
Return maximum of capacities.
int ncolors(void) const
Return number of colors.
int * capacities(void) const
Return capacities.
order_t orders(void) const
Return orders.
int norders(void) const
Return number of orders.
int * loss(void) const
Return loss values.
virtual void help(void)
Print help text.
SteelMillOptions(const char *n)
Initialize options for example with name n.
bool parse(int &argc, char *argv[])
Parse options from arguments argv (number is argc)
virtual void archive(Archive &e) const
Archive into e.
Choice(const Brancher &b, unsigned int a, int pos0, int val0)
int pos
Position of variable.
Custom brancher for steel mill slab design.
int start
Cache of first unassigned value.
virtual size_t dispose(Space &)
Delete brancher and return its size.
virtual void print(const Space &, const Gecode::Choice &_c, unsigned int a, std::ostream &o) const
Print explanation.
virtual Actor * copy(Space &home)
Copy brancher.
virtual ExecStatus commit(Space &home, const Gecode::Choice &_c, unsigned int a)
Perform commit for choice _c and alternative a.
SteelMillBranch(Space &home, SteelMillBranch &b)
Copy constructor.
virtual Gecode::Choice * choice(Space &home)
Return choice.
SteelMillBranch(Home home)
Construct brancher.
static void post(Home home)
Post brancher.
virtual bool status(const Space &home) const
Check status of brancher, return true if alternatives left.
virtual Choice * choice(const Space &, Archive &e)
Return choice from e.
Example: Steel-mill slab design problem
int ncapacities
Number of capacities.
SteelMill(const SteelMillOptions &opt)
Actual model.
unsigned int norders
Number of orders.
virtual void print(std::ostream &os) const
Print solution.
virtual IntVar cost(void) const
Return solution cost.
int main(int argc, char *argv[])
Main-function.
IntVarArray slab
Slab assigned to order i.
virtual Space * copy(void)
Copy during cloning.
int maxcapacity
Maximum capacity.
unsigned int nslabs
Number of slabs.
IntVarArray slabcost
Cost of slab j.
IntVar total_cost
Total cost.
@ SYMMETRY_BRANCHING
Breaking symmetries with symmetry.
@ SYMMETRY_LDSB
Use LDSB for symmetry breaking.
@ SYMMETRY_NONE
Simple symmetry.
int * loss
Loss for all sizes.
int ncolors
Number of colors.
IntVarArray slabload
Load of slab j.
int * capacities
Capacities.
order_t orders
Orders.
SteelMill(SteelMill &s)
Constructor for cloning s.
void parse(int argc, char *argv[])
Parse commandline arguments.
Definition test.cpp:120
bool me_failed(ModEvent me)
Check whether modification event me is failed.
Definition modevent.hpp:54
void branch(Home home, const FloatVarArgs &x, FloatVarBranch vars, FloatValBranch vals, FloatBranchFilter bf=nullptr, FloatVarValPrint vvp=nullptr)
Branch over x with variable selection vars and value selection vals.
Definition branch.cpp:39
void linear(Home home, const FloatVarArgs &x, FloatRelType frt, FloatVal c)
Post propagator for .
Definition linear.cpp:41
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1)
Post propagator for .
Definition rel.cpp:68
@ IRT_EQ
Equality ( )
Definition int.hh:926
@ IRT_LQ
Less or equal ( )
Definition int.hh:928
@ BOT_OR
Disjunction.
Definition int.hh:952
void quicksort(Type *l, Type *r, Less &less)
Standard quick sort.
Definition sort.hpp:130
Gecode toplevel namespace
SymmetryHandle ValueSymmetry(const IntArgs &v)
Values in v are interchangeable.
Definition ldsb.cpp:81
void channel(Home home, FloatVar x0, IntVar x1)
Post propagator for channeling a float and an integer variable .
Definition channel.cpp:41
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
void element(Home home, IntSharedArray n, IntVar x0, IntVar x1, IntPropLevel ipl=IPL_DEF)
Post domain consistent propagator for .
Definition element.cpp:39
IntVarBranch INT_VAR_MAX_MIN(BranchTbl tbl=nullptr)
Select variable with smallest max.
Definition var.hpp:196
IntValBranch INT_VAL_MIN(void)
Select smallest value.
Definition val.hpp:55
ExecStatus
Definition core.hpp:472
@ ES_OK
Execution is okay.
Definition core.hpp:476
@ ES_FAILED
Execution has resulted in failure.
Definition core.hpp:474
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
IntVarBranch INT_VAR_SIZE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest domain size.
Definition var.hpp:206
Post propagator for SetVar x
Definition set.hh:767
unsigned int csplib_maxcapacity
Maximum capacity.
const int order_weight
Weight-position in order-array elements.
int csplib_capacities[]
Constants for CSPLib instance of the Steel Mill Slab Design Problem.
unsigned int csplib_ncolors
Number of colors.
const int order_color
Color-position in order-array elements.
int csplib_orders[][2]
Orders.
unsigned int csplib_norders
Number of orders.
int csplib_loss[]
Loss for all sizes.
int(* order_t)[2]
Order-specifications.
unsigned int csplib_ncapacities
Number of capacities.