Generated on for Gecode by doxygen 1.15.0
minimodel.hh
Go to the documentation of this file.
1/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2/*
3 * Main authors:
4 * Christian Schulte <schulte@gecode.dev>
5 * Guido Tack <tack@gecode.dev>
6 * Matthias Balzer <matthias.balzer@itwm.fraunhofer.de>
7 * Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
8 * Vincent Barichard <Vincent.Barichard@univ-angers.fr>
9 *
10 * Contributing authors:
11 * Alexander Shepil <alexander.shepil@sap.com>
12 *
13 * Copyright:
14 * Christian Schulte, 2004
15 * Fraunhofer ITWM, 2017
16 * Guido Tack, 2004
17 * Mikael Zayenz Lagerkvist, 2005, 2026
18 * Alexander Shepil, 2024
19 * Vincent Barichard, 2012
20 *
21 * This file is part of Gecode, the generic constraint
22 * development environment:
23 * http://www.gecode.dev
24 *
25 * Permission is hereby granted, free of charge, to any person obtaining
26 * a copy of this software and associated documentation files (the
27 * "Software"), to deal in the Software without restriction, including
28 * without limitation the rights to use, copy, modify, merge, publish,
29 * distribute, sublicense, and/or sell copies of the Software, and to
30 * permit persons to whom the Software is furnished to do so, subject to
31 * the following conditions:
32 *
33 * The above copyright notice and this permission notice shall be
34 * included in all copies or substantial portions of the Software.
35 *
36 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
37 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
38 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
39 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
40 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
41 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
42 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
43 *
44 */
45
46#ifndef GECODE_MINIMODEL_HH
47#define GECODE_MINIMODEL_HH
48
49#include <gecode/kernel.hh>
50#include <gecode/int.hh>
51#ifdef GECODE_HAS_SET_VARS
52#include <gecode/set.hh>
53#endif
54#ifdef GECODE_HAS_FLOAT_VARS
55#include <gecode/float.hh>
56#endif
57
58#ifdef GECODE_HAS_FAULT_INJECTION
59#include <atomic>
60#endif
61
62#include <iostream>
63
64/*
65 * Support for DLLs under Windows
66 *
67 */
68
69#if !defined(GECODE_STATIC_LIBS) && \
70 (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
71
72#ifdef GECODE_BUILD_MINIMODEL
73#define GECODE_MINIMODEL_EXPORT __declspec( dllexport )
74#else
75#define GECODE_MINIMODEL_EXPORT __declspec( dllimport )
76#endif
77
78#else
79
80#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
81
82#define GECODE_MINIMODEL_EXPORT __attribute__ ((visibility("default")))
83
84#else
85
86#define GECODE_MINIMODEL_EXPORT
87
88#endif
89#endif
90
91// Configure auto-linking
92#ifndef GECODE_BUILD_MINIMODEL
93#define GECODE_LIBRARY_NAME "MiniModel"
94#include <gecode/support/auto-link.hpp>
95#endif
96
97namespace Gecode {
98
100 namespace MiniModel {}
101
102}
103
104#include <gecode/minimodel/exception.hpp>
105
106namespace Gecode {
107
109 class IntPropLevels {
110 protected:
111 IntPropLevel _linear2 : IPL_BITS_;
112 IntPropLevel _linear : IPL_BITS_;
113 IntPropLevel _abs : IPL_BITS_;
114 IntPropLevel _max2 : IPL_BITS_;
115 IntPropLevel _max : IPL_BITS_;
116 IntPropLevel _min2 : IPL_BITS_;
117 IntPropLevel _min : IPL_BITS_;
118 IntPropLevel _mult : IPL_BITS_;
119 IntPropLevel _div : IPL_BITS_;
120 IntPropLevel _mod : IPL_BITS_;
121 IntPropLevel _sqr : IPL_BITS_;
122 IntPropLevel _sqrt : IPL_BITS_;
123 IntPropLevel _pow : IPL_BITS_;
124 IntPropLevel _nroot : IPL_BITS_;
125 IntPropLevel _element : IPL_BITS_;
126 IntPropLevel _ite : IPL_BITS_;
127 public:
129 IntPropLevels(IntPropLevel ipl=IPL_DEF);
130
132 IntPropLevel linear2(void) const;
134 IntPropLevels& linear2(IntPropLevel ipl);
136 IntPropLevel linear(void) const;
138 IntPropLevels& linear(IntPropLevel ipl);
139
141 IntPropLevel abs(void) const;
143 IntPropLevels& abs(IntPropLevel ipl);
144
146 IntPropLevel max2(void) const;
148 IntPropLevels& max2(IntPropLevel ipl);
150 IntPropLevel max(void) const;
152 IntPropLevels& max(IntPropLevel ipl);
154 IntPropLevel min2(void) const;
156 IntPropLevels& min2(IntPropLevel ipl);
158 IntPropLevel min(void) const;
160 IntPropLevels& min(IntPropLevel ipl);
161
163 IntPropLevel mult(void) const;
165 IntPropLevels& mult(IntPropLevel ipl);
167 IntPropLevel div(void) const;
169 IntPropLevels& div(IntPropLevel ipl);
171 IntPropLevel mod(void) const;
173 IntPropLevels& mod(IntPropLevel ipl);
174
176 IntPropLevel sqr(void) const;
178 IntPropLevels& sqr(IntPropLevel ipl);
180 IntPropLevel sqrt(void) const;
182 IntPropLevels& sqrt(IntPropLevel ipl);
183
185 IntPropLevel pow(void) const;
187 IntPropLevels& pow(IntPropLevel ipl);
189 IntPropLevel nroot(void) const;
191 IntPropLevels& nroot(IntPropLevel ipl);
192
194 IntPropLevel element(void) const;
196 IntPropLevels& element(IntPropLevel ipl);
197
199 IntPropLevel ite(void) const;
201 IntPropLevels& ite(IntPropLevel ipl);
202
204 GECODE_MINIMODEL_EXPORT
205 static const IntPropLevels def;
206 };
207
208}
209
210#include <gecode/minimodel/ipl.hpp>
211
212namespace Gecode {
213
214 class LinIntRel;
215#ifdef GECODE_HAS_SET_VARS
216 class SetExpr;
217#endif
218#ifdef GECODE_HAS_FLOAT_VARS
219 class LinFloatExpr;
220#endif
221
223 class NonLinIntExpr {
224 public:
226 virtual IntVar post(Home home, IntVar* ret,
227 const IntPropLevels& ipls) const = 0;
229 virtual void post(Home home, IntRelType irt, int c,
230 const IntPropLevels& ipls) const = 0;
232 virtual void post(Home home, IntRelType irt, int c,
233 BoolVar b, const IntPropLevels& ipls) const = 0;
235 virtual ~NonLinIntExpr(void);
237 static IntVar result(Home home, IntVar* x);
239 static IntVar result(Home home, IntVar* x, IntVar y);
241 void* operator new(size_t s);
243 void operator delete(void* p, size_t s);
244 };
245
246}
247
248#include <gecode/minimodel/int-expr.hpp>
249
250namespace Gecode {
251
252 namespace MiniModel {
253 class ArithNonLinIntExpr;
254 }
255
257 class LinIntExpr {
258 friend class LinIntRel;
259 friend class MiniModel::ArithNonLinIntExpr;
260#ifdef GECODE_HAS_SET_VARS
261 friend class SetExpr;
262#endif
263#ifdef GECODE_HAS_FLOAT_VARS
264 friend class LinFloatExpr;
265#endif
266 public:
279 private:
281 struct NoNode {};
283 class Node;
285 Node* n;
287 LinIntExpr(NoNode);
288 public:
290 GECODE_MINIMODEL_EXPORT
291 LinIntExpr(void);
292#ifdef GECODE_HAS_FAULT_INJECTION
294 GECODE_MINIMODEL_EXPORT static void fault_reset_allocations(void);
296 GECODE_MINIMODEL_EXPORT static int fault_live_allocations(void);
297#endif
299 GECODE_MINIMODEL_EXPORT
300 LinIntExpr(int c);
302 GECODE_MINIMODEL_EXPORT
303 LinIntExpr(const IntVar& x, int a=1);
305 GECODE_MINIMODEL_EXPORT
306 LinIntExpr(const BoolVar& x, int a=1);
308 GECODE_MINIMODEL_EXPORT
309 explicit LinIntExpr(const IntVarArgs& x);
311 GECODE_MINIMODEL_EXPORT
312 LinIntExpr(const IntArgs& a, const IntVarArgs& x);
314 GECODE_MINIMODEL_EXPORT
315 explicit LinIntExpr(const BoolVarArgs& x);
317 GECODE_MINIMODEL_EXPORT
318 LinIntExpr(const IntArgs& a, const BoolVarArgs& x);
320 GECODE_MINIMODEL_EXPORT
321 LinIntExpr(const LinIntExpr& e);
323 GECODE_MINIMODEL_EXPORT
324 LinIntExpr(const LinIntExpr& e0, NodeType t, const LinIntExpr& e1);
326 GECODE_MINIMODEL_EXPORT
327 LinIntExpr(const LinIntExpr& e0, NodeType t, int c);
329 GECODE_MINIMODEL_EXPORT
330 LinIntExpr(int a, const LinIntExpr& e);
332 GECODE_MINIMODEL_EXPORT
333 explicit LinIntExpr(NonLinIntExpr* e);
335 GECODE_MINIMODEL_EXPORT
336 const LinIntExpr& operator =(const LinIntExpr& e);
338 GECODE_MINIMODEL_EXPORT
339 void post(Home home, IntRelType irt, const IntPropLevels& ipls) const;
341 GECODE_MINIMODEL_EXPORT
342 void post(Home home, IntRelType irt, const BoolVar& b,
343 const IntPropLevels& ipls) const;
345 GECODE_MINIMODEL_EXPORT
346 IntVar post(Home home, const IntPropLevels& ipls) const;
348 GECODE_MINIMODEL_EXPORT
349 NonLinIntExpr* nle(void) const;
351 GECODE_MINIMODEL_EXPORT
352 ~LinIntExpr(void);
353 };
354
355 class BoolExpr;
356
358 class LinIntRel {
359 friend class BoolExpr;
360 private:
362 LinIntExpr e;
364 IntRelType irt;
366 static IntRelType neg(IntRelType irt);
368 LinIntRel(void);
369 public:
371 LinIntRel(const LinIntExpr& l, IntRelType irt, const LinIntExpr& r);
373 LinIntRel(const LinIntExpr& l, IntRelType irt, int r);
375 LinIntRel(int l, IntRelType irt, const LinIntExpr& r);
377 void post(Home home, bool t, const IntPropLevels& ipls) const;
379 void post(Home home, const BoolVar& b, bool t, const IntPropLevels& ipls) const;
380 };
381
398
400
401 GECODE_MINIMODEL_EXPORT LinIntExpr
402 operator +(int, const IntVar&);
404 GECODE_MINIMODEL_EXPORT LinIntExpr
405 operator +(int, const BoolVar&);
407 GECODE_MINIMODEL_EXPORT LinIntExpr
408 operator +(int, const LinIntExpr&);
410 GECODE_MINIMODEL_EXPORT LinIntExpr
411 operator +(const IntVar&, int);
413 GECODE_MINIMODEL_EXPORT LinIntExpr
414 operator +(const BoolVar&, int);
416 GECODE_MINIMODEL_EXPORT LinIntExpr
417 operator +(const LinIntExpr&, int);
419 GECODE_MINIMODEL_EXPORT LinIntExpr
420 operator +(const IntVar&, const IntVar&);
422 GECODE_MINIMODEL_EXPORT LinIntExpr
423 operator +(const IntVar&, const BoolVar&);
425 GECODE_MINIMODEL_EXPORT LinIntExpr
426 operator +(const BoolVar&, const IntVar&);
428 GECODE_MINIMODEL_EXPORT LinIntExpr
429 operator +(const BoolVar&, const BoolVar&);
431 GECODE_MINIMODEL_EXPORT LinIntExpr
432 operator +(const IntVar&, const LinIntExpr&);
434 GECODE_MINIMODEL_EXPORT LinIntExpr
435 operator +(const BoolVar&, const LinIntExpr&);
437 GECODE_MINIMODEL_EXPORT LinIntExpr
438 operator +(const LinIntExpr&, const IntVar&);
440 GECODE_MINIMODEL_EXPORT LinIntExpr
441 operator +(const LinIntExpr&, const BoolVar&);
443 GECODE_MINIMODEL_EXPORT LinIntExpr
444 operator +(const LinIntExpr&, const LinIntExpr&);
445
447 GECODE_MINIMODEL_EXPORT LinIntExpr
448 operator -(int, const IntVar&);
450 GECODE_MINIMODEL_EXPORT LinIntExpr
451 operator -(int, const BoolVar&);
453 GECODE_MINIMODEL_EXPORT LinIntExpr
454 operator -(int, const LinIntExpr&);
456 GECODE_MINIMODEL_EXPORT LinIntExpr
457 operator -(const IntVar&, int);
459 GECODE_MINIMODEL_EXPORT LinIntExpr
460 operator -(const BoolVar&, int);
462 GECODE_MINIMODEL_EXPORT LinIntExpr
463 operator -(const LinIntExpr&, int);
465 GECODE_MINIMODEL_EXPORT LinIntExpr
466 operator -(const IntVar&, const IntVar&);
468 GECODE_MINIMODEL_EXPORT LinIntExpr
469 operator -(const IntVar&, const BoolVar&);
471 GECODE_MINIMODEL_EXPORT LinIntExpr
472 operator -(const BoolVar&, const IntVar&);
474 GECODE_MINIMODEL_EXPORT LinIntExpr
475 operator -(const BoolVar&, const BoolVar&);
477 GECODE_MINIMODEL_EXPORT LinIntExpr
478 operator -(const IntVar&, const LinIntExpr&);
480 GECODE_MINIMODEL_EXPORT LinIntExpr
481 operator -(const BoolVar&, const LinIntExpr&);
483 GECODE_MINIMODEL_EXPORT LinIntExpr
484 operator -(const LinIntExpr&, const IntVar&);
486 GECODE_MINIMODEL_EXPORT LinIntExpr
487 operator -(const LinIntExpr&, const BoolVar&);
489 GECODE_MINIMODEL_EXPORT LinIntExpr
490 operator -(const LinIntExpr&, const LinIntExpr&);
491
493 GECODE_MINIMODEL_EXPORT LinIntExpr
494 operator -(const IntVar&);
496 GECODE_MINIMODEL_EXPORT LinIntExpr
497 operator -(const BoolVar&);
499 GECODE_MINIMODEL_EXPORT LinIntExpr
500 operator -(const LinIntExpr&);
501
503 GECODE_MINIMODEL_EXPORT LinIntExpr
504 operator *(int, const IntVar&);
506 GECODE_MINIMODEL_EXPORT LinIntExpr
507 operator *(int, const BoolVar&);
509 GECODE_MINIMODEL_EXPORT LinIntExpr
510 operator *(const IntVar&, int);
512 GECODE_MINIMODEL_EXPORT LinIntExpr
513 operator *(const BoolVar&, int);
515 GECODE_MINIMODEL_EXPORT LinIntExpr
516 operator *(const LinIntExpr&, int);
518 GECODE_MINIMODEL_EXPORT LinIntExpr
519 operator *(int, const LinIntExpr&);
520
522 GECODE_MINIMODEL_EXPORT LinIntExpr
523 sum(const IntVarArgs& x);
525 GECODE_MINIMODEL_EXPORT LinIntExpr
526 sum(const IntArgs& a, const IntVarArgs& x);
528 GECODE_MINIMODEL_EXPORT LinIntExpr
529 sum(const BoolVarArgs& x);
531 GECODE_MINIMODEL_EXPORT LinIntExpr
532 sum(const IntArgs& a, const BoolVarArgs& x);
534 GECODE_MINIMODEL_EXPORT LinIntExpr
535 sum(const IntArgs& args);
536
538 GECODE_MINIMODEL_EXPORT LinIntRel
539 operator ==(int l, const IntVar& r);
541 GECODE_MINIMODEL_EXPORT LinIntRel
542 operator ==(int l, const BoolVar& r);
544 GECODE_MINIMODEL_EXPORT LinIntRel
545 operator ==(int l, const LinIntExpr& r);
547 GECODE_MINIMODEL_EXPORT LinIntRel
548 operator ==(const IntVar& l, int r);
550 GECODE_MINIMODEL_EXPORT LinIntRel
551 operator ==(const BoolVar& l, int r);
553 GECODE_MINIMODEL_EXPORT LinIntRel
554 operator ==(const LinIntExpr& l, int r);
556 GECODE_MINIMODEL_EXPORT LinIntRel
557 operator ==(const IntVar& l, const IntVar& r);
559 GECODE_MINIMODEL_EXPORT LinIntRel
560 operator ==(const IntVar& l, const BoolVar& r);
562 GECODE_MINIMODEL_EXPORT LinIntRel
563 operator ==(const BoolVar& l, const IntVar& r);
565 GECODE_MINIMODEL_EXPORT LinIntRel
566 operator ==(const BoolVar& l, const BoolVar& r);
568 GECODE_MINIMODEL_EXPORT LinIntRel
569 operator ==(const IntVar& l, const LinIntExpr& r);
571 GECODE_MINIMODEL_EXPORT LinIntRel
572 operator ==(const BoolVar& l, const LinIntExpr& r);
574 GECODE_MINIMODEL_EXPORT LinIntRel
575 operator ==(const LinIntExpr& l, const IntVar& r);
577 GECODE_MINIMODEL_EXPORT LinIntRel
578 operator ==(const LinIntExpr& l, const BoolVar& r);
580 GECODE_MINIMODEL_EXPORT LinIntRel
581 operator ==(const LinIntExpr& l, const LinIntExpr& r);
582
584 GECODE_MINIMODEL_EXPORT LinIntRel
585 operator !=(int l, const IntVar& r);
587 GECODE_MINIMODEL_EXPORT LinIntRel
588 operator !=(int l, const BoolVar& r);
590 GECODE_MINIMODEL_EXPORT LinIntRel
591 operator !=(int l, const LinIntExpr& r);
593 GECODE_MINIMODEL_EXPORT LinIntRel
594 operator !=(const IntVar& l, int r);
596 GECODE_MINIMODEL_EXPORT LinIntRel
597 operator !=(const BoolVar& l, int r);
599 GECODE_MINIMODEL_EXPORT LinIntRel
600 operator !=(const LinIntExpr& l, int r);
602 GECODE_MINIMODEL_EXPORT LinIntRel
603 operator !=(const IntVar& l, const IntVar& r);
605 GECODE_MINIMODEL_EXPORT LinIntRel
606 operator !=(const IntVar& l, const BoolVar& r);
608 GECODE_MINIMODEL_EXPORT LinIntRel
609 operator !=(const BoolVar& l, const IntVar& r);
611 GECODE_MINIMODEL_EXPORT LinIntRel
612 operator !=(const BoolVar& l, const BoolVar& r);
614 GECODE_MINIMODEL_EXPORT LinIntRel
615 operator !=(const IntVar& l, const LinIntExpr& r);
617 GECODE_MINIMODEL_EXPORT LinIntRel
618 operator !=(const BoolVar& l, const LinIntExpr& r);
620 GECODE_MINIMODEL_EXPORT LinIntRel
621 operator !=(const LinIntExpr& l, const IntVar& r);
623 GECODE_MINIMODEL_EXPORT LinIntRel
624 operator !=(const LinIntExpr& l, const BoolVar& r);
626 GECODE_MINIMODEL_EXPORT LinIntRel
627 operator !=(const LinIntExpr& l, const LinIntExpr& r);
628
630 GECODE_MINIMODEL_EXPORT LinIntRel
631 operator <(int l, const IntVar& r);
633 GECODE_MINIMODEL_EXPORT LinIntRel
634 operator <(int l, const BoolVar& r);
636 GECODE_MINIMODEL_EXPORT LinIntRel
637 operator <(int l, const LinIntExpr& r);
639 GECODE_MINIMODEL_EXPORT LinIntRel
640 operator <(const IntVar& l, int r);
642 GECODE_MINIMODEL_EXPORT LinIntRel
643 operator <(const BoolVar& l, int r);
645 GECODE_MINIMODEL_EXPORT LinIntRel
646 operator <(const LinIntExpr& l, int r);
648 GECODE_MINIMODEL_EXPORT LinIntRel
649 operator <(const IntVar& l, const IntVar& r);
651 GECODE_MINIMODEL_EXPORT LinIntRel
652 operator <(const IntVar& l, const BoolVar& r);
654 GECODE_MINIMODEL_EXPORT LinIntRel
655 operator <(const BoolVar& l, const IntVar& r);
657 GECODE_MINIMODEL_EXPORT LinIntRel
658 operator <(const BoolVar& l, const BoolVar& r);
660 GECODE_MINIMODEL_EXPORT LinIntRel
661 operator <(const IntVar& l, const LinIntExpr& r);
663 GECODE_MINIMODEL_EXPORT LinIntRel
664 operator <(const BoolVar& l, const LinIntExpr& r);
666 GECODE_MINIMODEL_EXPORT LinIntRel
667 operator <(const LinIntExpr& l, const IntVar& r);
669 GECODE_MINIMODEL_EXPORT LinIntRel
670 operator <(const LinIntExpr& l, const BoolVar& r);
672 GECODE_MINIMODEL_EXPORT LinIntRel
673 operator <(const LinIntExpr& l, const LinIntExpr& r);
674
676 GECODE_MINIMODEL_EXPORT LinIntRel
677 operator <=(int l, const IntVar& r);
679 GECODE_MINIMODEL_EXPORT LinIntRel
680 operator <=(int l, const BoolVar& r);
682 GECODE_MINIMODEL_EXPORT LinIntRel
683 operator <=(int l, const LinIntExpr& r);
685 GECODE_MINIMODEL_EXPORT LinIntRel
686 operator <=(const IntVar& l, int r);
688 GECODE_MINIMODEL_EXPORT LinIntRel
689 operator <=(const BoolVar& l, int r);
691 GECODE_MINIMODEL_EXPORT LinIntRel
692 operator <=(const LinIntExpr& l, int r);
694 GECODE_MINIMODEL_EXPORT LinIntRel
695 operator <=(const IntVar& l, const IntVar& r);
697 GECODE_MINIMODEL_EXPORT LinIntRel
698 operator <=(const IntVar& l, const BoolVar& r);
700 GECODE_MINIMODEL_EXPORT LinIntRel
701 operator <=(const BoolVar& l, const IntVar& r);
703 GECODE_MINIMODEL_EXPORT LinIntRel
704 operator <=(const BoolVar& l, const BoolVar& r);
706 GECODE_MINIMODEL_EXPORT LinIntRel
707 operator <=(const IntVar& l, const LinIntExpr& r);
709 GECODE_MINIMODEL_EXPORT LinIntRel
710 operator <=(const BoolVar& l, const LinIntExpr& r);
712 GECODE_MINIMODEL_EXPORT LinIntRel
713 operator <=(const LinIntExpr& l, const IntVar& r);
715 GECODE_MINIMODEL_EXPORT LinIntRel
716 operator <=(const LinIntExpr& l, const BoolVar& r);
718 GECODE_MINIMODEL_EXPORT LinIntRel
719 operator <=(const LinIntExpr& l, const LinIntExpr& r);
720
722 GECODE_MINIMODEL_EXPORT LinIntRel
723 operator >(int l, const IntVar& r);
725 GECODE_MINIMODEL_EXPORT LinIntRel
726 operator >(int l, const BoolVar& r);
728 GECODE_MINIMODEL_EXPORT LinIntRel
729 operator >(int l, const LinIntExpr& r);
731 GECODE_MINIMODEL_EXPORT LinIntRel
732 operator >(const IntVar& l, int r);
734 GECODE_MINIMODEL_EXPORT LinIntRel
735 operator >(const BoolVar& l, int r);
737 GECODE_MINIMODEL_EXPORT LinIntRel
738 operator >(const LinIntExpr& l, int r);
740 GECODE_MINIMODEL_EXPORT LinIntRel
741 operator >(const IntVar& l, const IntVar& r);
743 GECODE_MINIMODEL_EXPORT LinIntRel
744 operator >(const IntVar& l, const BoolVar& r);
746 GECODE_MINIMODEL_EXPORT LinIntRel
747 operator >(const BoolVar& l, const IntVar& r);
749 GECODE_MINIMODEL_EXPORT LinIntRel
750 operator >(const BoolVar& l, const BoolVar& r);
752 GECODE_MINIMODEL_EXPORT LinIntRel
753 operator >(const IntVar& l, const LinIntExpr& r);
755 GECODE_MINIMODEL_EXPORT LinIntRel
756 operator >(const BoolVar& l, const LinIntExpr& r);
758 GECODE_MINIMODEL_EXPORT LinIntRel
759 operator >(const LinIntExpr& l, const IntVar& r);
761 GECODE_MINIMODEL_EXPORT LinIntRel
762 operator >(const LinIntExpr& l, const BoolVar& r);
764 GECODE_MINIMODEL_EXPORT LinIntRel
765 operator >(const LinIntExpr& l, const LinIntExpr& r);
766
768 GECODE_MINIMODEL_EXPORT LinIntRel
769 operator >=(int l, const IntVar& r);
771 GECODE_MINIMODEL_EXPORT LinIntRel
772 operator >=(int l, const BoolVar& r);
774 GECODE_MINIMODEL_EXPORT LinIntRel
775 operator >=(int l, const LinIntExpr& r);
777 GECODE_MINIMODEL_EXPORT LinIntRel
778 operator >=(const IntVar& l, int r);
780 GECODE_MINIMODEL_EXPORT LinIntRel
781 operator >=(const BoolVar& l, int r);
783 GECODE_MINIMODEL_EXPORT LinIntRel
784 operator >=(const LinIntExpr& l, int r);
786 GECODE_MINIMODEL_EXPORT LinIntRel
787 operator >=(const IntVar& l, const IntVar& r);
789 GECODE_MINIMODEL_EXPORT LinIntRel
790 operator >=(const IntVar& l, const BoolVar& r);
792 GECODE_MINIMODEL_EXPORT LinIntRel
793 operator >=(const BoolVar& l, const IntVar& r);
795 GECODE_MINIMODEL_EXPORT LinIntRel
796 operator >=(const BoolVar& l, const BoolVar& r);
798 GECODE_MINIMODEL_EXPORT LinIntRel
799 operator >=(const IntVar& l, const LinIntExpr& r);
801 GECODE_MINIMODEL_EXPORT LinIntRel
802 operator >=(const BoolVar& l, const LinIntExpr& r);
804 GECODE_MINIMODEL_EXPORT LinIntRel
805 operator >=(const LinIntExpr& l, const IntVar& r);
807 GECODE_MINIMODEL_EXPORT LinIntRel
808 operator >=(const LinIntExpr& l, const BoolVar& r);
810 GECODE_MINIMODEL_EXPORT LinIntRel
811 operator >=(const LinIntExpr& l, const LinIntExpr& r);
813
814#ifdef GECODE_HAS_FLOAT_VARS
815
817 class NonLinFloatExpr {
818 public:
820 virtual FloatVar post(Home home, FloatVar* ret) const = 0;
822 virtual void post(Home home, FloatRelType frt, FloatVal c) const = 0;
824 virtual void post(Home home, FloatRelType frt, FloatVal c,
825 BoolVar b) const = 0;
827 virtual ~NonLinFloatExpr(void);
829 static FloatVar result(Home home, FloatVar* x);
831 static FloatVar result(Home home, FloatVar* x, FloatVar y);
833 void* operator new(size_t s);
835 void operator delete(void* p, size_t s);
836 };
837
838}
839
840#include <gecode/minimodel/float-expr.hpp>
841
842namespace Gecode {
843
845 class LinFloatExpr {
846 friend class LinFloatRel;
847 public:
858 private:
860 class Node;
861 Node* n;
862 public:
864 GECODE_MINIMODEL_EXPORT
865 LinFloatExpr(void);
867 GECODE_MINIMODEL_EXPORT
868 LinFloatExpr(const FloatVal& c);
870 GECODE_MINIMODEL_EXPORT
871 LinFloatExpr(const FloatVar& x);
873 GECODE_MINIMODEL_EXPORT
874 LinFloatExpr(const FloatVar& x, FloatVal a);
876 GECODE_MINIMODEL_EXPORT
877 explicit LinFloatExpr(const FloatVarArgs& x);
879 GECODE_MINIMODEL_EXPORT
880 LinFloatExpr(const FloatValArgs& a, const FloatVarArgs& x);
882 GECODE_MINIMODEL_EXPORT
883 LinFloatExpr(const LinFloatExpr& e);
885 GECODE_MINIMODEL_EXPORT
886 LinFloatExpr(const LinFloatExpr& e0, NodeType t, const LinFloatExpr& e1);
888 GECODE_MINIMODEL_EXPORT
889 LinFloatExpr(const LinFloatExpr& e0, NodeType t, const FloatVal& c);
891 GECODE_MINIMODEL_EXPORT
892 LinFloatExpr(FloatVal a, const LinFloatExpr& e);
894 GECODE_MINIMODEL_EXPORT
895 explicit LinFloatExpr(NonLinFloatExpr* e);
897 GECODE_MINIMODEL_EXPORT
898 const LinFloatExpr& operator =(const LinFloatExpr& e);
900 GECODE_MINIMODEL_EXPORT
901 void post(Home home, FloatRelType frt) const;
903 GECODE_MINIMODEL_EXPORT
904 void post(Home home, FloatRelType frt, const BoolVar& b) const;
906 GECODE_MINIMODEL_EXPORT
907 FloatVar post(Home home) const;
909 GECODE_MINIMODEL_EXPORT
910 NonLinFloatExpr* nlfe(void) const;
912 GECODE_MINIMODEL_EXPORT
913 ~LinFloatExpr(void);
914 };
915
916 class BoolExpr;
917
919 class LinFloatRel {
920 friend class BoolExpr;
921 private:
923 LinFloatExpr e;
925 FloatRelType frt;
927 static FloatRelType neg(FloatRelType frt);
929 LinFloatRel(void);
930 public:
932 LinFloatRel(const LinFloatExpr& l, FloatRelType frt, const LinFloatExpr& r);
934 LinFloatRel(const LinFloatExpr& l, FloatRelType frt, FloatVal r);
936 LinFloatRel(FloatVal l, FloatRelType frt, const LinFloatExpr& r);
938 void post(Home home, bool t) const;
940 void post(Home home, const BoolVar& b, bool t) const;
941 };
942
956
957 GECODE_MINIMODEL_EXPORT LinFloatExpr
958 operator +(const FloatVal&, const FloatVar&);
960 GECODE_MINIMODEL_EXPORT LinFloatExpr
961 operator +(const FloatVal&, const LinFloatExpr&);
963 GECODE_MINIMODEL_EXPORT LinFloatExpr
964 operator +(const FloatVar&, const FloatVal&);
966 GECODE_MINIMODEL_EXPORT LinFloatExpr
967 operator +(const LinFloatExpr&, const FloatVal&);
969 GECODE_MINIMODEL_EXPORT LinFloatExpr
970 operator +(const FloatVar&, const FloatVar&);
972 GECODE_MINIMODEL_EXPORT LinFloatExpr
973 operator +(const FloatVar&, const LinFloatExpr&);
975 GECODE_MINIMODEL_EXPORT LinFloatExpr
976 operator +(const LinFloatExpr&, const FloatVar&);
978 GECODE_MINIMODEL_EXPORT LinFloatExpr
979 operator +(const LinFloatExpr&, const LinFloatExpr&);
980
982 GECODE_MINIMODEL_EXPORT LinFloatExpr
983 operator -(const FloatVal&, const FloatVar&);
985 GECODE_MINIMODEL_EXPORT LinFloatExpr
986 operator -(const FloatVal&, const LinFloatExpr&);
988 GECODE_MINIMODEL_EXPORT LinFloatExpr
989 operator -(const FloatVar&, const FloatVal&);
991 GECODE_MINIMODEL_EXPORT LinFloatExpr
992 operator -(const LinFloatExpr&, const FloatVal&);
994 GECODE_MINIMODEL_EXPORT LinFloatExpr
995 operator -(const FloatVar&, const FloatVar&);
997 GECODE_MINIMODEL_EXPORT LinFloatExpr
998 operator -(const FloatVar&, const LinFloatExpr&);
1000 GECODE_MINIMODEL_EXPORT LinFloatExpr
1001 operator -(const LinFloatExpr&, const FloatVar&);
1003 GECODE_MINIMODEL_EXPORT LinFloatExpr
1004 operator -(const LinFloatExpr&, const LinFloatExpr&);
1005
1007 GECODE_MINIMODEL_EXPORT LinFloatExpr
1008 operator -(const FloatVar&);
1010 GECODE_MINIMODEL_EXPORT LinFloatExpr
1011 operator -(const LinFloatExpr&);
1012
1014 GECODE_MINIMODEL_EXPORT LinFloatExpr
1015 operator *(const FloatVal&, const FloatVar&);
1017 GECODE_MINIMODEL_EXPORT LinFloatExpr
1018 operator *(const FloatVar&, const FloatVal&);
1020 GECODE_MINIMODEL_EXPORT LinFloatExpr
1021 operator *(const LinFloatExpr&, const FloatVal&);
1023 GECODE_MINIMODEL_EXPORT LinFloatExpr
1024 operator *(const FloatVal&, const LinFloatExpr&);
1025
1027 GECODE_MINIMODEL_EXPORT LinFloatExpr
1028 sum(const FloatVarArgs& x);
1030 GECODE_MINIMODEL_EXPORT LinFloatExpr
1031 sum(const FloatValArgs& a, const FloatVarArgs& x);
1032
1034 GECODE_MINIMODEL_EXPORT LinFloatRel
1035 operator ==(const FloatVal& l, const FloatVar& r);
1037 GECODE_MINIMODEL_EXPORT LinFloatRel
1038 operator ==(const FloatVal& l, const LinFloatExpr& r);
1040 GECODE_MINIMODEL_EXPORT LinFloatRel
1041 operator ==(const FloatVar& l, const FloatVal& r);
1043 GECODE_MINIMODEL_EXPORT LinFloatRel
1044 operator ==(const LinFloatExpr& l, const FloatVal& r);
1046 GECODE_MINIMODEL_EXPORT LinFloatRel
1047 operator ==(const FloatVar& l, const FloatVar& r);
1049 GECODE_MINIMODEL_EXPORT LinFloatRel
1050 operator ==(const FloatVar& l, const LinFloatExpr& r);
1052 GECODE_MINIMODEL_EXPORT LinFloatRel
1053 operator ==(const LinFloatExpr& l, const FloatVar& r);
1055 GECODE_MINIMODEL_EXPORT LinFloatRel
1056 operator ==(const LinFloatExpr& l, const LinFloatExpr& r);
1057
1059 GECODE_MINIMODEL_EXPORT LinFloatRel
1060 operator !=(const FloatVal& l, const FloatVar& r);
1062 GECODE_MINIMODEL_EXPORT LinFloatRel
1063 operator !=(const FloatVal& l, const LinFloatExpr& r);
1065 GECODE_MINIMODEL_EXPORT LinFloatRel
1066 operator !=(const FloatVar& l, const FloatVal& r);
1068 GECODE_MINIMODEL_EXPORT LinFloatRel
1069 operator !=(const LinFloatExpr& l, const FloatVal& r);
1071 GECODE_MINIMODEL_EXPORT LinFloatRel
1072 operator !=(const FloatVar& l, const FloatVar& r);
1074 GECODE_MINIMODEL_EXPORT LinFloatRel
1075 operator !=(const FloatVar& l, const LinFloatExpr& r);
1077 GECODE_MINIMODEL_EXPORT LinFloatRel
1078 operator !=(const LinFloatExpr& l, const FloatVar& r);
1080 GECODE_MINIMODEL_EXPORT LinFloatRel
1081 operator !=(const LinFloatExpr& l, const LinFloatExpr& r);
1082
1084 GECODE_MINIMODEL_EXPORT LinFloatRel
1085 operator <(const FloatVal& l, const FloatVar& r);
1087 GECODE_MINIMODEL_EXPORT LinFloatRel
1088 operator <(const FloatVal& l, const LinFloatExpr& r);
1090 GECODE_MINIMODEL_EXPORT LinFloatRel
1091 operator <(const FloatVar& l, const FloatVal& r);
1093 GECODE_MINIMODEL_EXPORT LinFloatRel
1094 operator <(const LinFloatExpr& l, const FloatVal& r);
1096 GECODE_MINIMODEL_EXPORT LinFloatRel
1097 operator <(const FloatVar& l, const FloatVar& r);
1099 GECODE_MINIMODEL_EXPORT LinFloatRel
1100 operator <(const FloatVar& l, const LinFloatExpr& r);
1102 GECODE_MINIMODEL_EXPORT LinFloatRel
1103 operator <(const LinFloatExpr& l, const FloatVar& r);
1105 GECODE_MINIMODEL_EXPORT LinFloatRel
1106 operator <(const LinFloatExpr& l, const LinFloatExpr& r);
1107
1109 GECODE_MINIMODEL_EXPORT LinFloatRel
1110 operator <=(const FloatVal& l, const FloatVar& r);
1112 GECODE_MINIMODEL_EXPORT LinFloatRel
1113 operator <=(const FloatVal& l, const LinFloatExpr& r);
1115 GECODE_MINIMODEL_EXPORT LinFloatRel
1116 operator <=(const FloatVar& l, const FloatVal& r);
1118 GECODE_MINIMODEL_EXPORT LinFloatRel
1119 operator <=(const LinFloatExpr& l, const FloatVal& r);
1121 GECODE_MINIMODEL_EXPORT LinFloatRel
1122 operator <=(const FloatVar& l, const FloatVar& r);
1124 GECODE_MINIMODEL_EXPORT LinFloatRel
1125 operator <=(const FloatVar& l, const LinFloatExpr& r);
1127 GECODE_MINIMODEL_EXPORT LinFloatRel
1128 operator <=(const LinFloatExpr& l, const FloatVar& r);
1130 GECODE_MINIMODEL_EXPORT LinFloatRel
1131 operator <=(const LinFloatExpr& l, const LinFloatExpr& r);
1132
1134 GECODE_MINIMODEL_EXPORT LinFloatRel
1135 operator >(const FloatVal& l, const FloatVar& r);
1137 GECODE_MINIMODEL_EXPORT LinFloatRel
1138 operator >(const FloatVal& l, const LinFloatExpr& r);
1140 GECODE_MINIMODEL_EXPORT LinFloatRel
1141 operator >(const FloatVar& l, const FloatVal& r);
1143 GECODE_MINIMODEL_EXPORT LinFloatRel
1144 operator >(const LinFloatExpr& l, const FloatVal& r);
1146 GECODE_MINIMODEL_EXPORT LinFloatRel
1147 operator >(const FloatVar& l, const FloatVar& r);
1149 GECODE_MINIMODEL_EXPORT LinFloatRel
1150 operator >(const FloatVar& l, const LinFloatExpr& r);
1152 GECODE_MINIMODEL_EXPORT LinFloatRel
1153 operator >(const LinFloatExpr& l, const FloatVar& r);
1155 GECODE_MINIMODEL_EXPORT LinFloatRel
1156 operator >(const LinFloatExpr& l, const LinFloatExpr& r);
1157
1159 GECODE_MINIMODEL_EXPORT LinFloatRel
1160 operator >=(const FloatVal& l, const FloatVar& r);
1162 GECODE_MINIMODEL_EXPORT LinFloatRel
1163 operator >=(const FloatVal& l, const LinFloatExpr& r);
1165 GECODE_MINIMODEL_EXPORT LinFloatRel
1166 operator >=(const FloatVar& l, const FloatVal& r);
1168 GECODE_MINIMODEL_EXPORT LinFloatRel
1169 operator >=(const LinFloatExpr& l, const FloatVal& r);
1171 GECODE_MINIMODEL_EXPORT LinFloatRel
1172 operator >=(const FloatVar& l, const FloatVar& r);
1174 GECODE_MINIMODEL_EXPORT LinFloatRel
1175 operator >=(const FloatVar& l, const LinFloatExpr& r);
1177 GECODE_MINIMODEL_EXPORT LinFloatRel
1178 operator >=(const LinFloatExpr& l, const FloatVar& r);
1180 GECODE_MINIMODEL_EXPORT LinFloatRel
1181 operator >=(const LinFloatExpr& l, const LinFloatExpr& r);
1183#endif
1184
1185#ifdef GECODE_HAS_SET_VARS
1187 class SetExpr {
1188 public:
1199
1200 class Node;
1201 private:
1203 Node* n;
1204 public:
1206 SetExpr(void);
1208 GECODE_MINIMODEL_EXPORT
1209 SetExpr(const SetExpr& e);
1211 GECODE_MINIMODEL_EXPORT
1212 SetExpr(const SetExpr& l, NodeType t, const SetExpr& r);
1214 GECODE_MINIMODEL_EXPORT
1215 SetExpr(const SetVar& x);
1217 GECODE_MINIMODEL_EXPORT
1218 explicit SetExpr(const LinIntExpr& x);
1220 GECODE_MINIMODEL_EXPORT
1221 SetExpr(const IntSet& s);
1223 GECODE_MINIMODEL_EXPORT
1224 SetExpr(const SetExpr& e, NodeType t);
1226 GECODE_MINIMODEL_EXPORT
1227 SetVar post(Home home) const;
1229 GECODE_MINIMODEL_EXPORT
1230 void post(Home home, SetRelType srt, const SetExpr& e) const;
1232 GECODE_MINIMODEL_EXPORT
1233 void post(Home home, BoolVar b, bool t,
1234 SetRelType srt, const SetExpr& e) const;
1236 GECODE_MINIMODEL_EXPORT
1237 const SetExpr& operator =(const SetExpr& e);
1239 GECODE_MINIMODEL_EXPORT
1240 ~SetExpr(void);
1241 };
1242
1244 class SetCmpRel {
1245 public:
1247 SetExpr l;
1249 SetExpr r;
1251 SetRelType srt;
1253 SetCmpRel(const SetExpr& l, SetRelType srt, const SetExpr& r);
1254 };
1255
1257 class SetRel {
1258 private:
1260 SetExpr _e0;
1262 SetRelType _srt;
1264 SetExpr _e1;
1265 public:
1267 SetRel(void);
1269 SetRel(const SetExpr& e0, SetRelType srt, const SetExpr& e1);
1271 SetRel(const SetCmpRel& r);
1273 void post(Home home, bool t) const;
1275 void post(Home home, BoolVar b, bool t) const;
1276 };
1277
1286
1288
1289 GECODE_MINIMODEL_EXPORT SetExpr
1290 singleton(const LinIntExpr&);
1292 GECODE_MINIMODEL_EXPORT SetExpr
1293 operator -(const SetExpr&);
1295 GECODE_MINIMODEL_EXPORT SetExpr
1296 operator &(const SetExpr&, const SetExpr&);
1298 GECODE_MINIMODEL_EXPORT SetExpr
1299 operator |(const SetExpr&, const SetExpr&);
1301 GECODE_MINIMODEL_EXPORT SetExpr
1302 operator +(const SetExpr&, const SetExpr&);
1304 GECODE_MINIMODEL_EXPORT SetExpr
1305 operator -(const SetExpr&, const SetExpr&);
1306
1308 GECODE_MINIMODEL_EXPORT SetExpr
1309 inter(const SetVarArgs&);
1311 GECODE_MINIMODEL_EXPORT SetExpr
1312 setunion(const SetVarArgs&);
1314 GECODE_MINIMODEL_EXPORT SetExpr
1315 setdunion(const SetVarArgs&);
1316
1318 GECODE_MINIMODEL_EXPORT LinIntExpr
1319 cardinality(const SetExpr&);
1321 GECODE_MINIMODEL_EXPORT LinIntExpr
1322 min(const SetExpr&);
1324 GECODE_MINIMODEL_EXPORT LinIntExpr
1325 max(const SetExpr&);
1326
1328 GECODE_MINIMODEL_EXPORT SetRel
1329 operator ==(const SetExpr&, const SetExpr&);
1331 GECODE_MINIMODEL_EXPORT SetRel
1332 operator !=(const SetExpr&, const SetExpr&);
1334 GECODE_MINIMODEL_EXPORT SetCmpRel
1335 operator <=(const SetExpr&, const SetExpr&);
1337 GECODE_MINIMODEL_EXPORT BoolExpr
1338 operator <=(const SetCmpRel&, const SetExpr&);
1340 GECODE_MINIMODEL_EXPORT SetCmpRel
1341 operator >=(const SetExpr&, const SetExpr&);
1343 GECODE_MINIMODEL_EXPORT BoolExpr
1344 operator >=(const SetCmpRel&, const SetExpr&);
1346 GECODE_MINIMODEL_EXPORT SetRel
1347 operator ||(const SetExpr&, const SetExpr&);
1349#endif
1350
1352 class BoolExpr {
1353 public:
1366
1367 class GECODE_VTABLE_EXPORT Misc : public HeapAllocated {
1368 public:
1370 Misc(void);
1375 virtual void post(Home home, BoolVar b, bool neg,
1376 const IntPropLevels& ipls) = 0;
1378 virtual GECODE_MINIMODEL_EXPORT ~Misc(void);
1379 };
1380
1381 class Node;
1382 private:
1384 Node* n;
1386 BoolExpr(const BoolExpr& l, NodeType t, const BoolExpr& r,
1387 bool accumulator);
1388 friend GECODE_MINIMODEL_EXPORT
1389 BoolExpr operator &&(const BoolExpr&, const BoolExpr&);
1390 friend GECODE_MINIMODEL_EXPORT
1391 BoolExpr operator ||(const BoolExpr&, const BoolExpr&);
1392 public:
1399 GECODE_MINIMODEL_EXPORT
1400 BoolExpr(void);
1402 GECODE_MINIMODEL_EXPORT
1403 BoolExpr(const BoolExpr& e);
1405 GECODE_MINIMODEL_EXPORT
1406 BoolExpr(const BoolExpr& l, NodeType t, const BoolExpr& r);
1408 GECODE_MINIMODEL_EXPORT
1409 BoolExpr(const BoolVar& x);
1411 GECODE_MINIMODEL_EXPORT
1412 BoolExpr(const BoolExpr& e, NodeType t);
1414 GECODE_MINIMODEL_EXPORT
1415 BoolExpr(const LinIntRel& rl);
1416#ifdef GECODE_HAS_FLOAT_VARS
1418 GECODE_MINIMODEL_EXPORT
1419 BoolExpr(const LinFloatRel& rfl);
1420#endif
1421#ifdef GECODE_HAS_SET_VARS
1423 GECODE_MINIMODEL_EXPORT
1424 BoolExpr(const SetRel& rs);
1426 GECODE_MINIMODEL_EXPORT
1427 BoolExpr(const SetCmpRel& rs);
1428#endif
1430 GECODE_MINIMODEL_EXPORT
1431 explicit BoolExpr(Misc* m);
1433 GECODE_MINIMODEL_EXPORT
1434 BoolVar expr(Home home, const IntPropLevels& ipls) const;
1436 GECODE_MINIMODEL_EXPORT
1437 void rel(Home home, const IntPropLevels& ipls) const;
1439 GECODE_MINIMODEL_EXPORT
1440 const BoolExpr& operator =(const BoolExpr& e);
1442 GECODE_MINIMODEL_EXPORT
1443 ~BoolExpr(void);
1444 };
1445
1454
1456
1457 GECODE_MINIMODEL_EXPORT BoolExpr
1458 operator !(const BoolExpr&);
1466 GECODE_MINIMODEL_EXPORT BoolExpr
1467 operator &&(const BoolExpr&, const BoolExpr&);
1475 GECODE_MINIMODEL_EXPORT BoolExpr
1476 operator ||(const BoolExpr&, const BoolExpr&);
1478 GECODE_MINIMODEL_EXPORT BoolExpr
1479 operator ^(const BoolExpr&, const BoolExpr&);
1480
1482 GECODE_MINIMODEL_EXPORT BoolExpr
1483 operator !=(const BoolExpr&, const BoolExpr&);
1485 GECODE_MINIMODEL_EXPORT BoolExpr
1486 operator ==(const BoolExpr&, const BoolExpr&);
1488 GECODE_MINIMODEL_EXPORT BoolExpr
1489 operator >>(const BoolExpr&, const BoolExpr&);
1491 GECODE_MINIMODEL_EXPORT BoolExpr
1492 operator <<(const BoolExpr&, const BoolExpr&);
1493
1495
1501
1503
1504 GECODE_MINIMODEL_EXPORT BoolExpr
1505 dom(const IntVar& x, int n);
1507 GECODE_MINIMODEL_EXPORT BoolExpr
1508 dom(const IntVar& x, int l, int m);
1510 GECODE_MINIMODEL_EXPORT BoolExpr
1511 dom(const IntVar& x, const IntSet& s);
1512
1513#ifdef GECODE_HAS_SET_VARS
1515 GECODE_MINIMODEL_EXPORT BoolExpr
1516 dom(const SetVar& x, SetRelType rt, int i);
1518 GECODE_MINIMODEL_EXPORT BoolExpr
1519 dom(const SetVar& x, SetRelType rt, int i, int j);
1521 GECODE_MINIMODEL_EXPORT BoolExpr
1522 dom(const SetVar& x, SetRelType rt, const IntSet& s);
1523#endif
1524
1525#ifdef GECODE_HAS_FLOAT_VARS
1527 GECODE_MINIMODEL_EXPORT BoolExpr
1528 dom(const FloatVar& x, const FloatVal& n);
1530 GECODE_MINIMODEL_EXPORT BoolExpr
1531 dom(const FloatVar& x, FloatNum l, FloatNum u);
1532#endif
1534
1540
1542#ifdef GECODE_HAS_SET_VARS
1544 GECODE_MINIMODEL_EXPORT BoolExpr
1545 operator ==(const SetExpr& s, const LinIntExpr& x);
1547 GECODE_MINIMODEL_EXPORT BoolExpr
1548 operator ==(const LinIntExpr& x, const SetExpr& s);
1550 BoolExpr
1551 operator ==(const LinIntExpr&, IntSet) = delete;
1553 BoolExpr
1554 operator ==(IntSet, const LinIntExpr&) = delete;
1555
1557 GECODE_MINIMODEL_EXPORT BoolExpr
1558 operator !=(const SetExpr& s, const LinIntExpr& x);
1560 GECODE_MINIMODEL_EXPORT BoolExpr
1561 operator !=(const LinIntExpr& x, const SetExpr& s);
1563 BoolExpr
1564 operator !=(const LinIntExpr&, IntSet) = delete;
1566 BoolExpr
1567 operator !=(IntSet, const LinIntExpr&) = delete;
1568
1570 GECODE_MINIMODEL_EXPORT BoolExpr
1571 operator <=(const SetExpr& s, const LinIntExpr& x);
1573 GECODE_MINIMODEL_EXPORT BoolExpr
1574 operator <=(const LinIntExpr& x, const SetExpr& s);
1576 BoolExpr
1577 operator <=(const LinIntExpr&, IntSet) = delete;
1579 BoolExpr
1580 operator <=(IntSet, const LinIntExpr&) = delete;
1581
1583 GECODE_MINIMODEL_EXPORT BoolExpr
1584 operator <(const SetExpr& s, const LinIntExpr& x);
1586 GECODE_MINIMODEL_EXPORT BoolExpr
1587 operator <(const LinIntExpr& x, const SetExpr& s);
1589 BoolExpr
1590 operator <(const LinIntExpr&, IntSet) = delete;
1592 BoolExpr
1593 operator <(IntSet, const LinIntExpr&) = delete;
1594
1596 GECODE_MINIMODEL_EXPORT BoolExpr
1597 operator >=(const SetExpr& s, const LinIntExpr& x);
1599 GECODE_MINIMODEL_EXPORT BoolExpr
1600 operator >=(const LinIntExpr& x, const SetExpr& s);
1602 BoolExpr
1603 operator >=(const LinIntExpr&, IntSet) = delete;
1605 BoolExpr
1606 operator >=(IntSet, const LinIntExpr&) = delete;
1607
1609 GECODE_MINIMODEL_EXPORT BoolExpr
1610 operator >(const SetExpr& s, const LinIntExpr& x);
1612 GECODE_MINIMODEL_EXPORT BoolExpr
1613 operator >(const LinIntExpr& x, const SetExpr& s);
1615 BoolExpr
1616 operator >(const LinIntExpr&, IntSet) = delete;
1618 BoolExpr
1619 operator >(IntSet, const LinIntExpr&) = delete;
1620#endif
1622
1629
1630 GECODE_MINIMODEL_EXPORT IntVar
1631 expr(Home home, const LinIntExpr& e,
1632 const IntPropLevels& ipls=IntPropLevels::def);
1633#ifdef GECODE_HAS_FLOAT_VARS
1635 GECODE_MINIMODEL_EXPORT FloatVar
1636 expr(Home home, const LinFloatExpr& e);
1637#endif
1638#ifdef GECODE_HAS_SET_VARS
1640 GECODE_MINIMODEL_EXPORT SetVar
1641 expr(Home home, const SetExpr& e);
1642#endif
1644 GECODE_MINIMODEL_EXPORT BoolVar
1645 expr(Home home, const BoolExpr& e,
1646 const IntPropLevels& ipls=IntPropLevels::def);
1648 GECODE_MINIMODEL_EXPORT void
1649 rel(Home home, const BoolExpr& e,
1650 const IntPropLevels& ipls=IntPropLevels::def);
1652
1653}
1654
1655#include <gecode/minimodel/int-rel.hpp>
1656#include <gecode/minimodel/float-rel.hpp>
1657#include <gecode/minimodel/bool-expr.hpp>
1658#include <gecode/minimodel/set-expr.hpp>
1659#include <gecode/minimodel/set-rel.hpp>
1660
1661namespace Gecode {
1662
1663 namespace MiniModel {
1664 class ExpInfo;
1665 }
1666
1672 class GECODE_MINIMODEL_EXPORT REG {
1673 friend class MiniModel::ExpInfo;
1674 private:
1676 class Exp;
1678 Exp* e;
1680 REG(Exp* e);
1682 std::string toString(void) const;
1683 public:
1685 REG(void);
1687 REG(int s);
1694 REG(const IntArgs& x);
1695
1697 REG(const REG& r);
1699 const REG& operator =(const REG& r);
1700
1702 REG operator +(const REG& r);
1704 REG& operator +=(const REG& r);
1706 REG operator |(const REG& r);
1708 REG& operator |=(const REG& r);
1710 REG operator *(void);
1712 REG operator +(void);
1714 REG operator ()(unsigned int n, unsigned int m);
1716 REG operator ()(unsigned int n);
1718 template<class Char, class Traits>
1719 std::basic_ostream<Char,Traits>&
1720 print(std::basic_ostream<Char,Traits>& os) const;
1722 operator DFA(void);
1724 ~REG(void);
1725 };
1726
1730 template<class Char, class Traits>
1731 std::basic_ostream<Char,Traits>&
1732 operator <<(std::basic_ostream<Char,Traits>& os, const REG& r);
1733
1734}
1735
1736#include <gecode/minimodel/reg.hpp>
1737
1738namespace Gecode {
1739
1746
1747 GECODE_MINIMODEL_EXPORT LinIntExpr
1748 operator *(const LinIntExpr& x, const LinIntExpr& y);
1750 GECODE_MINIMODEL_EXPORT LinIntExpr
1751 operator /(const LinIntExpr& x, const LinIntExpr& y);
1753 GECODE_MINIMODEL_EXPORT LinIntExpr
1754 operator %(const LinIntExpr& x, const LinIntExpr& y);
1756 GECODE_MINIMODEL_EXPORT LinIntExpr
1757 abs(const LinIntExpr& e);
1759 GECODE_MINIMODEL_EXPORT LinIntExpr
1760 min(const LinIntExpr& x, const LinIntExpr& y);
1762 GECODE_MINIMODEL_EXPORT LinIntExpr
1763 min(const IntVarArgs& x);
1765 GECODE_MINIMODEL_EXPORT LinIntExpr
1766 max(const LinIntExpr& x, const LinIntExpr& y);
1768 GECODE_MINIMODEL_EXPORT LinIntExpr
1769 max(const IntVarArgs& x);
1771 GECODE_MINIMODEL_EXPORT LinIntExpr
1772 sqr(const LinIntExpr& x);
1774 GECODE_MINIMODEL_EXPORT LinIntExpr
1775 sqrt(const LinIntExpr& x);
1777 GECODE_MINIMODEL_EXPORT LinIntExpr
1778 pow(const LinIntExpr& x, int n);
1780 GECODE_MINIMODEL_EXPORT LinIntExpr
1781 nroot(const LinIntExpr& x, int n);
1783 GECODE_MINIMODEL_EXPORT LinIntExpr
1784 element(const IntVarArgs& x, const LinIntExpr& y);
1786 GECODE_MINIMODEL_EXPORT BoolExpr
1787 element(const BoolVarArgs& x, const LinIntExpr& y);
1789 GECODE_MINIMODEL_EXPORT LinIntExpr
1790 element(const IntArgs& x, const LinIntExpr& y);
1792 GECODE_MINIMODEL_EXPORT LinIntExpr
1793 ite(const BoolExpr& b, const LinIntExpr& x, const LinIntExpr& y);
1795
1796#ifdef GECODE_HAS_FLOAT_VARS
1798 GECODE_MINIMODEL_EXPORT LinFloatExpr
1799 operator *(const FloatVar&, const FloatVar&);
1801 GECODE_MINIMODEL_EXPORT LinFloatExpr
1802 operator *(const FloatVar&, const LinFloatExpr&);
1804 GECODE_MINIMODEL_EXPORT LinFloatExpr
1805 operator *(const LinFloatExpr&, const FloatVar&);
1807 GECODE_MINIMODEL_EXPORT LinFloatExpr
1808 abs(const LinFloatExpr& e);
1810 GECODE_MINIMODEL_EXPORT LinFloatExpr
1811 min(const LinFloatExpr& x, const LinFloatExpr& y);
1813 GECODE_MINIMODEL_EXPORT LinFloatExpr
1814 min(const FloatVarArgs& x);
1816 GECODE_MINIMODEL_EXPORT LinFloatExpr
1817 max(const LinFloatExpr& x, const LinFloatExpr& y);
1819 GECODE_MINIMODEL_EXPORT LinFloatExpr
1820 max(const FloatVarArgs& x);
1822 GECODE_MINIMODEL_EXPORT LinFloatExpr
1823 operator *(const LinFloatExpr& x, const LinFloatExpr& y);
1825 GECODE_MINIMODEL_EXPORT LinFloatExpr
1826 operator /(const LinFloatExpr& x, const LinFloatExpr& y);
1828 GECODE_MINIMODEL_EXPORT LinFloatExpr
1829 sqr(const LinFloatExpr& x);
1831 GECODE_MINIMODEL_EXPORT LinFloatExpr
1832 sqrt(const LinFloatExpr& x);
1834 GECODE_MINIMODEL_EXPORT LinFloatExpr
1835 pow(const LinFloatExpr& x, int n);
1837 GECODE_MINIMODEL_EXPORT LinFloatExpr
1838 nroot(const LinFloatExpr& x, int n);
1840
1841#ifdef GECODE_HAS_MPFR
1848
1849 GECODE_MINIMODEL_EXPORT LinFloatExpr
1850 exp(const LinFloatExpr& x);
1852 GECODE_MINIMODEL_EXPORT LinFloatExpr
1853 log(const LinFloatExpr& x);
1855
1862
1863 GECODE_MINIMODEL_EXPORT LinFloatExpr
1864 asin(const LinFloatExpr& x);
1866 GECODE_MINIMODEL_EXPORT LinFloatExpr
1867 sin(const LinFloatExpr& x);
1869 GECODE_MINIMODEL_EXPORT LinFloatExpr
1870 acos(const LinFloatExpr& x);
1872 GECODE_MINIMODEL_EXPORT LinFloatExpr
1873 cos(const LinFloatExpr& x);
1875 GECODE_MINIMODEL_EXPORT LinFloatExpr
1876 atan(const LinFloatExpr& x);
1878 GECODE_MINIMODEL_EXPORT LinFloatExpr
1879 tan(const LinFloatExpr& x);
1881#endif
1882#endif
1883
1884}
1885
1886namespace Gecode {
1887
1894
1895 BoolVar
1896 channel(Home home, IntVar x, IntPropLevel ipl=IPL_DEF);
1898 IntVar
1899 channel(Home home, BoolVar b, IntPropLevel ipl=IPL_DEF);
1900#ifdef GECODE_HAS_FLOAT_VARS
1902 IntVar
1903 channel(Home home, FloatVar f);
1904#endif
1905#ifdef GECODE_HAS_SET_VARS
1907 SetVar
1908 channel(Home home, const IntVarArgs& x, IntPropLevel ipl=IPL_DEF);
1909#endif
1911
1912}
1913
1914#include <gecode/minimodel/channel.hpp>
1915
1916namespace Gecode {
1917
1926
1928
1932 void
1933 atmost(Home home, const IntVarArgs& x, int n, int m,
1934 IntPropLevel ipl=IPL_DEF);
1939 void
1940 atmost(Home home, const IntVarArgs& x, IntVar y, int m,
1941 IntPropLevel ipl=IPL_DEF);
1949 void
1950 atmost(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1951 IntPropLevel ipl=IPL_DEF);
1956 void
1957 atmost(Home home, const IntVarArgs& x, int n, IntVar z,
1958 IntPropLevel ipl=IPL_DEF);
1963 void
1964 atmost(Home home, const IntVarArgs& x, IntVar y, IntVar z,
1965 IntPropLevel ipl=IPL_DEF);
1973 void
1974 atmost(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1975 IntPropLevel ipl=IPL_DEF);
1976
1981 void
1982 atleast(Home home, const IntVarArgs& x, int n, int m,
1983 IntPropLevel ipl=IPL_DEF);
1988 void
1989 atleast(Home home, const IntVarArgs& x, IntVar y, int m,
1990 IntPropLevel ipl=IPL_DEF);
1998 void
1999 atleast(Home home, const IntVarArgs& x, const IntArgs& y, int m,
2000 IntPropLevel ipl=IPL_DEF);
2005 void
2006 atleast(Home home, const IntVarArgs& x, int n, IntVar z,
2007 IntPropLevel ipl=IPL_DEF);
2012 void
2013 atleast(Home home, const IntVarArgs& x, IntVar y, IntVar z,
2014 IntPropLevel ipl=IPL_DEF);
2022 void
2023 atleast(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
2024 IntPropLevel ipl=IPL_DEF);
2025
2030 void
2031 exactly(Home home, const IntVarArgs& x, int n, int m,
2032 IntPropLevel ipl=IPL_DEF);
2037 void
2038 exactly(Home home, const IntVarArgs& x, IntVar y, int m,
2039 IntPropLevel ipl=IPL_DEF);
2047 void
2048 exactly(Home home, const IntVarArgs& x, const IntArgs& y, int m,
2049 IntPropLevel ipl=IPL_DEF);
2054 void
2055 exactly(Home home, const IntVarArgs& x, int n, IntVar z,
2056 IntPropLevel ipl=IPL_DEF);
2061 void
2062 exactly(Home home, const IntVarArgs& x, IntVar y, IntVar z,
2063 IntPropLevel ipl=IPL_DEF);
2071 void
2072 exactly(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
2073 IntPropLevel ipl=IPL_DEF);
2074
2077 void
2078 lex(Home home, const IntVarArgs& x, IntRelType r, const IntVarArgs& y,
2079 IntPropLevel ipl=IPL_DEF);
2082 void
2083 lex(Home home, const BoolVarArgs& x, IntRelType r, const BoolVarArgs& y,
2084 IntPropLevel ipl=IPL_DEF);
2085
2088 void
2089 values(Home home, const IntVarArgs& x, IntSet y,
2090 IntPropLevel ipl=IPL_DEF);
2092
2093#ifdef GECODE_HAS_SET_VARS
2102
2104
2109 void
2110 channel(Home home, const IntVarArgs& x, SetVar y);
2111
2114 void
2115 range(Home home, const IntVarArgs& x, SetVar y, SetVar z);
2116
2122 void
2123 roots(Home home, const IntVarArgs& x, SetVar y, SetVar z);
2125
2126#endif
2127
2128}
2129
2130#include <gecode/minimodel/aliases.hpp>
2131
2132namespace Gecode {
2133
2134 template<class> class Matrix;
2135
2143 template<class A>
2144 class Slice {
2145 public:
2147 typedef typename ArrayTraits<A>::ArgsType ArgsType;
2148 private:
2149 ArgsType _r;
2150 int _fc,
2151 _tc,
2152 _fr,
2153 _tr;
2154 public:
2156 Slice(const Matrix<A>& a, int fc, int tc, int fr, int tr);
2160 Slice& reverse(void);
2162 operator ArgsType(void);
2164 operator Matrix<ArgsType>(void);
2165
2167 operator const ArgsType(void) const;
2169 operator const Matrix<ArgsType>(void) const;
2170 };
2171
2173 template<class A>
2174 typename Slice<A>::ArgsType
2175 operator+(const Slice<A>& x, const Slice<A>& y);
2176
2178 template<class A>
2179 typename Slice<A>::ArgsType
2180 operator+(const Slice<A>& x, const typename ArrayTraits<A>::ArgsType& y);
2181
2183 template<class A>
2184 typename Slice<A>::ArgsType
2185 operator+(const typename ArrayTraits<A>::ArgsType& x, const Slice<A>& y);
2186
2188 template<class A>
2189 typename Slice<A>::ArgsType
2190 operator+(const Slice<A>& x, const typename ArrayTraits<A>::ValueType& y);
2191
2193 template<class A>
2194 typename Slice<A>::ArgsType
2195 operator+(const typename ArrayTraits<A>::ValueType& x, const Slice<A>& y);
2196
2207 template<class A>
2208 class Matrix {
2209 public:
2211 typedef typename ArrayTraits<A>::ValueType ValueType;
2213 typedef typename ArrayTraits<A>::ArgsType ArgsType;
2214
2215 private:
2217 typedef typename ArrayTraits<A>::StorageType StorageType;
2218 StorageType _a;
2219 int _w;
2220 int _h;
2221
2222 public:
2235 Matrix(A a, int w, int h);
2236
2249 Matrix(A a, int n);
2250
2252 int width(void) const;
2254 int height(void) const;
2256 ArgsType const get_array(void) const;
2257
2263 ValueType& operator ()(int c, int r);
2264
2270 const ValueType& operator ()(int c, int r) const;
2271
2281 Slice<A> slice(int fc, int tc, int fr, int tr) const;
2282
2284 Slice<A> row(int r) const;
2285
2287 Slice<A> col(int c) const;
2288 };
2289
2293 template<class Char, class Traits, class A>
2294 std::basic_ostream<Char,Traits>&
2295 operator <<(std::basic_ostream<Char,Traits>& os, const Matrix<A>& m);
2296
2300 template<class Char, class Traits, class A>
2301 std::basic_ostream<Char,Traits>&
2302 operator <<(std::basic_ostream<Char,Traits>& os, const Slice<A>& s);
2303
2310 void element(Home home, const Matrix<IntArgs>& m, IntVar x, IntVar y,
2311 IntVar z, IntPropLevel ipl=IPL_DEF);
2318 void element(Home home, const Matrix<IntArgs>& m, IntVar x, IntVar y,
2319 BoolVar z, IntPropLevel ipl=IPL_DEF);
2326 void element(Home home, const Matrix<IntVarArgs>& m, IntVar x, IntVar y,
2327 IntVar z, IntPropLevel ipl=IPL_DEF);
2334 void element(Home home, const Matrix<BoolVarArgs>& m, IntVar x, IntVar y,
2335 BoolVar z, IntPropLevel ipln=IPL_DEF);
2336#ifdef GECODE_HAS_SET_VARS
2343 void element(Home home, const Matrix<IntSetArgs>& m, IntVar x, IntVar y,
2344 SetVar z);
2351 void element(Home home, const Matrix<SetVarArgs>& m, IntVar x, IntVar y,
2352 SetVar z);
2353#endif
2354
2358 template<class A>
2359 SymmetryHandle rows_interchange(const Matrix<A>& m);
2363 template<class A>
2364 SymmetryHandle columns_interchange(const Matrix<A>& m);
2368 template<class A>
2369 SymmetryHandle rows_reflect(const Matrix<A>& m);
2373 template<class A>
2374 SymmetryHandle columns_reflect(const Matrix<A>& m);
2380 template<class A>
2381 SymmetryHandle diagonal_reflect(const Matrix<A>& m);
2382}
2383
2384#include <gecode/minimodel/matrix.hpp>
2385#include <gecode/minimodel/ldsb.hpp>
2386
2391namespace Gecode {
2392
2394 GECODE_MINIMODEL_EXPORT LinIntExpr
2395 sum(const Slice<IntArgs>& slice);
2397 GECODE_MINIMODEL_EXPORT LinIntExpr
2398 sum(const Matrix<IntArgs>& matrix);
2399
2400}
2402
2403namespace Gecode {
2404
2413
2418 class GECODE_VTABLE_EXPORT IntMinimizeSpace : public Space {
2419 public:
2421 IntMinimizeSpace(void);
2423 IntMinimizeSpace(IntMinimizeSpace& s);
2425 GECODE_MINIMODEL_EXPORT
2426 virtual void constrain(const Space& best);
2428 virtual IntVar cost(void) const = 0;
2429 };
2430
2435 class GECODE_VTABLE_EXPORT IntMaximizeSpace : public Space {
2436 public:
2438 IntMaximizeSpace(void);
2440 IntMaximizeSpace(IntMaximizeSpace& s);
2442 GECODE_MINIMODEL_EXPORT
2443 virtual void constrain(const Space& best);
2445 virtual IntVar cost(void) const = 0;
2446 };
2447
2452 class GECODE_VTABLE_EXPORT IntLexMinimizeSpace : public Space {
2453 public:
2455 IntLexMinimizeSpace(void);
2457 IntLexMinimizeSpace(IntLexMinimizeSpace& s);
2459 GECODE_MINIMODEL_EXPORT
2460 virtual void constrain(const Space& best);
2462 virtual IntVarArgs cost(void) const = 0;
2463 };
2464
2469 class GECODE_VTABLE_EXPORT IntLexMaximizeSpace : public Space {
2470 public:
2472 IntLexMaximizeSpace(void);
2474 IntLexMaximizeSpace(IntLexMaximizeSpace& s);
2476 GECODE_MINIMODEL_EXPORT
2477 virtual void constrain(const Space& best);
2479 virtual IntVarArgs cost(void) const = 0;
2480 };
2481
2482#ifdef GECODE_HAS_FLOAT_VARS
2483
2493 class GECODE_VTABLE_EXPORT FloatMinimizeSpace : public Space {
2494 protected:
2496 FloatNum step;
2497 public:
2499 FloatMinimizeSpace(FloatNum s=0.0);
2501 FloatMinimizeSpace(FloatMinimizeSpace& s);
2503 GECODE_MINIMODEL_EXPORT
2504 virtual void constrain(const Space& best);
2506 virtual FloatVar cost(void) const = 0;
2507 };
2508
2518 class GECODE_VTABLE_EXPORT FloatMaximizeSpace : public Space {
2519 protected:
2521 FloatNum step;
2522 public:
2524 FloatMaximizeSpace(FloatNum s=0.0);
2526 FloatMaximizeSpace(FloatMaximizeSpace& s);
2528 GECODE_MINIMODEL_EXPORT
2529 virtual void constrain(const Space& best);
2531 virtual FloatVar cost(void) const = 0;
2532 };
2533
2534#endif
2535
2536}
2537
2538#include <gecode/minimodel/optimize.hpp>
2539
2540#endif
2541
2542// IFDEF: GECODE_HAS_INT_VARS
2543// STATISTICS: minimodel-any
Gecode::ArrayTraits
Traits of arrays in Gecode.
Definition array.hpp:94
Gecode::BoolExpr::Misc
Miscealloneous Boolean expressions.
Definition minimodel.hh:1367
Gecode::BoolExpr::Misc::Misc
Misc(void)
Default constructor.
Definition bool-expr.hpp:42
Gecode::BoolExpr::Misc::post
virtual void post(Home home, BoolVar b, bool neg, const IntPropLevels &ipls)=0
Gecode::BoolExpr::Node
Node for Boolean expression
Definition bool-expr.cpp:49
Gecode::BoolExpr
Boolean expressions.
Definition minimodel.hh:1352
Gecode::BoolExpr::operator||
friend BoolExpr operator||(const BoolExpr &, const BoolExpr &)
Definition bool-expr.cpp:624
Gecode::BoolExpr::operator&&
friend BoolExpr operator&&(const BoolExpr &, const BoolExpr &)
Definition bool-expr.cpp:620
Gecode::BoolExpr::NodeType
NodeType
Type of Boolean expression.
Definition minimodel.hh:1355
Gecode::BoolExpr::NT_RLINFLOAT
@ NT_RLINFLOAT
Reified linear relation.
Definition minimodel.hh:1362
Gecode::BoolExpr::NT_AND
@ NT_AND
Conjunction.
Definition minimodel.hh:1358
Gecode::BoolExpr::NT_EQV
@ NT_EQV
Equivalence.
Definition minimodel.hh:1360
Gecode::BoolExpr::NT_RLIN
@ NT_RLIN
Reified linear relation.
Definition minimodel.hh:1361
Gecode::BoolExpr::NT_VAR
@ NT_VAR
Variable.
Definition minimodel.hh:1356
Gecode::BoolExpr::NT_OR
@ NT_OR
Disjunction.
Definition minimodel.hh:1359
Gecode::BoolExpr::NT_MISC
@ NT_MISC
Other Boolean expression.
Definition minimodel.hh:1364
Gecode::BoolExpr::NT_NOT
@ NT_NOT
Negation.
Definition minimodel.hh:1357
Gecode::BoolExpr::NT_RSET
@ NT_RSET
Reified set relation.
Definition minimodel.hh:1363
Gecode::BoolExpr::operator=
const BoolExpr & operator=(const BoolExpr &e)
Assignment operator.
Definition bool-expr.cpp:237
Gecode::BoolExpr::expr
BoolVar expr(Home home, const IntPropLevels &ipls) const
Post propagators for expression.
Definition bool-expr.cpp:607
Gecode::BoolExpr::~BoolExpr
~BoolExpr(void)
Destructor.
Definition bool-expr.cpp:249
Gecode::BoolExpr::rel
void rel(Home home, const IntPropLevels &ipls) const
Post propagators for relation.
Definition bool-expr.cpp:613
Gecode::BoolVarArgs
Passing Boolean variables.
Definition int.hh:738
Gecode::BoolVar
Boolean integer variables.
Definition int.hh:533
Gecode::DFA
Deterministic finite automaton (DFA).
Definition int.hh:2203
Gecode::FloatMaximizeSpace::constrain
virtual void constrain(const Space &best)
Member function constraining according to cost.
Definition optimize.cpp:97
Gecode::FloatMaximizeSpace::step
FloatNum step
Step by which a next solution has to have lower cost.
Definition minimodel.hh:2521
Gecode::FloatMaximizeSpace::cost
virtual FloatVar cost(void) const =0
Return variable with current cost.
Gecode::FloatMaximizeSpace::FloatMaximizeSpace
FloatMaximizeSpace(FloatNum s=0.0)
Constructor with step s.
Definition optimize.hpp:80
Gecode::FloatMinimizeSpace::cost
virtual FloatVar cost(void) const =0
Return variable with current cost.
Gecode::FloatMinimizeSpace::constrain
virtual void constrain(const Space &best)
Member function constraining according to cost.
Definition optimize.cpp:87
Gecode::FloatMinimizeSpace::FloatMinimizeSpace
FloatMinimizeSpace(FloatNum s=0.0)
Constructor with step s.
Definition optimize.hpp:71
Gecode::FloatMinimizeSpace::step
FloatNum step
Step by which a next solution has to have lower cost.
Definition minimodel.hh:2496
Gecode::FloatValArgs
Passing float arguments.
Definition float.hh:953
Gecode::FloatVal
Float value type.
Definition float.hh:334
Gecode::FloatVarArgs
Passing float variables.
Definition float.hh:982
Gecode::FloatVar
Float variables.
Definition float.hh:870
Gecode::HeapAllocated
Base class for heap allocated objects.
Definition heap.hpp:344
Gecode::Home
Home class for posting propagators
Definition core.hpp:863
Gecode::IntArgs
Passing integer arguments.
Definition int.hh:652
Gecode::IntLexMaximizeSpace::cost
virtual IntVarArgs cost(void) const =0
Return variables with current costs.
Gecode::IntLexMaximizeSpace::IntLexMaximizeSpace
IntLexMaximizeSpace(void)
Default constructor.
Definition optimize.hpp:61
Gecode::IntLexMaximizeSpace::constrain
virtual void constrain(const Space &best)
Member function constraining according to increasing costs.
Definition optimize.cpp:72
Gecode::IntLexMinimizeSpace::cost
virtual IntVarArgs cost(void) const =0
Return variables with current costs.
Gecode::IntLexMinimizeSpace::constrain
virtual void constrain(const Space &best)
Member function constraining according to decreasing costs.
Definition optimize.cpp:59
Gecode::IntLexMinimizeSpace::IntLexMinimizeSpace
IntLexMinimizeSpace(void)
Default constructor.
Definition optimize.hpp:53
Gecode::IntMaximizeSpace::cost
virtual IntVar cost(void) const =0
Return variable with current cost.
Gecode::IntMaximizeSpace::IntMaximizeSpace
IntMaximizeSpace(void)
Default constructor.
Definition optimize.hpp:45
Gecode::IntMaximizeSpace::constrain
virtual void constrain(const Space &best)
Member function constraining according to increasing cost.
Definition optimize.cpp:49
Gecode::IntMinimizeSpace::cost
virtual IntVar cost(void) const =0
Return variable with current cost.
Gecode::IntMinimizeSpace::IntMinimizeSpace
IntMinimizeSpace(void)
Default constructor.
Definition optimize.hpp:37
Gecode::IntMinimizeSpace::constrain
virtual void constrain(const Space &best)
Member function constraining according to decreasing cost.
Definition optimize.cpp:39
Gecode::IntPropLevels
Class for specifying integer propagation levels used by minimodel.
Definition minimodel.hh:109
Gecode::IntPropLevels::_linear
IntPropLevel _linear
For n-ary linear.
Definition minimodel.hh:112
Gecode::IntPropLevels::div
IntPropLevel div(void) const
Return integer propagation level for division constraints.
Definition ipl.hpp:114
Gecode::IntPropLevels::element
IntPropLevel element(void) const
Return integer propagation level for element constraints.
Definition ipl.hpp:164
Gecode::IntPropLevels::_sqr
IntPropLevel _sqr
For square.
Definition minimodel.hh:121
Gecode::IntPropLevels::mod
IntPropLevel mod(void) const
Return integer propagation level for modulo constraints.
Definition ipl.hpp:122
Gecode::IntPropLevels::linear
IntPropLevel linear(void) const
Return integer propagation level for non-binary linear constraints.
Definition ipl.hpp:55
Gecode::IntPropLevels::max2
IntPropLevel max2(void) const
Return integer propagation level for binary maximum constraints.
Definition ipl.hpp:73
Gecode::IntPropLevels::_mult
IntPropLevel _mult
For multiplication.
Definition minimodel.hh:118
Gecode::IntPropLevels::_mod
IntPropLevel _mod
For modulo.
Definition minimodel.hh:120
Gecode::IntPropLevels::ite
IntPropLevel ite(void) const
Return integer propagation level for if-then-else constraints.
Definition ipl.hpp:173
Gecode::IntPropLevels::mult
IntPropLevel mult(void) const
Return integer propagation level for multiplication constraints.
Definition ipl.hpp:106
Gecode::IntPropLevels::min
IntPropLevel min(void) const
Return integer propagation level for non-binary minimum constraints.
Definition ipl.hpp:97
Gecode::IntPropLevels::_sqrt
IntPropLevel _sqrt
For square root.
Definition minimodel.hh:122
Gecode::IntPropLevels::_ite
IntPropLevel _ite
For if-then-else.
Definition minimodel.hh:126
Gecode::IntPropLevels::nroot
IntPropLevel nroot(void) const
Return integer propagation level for root constraints.
Definition ipl.hpp:155
Gecode::IntPropLevels::abs
IntPropLevel abs(void) const
Return integer propagation level for absolute value constraints.
Definition ipl.hpp:64
Gecode::IntPropLevels::_max
IntPropLevel _max
For n-ary maximum.
Definition minimodel.hh:115
Gecode::IntPropLevels::_nroot
IntPropLevel _nroot
For root.
Definition minimodel.hh:124
Gecode::IntPropLevels::_pow
IntPropLevel _pow
For power.
Definition minimodel.hh:123
Gecode::IntPropLevels::_element
IntPropLevel _element
For element.
Definition minimodel.hh:125
Gecode::IntPropLevels::_div
IntPropLevel _div
For division.
Definition minimodel.hh:119
Gecode::IntPropLevels::_abs
IntPropLevel _abs
For absolute value.
Definition minimodel.hh:113
Gecode::IntPropLevels::sqrt
IntPropLevel sqrt(void) const
Return integer propagation level for square root constraints.
Definition ipl.hpp:139
Gecode::IntPropLevels::IntPropLevels
IntPropLevels(IntPropLevel ipl=IPL_DEF)
Initialize with default propagation level.
Definition ipl.hpp:37
Gecode::IntPropLevels::def
static const IntPropLevels def
Default propagation levels for all constraints.
Definition minimodel.hh:205
Gecode::IntPropLevels::linear2
IntPropLevel linear2(void) const
Return integer propagation level for binary linear constraints.
Definition ipl.hpp:47
Gecode::IntPropLevels::min2
IntPropLevel min2(void) const
Return integer propagation level for binary minimum constraints.
Definition ipl.hpp:89
Gecode::IntPropLevels::_min2
IntPropLevel _min2
For binary minimum.
Definition minimodel.hh:116
Gecode::IntPropLevels::pow
IntPropLevel pow(void) const
Return integer propagation level for power constraints.
Definition ipl.hpp:147
Gecode::IntPropLevels::_min
IntPropLevel _min
For minimum.
Definition minimodel.hh:117
Gecode::IntPropLevels::_linear2
IntPropLevel _linear2
For binary linear.
Definition minimodel.hh:111
Gecode::IntPropLevels::_max2
IntPropLevel _max2
For binary maximum.
Definition minimodel.hh:114
Gecode::IntPropLevels::max
IntPropLevel max(void) const
Return integer propagation level for non-binary maximum constraints.
Definition ipl.hpp:81
Gecode::IntPropLevels::sqr
IntPropLevel sqr(void) const
Return integer propagation level for square constraints.
Definition ipl.hpp:131
Gecode::IntSet
Integer sets.
Definition int.hh:178
Gecode::IntVarArgs
Passing integer variables.
Definition int.hh:680
Gecode::IntVar
Integer variables.
Definition int.hh:389
Gecode::LinFloatExpr
Float expressions
Definition minimodel.hh:845
Gecode::LinFloatExpr::LinFloatRel
friend class LinFloatRel
Definition minimodel.hh:846
Gecode::LinFloatExpr::nlfe
NonLinFloatExpr * nlfe(void) const
Return non-linear expression inside, or null if not non-linear.
Definition float-expr.cpp:138
Gecode::LinFloatExpr::LinFloatExpr
LinFloatExpr(void)
Default constructor.
Definition float-expr.cpp:226
Gecode::LinFloatExpr::operator=
const LinFloatExpr & operator=(const LinFloatExpr &e)
Assignment operator.
Definition float-expr.cpp:328
Gecode::LinFloatExpr::~LinFloatExpr
~LinFloatExpr(void)
Destructor.
Definition float-expr.cpp:337
Gecode::LinFloatExpr::post
void post(Home home, FloatRelType frt) const
Post propagator.
Definition float-expr.cpp:152
Gecode::LinFloatExpr::NodeType
NodeType
Type of linear expression.
Definition minimodel.hh:849
Gecode::LinFloatExpr::NT_VAR
@ NT_VAR
Linear term with variable.
Definition minimodel.hh:851
Gecode::LinFloatExpr::NT_CONST
@ NT_CONST
Float value constant.
Definition minimodel.hh:850
Gecode::LinFloatExpr::NT_SUM
@ NT_SUM
Sum of float variables.
Definition minimodel.hh:853
Gecode::LinFloatExpr::NT_NONLIN
@ NT_NONLIN
Non-linear expression.
Definition minimodel.hh:852
Gecode::LinFloatExpr::NT_ADD
@ NT_ADD
Addition of linear terms.
Definition minimodel.hh:854
Gecode::LinFloatExpr::NT_MUL
@ NT_MUL
Multiplication by coefficient.
Definition minimodel.hh:856
Gecode::LinFloatExpr::NT_SUB
@ NT_SUB
Subtraction of linear terms.
Definition minimodel.hh:855
Gecode::LinFloatRel
Linear relations.
Definition minimodel.hh:919
Gecode::LinFloatRel::post
void post(Home home, bool t) const
Post propagator for relation (if t is false for negated relation).
Definition float-rel.hpp:72
Gecode::LinFloatRel::BoolExpr
friend class BoolExpr
Definition minimodel.hh:920
Gecode::LinIntExpr
Linear expressions over integer variables.
Definition minimodel.hh:257
Gecode::LinIntExpr::NodeType
NodeType
Type of linear expression.
Definition minimodel.hh:268
Gecode::LinIntExpr::NT_CONST
@ NT_CONST
Integer constant.
Definition minimodel.hh:269
Gecode::LinIntExpr::NT_SUB
@ NT_SUB
Subtraction of linear terms.
Definition minimodel.hh:276
Gecode::LinIntExpr::NT_SUM_BOOL
@ NT_SUM_BOOL
Sum of Boolean variables.
Definition minimodel.hh:274
Gecode::LinIntExpr::NT_ADD
@ NT_ADD
Addition of linear terms.
Definition minimodel.hh:275
Gecode::LinIntExpr::NT_SUM_INT
@ NT_SUM_INT
Sum of integer variables.
Definition minimodel.hh:273
Gecode::LinIntExpr::NT_VAR_BOOL
@ NT_VAR_BOOL
Linear term with Boolean variable.
Definition minimodel.hh:271
Gecode::LinIntExpr::NT_MUL
@ NT_MUL
Multiplication by coefficient.
Definition minimodel.hh:277
Gecode::LinIntExpr::NT_NONLIN
@ NT_NONLIN
Non-linear expression.
Definition minimodel.hh:272
Gecode::LinIntExpr::NT_VAR_INT
@ NT_VAR_INT
Linear term with integer variable.
Definition minimodel.hh:270
Gecode::LinIntExpr::LinIntExpr
LinIntExpr(void)
Default constructor.
Definition int-expr.cpp:401
Gecode::LinIntExpr::LinFloatExpr
friend class LinFloatExpr
Definition minimodel.hh:264
Gecode::LinIntExpr::~LinIntExpr
~LinIntExpr(void)
Destructor.
Definition int-expr.cpp:587
Gecode::LinIntExpr::post
void post(Home home, IntRelType irt, const IntPropLevels &ipls) const
Post propagator.
Definition int-expr.cpp:191
Gecode::LinIntExpr::operator=
const LinIntExpr & operator=(const LinIntExpr &e)
Assignment operator.
Definition int-expr.cpp:576
Gecode::LinIntExpr::nle
NonLinIntExpr * nle(void) const
Return non-linear expression inside, or null if not non-linear.
Definition int-expr.cpp:394
Gecode::LinIntExpr::LinIntRel
friend class LinIntRel
Definition minimodel.hh:258
Gecode::LinIntExpr::SetExpr
friend class SetExpr
Definition minimodel.hh:261
Gecode::LinIntRel
Linear relations over integer variables.
Definition minimodel.hh:358
Gecode::LinIntRel::post
void post(Home home, bool t, const IntPropLevels &ipls) const
Post propagator for relation (if t is false for negated relation).
Definition int-rel.hpp:70
Gecode::LinIntRel::BoolExpr
friend class BoolExpr
Definition minimodel.hh:359
Gecode::Matrix
Matrix-interface for arrays.
Definition minimodel.hh:2208
Gecode::Matrix::width
int width(void) const
Return the width of the matrix.
Definition matrix.hpp:143
Gecode::Matrix::operator()
ValueType & operator()(int c, int r)
Access element (c, r) of the matrix.
Definition matrix.hpp:155
Gecode::Matrix::slice
Slice< A > slice(int fc, int tc, int fr, int tr) const
Access slice of the matrix.
Definition matrix.hpp:171
Gecode::Matrix::col
Slice< A > col(int c) const
Access column c.
Definition matrix.hpp:183
Gecode::Matrix::ValueType
ArrayTraits< A >::ValueType ValueType
The type of elements of this array.
Definition minimodel.hh:2211
Gecode::Matrix::row
Slice< A > row(int r) const
Access row r.
Definition matrix.hpp:177
Gecode::Matrix::get_array
ArgsType const get_array(void) const
Return an Args-array of the contents of the matrix.
Definition matrix.hpp:149
Gecode::Matrix::Matrix
Matrix(A a, int w, int h)
Basic constructor.
Definition matrix.hpp:127
Gecode::Matrix::ArgsType
ArrayTraits< A >::ArgsType ArgsType
The type of the Args-array type for ValueType values.
Definition minimodel.hh:2213
Gecode::Matrix::height
int height(void) const
Return the height of the matrix.
Definition matrix.hpp:146
Gecode::MiniModel::ArithNonLinIntExpr
Non-linear arithmetic expressions over integer variables.
Definition int-arith.cpp:45
Gecode::MiniModel::ExpInfo
Expression information.
Definition reg.cpp:535
Gecode::NonLinFloatExpr
Base class for non-linear float expressions.
Definition minimodel.hh:817
Gecode::NonLinFloatExpr::post
virtual void post(Home home, FloatRelType frt, FloatVal c) const =0
Post expression to be in relation frt with c.
Gecode::NonLinFloatExpr::result
static FloatVar result(Home home, FloatVar *x)
Return fresh variable if x is null, x otherwise.
Definition float-expr.hpp:40
Gecode::NonLinFloatExpr::~NonLinFloatExpr
virtual ~NonLinFloatExpr(void)
Destructor.
Definition float-expr.hpp:37
Gecode::NonLinFloatExpr::post
virtual void post(Home home, FloatRelType frt, FloatVal c, BoolVar b) const =0
Post reified expression to be in relation frt with c.
Gecode::NonLinFloatExpr::post
virtual FloatVar post(Home home, FloatVar *ret) const =0
Return variable constrained to be equal to the expression.
Gecode::NonLinIntExpr
Base class for non-linear expressions over integer variables.
Definition minimodel.hh:223
Gecode::NonLinIntExpr::post
virtual void post(Home home, IntRelType irt, int c, BoolVar b, const IntPropLevels &ipls) const =0
Post reified expression to be in relation irt with c.
Gecode::NonLinIntExpr::result
static IntVar result(Home home, IntVar *x)
Return fresh variable if x is null, x otherwise.
Definition int-expr.hpp:40
Gecode::NonLinIntExpr::post
virtual void post(Home home, IntRelType irt, int c, const IntPropLevels &ipls) const =0
Post expression to be in relation irt with c.
Gecode::NonLinIntExpr::post
virtual IntVar post(Home home, IntVar *ret, const IntPropLevels &ipls) const =0
Return variable constrained to be equal to the expression.
Gecode::NonLinIntExpr::~NonLinIntExpr
virtual ~NonLinIntExpr(void)
Destructor.
Definition int-expr.hpp:37
Gecode::REG::Exp
Implementation of the actual expression tree.
Definition reg.cpp:52
Gecode::REG
Regular expressions over integer values.
Definition minimodel.hh:1672
Gecode::SetCmpRel
Comparison relation (for two-sided comparisons).
Definition minimodel.hh:1244
Gecode::SetCmpRel::srt
SetRelType srt
Which relation.
Definition minimodel.hh:1251
Gecode::SetCmpRel::l
SetExpr l
Left side of relation.
Definition minimodel.hh:1247
Gecode::SetCmpRel::r
SetExpr r
Right side of relation.
Definition minimodel.hh:1249
Gecode::SetCmpRel::SetCmpRel
SetCmpRel(const SetExpr &l, SetRelType srt, const SetExpr &r)
Constructor.
Definition set-rel.hpp:43
Gecode::SetExpr
Set expressions
Definition minimodel.hh:1187
Gecode::SetExpr::SetExpr
SetExpr(void)
Default constructor.
Definition set-expr.hpp:44
Gecode::SetExpr::post
SetVar post(Home home) const
Post propagators for expression.
Definition set-expr.cpp:649
Gecode::SetExpr::~SetExpr
~SetExpr(void)
Destructor.
Definition set-expr.cpp:639
Gecode::SetExpr::NodeType
NodeType
Type of set expression.
Definition minimodel.hh:1190
Gecode::SetExpr::NT_CMPL
@ NT_CMPL
Complement.
Definition minimodel.hh:1194
Gecode::SetExpr::NT_INTER
@ NT_INTER
Intersection.
Definition minimodel.hh:1195
Gecode::SetExpr::NT_DUNION
@ NT_DUNION
Disjoint union.
Definition minimodel.hh:1197
Gecode::SetExpr::NT_VAR
@ NT_VAR
Variable.
Definition minimodel.hh:1191
Gecode::SetExpr::NT_LEXP
@ NT_LEXP
Linear expression.
Definition minimodel.hh:1193
Gecode::SetExpr::NT_CONST
@ NT_CONST
Constant.
Definition minimodel.hh:1192
Gecode::SetExpr::operator=
const SetExpr & operator=(const SetExpr &e)
Assignment operator.
Definition set-expr.cpp:629
Gecode::SetRel
Set relations
Definition minimodel.hh:1257
Gecode::SetRel::post
void post(Home home, bool t) const
Post propagators for relation (or negated relation if t is false).
Definition set-rel.hpp:58
Gecode::SetRel::SetRel
SetRel(void)
Default constructor.
Definition set-rel.hpp:47
Gecode::SetVarArgs
Passing set variables.
Definition set.hh:491
Gecode::SetVar
Set variables
Definition set.hh:127
Gecode::Slice
A slice of a matrix.
Definition minimodel.hh:2144
Gecode::Slice::Slice
Slice(const Matrix< A > &a, int fc, int tc, int fr, int tr)
Construct slice.
Definition matrix.hpp:43
Gecode::Slice::reverse
Slice & reverse(void)
Reverses the contents of the slice, and returns a reference to it.
Definition matrix.hpp:62
Gecode::Slice::ArgsType
ArrayTraits< A >::ArgsType ArgsType
The type of the Args-array type for ValueType values.
Definition minimodel.hh:2147
Gecode::SymmetryHandle
A reference-counted pointer to a SymmetryObject.
Definition int.hh:5601
Gecode::rel
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1)
Post propagator for .
Definition rel.cpp:68
Gecode::ite
void ite(Home home, BoolVar b, FloatVar x, FloatVar y, FloatVar z)
Post propagator for if-then-else constraint.
Definition bool.cpp:39
Gecode::FloatNum
double FloatNum
Floating point number base type.
Definition float.hh:106
Gecode::FloatRelType
FloatRelType
Relation types for floats.
Definition float.hh:1075
Gecode::IntRelType
IntRelType
Relation types for integers.
Definition int.hh:959
Gecode::IntPropLevel
IntPropLevel
Propagation levels for integer propagators.
Definition int.hh:1008
Gecode::IPL_BITS_
@ IPL_BITS_
Number of bits required (internal).
Definition int.hh:1019
Gecode::IPL_DEF
@ IPL_DEF
Simple propagation levels.
Definition int.hh:1010
Gecode::Space::Space
Space(void)
Default constructor.
Definition core.cpp:121
Gecode::SetRelType
SetRelType
Common relation types for sets.
Definition set.hh:650
print
void print(const Search::Statistics &stat, bool restart)
Print statistics.
Definition job-shop.cpp:606
GECODE_MINIMODEL_EXPORT
#define GECODE_MINIMODEL_EXPORT
Definition minimodel.hh:86
Gecode::MiniModel
Minimalistic modeling support.
Definition minimodel.hh:100
Gecode
Gecode toplevel namespace
Gecode::operator/
FloatVal operator/(const FloatVal &x, const FloatVal &y)
Definition val.hpp:230
Gecode::lex
void lex(Home home, const IntVarArgs &x, IntRelType r, const IntVarArgs &y, IntPropLevel ipl=IPL_DEF)
Post lexical order between x and y.
Definition aliases.hpp:132
Gecode::operator-
FloatVal operator-(const FloatVal &x)
Definition val.hpp:185
Gecode::operator<=
bool operator<=(const FloatVal &x, const FloatVal &y)
Definition val.hpp:260
Gecode::sin
void sin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition trigonometric.cpp:52
Gecode::operator+
FloatVal operator+(const FloatVal &x)
Definition val.hpp:181
Gecode::rows_reflect
SymmetryHandle rows_reflect(const Matrix< A > &m)
Reflect rows symmetry specification.
Definition ldsb.hpp:62
Gecode::channel
void channel(Home home, FloatVar x0, IntVar x1)
Post propagator for channeling a float and an integer variable .
Definition channel.cpp:41
Gecode::atmost
void atmost(Home home, const IntVarArgs &x, int n, int m, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition aliases.hpp:39
Gecode::operator||
SetRel operator||(const SetExpr &, const SetExpr &)
Disjointness of set expressions.
Definition set-rel.cpp:71
Gecode::sqr
void sqr(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition arithmetic.cpp:95
Gecode::expr
IntVar expr(Home home, const LinIntExpr &e, const IntPropLevels &ipls=IntPropLevels::def)
Post linear expression and return its value.
Definition int-expr.cpp:988
Gecode::operator&
SetExpr operator&(const SetExpr &, const SetExpr &)
Intersection of set expressions.
Definition set-expr.cpp:671
Gecode::operator<<
Archive & operator<<(Archive &e, FloatNumBranch nl)
Definition val-sel.hpp:39
Gecode::atleast
void atleast(Home home, const IntVarArgs &x, int n, int m, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition aliases.hpp:70
Gecode::cos
void cos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition trigonometric.cpp:66
Gecode::min
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition arithmetic.cpp:67
Gecode::neg
IntRelType neg(IntRelType irt)
Return negated relation type of irt.
Definition irt.hpp:52
Gecode::dom
void dom(Home home, FloatVar x, FloatVal n)
Propagates .
Definition dom.cpp:40
Gecode::abs
void abs(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition arithmetic.cpp:41
Gecode::operator<
bool operator<(const FloatVal &x, const FloatVal &y)
Definition val.hpp:243
Gecode::element
void element(Home home, IntSharedArray n, IntVar x0, IntVar x1, IntPropLevel ipl=IPL_DEF)
Post domain consistent propagator for .
Definition element.cpp:39
Gecode::inter
SetExpr inter(const SetVarArgs &)
Intersection of set variables.
Definition set-expr.cpp:696
Gecode::operator!
BoolExpr operator!(const BoolExpr &)
Negated Boolean expression.
Definition bool-expr.cpp:633
Gecode::operator^
BoolExpr operator^(const BoolExpr &, const BoolExpr &)
Exclusive-or of Boolean expressions.
Definition bool-expr.cpp:628
Gecode::range
void range(Home home, const IntVarArgs &x, SetVar y, SetVar z)
Post constraint .
Definition aliases.hpp:158
Gecode::roots
void roots(Home home, const IntVarArgs &x, SetVar y, SetVar z)
Post constraint .
Definition aliases.hpp:163
Gecode::sqrt
void sqrt(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition arithmetic.cpp:102
Gecode::values
void values(Home home, const IntVarArgs &x, IntSet y, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition aliases.hpp:143
Gecode::acos
void acos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition trigonometric.cpp:59
Gecode::columns_reflect
SymmetryHandle columns_reflect(const Matrix< A > &m)
Reflect columns symmetry specification.
Definition ldsb.hpp:85
Gecode::operator>
bool operator>(const FloatVal &x, const FloatVal &y)
Definition val.hpp:277
Gecode::log
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition transcendental.cpp:53
Gecode::operator>=
bool operator>=(const FloatVal &x, const FloatVal &y)
Definition val.hpp:294
Gecode::setdunion
SetExpr setdunion(const SetVarArgs &)
Disjoint union of set variables.
Definition set-expr.cpp:714
Gecode::rows_interchange
SymmetryHandle rows_interchange(const Matrix< A > &m)
Interchangeable rows symmetry specification.
Definition ldsb.hpp:40
Gecode::sum
LinIntExpr sum(const IntVarArgs &x)
Construct linear expression as sum of integer variables.
Definition int-expr.cpp:953
Gecode::exactly
void exactly(Home home, const IntVarArgs &x, int n, int m, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition aliases.hpp:101
Gecode::setunion
SetExpr setunion(const SetVarArgs &)
Union of set variables.
Definition set-expr.cpp:705
Gecode::singleton
SetExpr singleton(const LinIntExpr &)
Singleton expression.
Definition set-expr.cpp:691
Gecode::exp
void exp(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition transcendental.cpp:45
Gecode::atan
void atan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition trigonometric.cpp:73
Gecode::max
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition arithmetic.cpp:49
Gecode::operator>>
Archive & operator>>(Archive &e, FloatNumBranch &nl)
Definition val-sel.hpp:44
Gecode::operator&&
BoolExpr operator&&(const BoolExpr &, const BoolExpr &)
Definition bool-expr.cpp:620
Gecode::asin
void asin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition trigonometric.cpp:45
Gecode::operator|
SetExpr operator|(const SetExpr &, const SetExpr &)
Union of set expressions.
Definition set-expr.cpp:675
Gecode::pow
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for .
Definition arithmetic.cpp:109
Gecode::cardinality
LinIntExpr cardinality(const SetExpr &)
Cardinality of set expression.
Definition set-expr.cpp:817
Gecode::operator*
FloatVal operator*(const FloatVal &x, const FloatVal &y)
Definition val.hpp:217
Gecode::diagonal_reflect
SymmetryHandle diagonal_reflect(const Matrix< A > &m)
Reflect around main diagonal symmetry specification.
Definition ldsb.hpp:108
Gecode::nroot
void nroot(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for .
Definition arithmetic.cpp:118
Gecode::operator==
bool operator==(const FloatVal &x, const FloatVal &y)
Definition val.hpp:311
Gecode::operator%
LinIntExpr operator%(const LinIntExpr &x, const LinIntExpr &y)
Return expression for .
Definition int-arith.cpp:516
Gecode::operator!=
bool operator!=(const FloatVal &x, const FloatVal &y)
Definition val.hpp:334
Gecode::columns_interchange
SymmetryHandle columns_interchange(const Matrix< A > &m)
Interchangeable columns symmetry specification.
Definition ldsb.hpp:51
Gecode::tan
void tan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition trigonometric.cpp:80
GECODE_VTABLE_EXPORT
#define GECODE_VTABLE_EXPORT
Definition support.hh:76