Go to the documentation of this file.
271 template<
class VarImp>
323 static const int idx_c = VIC::idx_c;
325 static const int idx_d = VIC::idx_d;
327 static const int free_bits = VIC::free_bits;
329 unsigned int entries;
331 unsigned int free_and_bits;
346 unsigned int idx[pc_max+1];
380 void resize(
Space& home);
398 void _fail(
Space& home);
402 #ifdef GECODE_HAS_VAR_DISPOSE
451 unsigned int degree(
void)
const;
458 double afc(
void)
const;
509 unsigned int bits(
void)
const;
512 unsigned int&
bits(
void);
522 static void*
operator new(size_t,
Space&);
525 static void operator delete(
void*,
Space&);
527 static void operator delete(
void*);
684 bool empty(
void)
const;
714 virtual Actor* copy(
Space& home,
bool share) = 0;
720 virtual size_t dispose(
Space& home);
722 static void*
operator new(
size_t s,
Space& home);
724 static void operator delete(
void*
p,
Space& home);
730 static void*
operator new(
size_t s);
732 static void operator delete(
void*
p);
764 Group(
unsigned int gid0);
776 unsigned int id(
void)
const;
943 operator Space&(void);
1052 unsigned int id(
void)
const;
1077 unsigned int id(
void)
const;
1116 void disable(
Space& home);
1118 void enable(
Space& home);
1218 double afc(
void)
const;
1223 unsigned int id(
void)
const;
1230 bool disabled(
void)
const;
1255 bool empty(
void)
const;
1301 bool disposed(
void)
const;
1324 static void*
operator new(
size_t s,
Space& home);
1326 static void operator delete(
void*
p,
Space& home);
1330 static void operator delete(
void*
p);
1333 static void*
operator new(
size_t s);
1370 virtual NGL* copy(
Space& home,
bool share) = 0;
1373 virtual bool notice(
void)
const;
1375 virtual size_t dispose(
Space& home);
1378 bool leaf(
void)
const;
1381 NGL* next(
void)
const;
1391 static void*
operator new(
size_t s,
Space& home);
1394 static void operator delete(
void* s,
Space& home);
1396 static void operator delete(
void*
p);
1402 static void*
operator new(
size_t s);
1421 unsigned int id(
void)
const;
1427 unsigned int alternatives(
void)
const;
1431 virtual size_t size(
void)
const = 0;
1434 virtual void archive(
Archive& e)
const;
1475 virtual bool status(
const Space& home)
const = 0;
1493 unsigned int a) = 0;
1518 std::ostream& o)
const;
1522 unsigned int id(
void)
const;
1598 unsigned long int n;
1606 unsigned long int ng(
void)
const;
1608 void ng(
unsigned long int n);
1634 const unsigned long int r;
1637 const unsigned long int s;
1639 const unsigned long int f;
1647 const unsigned int a;
1655 unsigned long int s,
1656 unsigned long int f,
1662 Type type(
void)
const;
1666 unsigned long int restart(
void)
const;
1669 unsigned long int solution(
void)
const;
1671 unsigned long int fail(
void)
const;
1673 const Space* last(
void)
const;
1675 const NoGoods& nogoods(
void)
const;
1679 unsigned int asset(
void)
const;
1752 friend class Propagators;
1755 friend class Branchers;
1795 Brancher* brancher(
unsigned int id);
1804 void kill_brancher(
unsigned int id);
1807 static const unsigned reserved_bid = 0U;
1810 static const unsigned int sc_bits = 2;
1812 static const unsigned int sc_fast = 0;
1814 static const unsigned int sc_disabled = 1;
1816 static const unsigned int sc_trace = 2;
1861 void enqueue(Propagator*
p);
1866 #ifdef GECODE_HAS_VAR_DISPOSE
1872 template<
class VIC> VarImpBase* vars_d(
void)
const;
1874 template<
class VIC>
void vars_d(VarImpBase*
x);
1876 void update(ActorLink** sub);
1881 TraceRecorder* findtr(
void);
1919 bool share_info=
true);
1954 void _commit(
const Choice&
c,
unsigned int a);
1987 void _trycommit(
const Choice&
c,
unsigned int a);
1996 void ap_notice_dispose(Actor*
a,
bool d);
2004 void ap_ignore_dispose(Actor*
a,
bool d);
2025 Space(
bool share, Space& s);
2031 virtual ~Space(
void);
2038 virtual Space* copy(
bool share) = 0;
2074 virtual bool master(
const MetaInfo& mi);
2101 virtual bool slave(
const MetaInfo& mi);
2120 SpaceStatus status(StatusStatistics& stat=unused_status);
2154 const Choice* choice(
void);
2166 const Choice* choice(Archive& e)
const;
2191 Space*
clone(
bool share_data=
true,
2192 bool share_info=
true,
2193 CloneStatistics& stat=unused_clone)
const;
2229 void commit(
const Choice&
c,
unsigned int a,
2230 CommitStatistics& stat=unused_commit);
2263 void trycommit(
const Choice&
c,
unsigned int a,
2264 CommitStatistics& stat=unused_commit);
2284 NGL* ngl(
const Choice&
c,
unsigned int a);
2301 void print(
const Choice&
c,
unsigned int a, std::ostream& o)
const;
2349 ExecStatus ES_SUBSUMED_DISPOSED(Propagator&
p,
size_t s);
2409 ExecStatus ES_NOFIX_DISPOSE_FORCE(Council<A>&
c, A&
a);
2427 bool failed(
void)
const;
2432 bool stable(
void)
const;
2436 Home operator ()(Propagator&
p);
2439 Home operator ()(PropagatorGroup pg);
2441 Home operator ()(BrancherGroup bg);
2456 T* alloc(
long unsigned int n);
2464 T* alloc(
long int n);
2472 T* alloc(
unsigned int n);
2491 void free(T*
b,
long unsigned int n);
2502 void free(T*
b,
long int n);
2513 void free(T*
b,
unsigned int n);
2524 void free(T*
b,
int n);
2537 T* realloc(T*
b,
long unsigned int n,
long unsigned int m);
2550 T* realloc(T*
b,
long int n,
long int m);
2563 T* realloc(T*
b,
unsigned int n,
unsigned int m);
2576 T* realloc(T*
b,
int n,
int m);
2585 T** realloc(T**
b,
long unsigned int n,
long unsigned int m);
2594 T** realloc(T**
b,
long int n,
long int m);
2603 T** realloc(T**
b,
unsigned int n,
unsigned int m);
2612 T** realloc(T**
b,
int n,
int m);
2614 void* ralloc(
size_t s);
2616 void rfree(
void*
p,
size_t s);
2618 void* rrealloc(
void*
b,
size_t n,
size_t m);
2620 template<
size_t>
void* fl_alloc(
void);
2626 template<
size_t>
void fl_dispose(FreeList*
f, FreeList*
l);
2649 template<
class T,
typename A1>
2650 T& construct(A1
const& a1);
2656 template<
class T,
typename A1,
typename A2>
2657 T& construct(A1
const& a1, A2
const& a2);
2663 template<
class T,
typename A1,
typename A2,
typename A3>
2664 T& construct(A1
const& a1, A2
const& a2, A3
const& a3);
2670 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4>
2671 T& construct(A1
const& a1, A2
const& a2, A3
const& a3, A4
const& a4);
2677 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5>
2678 T& construct(A1
const& a1, A2
const& a2, A3
const& a3, A4
const& a4, A5
const& a5);
2683 void afc_decay(
double d);
2686 double afc_decay(
void)
const;
2707 Propagators(Space& home);
2709 bool operator ()(
void)
const;
2711 void operator ++(
void);
2720 class ScheduledPropagators {
2732 ScheduledPropagators(Space& home);
2734 bool operator ()(
void)
const;
2736 void operator ++(
void);
2745 class IdlePropagators {
2753 IdlePropagators(Space& home);
2755 bool operator ()(
void)
const;
2757 void operator ++(
void);
2774 Branchers(Space& home);
2776 bool operator ()(
void)
const;
2778 void operator ++(
void);
2780 Brancher& brancher(
void)
const;
2831 return mm.
alloc(sm,s);
2839 char*
b =
static_cast<char*
>(
_b);
2841 char*
p =
static_cast<char*
>(
ralloc(m));
2854 return mm.template fl_alloc<s>(sm);
2859 mm.template fl_dispose<s>(
f,
l);
2869 T*
p =
static_cast<T*
>(
ralloc(
sizeof(T)*
n));
2870 for (
long unsigned int i=
n;
i--; )
2871 (
void)
new (
p+
i) T();
2878 return alloc<T>(
static_cast<long unsigned int>(
n));
2883 return alloc<T>(
static_cast<long unsigned int>(
n));
2889 return alloc<T>(
static_cast<long unsigned int>(
n));
2895 for (
long unsigned int i=
n;
i--; )
2903 free<T>(
b,
static_cast<long unsigned int>(
n));
2908 free<T>(
b,
static_cast<long unsigned int>(
n));
2914 free<T>(
b,
static_cast<long unsigned int>(
n));
2921 T*
p =
static_cast<T*
>(
ralloc(
sizeof(T)*m));
2922 for (
long unsigned int i=
n;
i--; )
2923 (
void)
new (
p+
i) T(
b[
i]);
2924 for (
long unsigned int i=
n;
i<m;
i++)
2925 (
void)
new (
p+
i) T();
2936 assert((
n >= 0) && (m >= 0));
2937 return realloc<T>(
b,
static_cast<long unsigned int>(
n),
2938 static_cast<long unsigned int>(m));
2943 return realloc<T>(
b,
static_cast<long unsigned int>(
n),
2944 static_cast<long unsigned int>(m));
2949 assert((
n >= 0) && (m >= 0));
2950 return realloc<T>(
b,
static_cast<long unsigned int>(
n),
2951 static_cast<long unsigned int>(m));
2954 #define GECODE_KERNEL_REALLOC(T) \
2957 Space::realloc<T>(T* b, long unsigned int n, long unsigned int m) { \
2958 return static_cast<T*>(rrealloc(b,n*sizeof(T),m*sizeof(T))); \
2962 Space::realloc<T>(T* b, long int n, long int m) { \
2963 assert((n >= 0) && (m >= 0)); \
2964 return realloc<T>(b,static_cast<long unsigned int>(n), \
2965 static_cast<long unsigned int>(m)); \
2969 Space::realloc<T>(T* b, unsigned int n, unsigned int m) { \
2970 return realloc<T>(b,static_cast<long unsigned int>(n), \
2971 static_cast<long unsigned int>(m)); \
2975 Space::realloc<T>(T* b, int n, int m) { \
2976 assert((n >= 0) && (m >= 0)); \
2977 return realloc<T>(b,static_cast<long unsigned int>(n), \
2978 static_cast<long unsigned int>(m)); \
2993 #undef GECODE_KERNEL_REALLOC
2998 return static_cast<T**
>(
rrealloc(
b,
n*
sizeof(T),m*
sizeof(T*)));
3003 assert((
n >= 0) && (m >= 0));
3004 return realloc<T*>(
b,
static_cast<long unsigned int>(
n),
3005 static_cast<long unsigned int>(m));
3010 return realloc<T*>(
b,
static_cast<long unsigned int>(
n),
3011 static_cast<long unsigned int>(m));
3016 assert((
n >= 0) && (m >= 0));
3017 return realloc<T*>(
b,
static_cast<long unsigned int>(
n),
3018 static_cast<long unsigned int>(m));
3022 #ifdef GECODE_HAS_VAR_DISPOSE
3025 Space::vars_d(
void)
const {
3026 return _vars_d[VIC::idx_d];
3030 Space::vars_d(VarImpBase*
x) {
3031 _vars_d[VIC::idx_d] =
x;
3037 Actor::operator
delete(
void*) {}
3039 Actor::operator
delete(
void*,
Space&) {}
3041 Actor::operator
new(
size_t s,
Space& home) {
3042 return home.ralloc(s);
3054 return home.ralloc(s);
3059 Advisor::operator
delete(
void*) {}
3062 Advisor::operator
delete(
void*,
Space&) {}
3064 Advisor::operator
new(
size_t s,
Space& home) {
3065 return home.ralloc(s);
3069 NGL::operator
delete(
void*) {}
3073 NGL::operator
new(
size_t s,
Space& home) {
3074 return home.ralloc(s);
3083 : next(NULL), fwd(NULL), use_cnt(0) {}
3086 assert(use_cnt == 0);
3094 SharedHandle::subscribe(
void) {
3095 if (o != NULL) o->use_cnt++;
3098 SharedHandle::cancel(
void) {
3099 if ((o != NULL) && (--o->use_cnt == 0))
3106 cancel(); o=
n; subscribe();
3122 cancel(); o=sh.o; subscribe();
3132 }
else if (sh.o->fwd != NULL) {
3137 sh.o->next = home.pc.
c.shared;
3138 home.pc.
c.shared = sh.o;
3173 unsigned long int s0,
3174 unsigned long int f0,
3177 :
t(RESTART),
r(r0), s(s0),
f(f0),
l(l0), ng(ng0),
a(0) {}
3181 :
t(PORTFOLIO),
r(0), s(0),
f(0),
l(NULL), ng(
NoGoods::eng),
a(a0) {}
3252 p->_next =
n;
n->_prev =
p;
3257 _next =
this; _prev =
this;
3264 this->_next =
a;
a->_prev =
this;
3265 a->_next =
n;
n->_prev =
a;
3272 a->_next =
this; this->_prev =
a;
3273 p->_next =
a;
a->_prev =
p;
3278 return _next ==
this;
3309 return static_cast<Actor*
>(&
t);
3313 Actor::cast(
const ActorLink* al) {
3317 return static_cast<const Actor*
>(&
t);
3330 return const_cast<Space*
>(
this)->_clone(share_data,share_info);
3355 return sizeof(*this);
3366 : s(s0),
p(p0), pg(pg0), bg(bg0) {}
3390 return Home(*
this,&
p);
3427 return static_cast<What>(
who & 3);
3465 :
i(i0), g(g0),
p(p0), s(s0) {}
3491 :
b(b0),
c(c0),
a(a0) {}
3527 Propagator::cast(
const ActorLink* al) {
3545 Propagator::disable(
Space& home) {
3546 home.pc.
p.bid_sc |= Space::sc_disabled;
3551 Propagator::enable(Space& home) {
3567 static_cast<
Space&>(home).gpi.allocate(home.propagatorgroup().gid)) {
3569 assert((u.med == 0) && (u.size == 0));
3570 static_cast<Space&
>(home).pl.head(
this);
3575 : gpi_disabled(
p.gpi_disabled) {
3577 assert((u.med == 0) && (u.size == 0));
3615 p.u.size =
p.dispose(*
this);
3622 assert(
p.u.med != 0);
3629 assert(
p.u.med != 0);
3648 Brancher::cast(
const ActorLink* al) {
3652 return static_cast<const Brancher*
>(&
t);
3657 gid(_home.branchergroup().gid) {
3659 bid = home.pc.
p.bid_sc >> Space::sc_bits;
3660 home.pc.
p.bid_sc += (1 << Space::sc_bits);
3661 if ((home.pc.
p.bid_sc >> Space::sc_bits) == 0U)
3664 if (home.b_status == &
static_cast<Space&
>(home).bl) {
3665 home.b_status =
this;
3666 if (home.b_commit == &
static_cast<Space&
>(home).bl)
3667 home.b_commit =
this;
3674 : bid(
b.bid), gid(
b.gid) {
3700 b_commit = Brancher::cast(
b.next());
3702 b_status = Brancher::cast(
b.next());
3708 Space::kill(Propagator&
p) {
3715 Space::brancher(
unsigned int id) {
3732 while (b_commit != Brancher::cast(&bl))
3733 if (
id != b_commit->
id())
3734 b_commit = Brancher::cast(b_commit->next());
3737 if (b_commit == Brancher::cast(&bl)) {
3739 b_commit = Brancher::cast(bl.
next());
3740 while (b_commit != b_old)
3741 if (
id != b_commit->
id())
3742 b_commit = Brancher::cast(b_commit->next());
3785 fwdcopy(home,share);
3818 : bid(
b.id()), alt(
a) {}
3826 Choice::id(
void)
const {
3873 return sizeof(*this);
3893 Advisor::disposed(
void)
const {
3894 return prev() == NULL;
3898 Advisor::cast(ActorLink* al) {
3899 return static_cast<Advisor*
>(al);
3903 Advisor::cast(
const ActorLink* al) {
3904 return static_cast<const Advisor*
>(al);
3909 assert(!disposed());
3916 assert(!disposed());
3920 if ((
n != NULL) &&
n->disposed())
3926 return home.pc.
p.vti;
3969 while ((
a != NULL) &&
static_cast<A*
>(
a)->disposed())
3981 while ((
a != NULL) &&
static_cast<A*
>(
a)->disposed())
3986 if (
c.advisors != NULL) {
3990 Propagator* p_t = Propagator::cast(p_f->prev());
3995 while (*a_f != NULL) {
3996 if (
static_cast<A*
>(*a_f)->disposed()) {
3997 *a_f = (*a_f)->
next();
4000 A*
a =
new (home)
A(home,share,*
static_cast<A*
>(*a_f));
4025 if (!
static_cast<A*
>(
a)->disposed())
4026 static_cast<A*
>(
a)->dispose(home,*
this);
4041 while ((a != NULL) &&
static_cast<A*
>(a)->disposed())
4056 }
while ((
a != NULL) &&
static_cast<A*
>(
a)->disposed());
4062 return *
static_cast<A*
>(
a);
4074 ActorLink*
c = &pc.p.queue[
p->cost(*
this,
p->u.med).ac];
4076 if (
c > pc.p.active)
4105 return ((pc.p.active < &pc.p.queue[0]) ||
4110 Space::findtr(
void) {
4112 for (
Actor**
a=d_fst;
a<d_cur;
a++)
4125 ap_notice_dispose(&
a,
d);
4128 pc.p.bid_sc |= sc_trace;
4131 pc.p.bid_sc |= sc_trace;
4145 ap_ignore_dispose(&
a,
d);
4162 assert((pc >= 0) && (pc < pc_max+2));
4163 return (pc == 0) ?
b.base :
b.base+
u.idx[pc-1];
4168 VarImp<VIC>::actorNonZero(
PropCond pc) {
4169 assert((pc > 0) && (pc < pc_max+2));
4170 return b.base+
u.idx[pc-1];
4176 assert((pc > 0) && (pc < pc_max+2));
4183 assert((pc > 0) && (pc < pc_max+2));
4190 b.base = NULL; entries = 0;
4191 for (
PropCond pc=1; pc<pc_max+2; pc++)
4199 b.base = NULL; entries = 0;
4200 for (
PropCond pc=1; pc<pc_max+2; pc++)
4221 d += Propagator::cast(*a)->afc();
a++;
4230 ->propagator().afc();
4246 return free_and_bits;
4252 return free_and_bits;
4255 #ifdef GECODE_HAS_VAR_DISPOSE
4259 return static_cast<VarImp<VIC>*
>(home.vars_d<VIC>());
4264 VarImp<VIC>::vars_d(Space& home, VarImp<VIC>*
x) {
4265 home.vars_d<VIC>(
x);
4293 free_and_bits =
x.free_and_bits & ((1 << free_bits) - 1);
4294 if (
x.b.base == NULL) {
4296 reg = &home.pc.
c.vars_noidx;
4299 reg = &home.pc.
c.vars_u[idx_c];
4303 entries =
x.entries;
4304 for (
PropCond pc=1; pc<pc_max+2; pc++)
4305 idx(pc) =
x.idx(pc);
4316 return static_cast<ModEvent>((med & VIC::med_mask) >> VIC::med_fst);
4328 return VIC::me_combine(me1,me2);
4335 if (VIC::med_update(
p.u.med,me) || force)
4345 schedule(home,*Propagator::cast(*
p),me);
4351 if (
b.base == NULL) {
4352 assert((free_and_bits >> free_bits) == 0);
4354 free_and_bits += 4 << free_bits;
4356 for (
int i=0;
i<pc_max+1;
i++)
4360 unsigned int n = degree();
4364 ActorLink** s =
static_cast<ActorLink**
>(home.mm.
subscriptions());
4366 ((s <=
b.base) && (
b.base < s+home.pc.
p.n_sub)) ?
4367 (
n+4) : ((
n+1)*3>>1);
4368 ActorLink** prop = home.
alloc<ActorLink*>(m);
4369 free_and_bits += (m-
n) << free_bits;
4371 Heap::copy<ActorLink*>(prop,
b.base,
n);
4372 home.
free<ActorLink*>(
b.base,
n);
4379 VarImp<VIC>::enter(Space& home, Propagator*
p,
PropCond pc) {
4380 assert(pc <= pc_max);
4382 home.pc.p.n_sub += 1;
4383 if ((free_and_bits >> free_bits) == 0)
4385 free_and_bits -= 1 << free_bits;
4388 b.base[entries] = *actorNonZero(pc_max+1);
4390 for (
PropCond j = pc_max; j > pc; j--) {
4391 *actorNonZero(j+1) = *actorNonZero(j);
4394 *actorNonZero(pc+1) = *actor(pc);
4399 ActorLink**
f = actor(pc);
4400 while (
f < (pc == pc_max+1 ?
b.base+entries : actorNonZero(pc+1)))
4412 VarImp<VIC>::enter(Space& home, Advisor*
a) {
4415 home.pc.p.n_sub += 1;
4416 if ((free_and_bits >> free_bits) == 0)
4418 free_and_bits -= 1 << free_bits;
4421 b.base[entries++] = *actorNonZero(pc_max+1);
4422 *actorNonZero(pc_max+1) =
a;
4463 assert(pc <= pc_max);
4468 while (
f < actorNonZero(pc+1))
4476 while (*
f !=
a)
f++;
4479 *
f = *(actorNonZero(pc+1)-1);
4480 for (
PropCond j = pc+1; j< pc_max+1; j++) {
4481 *(actorNonZero(j)-1) = *(actorNonZero(j+1)-1);
4484 *(actorNonZero(pc_max+1)-1) =
b.base[entries-1];
4487 free_and_bits += 1 << free_bits;
4488 home.pc.
p.n_sub -= 1;
4505 while (
f <
b.base+entries)
4513 while (*
f !=
a)
f++;
4516 *
f =
b.base[--entries];
4517 free_and_bits += 1 << free_bits;
4518 home.pc.
p.n_sub -= 1;
4524 if (
b.base != NULL) {
4533 unsigned int n_sub = degree();
4534 home.pc.
p.n_sub -= n_sub;
4535 unsigned int n = (free_and_bits >> free_bits) + n_sub;
4542 for (
PropCond pc=1; pc<pc_max+2; pc++)
4544 free_and_bits &= (1 << free_bits) - 1;
4555 ActorLink** la = actorNonZero(pc_max+1);
4566 assert(!
a->disposed());
4568 switch (
p.advise(home,*
a,
d)) {
4574 schedule(home,
p,me);
4577 schedule(home,
p,me,
true);
4583 }
while (++la < le);
4595 ActorLink** la = actorNonZero(pc_max+1);
4606 assert(!
a->disposed());
4610 }
while (++la < le);
4627 x->u.idx[0] =
u.idx[0];
4628 if (pc_max > 0 &&
sizeof(
ActorLink**) >
sizeof(
unsigned int))
4629 x->u.idx[1] =
u.idx[1];
4632 static_cast<unsigned int>(
x->actorNonZero(pc_max+1) -
x->actor(0));
4634 static_cast<unsigned int >(
x->b.base +
x->entries -
4635 x->actorNonZero(pc_max+1));
4636 unsigned int n = na + np;
4650 t[0] = p0;
t[1] = p1;
t[2] = p2;
t[3] = p3;
4651 np -= 4;
t += 4;
f += 4;
4654 ActorLink* p0 =
f[0]->prev();
4655 ActorLink* p1 =
f[1]->prev();
4656 t[0] = p0;
t[1] = p1;
4657 np -= 2;
t += 2;
f += 2;
4660 ActorLink* p0 =
f[0]->prev();
4666 ptrdiff_t m0, m1, m2, m3;
4679 na -= 4;
t += 4;
f += 4;
4689 na -= 2;
t += 2;
f += 2;
4701 VarImp<VIC>::update(Space& home, ActorLink**& sub) {
4702 VarImp<VIC>*
x =
static_cast<VarImp<VIC>*
>(home.pc.c.vars_u[idx_c]);
4704 VarImp<VIC>*
n =
x->next();
x->forward()->
update(
x,sub);
x =
n;
4714 template<
class VarImp>
4716 #ifdef GECODE_HAS_VAR_DISPOSE
4717 Space::vd[VarImp::idx_d] =
this;
4721 template<
class VarImp>
4726 x->dispose(home);
x =
static_cast<VarImp*
>(
x->next_d());
4727 }
while (
x != NULL);
4806 return (m ==
LO) ? lo : hi;
4820 return crazy(m,
static_cast<unsigned int>(
n));
4829 return cubic(m,
static_cast<unsigned int>(
n));
4838 return quadratic(m,
static_cast<unsigned int>(
n));
4847 return linear(m,
static_cast<unsigned int>(
n));
4867 Space::Propagators::Propagators(
Space& home0)
4868 : home(home0), q(home.pc.
p.active) {
4869 while (q >= &home.pc.p.queue[0]) {
4870 if (q->next() != q) {
4871 c = q->next(); e = q; q--;
4877 if (!home.pl.empty()) {
4878 c = Propagator::cast(home.pl.next());
4879 e = Propagator::cast(&home.pl);
4885 Space::Propagators::operator ()(
void)
const {
4889 Space::Propagators::operator ++(
void) {
4895 while (q >= &home.pc.p.queue[0]) {
4896 if (q->next() != q) {
4897 c = q->next(); e = q; q--;
4903 if (!home.pl.empty()) {
4904 c = Propagator::cast(home.pl.next());
4905 e = Propagator::cast(&home.pl);
4914 return *Propagator::cast(
c);
4919 Space::ScheduledPropagators::ScheduledPropagators(Space& home0)
4920 : home(home0), q(home.pc.
p.active) {
4921 while (q >= &home.pc.p.queue[0]) {
4922 if (q->next() != q) {
4923 c = q->next(); e = q; q--;
4931 Space::ScheduledPropagators::operator ()(
void)
const {
4935 Space::ScheduledPropagators::operator ++(
void) {
4941 while (q >= &home.pc.p.queue[0]) {
4942 if (q->next() != q) {
4943 c = q->next(); e = q; q--;
4954 return *Propagator::cast(
c);
4959 Space::IdlePropagators::IdlePropagators(Space& home) {
4960 c = Propagator::cast(home.pl.next());
4961 e = Propagator::cast(&home.pl);
4964 Space::IdlePropagators::operator ()(
void)
const {
4968 Space::IdlePropagators::operator ++(
void) {
4973 return *Propagator::cast(
c);
4978 Space::Branchers::Branchers(Space& home)
4979 :
c(Brancher::cast(home.bl.next())), e(&home.bl) {}
4981 Space::Branchers::operator ()(
void)
const {
4985 Space::Branchers::operator ++(
void) {
4989 Space::Branchers::brancher(
void)
const {
4990 return *Brancher::cast(
c);
5047 return id() == g.
id();
5051 return id() != g.
id();
5085 return id() == g.
id();
5089 return id() != g.
id();
5107 while (ps() && !g.
in(ps.propagator().group()))
5118 while (ps() && !g.
in(ps.propagator().group()));
5122 return ps.propagator();
5128 while (bs() && !g.
in(bs.brancher().group()))
5139 while (bs() && !g.
in(bs.brancher().group()));
5143 return bs.brancher();
5156 template<
class T,
typename A1>
5159 T&
t = *
static_cast<T*
>(
ralloc(
sizeof(T)));
5163 template<
class T,
typename A1,
typename A2>
5166 T&
t = *
static_cast<T*
>(
ralloc(
sizeof(T)));
5170 template<
class T,
typename A1,
typename A2,
typename A3>
5173 T&
t = *
static_cast<T*
>(
ralloc(
sizeof(T)));
5174 new (&
t) T(a1,a2,a3);
5177 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4>
5180 T&
t = *
static_cast<T*
>(
ralloc(
sizeof(T)));
5181 new (&
t) T(a1,a2,a3,a4);
5184 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5>
5187 T&
t = *
static_cast<T*
>(
ralloc(
sizeof(T)));
5188 new (&
t) T(a1,a2,a3,a4,a5);
void notice(Actor &a, ActorProperty p, bool duplicate=false)
Notice actor property.
unsigned int degree(void) const
Return degree (number of subscribed propagators and advisors)
CommitStatistics(void)
Initialize.
const ModEvent ME_GEN_ASSIGNED
Generic modification event: variable is assigned a value.
void * unmark(void *p)
Return unmarked pointer for a marked pointer p.
Post propagator for SetVar x
unsigned int n_sub
Number of subscriptions.
Home operator()(Space &home)
To augment a space argument.
static PropCost record(void)
For recording information (no propagation allowed)
@ SUBSUMED
Propagator is subsumed.
Status status(void) const
Return propagator status.
void kill(Space &home)
Kill all branchers in a group.
@ SS_SOLVED
Space is solved (no brancher left)
Advisors(const Council< A > &c)
Initialize.
PropagateTraceInfo(unsigned int i, PropagatorGroup g, const Propagator *p, Status s)
Initialize.
@ FAILED
The literal is failed.
size_t size
The size of the propagator (used during subsumption)
@ AC_MAX
Maximal cost value.
#define GECODE_VTABLE_EXPORT
unsigned int id(void) const
Return propagator id.
Configuration class for variable implementations without index structure.
static BrancherGroup all
Group of all branchers.
static const PropCond pc_max
Maximal propagation condition.
bool operator!=(PropagatorGroup g) const
Test whether this group is different from group g.
const ViewTraceInfo & operator()(const Space &home) const
Provide access to view trace information.
void * ptrsplit(void *p, ptrdiff_t &m)
Split possibly marked pointer p into mark m and unmarked pointer.
virtual void dispose(Space &home, VarImpBase *x)
Dispose list of variable implementations starting at x.
PropagatorGroup group(void) const
Return propagator group.
ViewTraceInfo vti
View trace information.
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 free(T *b, long unsigned int n)
Delete n objects allocated from space heap starting at b.
Space * clone(bool share_data=true, bool share_info=true, CloneStatistics &stat=unused_clone) const
Clone space.
Propagator for recording trace information.
BrancherGroup branchergroup(void) const
Return brancher group.
NGL * add(NGL *n, bool l)
Add node n and mark it as leaf l and return n.
Base class for Variable type disposer.
ModEvent fail(Space &home)
Run advisors to be run on failure and returns ME_GEN_FAILED.
@ AC_TERNARY_HI
Three variables, expensive.
bool stable(void) const
Return if space is stable (at fixpoint or failed)
static PropCost binary(PropCost::Mod m)
Two variables for modifier pcm.
unsigned int alternatives(void) const
Return number of alternatives.
static BrancherGroup def
Group of branchers not in any user-defined group.
void update(Space &home, bool share, Council< A > &c)
Update during cloning (copies all advisors)
StatusStatistics operator+(const StatusStatistics &s)
Return sum with s.
unsigned int size(I &i)
Size of all ranges of range iterator i.
void operator++(void)
Move iterator to next brancher.
double afc(void) const
Return accumulated failure count (plus degree)
void reset(void)
Reset information.
virtual ~Choice(void)
Destructor.
CloneStatistics & operator+=(const CloneStatistics &s)
Increment by statistics s.
PostInfo(Home home)
Set information.
static const int idx_c
Index for update.
@ FAILED
Propagator failed.
bool assigned(View x, int v)
Whether x is assigned to value v.
unsigned int size(Space &home) const
Return number of propagators in a group.
const PropCond PC_GEN_ASSIGNED
Propagation condition for an assigned variable.
void * mark(void *p)
Return marked pointer for unmarked pointer p.
Class to iterate over advisors of a council.
Class to iterate over branchers in a group.
struct Gecode::Space::@56::@57 p
Data only available during propagation or branching.
void * funmark(void *p)
Return unmarked pointer for a possibly marked pointer p.
Gecode::IntArgs i(4, 1, 2, 3, 4)
PropagatorGroup propagatorgroup(void) const
Return propagator group.
LocalHandle(void)
Create local handle pointing to NULL object.
bool empty(void) const
Test whether council has advisor left.
@ SS_BRANCH
Space must be branched (at least one brancher left)
static ModEvent me_combine(ModEvent me1, ModEvent me2)
Combine modifications events me1 and me2.
BrancherGroup bg
A brancher group.
static const unsigned int GROUPID_ALL
Fake id for group of all actors.
Space & s
The space where the propagator is to be posted.
SharedHandle::Object * object(void) const
Access to the shared object.
void commit(const Choice &c, unsigned int a, CommitStatistics &stat=unused_commit)
Commit choice c for alternative a.
static ActorLink * cast(T *a)
Static cast for a non-null pointer (to give a hint to optimizer)
PropagatorGroup g
Propagator group.
void disable(Space &home)
Disable all propagators in a group.
static const int med_fst
Start of bits for modification event delta.
Exception: too many branchers
VarImp< VIC > * fwd
Forwarding pointer.
static PropCost linear(PropCost::Mod m, unsigned int n)
Linear complexity for modifier pcm and size measure n.
const Brancher & b
Brancher.
ExecStatus ES_NOFIX_PARTIAL(Propagator &p, const ModEventDelta &med)
Propagator p has not computed partial fixpoint
unsigned int alternative(void) const
Return alternative.
void * fmark(void *p)
Return marked pointer for p (possibly already marked)
static ModEventDelta med_combine(ModEventDelta med1, ModEventDelta med2)
Combine modification event delta med1 with med2.
Local (space-shared) object.
LocalHandle & operator=(const LocalHandle &lh)
Assignment operator.
Base-class for both propagators and branchers.
@ PROPAGATOR
A propagator is currently executing.
static PropCost quadratic(PropCost::Mod m, unsigned int n)
Quadratic complexity for modifier m and size measure n.
PropagatorGroup group(void) const
Return group propagator belongs to.
unsigned int bits(void) const
Provide access to free bits.
@ __ES_PARTIAL
Internal: propagator has computed partial fixpoint, do not use.
unsigned int pid
Propagator identifier.
void update(Space &home, bool share, VarImpVar< VarImp > &y)
Update this variable to be a clone of variable y.
CloneStatistics(void)
Initialize.
ExecStatus ES_SUBSUMED_DISPOSED(Propagator &p, size_t s)
Propagator p is subsumed
unsigned int i
Propagator id.
union Gecode::@579::NNF::@61 u
Union depending on nodetype t.
const bool clone
Whether engines create a clone when being initialized.
unsigned int bid_sc
Id of next brancher to be created plus status control.
Double-linked list for actors.
Choice(const Brancher &b, const unsigned int a)
Initialize for particular brancher b and alternatives a.
@ ES_NOFIX_FORCE
Advisor forces rescheduling of propagator.
@ AC_BINARY_HI
Two variables, expensive.
PropagatorGroup & operator=(const PropagatorGroup &g)
Assignment operator.
~LocalHandle(void)
Destructor.
static Group def
Group of actors not in any user-defined group.
void fl_dispose(FreeList *f, FreeList *l)
Return freelist-managed memory to freelist.
unsigned int gid
The group id.
What
What is currently executing.
~PostInfo(void)
Reset information.
@ NOFIX
Propagator did not compute fixpoint.
@ __ES_SUBSUMED
Internal: propagator is subsumed, do not use.
Gecode toplevel namespace
void enable(Space &home, bool s=true)
Enable all propagators in a group.
BrancherGroup & move(Space &home, BrancherGroup g)
Move branchers from group g to this group.
Base-class for propagators.
@ AC_UNARY_LO
Only single variable, cheap.
double afc(void) const
Return the accumlated failure count.
No-goods recorded from restarts.
const Choice & choice(void) const
Return choice.
void print(std::basic_ostream< Char, Traits > &s, bool assigned, IL &lb, IU &ub, unsigned int cardMin, unsigned int cardMax)
Print set view.
void operator++(void)
Move iterator to next propagator.
const Brancher & brancher(void) const
Return brancher.
@ AC_LINEAR_HI
Linear complexity, expensive.
Propagator * propagator(void) const
Return propagator (or NULL) for currently rewritten propagator.
void operator++(void)
Move iterator to next advisor.
static void reschedule(Space &home, Propagator &p, PropCond pc, bool assigned, ModEvent me)
Schedule propagator p.
@ FIX
Propagator computed fixpoint.
Home operator()(Propagator &p)
Return a home extended by propagator to be rewritten.
void reschedule(Space &home, Propagator &p, IntSet &y)
unsigned int size(Space &home) const
Return number of branchers in a group.
@ POST
A post function is executing.
unsigned int id(void) const
Return brancher id.
Generic domain change information to be supplied to advisors.
static PropagatorGroup all
Group of all propagators.
Handles for local (space-shared) objects.
ActorLink * next(void) const
Home operator()(Propagator &p)
Return a home for this space with the information that p is being rewritten.
Base-class for branchers.
Commit trace information.
VarImp * forward(void) const
Use forward pointer if variable already copied.
Mod
Propagation cost modifier.
static bool med_update(ModEventDelta &med, ModEvent me)
Update modification even delta med by me, return true on change.
const Brancher & brancher(void) const
Return currently executing brancher.
NGL(void)
Constructor for creation.
Home class for posting propagators
VarImp(void)
Creation of static instances.
struct Gecode::@579::NNF::@61::@63 a
For atomic nodes.
@ AC_BINARY_LO
Two variables, cheap.
struct Gecode::@579::NNF::@61::@62 b
For binary nodes (and, or, eqv)
virtual size_t dispose(Space &home)
Dispose.
static PropCost cubic(PropCost::Mod m, unsigned int n)
Cubic complexity for modifier m and size measure n.
@ AP_DISPOSE
Actor must always be disposed.
void update(Space &home, bool share, SharedHandle &sh)
Updating during cloning.
void tail(ActorLink *al)
Insert al directly before this.
const ModEvent ME_GEN_NONE
Generic modification event: no modification.
static LocalObject * cast(ActorLink *al)
Static cast for a non-null pointer (to give a hint to optimizer)
@ AC_QUADRATIC_LO
Quadratic complexity, cheap.
const Propagator & propagator(void) const
Return propagator.
static PropCost unary(PropCost::Mod m)
Single variable for modifier pcm.
Post propagator for SetVar SetOpType SetVar SetRelType r
static const int med_lst
End of bits for modification event delta.
BrancherGroup & operator=(const BrancherGroup &g)
Assignment operator.
virtual ~NoGoods(void)
Destructor.
ActualCost ac
Actual cost.
T * alloc(long unsigned int n)
Allocate block of n objects of type T from space heap.
Global propagator information.
Home & operator=(const Home &h)
Assignment operator.
TFE post(PropagatorGroup g)
Only post functions (but not propagators) from g are considered.
void init(void)
Initialize links (self-linked)
ModEventDelta med
A set of modification events (used during propagation)
IntRelType swap(IntRelType irt)
Return swapped relation type of irt.
ModEventDelta modeventdelta(void) const
Return the modification event delta.
void trycommit(const Choice &c, unsigned int a, CommitStatistics &stat=unused_commit)
If possible, commit choice c for alternative a.
bool in(Group a) const
Check whether actor group a is included in this group.
unsigned int id(void) const
Return propagator identifier.
ActorLink ** next_ref(void)
const Propagator * propagator(void) const
Return pointer to non-subsumed propagator.
unsigned int id(void) const
Return a unique id for the group.
void * alloc(SharedMemory *sm, size_t s)
Allocate memory of size s.
Statistics for execution of clone
PropagatorGroup & move(Space &home, PropagatorGroup g)
Move propagators from group g to this group.
void * fl_alloc(void)
Allocate from freelist-managed memory.
CommitStatistics & operator+=(const CommitStatistics &s)
Increment by statistics s.
Class to set group information when a post function is executed.
Propagator * p
A propagator (possibly) that is currently being rewritten.
Group baseclass for controlling actors.
Propagators(Space &home, PropagatorGroup g)
Initialize.
Class for storing timed-decay value.
bool advise(Space &home, ModEvent me, Delta &d)
Run advisors when variable implementation has been modified with modification event me and domain cha...
#define GECODE_KERNEL_EXPORT
Council(void)
Default constructor.
IntSet * A
Position of a piece in a square board.
const Brancher & brancher(void) const
Return propagator.
unsigned int gid
Group identifier.
ActorLink * active
Cost level with next propagator to be executed.
PropagatorGroup post(void) const
Return propagator group of currently executing post function.
Base class for heap allocated objects.
VarImpBase * vars_noidx
Keep variables during copying without index structure.
#define GECODE_NEVER
Assert that this command is never executed.
@ AC_CUBIC_LO
Cubic complexity, cheap.
void reset(void)
Reset information.
LocalObject * object(void) const
Access to the local object.
Group & operator=(const Group &g)
Assignment operator.
void subscribe(Space &home, Propagator &p, PropCond pc, bool assigned, ModEvent me, bool schedule)
Subscribe propagator p with propagation condition pc.
ExecStatus prune(Space &home, ViewArray< VX > &x, ConstIntView)
static const int free_bits
Freely available bits.
Exception: action has wrong arity
void reuse(void *p, size_t s)
Store for reusal, if of sufficient size for free list.
int ModEvent
Type for modification events.
Propagator & propagator(void) const
Return the advisor's propagator.
Base-class for freelist-managed objects.
PropagatorGroup(void)
Constructor.
BrancherGroup(void)
Constructor.
const Propagator * p
Propagator.
VarImp< VIC > * next
During cloning, points to the next copied variable.
@ AC_UNARY_HI
Only single variable, expensive.
StatusStatistics & operator+=(const StatusStatistics &s)
Increment by statistics s.
Gecode::ActorLink * advisors
A list of advisors (used during cloning)
bool operator!=(BrancherGroup g) const
Test whether this group is different from group g.
double afc_decay(void) const
Return AFC decay factor.
int PropCond
Type for propagation conditions.
ActorProperty
Actor properties.
bool operator==(PropagatorGroup g) const
Test whether this group is equal to group g.
static const unsigned int GROUPID_DEF
Pre-defined default group id.
bool failed(void) const
Check whether space is failed.
VarImpDisposer(void)
Constructor (registers disposer with kernel)
void fail(void)
Fail space.
static PropCost ternary(PropCost::Mod m)
Three variables for modifier pcm.
bool failed(void) const
Check whether corresponding space is failed.
bool empty(void) const
Test whether actor link is empty (points to itself)
ActualCost
The actual cost values that are used.
unsigned long int propagate
Number of propagator executions.
bool leaf(void) const
Test whether literal is a leaf.
ActorLink * prev(void) const
Routines for double-linked list.
bool in(void) const
Check whether this is a real group (and not just default)
bool operator==(BrancherGroup g) const
Test whether this group is equal to group g.
void * subscriptions(void) const
Get the memory area for subscriptions.
Class for AFC (accumulated failure count) management.
void cancel(Space &home, Propagator &p, IntSet &y)
BrancherGroup group(void) const
Return group brancher belongs to.
Iterator over subscribed propagators.
void fail(void)
Mark space as failed.
@ AC_RECORD
Reserved for recording information.
void reset(void)
Reset information.
Branchers(Space &home, BrancherGroup g)
Initialize.
void * rrealloc(void *b, size_t n, size_t m)
Reallocate memory block starting at b from size n to size s.
static const int idx_c
Index for cloning.
LocalObject * local
Linked list of local objects.
static PropagatorGroup def
Group of propagators not in any user-defined group.
static Group all
Group of all actors.
CommitStatistics operator+(const CommitStatistics &s)
Return sum with s.
bool operator()(void) const
Test whether there are branchers left.
StatusStatistics(void)
Initialize.
IntPropLevel sm(IntPropLevel ipl)
Extract speed or memory from propagation level.
void dispose(Space &home, Council< A > &c)
Dispose the advisor.
unsigned int degree(void) const
Return degree (number of subscribed propagators and advisors)
bool disabled(void) const
Whether propagator is currently disabled.
static void schedule(Space &home, Propagator &p, ModEvent me, bool force=false)
Schedule propagator p with modification event me.
@ ES_FIX
Propagation has computed fixpoint.
@ AC_CRAZY_LO
Exponential complexity, cheap.
void rfree(void *p, size_t s)
Free memory previously allocated with alloc (might be reused later)
void unlink(void)
Remove from predecessor and successor.
CommitTraceInfo(const Brancher &b, const Choice &c, unsigned int a)
Initialize.
static ModEvent me(const ModEventDelta &med)
Project modification event for this variable type from med.
~SharedHandle(void)
Destructor that maintains reference count.
static ModEvent modevent(const Delta &d)
Return modification event.
Statistics for execution of status
static const int idx_d
Index for dispose.
@ AC_CRAZY_HI
Exponential complexity, expensive.
struct Gecode::Space::@56::@58 c
Data available only during copying.
static ModEventDelta med(ModEvent me)
Translate modification event me into modification event delta.
void update(Space &home, bool share, LocalHandle &lh)
Updating during cloning.
virtual ~Object(void)
Delete shared object.
void decay(double d)
Set decay factor to d.
unsigned int id(void) const
Return brancher identifier.
static NoGoods eng
Empty no-goods.
const Propagator & propagator(void) const
Return currently executing propagator.
const ModEvent ME_GEN_FAILED
Generic modification event: failed variable.
SharedHandle & operator=(const SharedHandle &sh)
Assignment operator maintaining reference count.
ExecStatus ES_NOFIX_DISPOSE_FORCE(Council< A > &c, A &a)
Advisor a must be disposed and its propagator must be forcefully rescheduled
@ SUBSUMED
The literal is subsumed.
bool operator()(void) const
Test whether there advisors left.
BrancherGroup group(void) const
Return brancher group.
PropagatorGroup pg
A propagator group.
@ AC_TERNARY_LO
Three variables, cheap.
Base-class for variable implementations.
Base-class for variable implementations.
void ignore(Actor &a, ActorProperty p, bool duplicate=false)
Ignore actor property.
void * ptrjoin(void *p, ptrdiff_t m)
Join unmarked pointer p and m into marked pointer.
unsigned long int n
Number of no-goods.
virtual size_t dispose(Space &home)
Delete actor and return its size.
Home operator()(Space &home)
To augment a space argument.
void head(ActorLink *al)
Insert al directly after this.
ptrdiff_t who
Encoding a tagged pointer or a tagged group id.
Post propagator for f(x \diamond_{\mathit{op}} y) \sim_r z \f$ void rel(Home home
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.
LocalObject * fwd(Space &home, bool share)
Return forwarding pointer.
static unsigned int next
Next group id.
Gecode::FloatVal c(-8, 8)
bool copied(void) const
Is variable already copied.
void kill(Space &home)
Kill all propagators in a group.
Shared object for several memory areas.
No-good literal recorded during search.
A & advisor(void) const
Return advisor.
void cancel(Space &home)
Cancel all subscriptions when variable implementation is assigned.
SharedHandle::Object * shared
Linked list of shared objects.
void dispose(Space &home)
Dispose council.
const PropCond PC_GEN_NONE
Propagation condition to be ignored (convenience)
friend class PropagatorGroup
A mutex for mutual exclausion among several threads.
Propagate trace information.
void subscribe(Space &home, Propagator &p, IntSet &y)
ActorLink ** base
Subscribed actors.
unsigned int idx[pc_max+1]
Indices of subscribed actors.
int n
Number of negative literals for node type.
Status
The status of a no-good literal.
Choice for performing commit
void notice(Actor &a, ActorProperty p, bool duplicate=false)
Notice actor property.
Variable implementation disposer
@ ES_FAILED
Execution has resulted in failure.
ExecStatus ES_FIX_PARTIAL(Propagator &p, const ModEventDelta &med)
Propagator p has computed partial fixpoint
@ AC_LINEAR_LO
Linear complexity, cheap.
void * ralloc(size_t s)
Allocate memory on space heap.
int ModEventDelta
Modification event deltas.
@ AC_QUADRATIC_HI
Quadratic complexity, expensive.
SharedHandle(void)
Create shared handle with no object pointing to.
@ ES_NOFIX
Propagation has not computed fixpoint.
@ BRANCHER
A brancher is executing.
static const unsigned int GROUPID_MAX
The maximal group number.
NGL * next(void) const
Return pointer to next literal.
Propagator * fwd(void) const
Return forwarding pointer during copying.
ExecStatus ES_FIX_DISPOSE(Council< A > &c, A &a)
Advisor a must be disposed
What what(void) const
Return what is currently executing.
virtual Object * copy(void) const =0
Return fresh copy for update.
static const int idx_d
Index for disposal.
@ ES_OK
Execution is okay.
@ SS_FAILED
Space is failed
Class to iterate over propagators in a group.
Statistics for execution of commit
int p
Number of positive literals for node type.
TFE propagator(PropagatorGroup g)
Only propagators (but not post functions) from g are considered.
CloneStatistics operator+(const CloneStatistics &s)
Return sum with s.
unsigned long int ng(void) const
Return number of no-goods posted.
void other(void)
Record that nothing is known at this point.
bool operator()(void) const
Test whether there are propagators left.
#define GECODE_NOT_NULL(p)
Assert that a pointer is never NULL.
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.
bool marked(void *p)
Check whether p is marked.
static PropCost crazy(PropCost::Mod m, unsigned int n)
Exponential complexity for modifier m and size measure n.
@ AC_CUBIC_HI
Cubic complexity, expensive.
GPI::Info & gpi(void)
Provide access to global propagator information.
static Support::Mutex m
Mutex for protection.
static Gecode::ModEvent me_combine(ModEvent me1, ModEvent me2)
Combine modification events me1 and me2.
T & construct(void)
Construction routines.
#define GECODE_KERNEL_REALLOC(T)
unsigned int a
Alternative.
static const int med_mask
Bitmask for modification event delta.