155 template<
class A>
class Council;
157 template<
class VIC>
class VarImp;
194 template<
class VarImp>
246 static const int idx_c = VIC::idx_c;
248 static const int idx_d = VIC::idx_d;
250 static const int free_bits = VIC::free_bits;
252 unsigned int entries;
254 unsigned int free_and_bits;
259 const unsigned var_id;
273 unsigned int idx[pc_max+1];
307 void resize(
Space& home);
325 void _fail(
Space& home);
329#ifdef GECODE_HAS_VAR_DISPOSE
344 unsigned int id(
void)
const;
455 static void*
operator new(size_t,
Space&);
457 static void operator delete(
void*,
Space&);
459 static void operator delete(
void*);
616 bool empty(
void)
const;
652 virtual size_t dispose(
Space& home);
654 static void*
operator new(
size_t s,
Space& home);
656 static void operator delete(
void*
p,
Space& home);
662 static void*
operator new(
size_t s);
664 static void operator delete(
void*
p);
697 Group(
unsigned int gid0);
709 unsigned int id(
void)
const;
877 operator Space&(void);
993 unsigned int id(
void)
const;
1018 unsigned int id(
void)
const;
1088 void disable(
Space& home);
1090 void enable(
Space& home);
1191 double afc(
void)
const;
1193#ifdef GECODE_HAS_CBS
1203 typedef std::function<void(
unsigned int prop_id,
unsigned int var_id,
1204 int val,
double dens)> SendMarginal;
1205 virtual void solndistrib(
Space& home, SendMarginal send)
const;
1214 typedef std::function<bool(
unsigned int var_id)> InDecision;
1215 virtual void domainsizesum(InDecision in,
unsigned int& size,
1216 unsigned int& size_b)
const;
1222 unsigned int id(
void)
const;
1228 bool disabled(
void)
const;
1299 bool disposed(
void)
const;
1322 static void*
operator new(
size_t s,
Space& home);
1324 static void operator delete(
void*
p,
Space& home);
1329 static void operator delete(
void*
p);
1332 static void*
operator new(
size_t s);
1371 virtual bool notice(
void)
const;
1373 virtual size_t dispose(
Space& home);
1377 bool leaf(
void)
const;
1379 NGL* next(
void)
const;
1390 static void*
operator new(
size_t s,
Space& home);
1392 static void operator delete(
void* s,
Space& home);
1394 static void operator delete(
void*
p);
1400 static void*
operator new(
size_t s);
1419 unsigned int id(
void)
const;
1425 unsigned int alternatives(
void)
const;
1430 virtual void archive(
Archive& e)
const;
1489 unsigned int a) = 0;
1514 std::ostream& o)
const;
1519 unsigned int id(
void)
const;
1591 unsigned long int n;
1597 virtual void post(
Space& home)
const;
1599 unsigned long int ng(
void)
const;
1601 void ng(
unsigned long int n);
1628 const unsigned long int r;
1630 const unsigned long int s;
1632 const unsigned long int f;
1641 const unsigned int a;
1648 unsigned long int s,
1649 unsigned long int f,
1656 Type type(
void)
const;
1660 unsigned long int restart(
void)
const;
1662 unsigned long int solution(
void)
const;
1664 unsigned long int fail(
void)
const;
1666 const Space* last(
void)
const;
1668 const NoGoods& nogoods(
void)
const;
1673 unsigned int asset(
void)
const;
1765#ifdef GECODE_HAS_CBS
1767 unsigned int var_id_counter;
1792 Brancher* brancher(
unsigned int id);
1801 void kill_brancher(
unsigned int id);
1804 static const unsigned reserved_bid = 0U;
1807 static const unsigned int sc_bits = 2;
1809 static const unsigned int sc_fast = 0;
1811 static const unsigned int sc_disabled = 1;
1813 static const unsigned int sc_trace = 2;
1856 void enqueue(Propagator*
p);
1861#ifdef GECODE_HAS_VAR_DISPOSE
1865 VarImpBase* _vars_d[AllVarConf::idx_d];
1867 template<
class VIC> VarImpBase* vars_d(
void)
const;
1869 template<
class VIC>
void vars_d(VarImpBase*
x);
1872 void update(ActorLink** sub);
1937 void _commit(
const Choice& c,
unsigned int a);
1970 void _trycommit(
const Choice& c,
unsigned int a);
1974 TraceRecorder* findtracerecorder(
void);
1977 void post(
const PostInfo&
pi);
1986 void ap_notice_dispose(Actor*
a,
bool d);
1994 void ap_ignore_dispose(Actor*
a,
bool d);
2017 virtual ~Space(
void);
2060 virtual bool master(
const MetaInfo& mi);
2087 virtual bool slave(
const MetaInfo& mi);
2140 const Choice* choice(
void);
2205 void commit(
const Choice& c,
unsigned int a,
2239 void trycommit(
const Choice& c,
unsigned int a,
2277 void print(
const Choice& c,
unsigned int a, std::ostream& o)
const;
2403 bool failed(
void)
const;
2408 bool stable(
void)
const;
2432 T* alloc(
long unsigned int n);
2440 T* alloc(
long int n);
2448 T* alloc(
unsigned int n);
2467 void free(T*
b,
long unsigned int n);
2478 void free(T*
b,
long int n);
2489 void free(T*
b,
unsigned int n);
2500 void free(T*
b,
int n);
2513 T* realloc(T*
b,
long unsigned int n,
long unsigned int m);
2526 T* realloc(T*
b,
long int n,
long int m);
2539 T* realloc(T*
b,
unsigned int n,
unsigned int m);
2552 T* realloc(T*
b,
int n,
int m);
2561 T** realloc(T**
b,
long unsigned int n,
long unsigned int m);
2570 T** realloc(T**
b,
long int n,
long int m);
2579 T** realloc(T**
b,
unsigned int n,
unsigned int m);
2588 T** realloc(T**
b,
int n,
int m);
2590 void* ralloc(
size_t s);
2592 void rfree(
void*
p,
size_t s);
2594 void* rrealloc(
void*
b,
size_t n,
size_t m);
2596 template<
size_t>
void* fl_alloc(
void);
2616 template<
class T,
typename A1>
2617 T& construct(A1
const& a1);
2623 template<
class T,
typename A1,
typename A2>
2624 T& construct(A1
const& a1, A2
const& a2);
2630 template<
class T,
typename A1,
typename A2,
typename A3>
2631 T& construct(A1
const& a1, A2
const& a2, A3
const& a3);
2637 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4>
2638 T& construct(A1
const& a1, A2
const& a2, A3
const& a3, A4
const& a4);
2644 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5>
2645 T& construct(A1
const& a1, A2
const& a2, A3
const& a3, A4
const& a4, A5
const& a5);
2651 void afc_decay(
double d);
2653 double afc_decay(
void)
const;
2678 bool operator ()(
void)
const;
2680 void operator ++(
void);
2703 bool operator ()(
void)
const;
2705 void operator ++(
void);
2724 bool operator ()(
void)
const;
2726 void operator ++(
void);
2745 bool operator ()(
void)
const;
2747 void operator ++(
void);
2808 char*
b =
static_cast<char*
>(_b);
2810 char*
p =
static_cast<char*
>(
ralloc(m));
2838 T*
p =
static_cast<T*
>(
ralloc(
sizeof(T)*
n));
2839 for (
long unsigned int i=0; i<
n; i++)
2840 (
void)
new (
p+i) T();
2847 return alloc<T>(
static_cast<long unsigned int>(
n));
2852 return alloc<T>(
static_cast<long unsigned int>(
n));
2858 return alloc<T>(
static_cast<long unsigned int>(
n));
2864 for (
long unsigned int i=0; i<
n; i++)
2872 free<T>(
b,
static_cast<long unsigned int>(
n));
2877 free<T>(
b,
static_cast<long unsigned int>(
n));
2883 free<T>(
b,
static_cast<long unsigned int>(
n));
2890 T*
p =
static_cast<T*
>(
ralloc(
sizeof(T)*m));
2891 for (
long unsigned int i=0; i<
n; i++)
2892 (
void)
new (
p+i) T(
b[i]);
2893 for (
long unsigned int i=
n; i<m; i++)
2894 (
void)
new (
p+i) T();
2905 assert((
n >= 0) && (m >= 0));
2907 static_cast<long unsigned int>(m));
2913 static_cast<long unsigned int>(m));
2918 assert((
n >= 0) && (m >= 0));
2920 static_cast<long unsigned int>(m));
2923#define GECODE_KERNEL_REALLOC(T) \
2926 Space::realloc<T>(T* b, long unsigned int n, long unsigned int m) { \
2927 return static_cast<T*>(rrealloc(b,n*sizeof(T),m*sizeof(T))); \
2931 Space::realloc<T>(T* b, long int n, long int m) { \
2932 assert((n >= 0) && (m >= 0)); \
2933 return realloc<T>(b,static_cast<long unsigned int>(n), \
2934 static_cast<long unsigned int>(m)); \
2938 Space::realloc<T>(T* b, unsigned int n, unsigned int m) { \
2939 return realloc<T>(b,static_cast<long unsigned int>(n), \
2940 static_cast<long unsigned int>(m)); \
2944 Space::realloc<T>(T* b, int n, int m) { \
2945 assert((n >= 0) && (m >= 0)); \
2946 return realloc<T>(b,static_cast<long unsigned int>(n), \
2947 static_cast<long unsigned int>(m)); \
2962#undef GECODE_KERNEL_REALLOC
2967 return static_cast<T**
>(
rrealloc(
b,
n*
sizeof(T),m*
sizeof(T*)));
2972 assert((
n >= 0) && (m >= 0));
2974 static_cast<long unsigned int>(m));
2980 static_cast<long unsigned int>(m));
2985 assert((
n >= 0) && (m >= 0));
2987 static_cast<long unsigned int>(m));
2991#ifdef GECODE_HAS_VAR_DISPOSE
2994 Space::vars_d(
void)
const {
2995 return _vars_d[VIC::idx_d];
2999 Space::vars_d(VarImpBase*
x) {
3000 _vars_d[VIC::idx_d] =
x;
3006 Actor::operator
delete(
void*) {}
3008 Actor::operator
delete(
void*,
Space&) {}
3010 Actor::operator
new(
size_t s,
Space& home) {
3011 return home.ralloc(s);
3023 return home.ralloc(s);
3028 Advisor::operator
delete(
void*) {}
3031 Advisor::operator
delete(
void*,
Space&) {}
3033 Advisor::operator
new(
size_t s,
Space& home) {
3034 return home.ralloc(s);
3038 NGL::operator
delete(
void*) {}
3042 NGL::operator
new(
size_t s,
Space& home) {
3043 return home.ralloc(s);
3071 unsigned long int s0,
3072 unsigned long int f0,
3075 :
t(RESTART),
r(r0), s(s0), f(f0),
l(l0), ng(ng0),
a(0) {}
3079 :
t(PORTFOLIO),
r(0), s(0), f(0),
l(NULL), ng(
NoGoods::eng),
a(a0) {}
3150 p->_next =
n;
n->_prev =
p;
3155 _next =
this; _prev =
this;
3162 this->_next =
a;
a->_prev =
this;
3163 a->_next =
n;
n->_prev =
a;
3170 a->_next =
this; this->_prev =
a;
3171 p->_next =
a;
a->_prev =
p;
3176 return _next ==
this;
3207 return static_cast<Actor*
>(&
t);
3211 Actor::cast(
const ActorLink* al) {
3215 return static_cast<const Actor*
>(&
t);
3228 return const_cast<Space*
>(
this)->_clone();
3253 return sizeof(*this);
3264 : s(s0),
p(p0), pg(pg0), bg(bg0) {}
3288 return Home(*
this,&
p);
3333 return static_cast<What>(
who & 3);
3357 : h(home), pg(home.propagatorgroup()),
3358 pid(h.ssd.data().gpi.pid()),
3366 if (
h.pc.
p.
bid_sc & Space::sc_trace)
3380 : i(i0), g(g0),
p(p0), s(s0) {}
3406 :
b(b0), c(c0),
a(a0) {}
3435 : g(g0), s(s0),
n(n0) {}
3463 Propagator::cast(
const ActorLink* al) {
3481 Propagator::disable(
Space& home) {
3482 home.pc.
p.
bid_sc |= Space::sc_disabled;
3487 Propagator::enable(Space& home) {
3503 static_cast<
Space&>(home).ssd.data().gpi.allocate
3504 (home.propagatorgroup().gid)) {
3506 assert((u.med == 0) && (u.size == 0));
3507 static_cast<Space&
>(home).pl.head(
this);
3512 : gpi_disabled(
p.gpi_disabled) {
3514 assert((u.med == 0) && (u.size == 0));
3529#ifdef GECODE_HAS_CBS
3531 Propagator::solndistrib(
Space&, SendMarginal)
const {}
3534 Propagator::domainsizesum(InDecision,
unsigned int& size,
3535 unsigned int& size_b)
const {
3564 p.u.size =
p.dispose(*
this);
3571 assert(
p.u.med != 0);
3578 assert(
p.u.med != 0);
3597 Brancher::cast(
const ActorLink* al) {
3601 return static_cast<const Brancher*
>(&
t);
3606 gid(_home.branchergroup().gid) {
3608 bid = home.pc.
p.
bid_sc >> Space::sc_bits;
3609 home.pc.
p.
bid_sc += (1 << Space::sc_bits);
3610 if ((home.pc.
p.
bid_sc >> Space::sc_bits) == 0U)
3613 if (home.b_status == &
static_cast<Space&
>(home).bl) {
3614 home.b_status = this;
3615 if (home.b_commit == &static_cast<Space&>(home).bl)
3616 home.b_commit = this;
3623 : bid(
b.bid), gid(
b.gid) {
3649 b_commit = Brancher::cast(
b.next());
3651 b_status = Brancher::cast(
b.next());
3657 Space::kill(Propagator&
p) {
3664 Space::brancher(
unsigned int id) {
3681 while (b_commit != Brancher::cast(&bl))
3682 if (
id != b_commit->
id())
3683 b_commit = Brancher::cast(b_commit->next());
3686 if (b_commit == Brancher::cast(&bl)) {
3688 b_commit = Brancher::cast(bl.
next());
3689 while (b_commit != b_old)
3690 if (
id != b_commit->
id())
3691 b_commit = Brancher::cast(b_commit->next());
3767 : bid(
b.id()), alt(
a) {}
3775 Choice::id(
void)
const {
3822 return sizeof(*this);
3842 Advisor::disposed(
void)
const {
3843 return prev() == NULL;
3847 Advisor::cast(ActorLink* al) {
3848 return static_cast<Advisor*
>(al);
3852 Advisor::cast(
const ActorLink* al) {
3853 return static_cast<const Advisor*
>(al);
3858 assert(!disposed());
3865 assert(!disposed());
3869 if ((
n != NULL) &&
n->disposed())
3875 return home.pc.
p.
vti;
3918 while ((
a != NULL) &&
static_cast<A*
>(
a)->disposed())
3930 while ((
a != NULL) &&
static_cast<A*
>(
a)->disposed())
3935 if (c.advisors != NULL) {
3939 Propagator* p_t = Propagator::cast(p_f->prev());
3944 while (*a_f != NULL) {
3945 if (
static_cast<A*
>(*a_f)->disposed()) {
3946 *a_f = (*a_f)->
next();
3949 A*
a =
new (home) A(home,*
static_cast<A*
>(*a_f));
3974 if (!
static_cast<A*
>(
a)->disposed())
3975 static_cast<A*
>(
a)->dispose(home,*
this);
3990 while ((a != NULL) &&
static_cast<A*
>(a)->disposed())
4005 }
while ((
a != NULL) &&
static_cast<A*
>(
a)->disposed());
4011 return *
static_cast<A*
>(
a);
4023 ActorLink*
c = &pc.p.queue[
p->cost(*
this,
p->u.med).ac];
4025 if (
c > pc.p.active)
4054 return ((pc.p.active < &pc.p.queue[0]) ||
4061 ap_notice_dispose(&
a,d);
4064 pc.p.bid_sc |= sc_trace;
4067 pc.p.bid_sc |= sc_trace;
4078 ap_ignore_dispose(&
a,d);
4094 assert((pc >= 0) && (pc < pc_max+2));
4095 return (pc == 0) ?
b.base :
b.base+
u.idx[pc-1];
4100 VarImp<VIC>::actorNonZero(
PropCond pc) {
4101 assert((pc > 0) && (pc < pc_max+2));
4102 return b.base+
u.idx[pc-1];
4108 assert((pc > 0) && (pc < pc_max+2));
4115 assert((pc > 0) && (pc < pc_max+2));
4122#ifdef GECODE_HAS_CBS
4123 : var_id(++home.var_id_counter)
4126#ifndef GECODE_HAS_CBS
4129 b.base = NULL; entries = 0;
4130 for (
PropCond pc=1; pc<pc_max+2; pc++)
4138#ifdef GECODE_HAS_CBS
4142 b.base = NULL; entries = 0;
4143 for (
PropCond pc=1; pc<pc_max+2; pc++)
4148#ifdef GECODE_HAS_CBS
4172 d += Propagator::cast(*a)->afc();
a++;
4181 ->propagator().afc();
4197 return free_and_bits;
4203 return free_and_bits;
4206#ifdef GECODE_HAS_VAR_DISPOSE
4210 return static_cast<VarImp<VIC>*
>(home.vars_d<VIC>());
4215 VarImp<VIC>::vars_d(Space& home, VarImp<VIC>*
x) {
4216 home.vars_d<VIC>(
x);
4243#ifdef GECODE_HAS_CBS
4248 free_and_bits =
x.free_and_bits & ((1 << free_bits) - 1);
4249 if (
x.b.base == NULL) {
4254 reg = &home.pc.
c.
vars_u[idx_c];
4258 entries =
x.entries;
4259 for (
PropCond pc=1; pc<pc_max+2; pc++)
4260 idx(pc) =
x.idx(pc);
4271 return static_cast<ModEvent>((med & VIC::med_mask) >> VIC::med_fst);
4283 return VIC::me_combine(me1,me2);
4290 if (VIC::med_update(
p.u.med,me) || force)
4300 schedule(home,*Propagator::cast(*
p),me);
4306 if (
b.base == NULL) {
4307 assert((free_and_bits >> free_bits) == 0);
4309 free_and_bits += 4 << free_bits;
4311 for (
int i=0; i<pc_max+1; i++)
4315 unsigned int n = degree();
4319 ActorLink** s =
static_cast<ActorLink**
>(home.mm.
subscriptions());
4321 ((s <=
b.base) && (
b.base < s+home.pc.
p.
n_sub)) ?
4322 (
n+4) : ((
n+1)*3>>1);
4323 ActorLink** prop = home.
alloc<ActorLink*>(m);
4324 free_and_bits += (m-
n) << free_bits;
4327 home.
free<ActorLink*>(
b.base,
n);
4334 VarImp<VIC>::enter(Space& home, Propagator*
p,
PropCond pc) {
4335 assert(pc <= pc_max);
4337 home.pc.p.n_sub += 1;
4338 if ((free_and_bits >> free_bits) == 0)
4340 free_and_bits -= 1 << free_bits;
4343 b.base[entries] = *actorNonZero(pc_max+1);
4345 for (
PropCond j = pc_max; j > pc; j--) {
4346 *actorNonZero(j+1) = *actorNonZero(j);
4349 *actorNonZero(pc+1) = *actor(pc);
4354 ActorLink**
f = actor(pc);
4355 while (f < (pc == pc_max+1 ?
b.base+entries : actorNonZero(pc+1)))
4367 VarImp<VIC>::enter(Space& home, Advisor*
a) {
4370 home.pc.p.n_sub += 1;
4371 if ((free_and_bits >> free_bits) == 0)
4373 free_and_bits -= 1 << free_bits;
4376 b.base[entries++] = *actorNonZero(pc_max+1);
4377 *actorNonZero(pc_max+1) =
a;
4383 bool assigned,
ModEvent me,
bool schedule) {
4418 assert(pc <= pc_max);
4423 while (f < actorNonZero(pc+1))
4431 while (*f !=
a) f++;
4434 *f = *(actorNonZero(pc+1)-1);
4435 for (
PropCond j = pc+1; j< pc_max+1; j++) {
4436 *(actorNonZero(j)-1) = *(actorNonZero(j+1)-1);
4439 *(actorNonZero(pc_max+1)-1) =
b.base[entries-1];
4442 free_and_bits += 1 << free_bits;
4460 while (f <
b.base+entries)
4468 while (*f !=
a) f++;
4471 *f =
b.base[--entries];
4472 free_and_bits += 1 << free_bits;
4479 if (
b.base != NULL) {
4488 unsigned int n_sub = degree();
4489 home.pc.
p.
n_sub -= n_sub;
4490 unsigned int n = (free_and_bits >> free_bits) + n_sub;
4497 for (
PropCond pc=1; pc<pc_max+2; pc++)
4499 free_and_bits &= (1 << free_bits) - 1;
4510 ActorLink** la = actorNonZero(pc_max+1);
4521 assert(!
a->disposed());
4523 switch (
p.advise(home,*
a,d)) {
4529 schedule(home,
p,me);
4532 schedule(home,
p,me,
true);
4538 }
while (++la < le);
4550 ActorLink** la = actorNonZero(pc_max+1);
4561 assert(!
a->disposed());
4565 }
while (++la < le);
4582 x->u.idx[0] =
u.idx[0];
4583 if (pc_max > 0 &&
sizeof(
ActorLink**) >
sizeof(
unsigned int))
4584 x->u.idx[1] =
u.idx[1];
4587 static_cast<unsigned int>(
x->actorNonZero(pc_max+1) -
x->actor(0));
4589 static_cast<unsigned int >(
x->b.base +
x->entries -
4590 x->actorNonZero(pc_max+1));
4591 unsigned int n = na + np;
4605 t[0] = p0;
t[1] = p1;
t[2] = p2;
t[3] = p3;
4606 np -= 4;
t += 4; f += 4;
4609 ActorLink* p0 = f[0]->prev();
4610 ActorLink* p1 = f[1]->prev();
4611 t[0] = p0;
t[1] = p1;
4612 np -= 2;
t += 2; f += 2;
4615 ActorLink* p0 =
f[0]->prev();
4621 ptrdiff_t m0, m1, m2, m3;
4634 na -= 4;
t += 4;
f += 4;
4644 na -= 2;
t += 2;
f += 2;
4656 VarImp<VIC>::update(Space& home, ActorLink**& sub) {
4657 VarImp<VIC>*
x =
static_cast<VarImp<VIC>*
>(home.pc.c.vars_u[idx_c]);
4659 VarImp<VIC>*
n =
x->next();
x->forward()->
update(
x,sub);
x =
n;
4669 template<
class VarImp>
4671#ifdef GECODE_HAS_VAR_DISPOSE
4672 Space::vd[VarImp::idx_d] =
this;
4676 template<
class VarImp>
4681 x->dispose(home);
x =
static_cast<VarImp*
>(
x->next_d());
4682 }
while (
x != NULL);
4761 return (m ==
LO) ? lo : hi;
4775 return crazy(m,
static_cast<unsigned int>(
n));
4784 return cubic(m,
static_cast<unsigned int>(
n));
4793 return quadratic(m,
static_cast<unsigned int>(
n));
4802 return linear(m,
static_cast<unsigned int>(
n));
4823 : home(home0), q(home.pc.
p.active) {
4824 while (q >= &home.pc.p.queue[0]) {
4825 if (q->next() != q) {
4826 c = q->next(); e = q; q--;
4832 if (!home.pl.empty()) {
4833 c = Propagator::cast(home.pl.next());
4834 e = Propagator::cast(&home.pl);
4850 while (q >= &home.pc.p.queue[0]) {
4851 if (q->next() != q) {
4852 c = q->next(); e = q; q--;
4858 if (!home.pl.empty()) {
4859 c = Propagator::cast(home.pl.next());
4860 e = Propagator::cast(&home.pl);
4869 return *Propagator::cast(
c);
4875 : home(home0), q(home.pc.
p.
active) {
4876 while (q >= &home.pc.p.queue[0]) {
4877 if (q->next() != q) {
4878 c = q->next(); e = q; q--;
4896 while (q >= &home.pc.p.queue[0]) {
4897 if (q->next() != q) {
4898 c = q->next(); e = q; q--;
4909 return *Propagator::cast(
c);
4915 c = Propagator::cast(home.pl.
next());
4916 e = Propagator::cast(&home.pl);
4928 return *Propagator::cast(
c);
4934 :
c(
Brancher::cast(home.bl.next())), e(&home.bl) {}
4945 return *Brancher::cast(
c);
5002 return id() == g.
id();
5006 return id() != g.
id();
5040 return id() == g.
id();
5044 return id() != g.
id();
5061 : ps(const_cast<
Space&>(home)), g(g0) {
5082 : bs(const_cast<
Space&>(home)), g(g0) {
5111 template<
class T,
typename A1>
5114 T&
t = *
static_cast<T*
>(
ralloc(
sizeof(T)));
5118 template<
class T,
typename A1,
typename A2>
5121 T&
t = *
static_cast<T*
>(
ralloc(
sizeof(T)));
5125 template<
class T,
typename A1,
typename A2,
typename A3>
5128 T&
t = *
static_cast<T*
>(
ralloc(
sizeof(T)));
5129 new (&
t) T(a1,a2,a3);
5132 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4>
5135 T&
t = *
static_cast<T*
>(
ralloc(
sizeof(T)));
5136 new (&
t) T(a1,a2,a3,a4);
5139 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5>
5142 T&
t = *
static_cast<T*
>(
ralloc(
sizeof(T)));
5143 new (&
t) T(a1,a2,a3,a4,a5);
struct Gecode::@603::NNF::@65::@66 b
For binary nodes (and, or, eqv)
union Gecode::@603::NNF::@65 u
Union depending on nodetype t.
int p
Number of positive literals for node type.
int n
Number of negative literals for node type.
struct Gecode::@603::NNF::@65::@67 a
For atomic nodes.
Node * x
Pointer to corresponding Boolean expression node.
Class for AFC (accumulated failure count) management.
Double-linked list for actors.
ActorLink ** next_ref(void)
ActorLink * next(void) const
void init(void)
Initialize links (self-linked)
void unlink(void)
Remove from predecessor and successor.
void head(ActorLink *al)
Insert al directly after this.
void tail(ActorLink *al)
Insert al directly before this.
ActorLink * prev(void) const
Routines for double-linked list.
bool empty(void) const
Test whether actor link is empty (points to itself)
static ActorLink * cast(T *a)
Static cast for a non-null pointer (to give a hint to optimizer)
Base-class for both propagators and branchers.
virtual Actor * copy(Space &home)=0
Create copy.
virtual size_t dispose(Space &home)
Delete actor and return its size.
Propagator & propagator(void) const
Return the advisor's propagator.
void dispose(Space &home, Council< A > &c)
Dispose the advisor.
const ViewTraceInfo & operator()(const Space &home) const
Provide access to view trace information.
Class to iterate over advisors of a council.
Advisors(const Council< A > &c)
Initialize.
bool operator()(void) const
Test whether there advisors left.
void operator++(void)
Move iterator to next advisor.
A & advisor(void) const
Return advisor.
static ModEventDelta med_combine(ModEventDelta med1, ModEventDelta med2)
Combine modification event delta med1 with med2.
unsigned int size(Space &home) const
Return number of branchers in a group.
static BrancherGroup def
Group of branchers not in any user-defined group.
static BrancherGroup all
Group of all branchers.
BrancherGroup & operator=(const BrancherGroup &g)
Assignment operator.
BrancherGroup & move(Space &home, BrancherGroup g)
Move branchers from group g to this group.
Home operator()(Space &home)
To augment a space argument.
bool operator!=(BrancherGroup g) const
Test whether this group is different from group g.
void kill(Space &home)
Kill all branchers in a group.
bool operator==(BrancherGroup g) const
Test whether this group is equal to group g.
BrancherGroup(void)
Constructor.
Base-class for branchers.
virtual const Choice * choice(Space &home)=0
Return choice.
virtual ExecStatus commit(Space &home, const Choice &c, unsigned int a)=0
Commit for choice c and alternative a.
unsigned int id(void) const
Return brancher id.
virtual const Choice * choice(const Space &home, Archive &e)=0
Return choice from e.
BrancherGroup group(void) const
Return group brancher belongs to.
virtual bool status(const Space &home) const =0
Check status of brancher, return true if alternatives left.
Class to iterate over branchers in a group.
void operator++(void)
Move iterator to next brancher.
const Brancher & brancher(void) const
Return propagator.
bool operator()(void) const
Test whether there are branchers left.
Branchers(const Space &home, BrancherGroup g)
Initialize.
Choice for performing commit
Choice(const Brancher &b, const unsigned int a)
Initialize for particular brancher b and alternatives a.
virtual ~Choice(void)
Destructor.
unsigned int alternatives(void) const
Return number of alternatives.
Statistics for execution of clone
CloneStatistics operator+(const CloneStatistics &s)
Return sum with s.
void reset(void)
Reset information.
CloneStatistics & operator+=(const CloneStatistics &s)
Increment by statistics s.
CloneStatistics(void)
Initialize.
Statistics for execution of commit
CommitStatistics & operator+=(const CommitStatistics &s)
Increment by statistics s.
void reset(void)
Reset information.
CommitStatistics operator+(const CommitStatistics &s)
Return sum with s.
CommitStatistics(void)
Initialize.
Commit trace information.
BrancherGroup group(void) const
Return brancher group.
unsigned int alternative(void) const
Return alternative.
const Brancher & b
Brancher.
CommitTraceInfo(const Brancher &b, const Choice &c, unsigned int a)
Initialize.
unsigned int id(void) const
Return brancher identifier.
unsigned int a
Alternative.
const Choice & choice(void) const
Return choice.
const Brancher & brancher(void) const
Return brancher.
bool empty(void) const
Test whether council has advisor left.
void update(Space &home, Council< A > &c)
Update during cloning (copies all advisors)
void dispose(Space &home)
Dispose council.
Council(Space &home)
Construct advisor council.
Council(void)
Default constructor.
Generic domain change information to be supplied to advisors.
Base-class for freelist-managed objects.
Group baseclass for controlling actors.
static Group all
Group of all actors.
static Group def
Group of actors not in any user-defined group.
static const unsigned int GROUPID_ALL
Fake id for group of all actors.
bool in(void) const
Check whether this is a real group (and not just default)
static Support::Mutex m
Mutex for protection.
static const unsigned int GROUPID_MAX
The maximal group number.
Group & operator=(const Group &g)
Assignment operator.
unsigned int id(void) const
Return a unique id for the group.
static const unsigned int GROUPID_DEF
Pre-defined default group id.
unsigned int gid
The group id.
bool in(Group a) const
Check whether actor group a is included in this group.
static unsigned int next
Next group id.
Base class for heap allocated objects.
static T * copy(T *d, const T *s, long unsigned int n)
Copy n objects starting at s to d.
Home class for posting propagators
PropagatorGroup pg
A propagator group.
BrancherGroup branchergroup(void) const
Return brancher group.
void notice(Actor &a, ActorProperty p, bool duplicate=false)
Notice actor property.
Home(Space &s, Propagator *p=NULL, PropagatorGroup pg=PropagatorGroup::def, BrancherGroup bg=BrancherGroup::def)
Initialize the home with space s and propagator p and group g.
Propagator * p
A propagator (possibly) that is currently being rewritten.
Space & s
The space where the propagator is to be posted.
void fail(void)
Mark space as failed.
BrancherGroup bg
A brancher group.
Propagator * propagator(void) const
Return propagator (or NULL) for currently rewritten propagator.
PropagatorGroup propagatorgroup(void) const
Return propagator group.
Home operator()(Propagator &p)
Return a home extended by propagator to be rewritten.
bool failed(void) const
Check whether corresponding space is failed.
Home & operator=(const Home &h)
Assignment operator.
Class for storing propagator information.
unsigned int pid
Propagator identifier.
unsigned int gid
Group identifier.
void decay(double d)
Set decay factor to d.
void reuse(void *p, size_t s)
Store for reusal, if of sufficient size for free list.
void * alloc(SharedMemory &sm, size_t s)
Allocate memory of size s.
void * subscriptions(void) const
Get the memory area for subscriptions.
GPI gpi
The global propagator information.
SharedMemory sm
The shared memory area.
Class to store data shared among several spaces.
Data & data(void) const
Provide access.
Handles for local (space-shared) objects.
LocalHandle(void)
Create local handle pointing to NULL object.
~LocalHandle(void)
Destructor.
void update(Space &home, LocalHandle &lh)
Updating during cloning.
LocalHandle & operator=(const LocalHandle &lh)
Assignment operator.
LocalObject * object(void) const
Access to the local object.
Local (space-shared) object.
static LocalObject * cast(ActorLink *al)
Static cast for a non-null pointer (to give a hint to optimizer)
LocalObject * fwd(Space &home)
Return forwarding pointer.
No-good literal recorded during search.
bool leaf(void) const
Test whether literal is a leaf.
virtual ExecStatus prune(Space &home)=0
Propagate the negation of the no-good literal.
virtual void cancel(Space &home, Propagator &p)=0
Cancel propagator p from all views of the no-good literal.
virtual void subscribe(Space &home, Propagator &p)=0
Subscribe propagator p to all views of the no-good literal.
virtual NGL::Status status(const Space &home) const =0
Test the status of the no-good literal.
NGL(void)
Constructor for creation.
virtual NGL * copy(Space &home)=0
Create copy.
Status
The status of a no-good literal.
@ SUBSUMED
The literal is subsumed.
@ FAILED
The literal is failed.
virtual void reschedule(Space &home, Propagator &p)=0
Schedule propagator p for all views of the no-good literal.
NGL * next(void) const
Return pointer to next literal.
virtual size_t dispose(Space &home)
Dispose.
NGL * add(NGL *n, bool l)
Add node n and mark it as leaf l and return n.
No-goods recorded from restarts.
static NoGoods eng
Empty no-goods.
virtual ~NoGoods(void)
Destructor.
unsigned long int ng(void) const
Return number of no-goods posted.
unsigned long int n
Number of no-goods.
Configuration class for variable implementations without index structure.
static bool med_update(ModEventDelta &med, ModEvent me)
Update modification even delta med by me, return true on change.
static const int free_bits
Freely available bits.
static const int idx_c
Index for update.
static const int med_fst
Start of bits for modification event delta.
static const int med_lst
End of bits for modification event delta.
static const PropCond pc_max
Maximal propagation condition.
static const int idx_d
Index for disposal.
static Gecode::ModEvent me_combine(ModEvent me1, ModEvent me2)
Combine modification events me1 and me2.
static const int med_mask
Bitmask for modification event delta.
Class to set group information when a post function is executed.
PostInfo(Home home)
Set information.
bool nested
Whether it is used nested.
unsigned int pid
Next free propagator id.
PropagatorGroup pg
The propagator group.
~PostInfo(void)
Reset information.
unsigned int propagators(void) const
Return number of posted propagators.
PropagatorGroup group(void) const
Return propagator group.
PropagatorGroup g
Propagator group.
@ SUBSUMED
Propagator not posted as already subsumed.
@ POSTED
Propagator was posted.
Status status(void) const
Return post status.
PostTraceInfo(PropagatorGroup g, Status s, unsigned int n)
Initialize.
unsigned int n
Number of posted propagators.
ActualCost ac
Actual cost.
static PropCost unary(PropCost::Mod m)
Single variable for modifier pcm.
static PropCost ternary(PropCost::Mod m)
Three variables for modifier pcm.
static PropCost record(void)
For recording information (no propagation allowed)
static PropCost crazy(PropCost::Mod m, unsigned int n)
Exponential complexity for modifier m and size measure n.
static PropCost quadratic(PropCost::Mod m, unsigned int n)
Quadratic complexity for modifier m and size measure n.
static PropCost linear(PropCost::Mod m, unsigned int n)
Linear complexity for modifier pcm and size measure n.
static PropCost cubic(PropCost::Mod m, unsigned int n)
Cubic complexity for modifier m and size measure n.
static PropCost binary(PropCost::Mod m)
Two variables for modifier pcm.
Mod
Propagation cost modifier.
ActualCost
The actual cost values that are used.
@ AC_TERNARY_LO
Three variables, cheap.
@ AC_TERNARY_HI
Three variables, expensive.
@ AC_BINARY_LO
Two variables, cheap.
@ AC_CUBIC_LO
Cubic complexity, cheap.
@ AC_UNARY_HI
Only single variable, expensive.
@ AC_RECORD
Reserved for recording information.
@ AC_BINARY_HI
Two variables, expensive.
@ AC_LINEAR_HI
Linear complexity, expensive.
@ AC_CUBIC_HI
Cubic complexity, expensive.
@ AC_MAX
Maximal cost value.
@ AC_CRAZY_LO
Exponential complexity, cheap.
@ AC_LINEAR_LO
Linear complexity, cheap.
@ AC_UNARY_LO
Only single variable, cheap.
@ AC_QUADRATIC_LO
Quadratic complexity, cheap.
@ AC_CRAZY_HI
Exponential complexity, expensive.
@ AC_QUADRATIC_HI
Quadratic complexity, expensive.
Propagate trace information.
unsigned int i
Propagator id.
@ SUBSUMED
Propagator is subsumed.
@ FIX
Propagator computed fixpoint.
@ NOFIX
Propagator did not compute fixpoint.
@ FAILED
Propagator failed.
PropagateTraceInfo(unsigned int i, PropagatorGroup g, const Propagator *p, Status s)
Initialize.
const Propagator * propagator(void) const
Return pointer to non-subsumed propagator.
unsigned int id(void) const
Return propagator identifier.
Status status(void) const
Return propagator status.
const Propagator * p
Propagator.
PropagatorGroup g
Propagator group.
PropagatorGroup group(void) const
Return propagator group.
unsigned int size(Space &home) const
Return number of propagators in a group.
bool operator==(PropagatorGroup g) const
Test whether this group is equal to group g.
static PropagatorGroup def
Group of propagators not in any user-defined group.
PropagatorGroup & move(Space &home, PropagatorGroup g)
Move propagators from group g to this group.
bool operator!=(PropagatorGroup g) const
Test whether this group is different from group g.
PropagatorGroup(void)
Constructor.
PropagatorGroup & operator=(const PropagatorGroup &g)
Assignment operator.
void disable(Space &home)
Disable all propagators in a group.
void enable(Space &home, bool s=true)
Enable all propagators in a group.
Home operator()(Space &home)
To augment a space argument.
void kill(Space &home)
Kill all propagators in a group.
static PropagatorGroup all
Group of all propagators.
Base-class for propagators.
virtual void reschedule(Space &home)=0
Schedule function.
size_t size
The size of the propagator (used during subsumption)
double afc(void) const
Return the accumlated failure count.
virtual PropCost cost(const Space &home, const ModEventDelta &med) const =0
Cost function.
virtual ExecStatus advise(Space &home, Advisor &a, const Delta &d)
Advise function.
Kernel::GPI::Info & gpi(void)
Provide access to global propagator information.
unsigned int id(void) const
Return propagator id.
PropagatorGroup group(void) const
Return group propagator belongs to.
ModEventDelta modeventdelta(void) const
Return the modification event delta.
Propagator * fwd(void) const
Return forwarding pointer during copying.
friend class PropagatorGroup
bool disabled(void) const
Whether propagator is currently disabled.
virtual ExecStatus propagate(Space &home, const ModEventDelta &med)=0
Propagation function.
ModEventDelta med
A set of modification events (used during propagation)
Gecode::ActorLink * advisors
A list of advisors (used during cloning)
Class to iterate over propagators in a group.
bool operator()(void) const
Test whether there are propagators left.
const Propagator & propagator(void) const
Return propagator.
void operator++(void)
Move iterator to next propagator.
Propagators(const Space &home, PropagatorGroup g)
Initialize.
Class to iterate over branchers of a space.
Brancher & brancher(void) const
Return propagator.
void operator++(void)
Move iterator to next brancher.
Branchers(Space &home)
Initialize.
bool operator()(void) const
Test whether there are branchers left.
Class to iterate over idle propagators of a space.
void operator++(void)
Move iterator to next propagator.
Propagator & propagator(void) const
Return propagator.
bool operator()(void) const
Test whether there are propagators left.
IdlePropagators(Space &home)
Initialize.
Class to iterate over propagators of a space.
bool operator()(void) const
Test whether there are propagators left.
Propagators(Space &home)
Initialize.
void operator++(void)
Move iterator to next propagator.
Propagator & propagator(void) const
Return propagator.
Class to iterate over scheduled propagators of a space.
ScheduledPropagators(Space &home)
Initialize.
Propagator & propagator(void) const
Return propagator.
bool operator()(void) const
Test whether there are propagators left.
void operator++(void)
Move iterator to next propagator.
T * realloc(T *b, long unsigned int n, long unsigned int m)
Reallocate block of n objects starting at b to m objects of type T from the space heap.
void * ralloc(size_t s)
Allocate memory on space heap.
double afc_decay(void) const
Return AFC decay factor.
struct Gecode::Space::@61::@63 c
Data available only during copying.
T & construct(void)
Construction routines.
LocalObject * local
Linked list of local objects.
void * rrealloc(void *b, size_t n, size_t m)
Reallocate memory block starting at b from size n to size s.
void rfree(void *p, size_t s)
Free memory previously allocated with alloc (might be reused later)
struct Gecode::Space::@61::@62 p
Data only available during propagation or branching.
VarImpBase * vars_noidx
Keep variables during copying without index structure.
void * fl_alloc(void)
Allocate from freelist-managed memory.
VarImpBase * vars_u[AllVarConf::idx_c]
Entries for updating variables.
void fl_dispose(FreeList *f, FreeList *l)
Return freelist-managed memory to freelist.
unsigned int n_sub
Number of subscriptions.
T * alloc(long unsigned int n)
Allocate block of n objects of type T from space heap.
unsigned int bid_sc
Id of next brancher to be created plus status control.
ActorLink * active
Cost level with next propagator to be executed.
void free(T *b, long unsigned int n)
Delete n objects allocated from space heap starting at b.
ViewTraceInfo vti
View trace information.
Home operator()(Propagator &p)
Return a home for this space with the information that p is being rewritten.
Statistics for execution of status
unsigned long int propagate
Number of propagator executions.
void reset(void)
Reset information.
StatusStatistics(void)
Initialize.
StatusStatistics operator+(const StatusStatistics &s)
Return sum with s.
StatusStatistics & operator+=(const StatusStatistics &s)
Increment by statistics s.
Iterator over subscribed propagators.
A mutex for mutual exclausion among several threads.
Exception: too many branchers
Propagator for recording trace information.
Base-class for variable implementations.
Base class for Variable type disposer.
Variable implementation disposer
VarImpDisposer(void)
Constructor (registers disposer with kernel)
virtual void dispose(Space &home, VarImpBase *x)
Dispose list of variable implementations starting at x.
void update(Space &home, VarImpVar< VarImp > &y)
Update this variable to be a clone of variable y.
unsigned int degree(void) const
Return degree (number of subscribed propagators and advisors)
Base-class for variable implementations.
void subscribe(Space &home, Propagator &p, PropCond pc, bool assigned, ModEvent me, bool schedule)
Subscribe propagator p with propagation condition pc.
ModEvent fail(Space &home)
Run advisors to be run on failure and returns ME_GEN_FAILED.
void cancel(Space &home)
Cancel all subscriptions when variable implementation is assigned.
bool advise(Space &home, ModEvent me, Delta &d)
Run advisors when variable implementation has been modified with modification event me and domain cha...
VarImp(void)
Creation of static instances.
double afc(void) const
Return accumulated failure count (plus degree)
void subscribe(Space &home, Advisor &a, bool assigned, bool fail)
Subscribe advisor a to variable.
VarImp(Space &home, VarImp &x)
Constructor for cloning.
unsigned int bits(void) const
Provide access to free bits.
ActorLink ** base
Subscribed actors.
bool copied(void) const
Is variable already copied.
static void reschedule(Space &home, Propagator &p, PropCond pc, bool assigned, ModEvent me)
Schedule propagator p.
static void schedule(Space &home, Propagator &p, ModEvent me, bool force=false)
Schedule propagator p with modification event me.
unsigned int idx[pc_max+1]
Indices of subscribed actors.
VarImp * forward(void) const
Use forward pointer if variable already copied.
static ModEvent me(const ModEventDelta &med)
Project modification event for this variable type from med.
VarImp * next(void) const
Return next copied variable.
static ModEvent me_combine(ModEvent me1, ModEvent me2)
Combine modifications events me1 and me2.
void cancel(Space &home, Advisor &a, bool fail)
Cancel subscription of advisor a.
unsigned int degree(void) const
Return degree (number of subscribed propagators and advisors)
unsigned int & bits(void)
Provide access to free bits.
VarImp(Space &home)
Creation.
static ModEventDelta med(ModEvent me)
Translate modification event me into modification event delta.
VarImp< VIC > * fwd
Forwarding pointer.
void cancel(Space &home, Propagator &p, PropCond pc)
Cancel subscription of propagator p with propagation condition pc.
VarImp< VIC > * next
During cloning, points to the next copied variable.
void schedule(Space &home, PropCond pc1, PropCond pc2, ModEvent me)
Schedule subscribed propagators.
static ModEvent modevent(const Delta &d)
Return modification event.
What what(void) const
Return what is currently executing.
const Brancher & brancher(void) const
Return currently executing brancher.
const Propagator & propagator(void) const
Return currently executing propagator.
void other(void)
Record that nothing is known at this point.
What
What is currently executing.
@ BRANCHER
A brancher is executing.
@ POST
A post function is executing.
@ PROPAGATOR
A propagator is currently executing.
PropagatorGroup post(void) const
Return propagator group of currently executing post function.
ptrdiff_t who
Encoding a tagged pointer or a tagged group id.
void post(PropagatorGroup g)
Record that a post function with propagator group g is executing.
#define GECODE_KERNEL_REALLOC(T)
ExecStatus ES_NOFIX_PARTIAL(Propagator &p, const ModEventDelta &med)
Propagator p has not computed partial fixpoint
ExecStatus ES_FIX_PARTIAL(Propagator &p, const ModEventDelta &med)
Propagator p has computed partial fixpoint
ExecStatus ES_SUBSUMED_DISPOSED(Propagator &p, size_t s)
Propagator p is subsumed
ExecStatus ES_FIX_DISPOSE(Council< A > &c, A &a)
Advisor a must be disposed
ExecStatus ES_NOFIX_DISPOSE_FORCE(Council< A > &c, A &a)
Advisor a must be disposed and its propagator must be forcefully rescheduled
ExecStatus ES_NOFIX_DISPOSE(Council< A > &c, A &a)
Advisor a must be disposed and its propagator must be run
ExecStatus ES_SUBSUMED(Propagator &p)
void ignore(Actor &a, ActorProperty p, bool duplicate=false)
Ignore actor property.
int ModEventDelta
Modification event deltas.
bool failed(void) const
Check whether space is failed.
ActorProperty
Actor properties.
void notice(Actor &a, ActorProperty p, bool duplicate=false)
Notice actor property.
bool stable(void) const
Return if space is stable (at fixpoint or failed)
void fail(void)
Fail space.
@ AP_DISPOSE
Actor must always be disposed.
GECODE_FLOAT_EXPORT void trace(Home home, const FloatVarArgs &x, TraceFilter tf, int te=(TE_INIT|TE_PRUNE|TE_FIX|TE_FAIL|TE_DONE), FloatTracer &t=StdFloatTracer::def)
Create a tracer for float variables.
virtual Space * copy(void)=0
Copying member function.
void trycommit(const Choice &c, unsigned int a, CommitStatistics &stat=unused_commit)
If possible, commit choice c for alternative a.
void commit(const Choice &c, unsigned int a, CommitStatistics &stat=unused_commit)
Commit choice c for alternative a.
Space * clone(CloneStatistics &stat=unused_clone) const
Clone space.
@ SS_BRANCH
Space must be branched (at least one brancher left)
@ SS_SOLVED
Space is solved (no brancher left)
@ SS_FAILED
Space is failed
void print(const Search::Statistics &stat, bool restart)
Print statistics.
#define GECODE_KERNEL_EXPORT
void * ptrjoin(void *p, ptrdiff_t m)
Join unmarked pointer p and m into marked pointer.
void * ptrsplit(void *p, ptrdiff_t &m)
Split possibly marked pointer p into mark m and unmarked pointer.
void * unmark(void *p)
Return unmarked pointer for a marked pointer p.
void * fmark(void *p)
Return marked pointer for p (possibly already marked)
void * funmark(void *p)
Return unmarked pointer for a possibly marked pointer p.
void * mark(void *p)
Return marked pointer for unmarked pointer p.
bool marked(void *p)
Check whether p is marked.
Gecode toplevel namespace
Post propagator for SetVar SetOpType SetVar SetRelType r
const PropCond PC_GEN_ASSIGNED
Propagation condition for an assigned variable.
const ModEvent ME_GEN_NONE
Generic modification event: no modification.
TFE propagator(PropagatorGroup g)
Only propagators (but not post functions) from g are considered.
@ ES_OK
Execution is okay.
@ ES_FIX
Propagation has computed fixpoint.
@ ES_NOFIX_FORCE
Advisor forces rescheduling of propagator.
@ __ES_SUBSUMED
Internal: propagator is subsumed, do not use.
@ __ES_PARTIAL
Internal: propagator has computed partial fixpoint, do not use.
@ ES_FAILED
Execution has resulted in failure.
@ ES_NOFIX
Propagation has not computed fixpoint.
const ModEvent ME_GEN_FAILED
Generic modification event: failed variable.
int PropCond
Type for propagation conditions.
const ModEvent ME_GEN_ASSIGNED
Generic modification event: variable is assigned a value.
Post propagator for SetVar x
const PropCond PC_GEN_NONE
Propagation condition to be ignored (convenience)
int ModEvent
Type for modification events.
#define GECODE_NEVER
Assert that this command is never executed.
#define GECODE_NOT_NULL(p)
Assert that a pointer is never NULL.
#define GECODE_VTABLE_EXPORT