Generated on for Gecode by doxygen 1.17.0
cumulative.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 *
7 * Copyright:
8 * Christian Schulte, 2009
9 * Guido Tack, 2010
10 *
11 * This file is part of Gecode, the generic constraint
12 * development environment:
13 * http://www.gecode.dev
14 *
15 * Permission is hereby granted, free of charge, to any person obtaining
16 * a copy of this software and associated documentation files (the
17 * "Software"), to deal in the Software without restriction, including
18 * without limitation the rights to use, copy, modify, merge, publish,
19 * distribute, sublicense, and/or sell copies of the Software, and to
20 * permit persons to whom the Software is furnished to do so, subject to
21 * the following conditions:
22 *
23 * The above copyright notice and this permission notice shall be
24 * included in all copies or substantial portions of the Software.
25 *
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
30 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
31 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
32 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
33 *
34 */
35
36#ifndef GECODE_INT_CUMULATIVE_HH
37#define GECODE_INT_CUMULATIVE_HH
38
39#include <gecode/int/task.hh>
40#include <gecode/int/unary.hh>
41
56
57namespace Gecode { namespace Int { namespace Cumulative {
58
60 void mul_check(long long int x, long long int y);
61
63 void mul_check(long long int x, long long int y, long long int z);
64
65}}}
66
68
69namespace Gecode { namespace Int { namespace Cumulative {
70
73 protected:
75 int _c;
76 public:
78
79
80 ManFixPTask(void);
82 ManFixPTask(IntVar s, int p, int c);
84 void init(IntVar s, int p, int c);
86 void init(const ManFixPTask& t);
88
90
91
92 int c(void) const;
94 long long int e(void) const;
96
98
99
100 void update(Space& home, ManFixPTask& t);
102
103 };
104
109 template<class Char, class Traits>
110 std::basic_ostream<Char,Traits>&
111 operator <<(std::basic_ostream<Char,Traits>& os, const ManFixPTask& t);
112
115 protected:
117 int _c;
118 public:
120
121
122 ManFixPSETask(void);
130 ManFixPSETask(TaskType t, IntVar s, int p, int c);
138 void init(TaskType t, IntVar s, int p, int c);
140 void init(const ManFixPSETask& t);
142
144
145
146 int c(void) const;
148 long long int e(void) const;
150
152
153
154 void update(Space& home, ManFixPSETask& t);
156
157 };
158
163 template<class Char, class Traits>
164 std::basic_ostream<Char,Traits>&
165 operator <<(std::basic_ostream<Char,Traits>& os, const ManFixPSETask& t);
166
169 protected:
171 int _c;
172 public:
174
175
176 ManFlexTask(void);
178 ManFlexTask(IntVar s, IntVar p, IntVar e, int c);
180 void init(IntVar s, IntVar p, IntVar e, int c);
182 void init(const ManFlexTask& t);
184
186
187
188 int c(void) const;
190 long long int e(void) const;
192
194
195
196 void update(Space& home, ManFlexTask& t);
198
199 };
200
205 template<class Char, class Traits>
206 std::basic_ostream<Char,Traits>&
207 operator <<(std::basic_ostream<Char,Traits>& os, const ManFlexTask& t);
208
209
211 class OptFixPTask : public ManToOptTask<ManFixPTask> {
212 protected:
214 public:
216
217
218 OptFixPTask(void);
220 OptFixPTask(IntVar s, int p, int c, BoolVar m);
222 void init(IntVar s, int p, int c, BoolVar m);
224
225 operator Unary::OptFixPTask (void);
226 };
227
232 template<class Char, class Traits>
233 std::basic_ostream<Char,Traits>&
234 operator <<(std::basic_ostream<Char,Traits>& os, const OptFixPTask& t);
235
237 class OptFixPSETask : public ManToOptTask<ManFixPSETask> {
238 protected:
240 public:
242
243
244 OptFixPSETask(void);
246 OptFixPSETask(TaskType t, IntVar s, int p, int c, BoolVar m);
248 void init(TaskType t, IntVar s, int p, int c, BoolVar m);
250
251 operator Unary::OptFixPSETask (void);
252 };
253
258 template<class Char, class Traits>
259 std::basic_ostream<Char,Traits>&
260 operator <<(std::basic_ostream<Char,Traits>& os, const OptFixPSETask& t);
261
263 class OptFlexTask : public ManToOptTask<ManFlexTask> {
264 protected:
266 public:
268
269
270 OptFlexTask(void);
272 OptFlexTask(IntVar s, IntVar p, IntVar e, int c, BoolVar m);
274 void init(IntVar s, IntVar p, IntVar e, int c, BoolVar m);
276
277 operator Unary::OptFlexTask (void);
278 };
279
284 template<class Char, class Traits>
285 std::basic_ostream<Char,Traits>&
286 operator <<(std::basic_ostream<Char,Traits>& os, const OptFlexTask& t);
287
288}}}
289
291
292namespace Gecode { namespace Int { namespace Cumulative {
293
296
299
302
305
308
311
314
317
320
323
326
329
330
335 template<class Char, class Traits>
336 std::basic_ostream<Char,Traits>&
337 operator <<(std::basic_ostream<Char,Traits>& os, const ManFixPTaskBwd& t);
338
343 template<class Char, class Traits>
344 std::basic_ostream<Char,Traits>&
345 operator <<(std::basic_ostream<Char,Traits>& os, const ManFixPSETaskBwd& t);
346
351 template<class Char, class Traits>
352 std::basic_ostream<Char,Traits>&
353 operator <<(std::basic_ostream<Char,Traits>& os, const OptFixPTaskBwd& t);
354
359 template<class Char, class Traits>
360 std::basic_ostream<Char,Traits>&
361 operator <<(std::basic_ostream<Char,Traits>& os, const OptFixPSETaskBwd& t);
362
363}}}
364
366
367namespace Gecode { namespace Int {
368
370 template<>
371 class TaskViewTraits<Cumulative::ManFixPTaskFwd> {
372 public:
375 };
376
378 template<>
379 class TaskViewTraits<Cumulative::ManFixPTaskBwd> {
380 public:
383 };
384
386 template<>
387 class TaskViewTraits<Cumulative::ManFixPSETaskFwd> {
388 public:
391 };
392
394 template<>
395 class TaskViewTraits<Cumulative::ManFixPSETaskBwd> {
396 public:
399 };
400
402 template<>
403 class TaskViewTraits<Cumulative::OptFixPTaskFwd> {
404 public:
407 };
408
410 template<>
411 class TaskViewTraits<Cumulative::OptFixPTaskBwd> {
412 public:
415 };
416
418 template<>
419 class TaskViewTraits<Cumulative::OptFixPSETaskFwd> {
420 public:
423 };
424
426 template<>
427 class TaskViewTraits<Cumulative::OptFixPSETaskBwd> {
428 public:
431 };
432
434 template<>
435 class TaskViewTraits<Cumulative::ManFlexTaskFwd> {
436 public:
439 };
440
442 template<>
443 class TaskViewTraits<Cumulative::ManFlexTaskBwd> {
444 public:
447 };
448
450 template<>
451 class TaskViewTraits<Cumulative::OptFlexTaskFwd> {
452 public:
455 };
456
458 template<>
459 class TaskViewTraits<Cumulative::OptFlexTaskBwd> {
460 public:
463 };
464
465
467 template<>
477
479 template<>
489
491 template<>
503
505 template<>
517
519 template<>
529
531 template<>
543
544}}
545
546namespace Gecode { namespace Int { namespace Cumulative {
547
549 class OmegaNode {
550 public:
552 long long int e;
554 long long int env;
556 void init(const OmegaNode& l, const OmegaNode& r);
558 void update(const OmegaNode& l, const OmegaNode& r);
559 };
560
562 template<class TaskView>
563 class OmegaTree : public TaskTree<TaskView,OmegaNode> {
564 protected:
565 using TaskTree<TaskView,OmegaNode>::tasks;
566 using TaskTree<TaskView,OmegaNode>::leaf;
567 using TaskTree<TaskView,OmegaNode>::root;
568 using TaskTree<TaskView,OmegaNode>::init;
569 using TaskTree<TaskView,OmegaNode>::update;
571 int c;
572 public:
574 OmegaTree(Region& r, int c, const TaskViewArray<TaskView>& t);
576 void insert(int i);
578 void remove(int i);
580 long long int env(void) const;
581 };
582
584 class ExtOmegaNode : public OmegaNode {
585 public:
587 long long int cenv;
589 void init(const ExtOmegaNode& l, const ExtOmegaNode& r);
591 void update(const ExtOmegaNode& l, const ExtOmegaNode& r);
592 };
593
595 template<class TaskView>
596 class ExtOmegaTree : public TaskTree<TaskView,ExtOmegaNode> {
597 protected:
598 using TaskTree<TaskView,ExtOmegaNode>::tasks;
599 using TaskTree<TaskView,ExtOmegaNode>::leaf;
600 using TaskTree<TaskView,ExtOmegaNode>::root;
601 using TaskTree<TaskView,ExtOmegaNode>::init;
602 using TaskTree<TaskView,ExtOmegaNode>::update;
603 using TaskTree<TaskView,ExtOmegaNode>::node;
604 using TaskTree<TaskView,ExtOmegaNode>::n_leaf;
605 using TaskTree<TaskView,ExtOmegaNode>::n_left;
606 using TaskTree<TaskView,ExtOmegaNode>::left;
607 using TaskTree<TaskView,ExtOmegaNode>::n_right;
608 using TaskTree<TaskView,ExtOmegaNode>::right;
609 using TaskTree<TaskView,ExtOmegaNode>::n_root;
610 using TaskTree<TaskView,ExtOmegaNode>::n_parent;
611 using TaskTree<TaskView,ExtOmegaNode>::n_nodes;
612 using TaskTree<TaskView,ExtOmegaNode>::_leaf;
614 int c, ci;
615 public:
617 template<class Node>
618 ExtOmegaTree(Region& r, int c, const TaskTree<TaskView,Node>& t);
620 void init(int ci);
622 long long int env(int i);
623 };
624
625
627 class OmegaLambdaNode : public OmegaNode {
628 public:
630 static const int undef = -1;
632 long long int le;
634 long long int lenv;
636 int resLe;
640 void init(const OmegaLambdaNode& l, const OmegaLambdaNode& r);
642 void update(const OmegaLambdaNode& l, const OmegaLambdaNode& r);
643 };
644
646 template<class TaskView>
647 class OmegaLambdaTree : public TaskTree<TaskView,OmegaLambdaNode> {
648 protected:
649 using TaskTree<TaskView,OmegaLambdaNode>::tasks;
650 using TaskTree<TaskView,OmegaLambdaNode>::leaf;
651 using TaskTree<TaskView,OmegaLambdaNode>::root;
652 using TaskTree<TaskView,OmegaLambdaNode>::init;
653 using TaskTree<TaskView,OmegaLambdaNode>::update;
655 int c;
656 public:
660 void shift(int i);
662 void lremove(int i);
664 bool lempty(void) const;
666 int responsible(void) const;
668 long long int env(void) const;
670 long long int lenv(void) const;
671 };
672
673}}}
674
676
677namespace Gecode { namespace Int { namespace Cumulative {
678
680 template<class Task>
682 subsumed(Space& home, Propagator& p, int c, TaskArray<Task>& t);
683
685 template<class ManTask>
686 ExecStatus overload(Space& home, int c, TaskArray<ManTask>& t);
687
689 template<class Task>
692 return ES_OK;
693 }
694 template<class Task> struct SupportsKnapsackOverload {
695 static const bool value = false;
696 };
698 static const bool value = true;
699 };
701 static const bool value = true;
702 };
704 static const bool value = true;
705 };
707 static const bool value = true;
708 };
717
719 template<class Task, class Cap>
720 ExecStatus timetabling(Space& home, Propagator& p, Cap c,
721 TaskArray<Task>& t);
722
724 template<class Task>
726
733 template<class ManTask, class Cap, class PL>
734 class ManProp : public TaskProp<ManTask,PL> {
735 protected:
736 using TaskProp<ManTask,PL>::t;
738 Cap c;
740 ManProp(Home home, Cap c, TaskArray<ManTask>& t);
742 ManProp(Space& home, ManProp& p);
743 public:
745 virtual PropCost cost(const Space& home,
746 const ModEventDelta& med) const;
748 virtual Actor* copy(Space& home);
750 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
752 static ExecStatus post(Home home, Cap c, TaskArray<ManTask>& t);
754 virtual size_t dispose(Space& home);
755 };
756
763 template<class OptTask, class Cap, class PL>
764 class OptProp : public TaskProp<OptTask,PL> {
765 protected:
766 using TaskProp<OptTask,PL>::t;
768 Cap c;
770 OptProp(Home home, Cap c, TaskArray<OptTask>& t);
772 OptProp(Space& home, OptProp& p);
773 public:
775 virtual PropCost cost(const Space& home,
776 const ModEventDelta& med) const;
778 virtual Actor* copy(Space& home);
780 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
782 static ExecStatus post(Home home, Cap c, TaskArray<OptTask>& t);
784 virtual size_t dispose(Space& home);
785 };
786
788 template<class ManTask, class Cap>
791
793 template<class OptTask, class Cap>
796
797}}}
798
807
808#endif
809
810// STATISTICS: int-prop
Boolean integer variables.
Definition int.hh:534
Home class for posting propagators
Definition core.hpp:863
Integer variables.
Definition int.hh:390
Node for an extended omega tree.
void update(const ExtOmegaNode &l, const ExtOmegaNode &r)
Update node from left child l and right child r.
Definition tree.hpp:98
void init(const ExtOmegaNode &l, const ExtOmegaNode &r)
Initialize node from left child l and right child r.
Definition tree.hpp:92
long long int cenv
Energy envelope for subtree.
long long int env(int i)
Compute update for task with index i.
Definition tree.hpp:120
ExtOmegaTree(Region &r, int c, const TaskTree< TaskView, Node > &t)
Initialize tree for tasks t and capacity c.
Definition tree.hpp:114
void init(int ci)
Initialize tasks for current capacity ci.
Definition tree.hpp:104
Cumulative (mandatory) task with fixed processing, start or end time.
void init(TaskType t, IntVar s, int p, int c)
Initialize task.
Definition task.hpp:89
long long int e(void) const
Return required energy.
Definition task.hpp:102
ManFixPSETask(void)
Default constructor.
Definition task.hpp:84
int c(void) const
Return required capacity.
Definition task.hpp:98
void update(Space &home, ManFixPSETask &t)
Update this task to be a clone of task t.
Definition task.hpp:107
Cumulative (mandatory) task with fixed processing time.
Definition cumulative.hh:72
void init(IntVar s, int p, int c)
Initialize task with start time s, processing time p, and required resource c.
Definition task.hpp:48
long long int e(void) const
Return required energy.
Definition task.hpp:61
ManFixPTask(void)
Default constructor.
Definition task.hpp:43
int c(void) const
Return required capacity.
Definition task.hpp:57
void update(Space &home, ManFixPTask &t)
Update this task to be a clone of task t.
Definition task.hpp:66
Cumulative (mandatory) task with flexible processing time.
void init(IntVar s, IntVar p, IntVar e, int c)
Initialize with start time s, processing time p, end time e.
Definition task.hpp:130
long long int e(void) const
Return required energy.
Definition task.hpp:143
void update(Space &home, ManFlexTask &t)
Update this task to be a clone of task t.
Definition task.hpp:148
ManFlexTask(void)
Default constructor.
Definition task.hpp:125
int c(void) const
Return required capacity.
Definition task.hpp:139
virtual PropCost cost(const Space &home, const ModEventDelta &med) const
Return propagation cost.
Definition man-prop.hpp:79
virtual Actor * copy(Space &home)
Perform copying during cloning.
Definition man-prop.hpp:90
virtual ExecStatus propagate(Space &home, const ModEventDelta &med)
Perform propagation.
Definition man-prop.hpp:104
virtual size_t dispose(Space &home)
Delete propagator and return its size.
Definition man-prop.hpp:96
static ExecStatus post(Home home, Cap c, TaskArray< ManTask > &t)
Post propagator that schedules tasks on cumulative resource.
Definition man-prop.hpp:54
ManProp(Home home, Cap c, TaskArray< ManTask > &t)
Constructor for creation.
Definition man-prop.hpp:40
Node for an omega lambda tree.
long long int le
Energy for subtree.
void init(const OmegaLambdaNode &l, const OmegaLambdaNode &r)
Initialize node from left child l and right child r.
Definition tree.hpp:174
void update(const OmegaLambdaNode &l, const OmegaLambdaNode &r)
Update node from left child l and right child r.
Definition tree.hpp:181
long long int lenv
Energy envelope for subtree.
int resLe
Node which is responsible for le.
static const int undef
Undefined task.
int resLenv
Node which is responsible for lenv.
int responsible(void) const
Return responsible task.
Definition tree.hpp:254
long long int lenv(void) const
Return energy envelope of all tasks excluding lambda tasks.
Definition tree.hpp:266
void shift(int i)
Shift task with index i from omega to lambda.
Definition tree.hpp:221
OmegaLambdaTree(Region &r, int c, const TaskViewArray< TaskView > &t)
Initialize tree for tasks t and capcity c with all tasks included in omega.
Definition tree.hpp:204
void lremove(int i)
Remove task with index i from lambda.
Definition tree.hpp:235
long long int env(void) const
Return energy envelope of all tasks.
Definition tree.hpp:260
bool lempty(void) const
Whether has responsible task.
Definition tree.hpp:248
Node for an omega tree.
void init(const OmegaNode &l, const OmegaNode &r)
Initialize node from left child l and right child r.
Definition tree.hpp:46
void update(const OmegaNode &l, const OmegaNode &r)
Update node from left child l and right child r.
Definition tree.hpp:51
long long int e
Energy for subtree.
long long int env
Energy envelope for subtree.
void remove(int i)
Remove task with index i.
Definition tree.hpp:76
OmegaTree(Region &r, int c, const TaskViewArray< TaskView > &t)
Initialize tree for tasks t and capacity c.
Definition tree.hpp:56
long long int env(void) const
Return energy envelope of all tasks.
Definition tree.hpp:83
void insert(int i)
Insert task with index i.
Definition tree.hpp:67
Cumulative optional task with fixed processing, start or end time.
void init(TaskType t, IntVar s, int p, int c, BoolVar m)
Initialize with start time s, processing time p, required capacity c, and mandatory flag m.
Definition task.hpp:202
OptFixPSETask(void)
Default constructor.
Definition task.hpp:196
Cumulative optional task with fixed processing time.
OptFixPTask(void)
Default constructor.
Definition task.hpp:167
void init(IntVar s, int p, int c, BoolVar m)
Initialize with start time s, processing time p, required capacity c, and mandatory flag m.
Definition task.hpp:173
Cumulative optional task with flexible processing time
OptFlexTask(void)
Default constructor.
Definition task.hpp:225
void init(IntVar s, IntVar p, IntVar e, int c, BoolVar m)
Initialize with start time s, processing time p, end time e, and mandatory flag m.
Definition task.hpp:231
virtual ExecStatus propagate(Space &home, const ModEventDelta &med)
Perform propagation.
Definition opt-prop.hpp:131
virtual size_t dispose(Space &home)
Delete propagator and return its size.
Definition opt-prop.hpp:123
virtual PropCost cost(const Space &home, const ModEventDelta &med) const
Return propagation cost.
Definition opt-prop.hpp:102
OptProp(Home home, Cap c, TaskArray< OptTask > &t)
Constructor for creation.
Definition opt-prop.hpp:42
static ExecStatus post(Home home, Cap c, TaskArray< OptTask > &t)
Post propagator that schedules tasks on cumulative resource.
Definition opt-prop.hpp:56
virtual Actor * copy(Space &home)
Perform copying during cloning.
Definition opt-prop.hpp:117
Task mapper: turns a task view into its dual.
Definition task.hh:102
Task array.
Definition task.hh:165
TaskProp(Home home, TaskArray< ManTask > &t)
Definition prop.hpp:38
Cumulative::ManFixPSETaskBwd TaskViewBwd
The backward task view type.
Unary::ManFixPSETask UnaryTask
The corresponding unary task type.
Cumulative::ManFixPSETaskFwd TaskViewFwd
The forward task view type.
Cumulative::ManFixPTaskBwd TaskViewBwd
The backward task view type.
Unary::ManFixPTask UnaryTask
The corresponding unary task type.
Cumulative::ManFixPTaskFwd TaskViewFwd
The forward task view type.
Unary::ManFlexTask UnaryTask
The corresponding unary task type.
Cumulative::ManFlexTaskFwd TaskViewFwd
The forward task view type.
Cumulative::ManFlexTaskBwd TaskViewBwd
The backward task view type.
Cumulative::OptFixPSETaskBwd TaskViewBwd
The backward task view type.
Unary::OptFixPSETask UnaryTask
The corresponding unary task type.
Cumulative::ManFixPSETask ManTask
The corresponding mandatory task.
Cumulative::OptFixPSETaskFwd TaskViewFwd
The forward task view type.
Cumulative::ManFixPTask ManTask
The corresponding mandatory task.
Unary::OptFixPTask UnaryTask
The corresponding unary task type.
Cumulative::OptFixPTaskFwd TaskViewFwd
The forward task view type.
Cumulative::OptFixPTaskBwd TaskViewBwd
The backward task view type.
Cumulative::ManFlexTask ManTask
The corresponding mandatory task.
Unary::OptFlexTask UnaryTask
The corresponding unary task type.
Cumulative::OptFlexTaskBwd TaskViewBwd
The backward task view type.
Cumulative::OptFlexTaskFwd TaskViewFwd
The forward task view type.
Traits class for mapping tasks to task views.
Definition task.hh:157
const TaskViewArray< TaskView > & tasks
Definition task.hh:369
TaskTree(Region &r, const TaskViewArray< TaskView > &t)
Definition tree.hpp:141
const OmegaNode & root(void) const
Definition tree.hpp:109
Task view array.
Definition task.hh:233
Cumulative::ManFixPSETask Task
The task type.
Cumulative::ManFixPSETask Task
The task type.
Cumulative::OptFixPSETask Task
The task type.
Cumulative::OptFixPSETask Task
The task type.
Traits class for mapping task views to tasks.
Definition task.hh:148
Unary (mandatory) task with fixed processing, start or end time
Definition unary.hh:148
Unary (mandatory) task with fixed processing time
Definition unary.hh:54
Unary (mandatory) task with flexible processing time
Definition unary.hh:270
IntVar p(void) const
Return processing time.
Definition task.hpp:372
Unary optional task with fixed processing, start or end time.
Definition unary.hh:246
Unary optional task with fixed processing time
Definition unary.hh:222
Unary optional task with flexible processing time
Definition unary.hh:370
Propagation cost.
Definition core.hpp:493
Base-class for propagators.
Definition core.hpp:1073
friend class Space
Definition core.hpp:1075
ModEventDelta med
A set of modification events (used during propagation).
Definition core.hpp:1084
Handle to region.
Definition region.hpp:55
Computation spaces.
Definition core.hpp:1787
int ModEventDelta
Modification event deltas.
Definition core.hpp:94
TaskType
Type of task for scheduling constraints.
Definition int.hh:1305
IntPropLevel
Propagation levels for integer propagators.
Definition int.hh:1274
Scheduling for cumulative resources
ExecStatus knapsack_overload(Space &, int, TaskArray< Task > &)
Perform knapsack-augmented overload checking.
FwdToBwd< ManFlexTaskFwd > ManFlexTaskBwd
Backward (dual) mandatory flexible task view.
ManFlexTask ManFlexTaskFwd
Forward mandatory flexible task view.
FwdToBwd< ManFixPSETaskFwd > ManFixPSETaskBwd
Backward (dual) mandatory fixed task view.
ExecStatus timetabling(Space &home, Propagator &p, Cap c, TaskArray< Task > &t)
Perform time-tabling propagation.
ExecStatus cmanpost(Home home, Cap c, TaskArray< ManTask > &t, IntPropLevel ipl)
Post mandatory task propagator according to propagation level.
OptFlexTask OptFlexTaskFwd
Forward optional flexible task view.
FwdToBwd< OptFixPTaskFwd > OptFixPTaskBwd
Backward (dual) optional fixed task view.
FwdToBwd< OptFlexTaskFwd > OptFlexTaskBwd
Backward (dual) optional flexible task view.
OptFixPTask OptFixPTaskFwd
Forward optional fixed task view.
FwdToBwd< OptFixPSETaskFwd > OptFixPSETaskBwd
Backward (dual) optional fixed task view.
void mul_check(long long int x, long long int y)
Throw exception if multiplication of x and y overflows.
Definition limits.hpp:37
ExecStatus coptpost(Home home, Cap c, TaskArray< OptTask > &t, IntPropLevel ipl)
Post optional task propagator according to propagation level.
FwdToBwd< ManFixPTaskFwd > ManFixPTaskBwd
Backward (dual) mandatory fixed task view.
ManFixPSETask ManFixPSETaskFwd
Forward mandatory fixed task view.
ExecStatus subsumed(Space &home, Propagator &p, int c, TaskArray< Task > &t)
Check for subsumption (all tasks must be assigned).
ManFixPTask ManFixPTaskFwd
Forward mandatory fixed task view.
std::basic_ostream< Char, Traits > & operator<<(std::basic_ostream< Char, Traits > &os, const ManFixPTaskBwd &t)
Definition task-view.hpp:40
OptFixPSETask OptFixPSETaskFwd
Forward optional fixed task view.
ExecStatus edgefinding(Space &home, int c, TaskArray< Task > &t)
Propagate by edge-finding.
ExecStatus overload(Space &home, int c, TaskArray< ManTask > &t)
Check mandatory tasks t for overload.
Definition overload.hpp:41
Finite domain integers.
Definition lastval.hh:52
Gecode toplevel namespace
ExecStatus
Definition core.hpp:479
@ ES_OK
Execution is okay.
Definition core.hpp:483
#define forceinline
Definition config.hpp:144