38 #ifndef __GECODE_INT_TASK_HH__ 39 #define __GECODE_INT_TASK_HH__ 43 namespace Gecode {
namespace Int {
46 template<
class ManTask>
102 namespace Gecode {
namespace Int {
105 template<
class TaskView>
119 int pmin(
void)
const;
121 int pmax(
void)
const;
143 namespace Gecode {
namespace Int {
151 template<
class TaskView>
165 namespace Gecode {
namespace Int {
190 int size(
void)
const;
221 static void*
operator new(size_t);
222 static void operator delete(
void*,size_t);
229 template<
class Char,
class Traits,
class Task>
230 std::basic_ostream<Char,Traits>&
236 template<
class TaskView>
252 int size(
void)
const;
266 static void*
operator new(size_t);
267 static void operator delete(
void*,size_t);
274 template<
class Char,
class Traits,
class TaskView>
275 std::basic_ostream<Char,Traits>&
283 namespace Gecode {
namespace Int {
294 template<
class TaskView, SortTaskOrder sto,
bool inc>
298 template<
class TaskView, SortTaskOrder sto,
bool inc>
302 template<
class TaskView, SortTaskOrder sto,
bool inc>
309 namespace Gecode {
namespace Int {
312 template<
class TaskView, SortTaskOrder sto,
bool inc>
329 int left(
void)
const;
336 int task(
void)
const;
342 template<
class OptTaskView, SortTaskOrder sto,
bool inc>
356 namespace Gecode {
namespace Int {
362 long long int plus(
long long int x,
long long int y);
365 double plus(
double x,
double y);
368 template<
class TaskView,
class Node>
390 static bool left(
int i);
401 const Node&
root(
void)
const;
419 namespace Gecode {
namespace Int {
427 template<
class Task,
class PL>
446 template<
class OptTask,
class PL>
450 template<
class OptTask,
class PL,
class Cap>
491 namespace Gecode {
namespace Int {
516 int time(
void)
const;
530 template<
class Char,
class Traits>
531 std::basic_ostream<Char,Traits>&
Sort by earliest completion times.
Zero-length task start time.
Task & operator [](int i)
Return task at position i.
TaskProp(Home home, TaskArray< Task > &t)
Constructor for creation.
int pmax(void) const
Return maximum processing time.
static int n_right(int i)
Return index of right child of node i.
ManTaskViewIter(Region &r, const TaskViewArray< OptTaskView > &t)
Initialize iterator with mandatory tasks.
static int n_left(int i)
Return index of left child of node i.
TaskArray< Task > & t
Access to task array.
Type type(void) const
Return event type.
unsigned int ei
Combines type and number of task.
void operator++(void)
Move iterator to next task.
Class for defining basic propagation level.
int time(void) const
Return event time.
bool excluded(void) const
Whether task is excluded.
void reschedule(Space &home, Propagator &p, PropCond pc)
Schedule propagator p.
int idx(void) const
Return event index.
SortTaskOrder
How to sort tasks.
int ect(void) const
Return earliest completion time.
TaskView & operator [](int i)
Return task view at position i.
int size(void) const
Return size of array (number of elements)
static const bool basic
Perform basic propagation.
static bool right(int i)
Test whether node i is a right child.
ModEvent norun(Space &home, int e, int l)
Update such that task cannot run from e to l.
void init(Type e, int t, int i)
Initialize event.
void subscribe(Space &home, Propagator &p, PropCond pc)
Subscribe propagator p to task.
static const PropCond pc
For basic propagation, domain operations are needed.
static const bool basic
Perform basic propagation.
int ModEvent
Type for modification events.
Base-class for propagators.
TaskArray(void)
Default constructor (array of size 0)
Earliest required time of task.
void reschedule(Space &home, Propagator &p, PropCond pc=Int::PC_INT_BND)
Schedule propagator p.
static const bool basic
Perform basic propagation.
int lct(void) const
Return latest completion time.
virtual void reschedule(Space &home)
Schedule function.
TaskViewArray(TaskArray< Task > &t)
Initialize from task array a.
Traits class for mapping tasks to task views.
Sort by earliest start times.
Class for defining advanced propagation level.
TaskViewIter(void)
Default constructor (no initialization)
struct Gecode::@579::NNF::@61::@63 a
For atomic nodes.
Gecode::FloatVal c(-8, 8)
Class for defining basic and advanced propagation level.
void sort(TaskViewArray< TaskView > &t)
Sort task view array t according to sto and inc (increasing or decreasing)
int p
Number of positive literals for node type.
void update(Space &, bool share, TaskArray &a)
Update array to be a clone of array a.
Gecode::IntArgs i(4, 1, 2, 3, 4)
int n
Number of negative literals for node type.
static int n_parent(int i)
Return index of parent of node i.
Time-tabling event for task.
void update(void)
Update all inner nodes of tree after leaves have been initialized.
TaskViewTraits< TaskView >::Task Task
The underlying task type.
void init(void)
Initialize tree after leaves have been initialized.
int task(void) const
Return current task position.
const Gecode::PropCond PC_INT_BND
Propagate when minimum or maximum of a view changes.
int PropCond
Type for propagation conditions.
static const bool advanced
Do not perform advanced propagation.
ModEventDelta med
A set of modification events (used during propagation)
Allows to iterate over task views according to a specified order.
int lst(void) const
Return latest start time.
int plus(int x, int y)
Safe addition in case x is -Int::Limits::infinity.
ManToOptTask(void)
Default constructor.
const Gecode::PropCond PC_INT_DOM
Propagate when domain changes.
Class to define an optional from a mandatory task.
int * _leaf
Map task number to leaf node number in right order.
int est(void) const
Return earliest start time.
bool n_leaf(int i) const
Whether node i is leaf.
Sort by latest completion times.
bool operator<(const Event &e) const
Order among events.
bool operator()(void) const
Test whether iterator is still at a task.
Latest completion time of task.
static const PropCond pc
For basic propagation, domain operations are needed.
Task mapper: turns a task view into its dual.
Post propagator for SetVar SetOpType SetVar SetRelType r
void subscribe(Space &home, Propagator &p, PropCond pc=Int::PC_INT_BND)
Subscribe propagator p to all tasks.
int * map
Map for iteration order.
Post propagator for SetVar SetOpType SetVar y
bool mandatory(void) const
Whether task is mandatory.
int n_inner(void) const
Return number of inner nodes.
const Node & root(void) const
Return root node.
std::basic_ostream< Char, Traits > & operator<<(std::basic_ostream< Char, Traits > &os, const IdxViewArray< View > &x)
static bool left(int i)
Test whether node i is a left child.
bool assigned(View x, int v)
Whether x is assigned to value v.
int pmin(void) const
Return minimum processing time.
void cancel(Space &home, Propagator &p, PropCond pc=Int::PC_INT_BND)
Cancel subscription of propagator p for all tasks.
Node & leaf(int i)
Return leaf for task i.
void cancel(Space &home, Propagator &p, PropCond pc)
Cancel subscription of propagator p for task.
Allows to iterate over mandatory task views according to a specified order.
Post propagator for SetVar x
static bool n_root(int i)
Whether node i is index of root.
Latest required time of task.
static Event * events(Region &r, const TaskArray< Task > &t, bool &assigned)
Allocate from r and initialize event array with tasks t.
bool optional(void) const
Whether task can still be optional.
Traits class for mapping task views to tasks.
bool shared(const ConstView< ViewA > &, const ConstView< ViewB > &)
Test whether views share same variable.
Int::BoolView _m
Boolean view whether task is mandatory (= 1) or not.
Gecode toplevel namespace
virtual PropCost cost(const Space &home, const ModEventDelta &med) const
Cost function (defined as high linear)
const TaskViewArray< TaskView > & tasks
The tasks from which the tree is computed.
static const PropCond pc
For basic propagation, domain operations are needed.
static const bool advanced
Do not perform advanced propagation.
void update(Space &home, bool share, ManToOptTask &t)
Update this task to be a clone of task t.
TaskArray< Task > t
Tasks.
const TaskArray< Task > & operator=(const TaskArray< Task > &a)
Initialize from task array a (share elements)
virtual size_t dispose(Space &home)
Delete propagator and return its size.
Sort by latest start times.
int ModEventDelta
Modification event deltas.
int left(void) const
How many tasks are left to be iterated.
Home class for posting propagators
int n_nodes(void) const
Return number of nodes for balanced binary tree.
Task trees for task views with node type Node.
Type
Event type for task with order in which they are processed.
ExecStatus purge(Space &home, Propagator &p, TaskArray< OptTask > &t)
Purge optional tasks that are excluded and possibly rewrite propagator.
static const bool advanced
Do not perform advanced propagation.
bool assigned(void) const
Test whether task is assigned.
int size(void) const
Return size of array (number of elements)
Boolean view for Boolean variables.
Earliest start time of task.