195 template<
class VarImp>
247 static const int idx_c = VIC::idx_c;
249 static const int idx_d = VIC::idx_d;
251 static const int free_bits = VIC::free_bits;
253 unsigned int entries;
255 unsigned int free_and_bits;
270 unsigned int idx[pc_max+1];
282 unsigned int idx(
PropCond pc)
const;
304 void resize(
Space& home);
322 void _fail(
Space& home);
326 #ifdef GECODE_HAS_VAR_DISPOSE 375 unsigned int degree(
void)
const;
382 double afc(
void)
const;
390 bool copied(
void)
const;
392 VarImp* forward(
void)
const;
433 unsigned int bits(
void)
const;
436 unsigned int& bits(
void);
446 static void*
operator new(size_t,
Space&);
449 static void operator delete(
void*,
Space&);
451 static void operator delete(
void*);
608 bool empty(
void)
const;
610 template<
class T>
static ActorLink* cast(T*
a);
612 template<
class T>
static const ActorLink* cast(
const T*
a);
644 virtual size_t dispose(
Space& home);
646 static void*
operator new(
size_t s,
Space& home);
648 static void operator delete(
void*
p,
Space& home);
654 static void*
operator new(
size_t s);
656 static void operator delete(
void*
p);
674 static const unsigned int GROUPID_ALL = 0U;
676 static const unsigned int GROUPID_DEF = 1U;
678 static const unsigned int GROUPID_MAX = UINT_MAX >> 2;
688 Group(
unsigned int gid0);
700 unsigned int id(
void)
const;
764 void kill(
Space& home);
767 void disable(
Space& home);
775 void enable(
Space& home,
bool s=
true);
833 void kill(
Space& home);
867 operator Space&(void);
886 bool failed(
void)
const;
926 What what(
void)
const;
930 const Brancher& brancher(
void)
const;
976 unsigned int id(
void)
const;
982 Status status(
void)
const;
1001 unsigned int id(
void)
const;
1005 const Brancher& brancher(
void)
const;
1007 const Choice& choice(
void)
const;
1009 unsigned int alternative(
void)
const;
1040 void disable(
Space& home);
1042 void enable(
Space& home);
1142 double afc(
void)
const;
1147 unsigned int id(
void)
const;
1154 bool disabled(
void)
const;
1179 bool empty(
void)
const;
1183 void dispose(
Space& home);
1200 bool operator ()(
void)
const;
1202 void operator ++(
void);
1204 A& advisor(
void)
const;
1225 bool disposed(
void)
const;
1248 static void*
operator new(
size_t s,
Space& home);
1250 static void operator delete(
void*
p,
Space& home);
1254 static void operator delete(
void*
p);
1257 static void*
operator new(
size_t s);
1294 virtual NGL* copy(
Space& home) = 0;
1297 virtual bool notice(
void)
const;
1299 virtual size_t dispose(
Space& home);
1302 bool leaf(
void)
const;
1305 NGL* next(
void)
const;
1315 static void*
operator new(
size_t s,
Space& home);
1318 static void operator delete(
void* s,
Space& home);
1320 static void operator delete(
void*
p);
1326 static void*
operator new(
size_t s);
1345 unsigned int id(
void)
const;
1351 unsigned int alternatives(
void)
const;
1356 virtual void archive(
Archive& e)
const;
1397 virtual bool status(
const Space& home)
const = 0;
1415 unsigned int a) = 0;
1440 std::ostream& o)
const;
1444 unsigned int id(
void)
const;
1517 unsigned long int n;
1525 unsigned long int ng(
void)
const;
1527 void ng(
unsigned long int n);
1553 const unsigned long int r;
1556 const unsigned long int s;
1558 const unsigned long int f;
1566 const unsigned int a;
1574 unsigned long int s,
1575 unsigned long int f,
1581 Type type(
void)
const;
1585 unsigned long int restart(
void)
const;
1588 unsigned long int solution(
void)
const;
1590 unsigned long int fail(
void)
const;
1592 const Space* last(
void)
const;
1594 const NoGoods& nogoods(
void)
const;
1598 unsigned int asset(
void)
const;
1714 Brancher* brancher(
unsigned int id);
1723 void kill_brancher(
unsigned int id);
1726 static const unsigned reserved_bid = 0U;
1729 static const unsigned int sc_bits = 2;
1731 static const unsigned int sc_fast = 0;
1733 static const unsigned int sc_disabled = 1;
1735 static const unsigned int sc_trace = 2;
1783 #ifdef GECODE_HAS_VAR_DISPOSE 1789 template<
class VIC>
VarImpBase* vars_d(
void)
const;
1859 void _commit(
const Choice&
c,
unsigned int a);
1892 void _trycommit(
const Choice&
c,
unsigned int a);
1905 void ap_notice_dispose(
Actor*
a,
bool d);
1913 void ap_ignore_dispose(
Actor*
a,
bool d);
1937 virtual ~
Space(
void);
1944 virtual Space* copy(
void) = 0;
1980 virtual bool master(
const MetaInfo& mi);
2007 virtual bool slave(
const MetaInfo& mi);
2060 const Choice* choice(
void);
2125 void commit(
const Choice&
c,
unsigned int a,
2159 void trycommit(
const Choice&
c,
unsigned int a,
2197 void print(
const Choice&
c,
unsigned int a, std::ostream& o)
const;
2323 bool failed(
void)
const;
2328 bool stable(
void)
const;
2352 T* alloc(
long unsigned int n);
2360 T* alloc(
long int n);
2368 T* alloc(
unsigned int n);
2387 void free(T*
b,
long unsigned int n);
2398 void free(T*
b,
long int n);
2409 void free(T*
b,
unsigned int n);
2420 void free(T*
b,
int n);
2433 T* realloc(T*
b,
long unsigned int n,
long unsigned int m);
2446 T* realloc(T*
b,
long int n,
long int m);
2459 T* realloc(T*
b,
unsigned int n,
unsigned int m);
2472 T* realloc(T*
b,
int n,
int m);
2481 T** realloc(T**
b,
long unsigned int n,
long unsigned int m);
2490 T** realloc(T**
b,
long int n,
long int m);
2499 T** realloc(T**
b,
unsigned int n,
unsigned int m);
2508 T** realloc(T**
b,
int n,
int m);
2510 void* ralloc(
size_t s);
2512 void rfree(
void*
p,
size_t s);
2514 void* rrealloc(
void*
b,
size_t n,
size_t m);
2516 template<
size_t>
void* fl_alloc(
void);
2536 template<
class T,
typename A1>
2537 T& construct(A1
const& a1);
2543 template<
class T,
typename A1,
typename A2>
2544 T& construct(A1
const& a1, A2
const& a2);
2550 template<
class T,
typename A1,
typename A2,
typename A3>
2551 T& construct(A1
const& a1, A2
const& a2, A3
const& a3);
2557 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4>
2558 T& construct(A1
const& a1, A2
const& a2, A3
const& a3, A4
const& a4);
2564 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5>
2565 T& construct(A1
const& a1, A2
const& a2, A3
const& a3, A4
const& a4, A5
const& a5);
2570 void afc_decay(
double d);
2573 double afc_decay(
void)
const;
2598 bool operator ()(
void)
const;
2600 void operator ++(
void);
2623 bool operator ()(
void)
const;
2625 void operator ++(
void);
2644 bool operator ()(
void)
const;
2646 void operator ++(
void);
2665 bool operator ()(
void)
const;
2667 void operator ++(
void);
2684 bool operator ()(
void)
const;
2686 void operator ++(
void);
2702 bool operator ()(
void)
const;
2704 void operator ++(
void);
2706 const Brancher& brancher(
void)
const;
2720 return mm.alloc(ssd.data().sm,s);
2724 return mm.reuse(p,s);
2728 char*
b =
static_cast<char*
>(
_b);
2730 char*
p =
static_cast<char*
>(ralloc(m));
2743 return mm.template fl_alloc<s>(ssd.data().sm);
2748 mm.template fl_dispose<s>(
f,
l);
2758 T*
p =
static_cast<T*
>(ralloc(
sizeof(T)*n));
2759 for (
long unsigned int i=n;
i--; )
2760 (
void)
new (p+
i) T();
2767 return alloc<T>(
static_cast<long unsigned int>(
n));
2772 return alloc<T>(
static_cast<long unsigned int>(
n));
2778 return alloc<T>(
static_cast<long unsigned int>(
n));
2784 for (
long unsigned int i=n;
i--; )
2786 rfree(b,n*
sizeof(T));
2792 free<T>(
b,
static_cast<long unsigned int>(
n));
2797 free<T>(
b,
static_cast<long unsigned int>(
n));
2803 free<T>(
b,
static_cast<long unsigned int>(
n));
2810 T*
p =
static_cast<T*
>(ralloc(
sizeof(T)*m));
2811 for (
long unsigned int i=n;
i--; )
2812 (
void)
new (p+
i) T(b[
i]);
2813 for (
long unsigned int i=n; i<m; i++)
2814 (
void)
new (p+
i) T();
2825 assert((n >= 0) && (m >= 0));
2826 return realloc<T>(
b,
static_cast<long unsigned int>(
n),
2827 static_cast<long unsigned int>(m));
2832 return realloc<T>(
b,
static_cast<long unsigned int>(
n),
2833 static_cast<long unsigned int>(m));
2838 assert((n >= 0) && (m >= 0));
2839 return realloc<T>(
b,
static_cast<long unsigned int>(
n),
2840 static_cast<long unsigned int>(m));
2843 #define GECODE_KERNEL_REALLOC(T) \ 2846 Space::realloc<T>(T* b, long unsigned int n, long unsigned int m) { \ 2847 return static_cast<T*>(rrealloc(b,n*sizeof(T),m*sizeof(T))); \ 2851 Space::realloc<T>(T* b, long int n, long int m) { \ 2852 assert((n >= 0) && (m >= 0)); \ 2853 return realloc<T>(b,static_cast<long unsigned int>(n), \ 2854 static_cast<long unsigned int>(m)); \ 2858 Space::realloc<T>(T* b, unsigned int n, unsigned int m) { \ 2859 return realloc<T>(b,static_cast<long unsigned int>(n), \ 2860 static_cast<long unsigned int>(m)); \ 2864 Space::realloc<T>(T* b, int n, int m) { \ 2865 assert((n >= 0) && (m >= 0)); \ 2866 return realloc<T>(b,static_cast<long unsigned int>(n), \ 2867 static_cast<long unsigned int>(m)); \ 2882 #undef GECODE_KERNEL_REALLOC 2887 return static_cast<T**
>(rrealloc(b,n*
sizeof(T),m*
sizeof(T*)));
2892 assert((n >= 0) && (m >= 0));
2893 return realloc<T*>(
b,
static_cast<long unsigned int>(
n),
2894 static_cast<long unsigned int>(m));
2899 return realloc<T*>(
b,
static_cast<long unsigned int>(
n),
2900 static_cast<long unsigned int>(m));
2905 assert((n >= 0) && (m >= 0));
2906 return realloc<T*>(
b,
static_cast<long unsigned int>(
n),
2907 static_cast<long unsigned int>(m));
2911 #ifdef GECODE_HAS_VAR_DISPOSE 2914 Space::vars_d(
void)
const {
2915 return _vars_d[VIC::idx_d];
2920 _vars_d[VIC::idx_d] =
x;
2926 Actor::operator
delete(
void*) {}
2928 Actor::operator
delete(
void*,
Space&) {}
2930 Actor::operator
new(
size_t s,
Space& home) {
2931 return home.ralloc(s);
2943 return home.ralloc(s);
2948 Advisor::operator
delete(
void*) {}
2951 Advisor::operator
delete(
void*,
Space&) {}
2953 Advisor::operator
new(
size_t s,
Space& home) {
2954 return home.ralloc(s);
2958 NGL::operator
delete(
void*) {}
2962 NGL::operator
new(
size_t s,
Space& home) {
2963 return home.ralloc(s);
2991 unsigned long int s0,
2992 unsigned long int f0,
2995 :
t(RESTART),
r(r0), s(s0),
f(f0),
l(l0),
ng(ng0),
a(0) {}
3070 p->_next =
n; n->_prev =
p;
3075 _next =
this; _prev =
this;
3082 this->_next =
a; a->_prev =
this;
3083 a->_next =
n; n->_prev =
a;
3090 a->_next =
this; this->_prev =
a;
3091 p->_next =
a; a->_prev =
p;
3096 return _next ==
this;
3127 return static_cast<Actor*
>(&
t);
3135 return static_cast<const Actor*
>(&
t);
3140 s.notice(a,p,duplicate);
3148 return const_cast<Space*
>(
this)->_clone();
3163 return ssd.data().gpi.decay();
3168 ssd.data().gpi.decay(d);
3173 return sizeof(*this);
3184 : s(s0),
p(p0), pg(pg0), bg(bg0) {}
3208 return Home(*
this,&p);
3229 who =
reinterpret_cast<ptrdiff_t
>(&
p) | PROPAGATOR;
3233 who =
reinterpret_cast<ptrdiff_t
>(&
b) | BRANCHER;
3237 who = (g.
id() << 2) | POST;
3245 return static_cast<What>(who & 3);
3249 assert(what() == PROPAGATOR);
3255 assert(what() == BRANCHER);
3256 return *
reinterpret_cast<Brancher*
>(who & ~3);
3260 assert(what() == POST);
3283 :
i(i0), g(g0),
p(p0), s(s0) {}
3309 :
b(b0),
c(c0),
a(a0) {}
3363 Propagator::disable(
Space& home) {
3364 home.pc.
p.bid_sc |= Space::sc_disabled;
3369 Propagator::enable(
Space& home) {
3385 static_cast<
Space&>(home).ssd.data().gpi.allocate
3386 (home.propagatorgroup().gid)) {
3388 assert((u.med == 0) && (u.size == 0));
3389 static_cast<Space&
>(home).pl.head(
this);
3394 : gpi_disabled(p.gpi_disabled) {
3396 assert((u.med == 0) && (u.size == 0));
3441 assert(p.u.
med != 0);
3448 assert(p.u.
med != 0);
3471 return static_cast<const Brancher*
>(&
t);
3476 gid(_home.branchergroup().gid) {
3478 bid = home.pc.
p.bid_sc >> Space::sc_bits;
3479 home.pc.
p.bid_sc += (1 << Space::sc_bits);
3480 if ((home.pc.
p.bid_sc >> Space::sc_bits) == 0U)
3483 if (home.b_status == &static_cast<Space&>(home).bl) {
3484 home.b_status =
this;
3485 if (home.b_commit == &static_cast<Space&>(home).bl)
3486 home.b_commit =
this;
3493 : bid(b.bid), gid(b.gid) {
3519 b_commit = Brancher::cast(b.next());
3521 b_status = Brancher::cast(b.next());
3534 Space::brancher(
unsigned int id) {
3551 while (b_commit != Brancher::cast(&bl))
3552 if (
id != b_commit->id())
3553 b_commit = Brancher::cast(b_commit->next());
3556 if (b_commit == Brancher::cast(&bl)) {
3558 b_commit = Brancher::cast(bl.next());
3559 while (b_commit != b_old)
3560 if (
id != b_commit->id())
3561 b_commit = Brancher::cast(b_commit->next());
3637 : bid(b.id()), alt(a) {}
3645 Choice::id(
void)
const {
3692 return sizeof(*this);
3712 Advisor::disposed(
void)
const {
3713 return prev() == NULL;
3718 return static_cast<Advisor*
>(al);
3723 return static_cast<const Advisor*
>(al);
3728 assert(!disposed());
3735 assert(!disposed());
3739 if ((n != NULL) && n->disposed())
3745 return home.pc.
p.vti;
3788 while ((a != NULL) && static_cast<A*>(a)->disposed())
3800 while ((a != NULL) && static_cast<A*>(a)->disposed())
3805 if (c.advisors != NULL) {
3809 Propagator* p_t = Propagator::cast(p_f->prev());
3814 while (*a_f != NULL) {
3815 if (static_cast<A*>(*a_f)->disposed()) {
3816 *a_f = (*a_f)->next();
3819 A*
a =
new (home) A(home,*static_cast<A*>(*a_f));
3827 a_f = (*a_f)->next_ref();
3844 if (!static_cast<A*>(a)->disposed())
3845 static_cast<A*
>(
a)->dispose(home,*
this);
3860 while ((a != NULL) && static_cast<A*>(a)->disposed())
3875 }
while ((a != NULL) && static_cast<A*>(a)->disposed());
3881 return *
static_cast<A*
>(a);
3895 if (c > pc.p.active)
3924 return ((pc.p.active < &pc.p.queue[0]) ||
3931 ap_notice_dispose(&a,d);
3934 pc.p.bid_sc |= sc_trace;
3937 pc.p.bid_sc |= sc_trace;
3948 ap_ignore_dispose(&a,d);
3964 assert((pc >= 0) && (pc < pc_max+2));
3965 return (pc == 0) ? b.base : b.base+
u.idx[pc-1];
3971 assert((pc > 0) && (pc < pc_max+2));
3972 return b.base+
u.idx[pc-1];
3978 assert((pc > 0) && (pc < pc_max+2));
3985 assert((pc > 0) && (pc < pc_max+2));
3992 b.base = NULL; entries = 0;
3993 for (
PropCond pc=1; pc<pc_max+2; pc++)
4001 b.base = NULL; entries = 0;
4002 for (
PropCond pc=1; pc<pc_max+2; pc++)
4023 d += Propagator::cast(*a)->afc(); a++;
4032 ->propagator().afc();
4048 return free_and_bits;
4054 return free_and_bits;
4057 #ifdef GECODE_HAS_VAR_DISPOSE 4061 return static_cast<VarImp<VIC>*
>(home.vars_d<VIC>());
4067 home.vars_d<VIC>(
x);
4095 free_and_bits = x.free_and_bits & ((1 << free_bits) - 1);
4096 if (x.b.
base == NULL) {
4098 reg = &home.pc.
c.vars_noidx;
4101 reg = &home.pc.
c.vars_u[idx_c];
4105 entries = x.entries;
4106 for (
PropCond pc=1; pc<pc_max+2; pc++)
4107 idx(pc) = x.
idx(pc);
4118 return static_cast<ModEvent>((med & VIC::med_mask) >> VIC::med_fst);
4130 return VIC::me_combine(me1,me2);
4137 if (VIC::med_update(p.u.
med,me) || force)
4147 schedule(home,*Propagator::cast(*p),me);
4153 if (b.base == NULL) {
4154 assert((free_and_bits >> free_bits) == 0);
4156 free_and_bits += 4 << free_bits;
4158 for (
int i=0;
i<pc_max+1;
i++)
4162 unsigned int n = degree();
4168 ((s <= b.base) && (b.base < s+home.pc.
p.n_sub)) ?
4169 (n+4) : ((n+1)*3>>1);
4171 free_and_bits += (m-
n) << free_bits;
4173 Heap::copy<ActorLink*>(prop, b.base,
n);
4182 assert(pc <= pc_max);
4184 home.pc.
p.n_sub += 1;
4185 if ((free_and_bits >> free_bits) == 0)
4187 free_and_bits -= 1 << free_bits;
4190 b.base[entries] = *actorNonZero(pc_max+1);
4192 for (
PropCond j = pc_max; j > pc; j--) {
4193 *actorNonZero(j+1) = *actorNonZero(j);
4196 *actorNonZero(pc+1) = *actor(pc);
4202 while (f < (pc == pc_max+1 ? b.base+entries : actorNonZero(pc+1)))
4217 home.pc.
p.n_sub += 1;
4218 if ((free_and_bits >> free_bits) == 0)
4220 free_and_bits -= 1 << free_bits;
4223 b.base[entries++] = *actorNonZero(pc_max+1);
4224 *actorNonZero(pc_max+1) = a;
4265 assert(pc <= pc_max);
4270 while (f < actorNonZero(pc+1))
4278 while (*f != a) f++;
4281 *f = *(actorNonZero(pc+1)-1);
4282 for (
PropCond j = pc+1; j< pc_max+1; j++) {
4283 *(actorNonZero(j)-1) = *(actorNonZero(j+1)-1);
4286 *(actorNonZero(pc_max+1)-1) = b.base[entries-1];
4289 free_and_bits += 1 << free_bits;
4290 home.pc.
p.n_sub -= 1;
4307 while (f < b.base+entries)
4315 while (*f != a) f++;
4318 *f = b.base[--entries];
4319 free_and_bits += 1 << free_bits;
4320 home.pc.
p.n_sub -= 1;
4326 if (b.base != NULL) {
4335 unsigned int n_sub = degree();
4336 home.pc.
p.n_sub -= n_sub;
4337 unsigned int n = (free_and_bits >> free_bits) + n_sub;
4344 for (
PropCond pc=1; pc<pc_max+2; pc++)
4346 free_and_bits &= (1 << free_bits) - 1;
4357 ActorLink** la = actorNonZero(pc_max+1);
4368 assert(!a->disposed());
4370 switch (p.advise(home,*a,d)) {
4376 schedule(home,p,me);
4379 schedule(home,p,me,
true);
4385 }
while (++la < le);
4397 ActorLink** la = actorNonZero(pc_max+1);
4406 Advisor* a = Advisor::cast(static_cast<ActorLink*>
4408 assert(!a->disposed());
4412 }
while (++la < le);
4429 x->u.
idx[0] =
u.idx[0];
4430 if (pc_max > 0 &&
sizeof(
ActorLink**) >
sizeof(
unsigned int))
4431 x->u.
idx[1] =
u.idx[1];
4434 static_cast<unsigned int>(x->actorNonZero(pc_max+1) - x->actor(0));
4436 static_cast<unsigned int >(x->b.
base + x->entries -
4437 x->actorNonZero(pc_max+1));
4438 unsigned int n = na + np;
4439 assert(n == x->
degree());
4452 t[0] = p0; t[1] = p1; t[2] = p2; t[3] = p3;
4453 np -= 4; t += 4; f += 4;
4458 t[0] = p0; t[1] = p1;
4459 np -= 2; t += 2; f += 2;
4468 ptrdiff_t m0, m1, m2, m3;
4481 na -= 4; t += 4; f += 4;
4491 na -= 2; t += 2; f += 2;
4516 template<
class VarImp>
4518 #ifdef GECODE_HAS_VAR_DISPOSE 4519 Space::vd[VarImp::idx_d] =
this;
4523 template<
class VarImp>
4528 x->dispose(home); x =
static_cast<VarImp*
>(x->next_d());
4529 }
while (x != NULL);
4602 return (m == LO) ? AC_UNARY_LO : AC_UNARY_HI;
4604 return (m == LO) ? AC_BINARY_LO : AC_BINARY_HI;
4606 return (m == LO) ? AC_TERNARY_LO : AC_TERNARY_HI;
4608 return (m == LO) ? lo : hi;
4617 return cost(m,AC_CRAZY_LO,AC_CRAZY_HI,n);
4622 return crazy(m,static_cast<unsigned int>(n));
4626 return cost(m,AC_CUBIC_LO,AC_CUBIC_HI,n);
4631 return cubic(m,static_cast<unsigned int>(n));
4635 return cost(m,AC_QUADRATIC_LO,AC_QUADRATIC_HI,n);
4640 return quadratic(m,static_cast<unsigned int>(n));
4644 return cost(m,AC_LINEAR_LO,AC_LINEAR_HI,n);
4649 return linear(m,static_cast<unsigned int>(n));
4653 return (m == LO) ? AC_TERNARY_LO : AC_TERNARY_HI;
4657 return (m == LO) ? AC_BINARY_LO : AC_BINARY_HI;
4661 return (m == LO) ? AC_UNARY_LO : AC_UNARY_HI;
4670 : home(home0), q(home.pc.p.active) {
4671 while (q >= &home.pc.
p.queue[0]) {
4672 if (q->
next() != q) {
4673 c = q->
next(); e = q; q--;
4679 if (!home.pl.
empty()) {
4680 c = Propagator::cast(home.pl.
next());
4681 e = Propagator::cast(&home.pl);
4697 while (q >= &home.pc.
p.queue[0]) {
4698 if (q->
next() != q) {
4699 c = q->
next(); e = q; q--;
4705 if (!home.pl.
empty()) {
4706 c = Propagator::cast(home.pl.
next());
4707 e = Propagator::cast(&home.pl);
4716 return *Propagator::cast(c);
4722 : home(home0), q(home.pc.p.
active) {
4723 while (q >= &home.pc.
p.queue[0]) {
4724 if (q->
next() != q) {
4725 c = q->
next(); e = q; q--;
4743 while (q >= &home.pc.
p.queue[0]) {
4744 if (q->
next() != q) {
4745 c = q->
next(); e = q; q--;
4756 return *Propagator::cast(c);
4762 c = Propagator::cast(home.pl.
next());
4763 e = Propagator::cast(&home.pl);
4775 return *Propagator::cast(c);
4781 : c(
Brancher::cast(home.bl.next())), e(&home.bl) {}
4792 return *Brancher::cast(c);
4849 return id() == g.
id();
4853 return id() != g.
id();
4887 return id() == g.
id();
4891 return id() != g.
id();
4958 template<
class T,
typename A1>
4961 T&
t = *
static_cast<T*
>(ralloc(
sizeof(T)));
4965 template<
class T,
typename A1,
typename A2>
4968 T&
t = *
static_cast<T*
>(ralloc(
sizeof(T)));
4972 template<
class T,
typename A1,
typename A2,
typename A3>
4975 T&
t = *
static_cast<T*
>(ralloc(
sizeof(T)));
4976 new (&
t) T(a1,a2,a3);
4979 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4>
4982 T&
t = *
static_cast<T*
>(ralloc(
sizeof(T)));
4983 new (&
t) T(a1,a2,a3,a4);
4986 template<
class T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5>
4989 T&
t = *
static_cast<T*
>(ralloc(
sizeof(T)));
4990 new (&
t) T(a1,a2,a3,a4,a5);
bool empty(void) const
Test whether actor link is empty (points to itself)
static const int med_lst
End of bits for modification event delta.
void other(void)
Record that nothing is known at this point.
Double-linked list for actors.
unsigned int alternatives(void) const
Return number of alternatives.
void reset(void)
Reset information.
const PropCond PC_GEN_NONE
Propagation condition to be ignored (convenience)
bool marked(void *p)
Check whether p is marked.
Iterator over subscribed propagators.
void init(void)
Initialize links (self-linked)
Base-class for variable implementations.
Propagator * fwd(void) const
Return forwarding pointer during copying.
Space must be branched (at least one brancher left)
Class to iterate over branchers in a group.
ActorLink ** next_ref(void)
Routines for double-linked list.
static PropCost quadratic(PropCost::Mod m, unsigned int n)
Quadratic complexity for modifier m and size measure n.
bool operator!=(PropagatorGroup g) const
Test whether this group is different from group g.
unsigned int bid_sc
Id of next brancher to be created plus status control.
BrancherGroup group(void) const
Return brancher group.
PropagatorGroup propagatorgroup(void) const
Return propagator group.
unsigned int a
Alternative.
void unlink(void)
Remove from predecessor and successor.
VarImp * forward(void) const
Use forward pointer if variable already copied.
static BrancherGroup all
Group of all branchers.
Kernel::GPI::Info & gpi(void)
Provide access to global propagator information.
LocalObject(Home home)
Constructor for creation.
static PropCost linear(PropCost::Mod m, unsigned int n)
Linear complexity for modifier pcm and size measure n.
Group & operator=(const Group &g)
Assignment operator.
bool in(Group a) const
Check whether actor group a is included in this group.
VarImp(void)
Creation of static instances.
ExecStatus ES_SUBSUMED(Propagator &p)
VarImpDisposer(void)
Constructor (registers disposer with kernel)
void update(Space &home, LocalHandle &lh)
Updating during cloning.
VarImp< VIC > * next
During cloning, points to the next copied variable.
LocalObject * object(void) const
Access to the local object.
ActorLink * next(void) const
Routines for double-linked list.
Actor must always be disposed.
Gecode::ActorLink * advisors
A list of advisors (used during cloning)
const ViewTraceInfo & operator()(const Space &home) const
Provide access to view trace information.
PropagatorGroup(void)
Constructor.
NGL(void)
Constructor for creation.
void cancel(Space &home, Propagator &p, IntSet &y)
static const int free_bits
Freely available bits.
ExecStatus ES_NOFIX_PARTIAL(Propagator &p, const ModEventDelta &med)
Propagator p has not computed partial fixpoint
~PostInfo(void)
Reset information.
static PropagatorGroup all
Group of all propagators.
static BrancherGroup def
Group of branchers not in any user-defined group.
Propagators(Space &home, PropagatorGroup g)
Initialize.
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...
ActorLink * prev(void) const
Routines for double-linked list.
const Propagator * propagator(void) const
Return pointer to non-subsumed propagator.
Class to iterate over propagators in a group.
Statistics for execution of commit
const ModEvent ME_GEN_ASSIGNED
Generic modification event: variable is assigned a value.
unsigned int degree(void) const
Return degree (number of subscribed propagators and advisors)
Local (space-shared) object.
Status
The status of a no-good literal.
int ModEvent
Type for modification events.
static void schedule(Space &home, Propagator &p, ModEvent me, bool force=false)
Schedule propagator p with modification event me.
void linear(Home home, const FloatVarArgs &x, FloatRelType frt, FloatVal c)
Post propagator for .
Branchers(Space &home)
Initialize.
static ModEvent modevent(const Delta &d)
Return modification event.
Base-class for propagators.
Internal: propagator is subsumed, do not use.
virtual ~Choice(void)
Destructor.
const Brancher & b
Brancher.
T & construct(void)
Construction routines.
static const int idx_d
Index for disposal.
static ModEventDelta med(ModEvent me)
Translate modification event me into modification event delta.
static PropCost record(void)
For recording information (no propagation allowed)
ActorLink ** base
Subscribed actors.
Propagator & propagator(void) const
Return propagator.
ExecStatus ES_NOFIX_DISPOSE(Council< A > &c, A &a)
Advisor a must be disposed and its propagator must be run
unsigned int idx[pc_max+1]
Indices of subscribed actors.
Class to iterate over advisors of a council.
static Group def
Group of actors not in any user-defined group.
void * mark(void *p)
Return marked pointer for unmarked pointer p.
BrancherGroup & move(Space &home, BrancherGroup g)
Move branchers from group g to this group.
PropagatorGroup pg
A propagator group.
Base-class for variable implementations.
LocalObject * local
Linked list of local objects.
unsigned long int propagate
Number of propagator executions.
Propagation has computed fixpoint.
unsigned int id(void) const
Return a unique id for the group.
void operator++(void)
Move iterator to next brancher.
virtual PropCost cost(const Space &home, const ModEventDelta &med) const =0
Cost function.
static PropCost unary(PropCost::Mod m)
Single variable for modifier pcm.
ExecStatus prune(Space &home, ViewArray< VX > &x, ConstIntView)
LocalHandle & operator=(const LocalHandle &lh)
Assignment operator.
void * rrealloc(void *b, size_t n, size_t m)
Reallocate memory block starting at b from size n to size s.
PostInfo(Home home)
Set information.
Base-class for both propagators and branchers.
Statistics for execution of status
void cancel(Space &home)
Cancel all subscriptions when variable implementation is assigned.
unsigned int id(void) const
Return propagator id.
A mutex for mutual exclausion among several threads.
void * funmark(void *p)
Return unmarked pointer for a possibly marked pointer p.
T * alloc(long unsigned int n)
Allocate block of n objects of type T from space heap.
CloneStatistics operator+(const CloneStatistics &s)
Return sum with s.
PropagatorGroup & move(Space &home, PropagatorGroup g)
Move propagators from group g to this group.
static const unsigned int GROUPID_DEF
Pre-defined default group id.
bool operator()(void) const
Test whether there are branchers left.
void head(ActorLink *al)
Insert al directly after this.
Gecode::FloatVal c(-8, 8)
Configuration class for variable implementations without index structure.
int p
Number of positive literals for node type.
bool leaf(void) const
Test whether literal is a leaf.
Handles for local (space-shared) objects.
Class to iterate over branchers of a space.
Gecode::IntArgs i(4, 1, 2, 3, 4)
Base-class for branchers.
Class for AFC (accumulated failure count) management.
const Brancher & brancher(void) const
Return currently executing brancher.
int n
Number of negative literals for node type.
BrancherGroup group(void) const
Return group brancher belongs to.
CloneStatistics & operator+=(const CloneStatistics &s)
Increment by statistics s.
const Propagator * p
Propagator.
What
What is currently executing.
void reset(void)
Reset information.
void reset(void)
Reset information.
BrancherGroup & operator=(const BrancherGroup &g)
Assignment operator.
bool operator()(void) const
Test whether there are propagators left.
double afc_decay(void) const
Return AFC decay factor.
static ModEvent me(const ModEventDelta &med)
Project modification event for this variable type from med.
bool copied(void) const
Is variable already copied.
Propagator & propagator(void) const
Return propagator.
static LocalObject * cast(ActorLink *al)
Static cast for a non-null pointer (to give a hint to optimizer)
Execution has resulted in failure.
PropagatorGroup & operator=(const PropagatorGroup &g)
Assignment operator.
Commit trace information.
StatusStatistics(void)
Initialize.
Propagator & propagator(void) const
Return propagator.
FloatVal operator+(const FloatVal &x)
void operator++(void)
Move iterator to next propagator.
PropagatorGroup group(void) const
Return propagator group.
Propagator for recording trace information.
Space * clone(CloneStatistics &stat=unused_clone) const
Clone space.
Statistics for execution of clone
Class to set group information when a post function is executed.
bool operator!=(const FloatVal &x, const FloatVal &y)
int PropCond
Type for propagation conditions.
void subscribe(Space &home, Propagator &p, IntSet &y)
virtual ~NoGoods(void)
Destructor.
bool failed(void) const
Check whether space is failed.
Propagator computed fixpoint.
ModEventDelta med
A set of modification events (used during propagation)
void commit(const Choice &c, unsigned int a, CommitStatistics &stat=unused_commit)
Commit choice c for alternative a.
unsigned int n_sub
Number of subscriptions.
void fail(void)
Fail space.
static const int idx_c
Index for update.
void operator++(void)
Move iterator to next propagator.
static Gecode::ModEvent me_combine(ModEvent me1, ModEvent me2)
Combine modification events me1 and me2.
struct Gecode::Space::@58::@59 p
Data only available during propagation or branching.
bool failed(void) const
Check whether corresponding space is failed.
static const int med_mask
Bitmask for modification event delta.
PropagatorGroup g
Propagator group.
unsigned int size(I &i)
Size of all ranges of range iterator i.
const Propagator & propagator(void) const
Return propagator.
bool stable(void) const
Return if space is stable (at fixpoint or failed)
ExecStatus ES_SUBSUMED_DISPOSED(Propagator &p, size_t s)
Propagator p is subsumed
CloneStatistics(void)
Initialize.
LocalHandle(void)
Create local handle pointing to NULL object.
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.
struct Gecode::Space::@58::@60 c
Data available only during copying.
const PropCond PC_GEN_ASSIGNED
Propagation condition for an assigned variable.
virtual void dispose(Space &home, VarImpBase *x)
Dispose list of variable implementations starting at x.
void * ptrjoin(void *p, ptrdiff_t m)
Join unmarked pointer p and m into marked pointer.
PropagatorGroup group(void) const
Return group propagator belongs to.
bool operator()(void) const
Test whether there are propagators left.
size_t size
The size of the propagator (used during subsumption)
virtual ExecStatus advise(Space &home, Advisor &a, const Delta &d)
Advise function.
static Support::Mutex m
Mutex for protection.
Group baseclass for controlling actors.
bool operator()(void) const
Test whether there advisors left.
bool disabled(void) const
Whether propagator is currently disabled.
friend class PropagatorGroup
union Gecode::@585::NNF::@62 u
Union depending on nodetype t.
bool operator()(void) const
Test whether there are propagators left.
const Choice & choice(void) const
Return choice.
Council(void)
Default constructor.
PropagatorGroup post(void) const
Return propagator group of currently executing post function.
#define GECODE_KERNEL_EXPORT
ExecStatus ES_FIX_DISPOSE(Council< A > &c, A &a)
Advisor a must be disposed
void * unmark(void *p)
Return unmarked pointer for a marked pointer p.
unsigned int alternative(void) const
Return alternative.
static unsigned int next
Next group id.
Home & operator=(const Home &h)
Assignment operator.
IdlePropagators(Space &home)
Initialize.
bool operator==(PropagatorGroup g) const
Test whether this group is equal to group g.
Propagate trace information.
Choice(const Brancher &b, const unsigned int a)
Initialize for particular brancher b and alternatives a.
Branchers(Space &home, BrancherGroup g)
Initialize.
TFE propagator(PropagatorGroup g)
Only propagators (but not post functions) from g are considered.
Exception: too many branchers
ExecStatus ES_FIX_PARTIAL(Propagator &p, const ModEventDelta &med)
Propagator p has computed partial fixpoint
void notice(Actor &a, ActorProperty p, bool duplicate=false)
Notice actor property.
Mod
Propagation cost modifier.
bool operator()(void) const
Test whether there are branchers left.
double afc(void) const
Return accumulated failure count (plus degree)
NGL * next(void) const
Return pointer to next literal.
bool operator()(void) const
Test whether there are propagators left.
BrancherGroup branchergroup(void) const
Return brancher group.
ModEventDelta modeventdelta(void) const
Return the modification event delta.
Advisor forces rescheduling of propagator.
void free(T *b, long unsigned int n)
Delete n objects allocated from space heap starting at b.
void * subscriptions(void) const
Get the memory area for subscriptions.
Post propagator for SetVar SetOpType SetVar SetRelType r
unsigned int id(void) const
Return brancher id.
Class to iterate over propagators of a space.
Home operator()(Space &home)
To augment a space argument.
Class to iterate over idle propagators of a space.
const Brancher & brancher(void) const
Return propagator.
Class to store data shared among several spaces.
unsigned int i
Propagator id.
void print(std::basic_ostream< Char, Traits > &s, bool assigned, IL &lb, IU &ub, unsigned int cardMin, unsigned int cardMax)
Print set view.
struct Gecode::@585::NNF::@62::@63 b
For binary nodes (and, or, eqv)
static PropagatorGroup def
Group of propagators not in any user-defined group.
Post propagator for f(x \diamond_{\mathit{op}} y) \sim_r z \f$ void rel(Home home
void * ralloc(size_t s)
Allocate memory on space heap.
ScheduledPropagators(Space &home)
Initialize.
BrancherGroup(void)
Constructor.
Propagators(Space &home)
Initialize.
Class for storing propagator information.
ActualCost ac
Actual cost.
Home operator()(Propagator &p)
Return a home extended by propagator to be rewritten.
const Brancher & brancher(void) const
Return brancher.
static PropCost cubic(PropCost::Mod m, unsigned int n)
Cubic complexity for modifier m and size measure n.
CommitStatistics operator+(const CommitStatistics &s)
Return sum with s.
Generic domain change information to be supplied to advisors.
void ignore(Actor &a, ActorProperty p, bool duplicate=false)
Ignore actor property.
Brancher(Home home)
Constructor for creation.
static const int idx_c
Index for cloning.
Home operator()(Propagator &p)
Return a home for this space with the information that p is being rewritten.
Propagator did not compute fixpoint.
struct Gecode::@585::NNF::@62::@64 a
For atomic nodes.
Propagator & propagator(void) const
Return the advisor's propagator.
Choice for performing commit
void notice(Actor &a, ActorProperty p, bool duplicate=false)
Notice actor property.
No-goods recorded from restarts.
virtual size_t dispose(Space &home)
Delete actor and return its size.
void dispose(Space &home, Council< A > &c)
Dispose the advisor.
void operator++(void)
Move iterator to next advisor.
Advisor(Space &home, Propagator &p, Council< A > &c)
Constructor for creation.
#define GECODE_KERNEL_REALLOC(T)
bool operator!=(BrancherGroup g) const
Test whether this group is different from group g.
static ActorLink * cast(T *a)
Static cast for a non-null pointer (to give a hint to optimizer)
static ModEventDelta med_combine(ModEventDelta med1, ModEventDelta med2)
Combine modification event delta med1 with med2.
CommitStatistics & operator+=(const CommitStatistics &s)
Increment by statistics s.
bool assigned(View x, int v)
Whether x is assigned to value v.
void operator++(void)
Move iterator to next propagator.
unsigned int id(void) const
Return brancher identifier.
static PropCost crazy(PropCost::Mod m, unsigned int n)
Exponential complexity for modifier m and size measure n.
Space & s
The space where the propagator is to be posted.
static NoGoods eng
Empty no-goods.
const Propagator & propagator(void) const
Return currently executing propagator.
static const PropCond pc_max
Maximal propagation condition.
Home operator()(Space &home)
To augment a space argument.
LocalObject * fwd(Space &home)
Return forwarding pointer.
void operator++(void)
Move iterator to next brancher.
static void reschedule(Space &home, Propagator &p, PropCond pc, bool assigned, ModEvent me)
Schedule propagator p.
Base-class for freelist-managed objects.
void trycommit(const Choice &c, unsigned int a, CommitStatistics &stat=unused_commit)
If possible, commit choice c for alternative a.
ModEvent fail(Space &home)
Run advisors to be run on failure and returns ME_GEN_FAILED.
void operator++(void)
Move iterator to next propagator.
Internal: propagator has computed partial fixpoint, do not use.
Variable implementation disposer
void fl_dispose(FreeList *f, FreeList *l)
Return freelist-managed memory to freelist.
const ModEvent ME_GEN_NONE
Generic modification event: no modification.
Post propagator for SetVar x
void * fmark(void *p)
Return marked pointer for p (possibly already marked)
VarImp< VIC > * fwd
Forwarding pointer.
Status status(void) const
Return propagator status.
virtual size_t dispose(Space &home)
Dispose.
Propagation has not computed fixpoint.
PropagateTraceInfo(unsigned int i, PropagatorGroup g, const Propagator *p, Status s)
Initialize.
bool operator==(BrancherGroup g) const
Test whether this group is equal to group g.
unsigned int id(void) const
Return propagator identifier.
Propagator * p
A propagator (possibly) that is currently being rewritten.
void fail(void)
Mark space as failed.
void trace(Home home, const FloatVarArgs &x, TraceFilter tf, int te, FloatTracer &t)
Create a tracer for float variables.
NGL * add(NGL *n, bool l)
Add node n and mark it as leaf l and return n.
Propagator * propagator(void) const
Return propagator (or NULL) for currently rewritten propagator.
bool in(void) const
Check whether this is a real group (and not just default)
void * ptrsplit(void *p, ptrdiff_t &m)
Split possibly marked pointer p into mark m and unmarked pointer.
bool operator==(const FloatVal &x, const FloatVal &y)
StatusStatistics operator+(const StatusStatistics &s)
Return sum with s.
#define GECODE_NOT_NULL(p)
Assert that a pointer is never NULL.
static PropCost ternary(PropCost::Mod m)
Three variables for modifier pcm.
Propagator(Home home)
Constructor for posting.
Gecode toplevel namespace
static Group all
Group of all actors.
BrancherGroup bg
A brancher group.
static ModEvent me_combine(ModEvent me1, ModEvent me2)
Combine modifications events me1 and me2.
ActorLink * active
Cost level with next propagator to be executed.
#define GECODE_VTABLE_EXPORT
Class to iterate over scheduled propagators of a space.
unsigned int pid
Propagator identifier.
What what(void) const
Return what is currently executing.
VarImpBase * vars_noidx
Keep variables during copying without index structure.
ActorProperty
Actor properties.
VarImp * next(void) const
Return next copied variable.
void reschedule(Space &home, Propagator &p, IntSet &y)
unsigned long int ng(void) const
Return number of no-goods posted.
ActualCost
The actual cost values that are used.
static const unsigned int GROUPID_ALL
Fake id for group of all actors.
unsigned long int n
Number of no-goods.
void * fl_alloc(void)
Allocate from freelist-managed memory.
int ModEventDelta
Modification event deltas.
CommitTraceInfo(const Brancher &b, const Choice &c, unsigned int a)
Initialize.
unsigned int gid
Group identifier.
static const int idx_d
Index for dispose.
ptrdiff_t who
Encoding a tagged pointer or a tagged group id.
Home class for posting propagators
unsigned int bits(void) const
Provide access to free bits.
Base class for heap allocated objects.
static const int med_fst
Start of bits for modification event delta.
static PropCost binary(PropCost::Mod m)
Two variables for modifier pcm.
#define GECODE_NEVER
Assert that this command is never executed.
A & advisor(void) const
Return advisor.
static bool med_update(ModEventDelta &med, ModEvent me)
Update modification even delta med by me, return true on change.
StatusStatistics & operator+=(const StatusStatistics &s)
Increment by statistics s.
void unary(Home home, const IntVarArgs &s, const IntArgs &p, IntPropLevel ipl)
Post propagators for scheduling tasks on unary resources.
void update(IntSet &y, Space &home, IntSet &py)
bool advise(Space &home, ModEvent me, Delta &d)
Run advisors when variable implementation has been modified with modification event me and domain cha...
Brancher & brancher(void) const
Return propagator.
CommitStatistics(void)
Initialize.
const ModEvent ME_GEN_FAILED
Generic modification event: failed variable.
ViewTraceInfo vti
View trace information.
Base class for Variable type disposer.
ExecStatus ES_NOFIX_DISPOSE_FORCE(Council< A > &c, A &a)
Advisor a must be disposed and its propagator must be forcefully rescheduled
const bool clone
Whether engines create a clone when being initialized.
double afc(void) const
Return the accumlated failure count.
TFE post(PropagatorGroup g)
Only post functions (but not propagators) from g are considered.
void rfree(void *p, size_t s)
Free memory previously allocated with alloc (might be reused later)
unsigned int gid
The group id.
void tail(ActorLink *al)
Insert al directly before this.
void subscribe(Space &home, Propagator &p, PropCond pc, bool assigned, ModEvent me, bool schedule)
Subscribe propagator p with propagation condition pc.
Space is solved (no brancher left)
No-good literal recorded during search.
~LocalHandle(void)
Destructor.