main page
modules
namespaces
classes
files
Gecode home
Generated on Fri Jan 10 2020 11:38:25 for Gecode by
doxygen
1.8.16
gecode
int
view
cached.hpp
Go to the documentation of this file.
1
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2
/*
3
* Main authors:
4
* Guido Tack <tack@gecode.org>
5
*
6
* Contributing authors:
7
* Samuel Gagnon <samuel.gagnon92@gmail.com>
8
*
9
* Copyright:
10
* Guido Tack, 2011
11
* Samuel Gagnon, 2018
12
*
13
* This file is part of Gecode, the generic constraint
14
* development environment:
15
* http://www.gecode.org
16
*
17
* Permission is hereby granted, free of charge, to any person obtaining
18
* a copy of this software and associated documentation files (the
19
* "Software"), to deal in the Software without restriction, including
20
* without limitation the rights to use, copy, modify, merge, publish,
21
* distribute, sublicense, and/or sell copies of the Software, and to
22
* permit persons to whom the Software is furnished to do so, subject to
23
* the following conditions:
24
*
25
* The above copyright notice and this permission notice shall be
26
* included in all copies or substantial portions of the Software.
27
*
28
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
29
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
30
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
31
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
32
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
33
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
34
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35
*
36
*/
37
38
namespace
Gecode
{
namespace
Int {
39
40
/*
41
* Constructors and initialization
42
*
43
*/
44
template
<
class
View>
45
forceinline
46
CachedView<View>::CachedView
(
void
) : _size(0) {}
47
template
<
class
View>
48
forceinline
49
CachedView<View>::CachedView
(
const
View&
y
)
50
:
DerivedView
<View>(
y
), _firstRange(NULL), _lastRange(NULL),
51
_size(0) {}
52
53
54
/*
55
* Value access
56
*
57
*/
58
template
<
class
View>
59
forceinline
int
60
CachedView<View>::min
(
void
)
const
{
61
return
x
.min();
62
}
63
template
<
class
View>
64
forceinline
int
65
CachedView<View>::max
(
void
)
const
{
66
return
x
.max();
67
}
68
template
<
class
View>
69
forceinline
int
70
CachedView<View>::med
(
void
)
const
{
71
return
x
.med();
72
}
73
template
<
class
View>
74
forceinline
int
75
CachedView<View>::val
(
void
)
const
{
76
return
x
.val();
77
}
78
#ifdef GECODE_HAS_CBS
79
template
<
class
View>
80
forceinline
int
81
CachedView<View>::baseval
(
int
val)
const
{
82
return
val;
83
}
84
#endif
85
86
template
<
class
View>
87
forceinline
unsigned
int
88
CachedView<View>::width
(
void
)
const
{
89
return
x
.width();
90
}
91
template
<
class
View>
92
forceinline
unsigned
int
93
CachedView<View>::size
(
void
)
const
{
94
return
x
.size();
95
}
96
template
<
class
View>
97
forceinline
unsigned
int
98
CachedView<View>::regret_min
(
void
)
const
{
99
return
x
.regret_min();
100
}
101
template
<
class
View>
102
forceinline
unsigned
int
103
CachedView<View>::regret_max
(
void
)
const
{
104
return
x
.regret_max();
105
}
106
107
/*
108
* Domain tests
109
*
110
*/
111
template
<
class
View>
112
forceinline
bool
113
CachedView<View>::range
(
void
)
const
{
114
return
x
.range();
115
}
116
template
<
class
View>
117
forceinline
bool
118
CachedView<View>::in
(
int
n
)
const
{
119
return
x
.in(
n
);
120
}
121
template
<
class
View>
122
forceinline
bool
123
CachedView<View>::in
(
long
long
int
n
)
const
{
124
return
x
.in(
n
);
125
}
126
127
128
/*
129
* Domain update by value
130
*
131
*/
132
template
<
class
View>
133
forceinline
ModEvent
134
CachedView<View>::lq
(
Space
& home,
int
n
) {
135
return
x
.lq(home,
n
);
136
}
137
template
<
class
View>
138
forceinline
ModEvent
139
CachedView<View>::lq
(
Space
& home,
long
long
int
n
) {
140
return
x
.lq(home,
n
);
141
}
142
template
<
class
View>
143
forceinline
ModEvent
144
CachedView<View>::le
(
Space
& home,
int
n
) {
145
return
x
.le(home,
n
);
146
}
147
template
<
class
View>
148
forceinline
ModEvent
149
CachedView<View>::le
(
Space
& home,
long
long
int
n
) {
150
return
x
.le(home,
n
);
151
}
152
template
<
class
View>
153
forceinline
ModEvent
154
CachedView<View>::gq
(
Space
& home,
int
n
) {
155
return
x
.gq(home,
n
);
156
}
157
template
<
class
View>
158
forceinline
ModEvent
159
CachedView<View>::gq
(
Space
& home,
long
long
int
n
) {
160
return
x
.gq(home,
n
);
161
}
162
template
<
class
View>
163
forceinline
ModEvent
164
CachedView<View>::gr
(
Space
& home,
int
n
) {
165
return
x
.gr(home,
n
);
166
}
167
template
<
class
View>
168
forceinline
ModEvent
169
CachedView<View>::gr
(
Space
& home,
long
long
int
n
) {
170
return
x
.gr(home,
n
);
171
}
172
template
<
class
View>
173
forceinline
ModEvent
174
CachedView<View>::nq
(
Space
& home,
int
n
) {
175
return
x
.nq(home,
n
);
176
}
177
template
<
class
View>
178
forceinline
ModEvent
179
CachedView<View>::nq
(
Space
& home,
long
long
int
n
) {
180
return
x
.nq(home,
n
);
181
}
182
template
<
class
View>
183
forceinline
ModEvent
184
CachedView<View>::eq
(
Space
& home,
int
n
) {
185
return
x
.eq(home,
n
);
186
}
187
template
<
class
View>
188
forceinline
ModEvent
189
CachedView<View>::eq
(
Space
& home,
long
long
int
n
) {
190
return
x
.eq(home,
n
);
191
}
192
193
194
/*
195
* Iterator-based domain update
196
*
197
*/
198
template
<
class
View>
199
template
<
class
I>
200
forceinline
ModEvent
201
CachedView<View>::narrow_r
(
Space
& home, I&
i
,
bool
depend) {
202
return
x
.narrow_r(home,
i
,depend);
203
}
204
template
<
class
View>
205
template
<
class
I>
206
forceinline
ModEvent
207
CachedView<View>::inter_r
(
Space
& home, I&
i
,
bool
depend) {
208
return
x
.inter_r(home,
i
,depend);
209
}
210
template
<
class
View>
211
template
<
class
I>
212
forceinline
ModEvent
213
CachedView<View>::minus_r
(
Space
& home, I&
i
,
bool
depend) {
214
return
x
.minus_r(home,
i
,depend);
215
}
216
template
<
class
View>
217
template
<
class
I>
218
forceinline
ModEvent
219
CachedView<View>::narrow_v
(
Space
& home, I&
i
,
bool
depend) {
220
return
x
.narrow_v(home,
i
,depend);
221
}
222
template
<
class
View>
223
template
<
class
I>
224
forceinline
ModEvent
225
CachedView<View>::inter_v
(
Space
& home, I&
i
,
bool
depend) {
226
return
x
.inter_v(home,
i
,depend);
227
}
228
template
<
class
View>
229
template
<
class
I>
230
forceinline
ModEvent
231
CachedView<View>::minus_v
(
Space
& home, I&
i
,
bool
depend) {
232
return
x
.minus_v(home,
i
,depend);
233
}
234
235
236
237
/*
238
* Propagator modification events
239
*
240
*/
241
template
<
class
View>
242
forceinline
ModEventDelta
243
CachedView<View>::med
(
ModEvent
me) {
244
return
View::med(me);
245
}
246
247
248
/*
249
* Delta information for advisors
250
*
251
*/
252
template
<
class
View>
253
forceinline
int
254
CachedView<View>::min
(
const
Delta
&
d
)
const
{
255
return
x
.min(
d
);
256
}
257
template
<
class
View>
258
forceinline
int
259
CachedView<View>::max
(
const
Delta
&
d
)
const
{
260
return
x
.max(
d
);
261
}
262
template
<
class
View>
263
forceinline
unsigned
int
264
CachedView<View>::width
(
const
Delta
&
d
)
const
{
265
return
x
.width(
d
);
266
}
267
template
<
class
View>
268
forceinline
bool
269
CachedView<View>::any
(
const
Delta
&
d
)
const
{
270
return
x
.any(
d
);
271
}
272
273
274
275
/*
276
* Cloning
277
*
278
*/
279
template
<
class
View>
280
void
281
CachedView<View>::update
(
Space
& home,
CachedView<View>
&
y
) {
282
DerivedView<View>::update
(home,
y
);
283
if
(
y
._firstRange) {
284
_firstRange =
new
(home)
RangeList
(
y
._firstRange->min(),
285
y
._firstRange->max(),NULL);
286
RangeList
* cur = _firstRange;
287
288
for
(
RangeList
* y_cur =
y
._firstRange->next(); y_cur != NULL;
289
y_cur = y_cur->next()) {
290
RangeList
* next =
291
new
(home)
RangeList
(y_cur->min(),y_cur->max(),NULL);
292
cur->
next
(next);
293
cur = next;
294
}
295
_lastRange = cur;
296
_size =
y
._size;
297
}
298
}
299
300
301
/*
302
* Cache operations
303
*
304
*/
305
template
<
class
View>
306
void
307
CachedView<View>::initCache
(
Space
& home,
const
IntSet
& s) {
308
_firstRange = NULL;
309
for
(
int
i
=s.
ranges
();
i
--;) {
310
_firstRange =
new
(home)
RangeList
(s.
min
(
i
),s.
max
(
i
),_firstRange);
311
if
(
i
==s.
ranges
()-1)
312
_lastRange = _firstRange;
313
}
314
_size = s.
size
();
315
}
316
317
template
<
class
View>
318
void
319
CachedView<View>::cache
(
Space
& home) {
320
_firstRange->dispose(home,_lastRange);
321
ViewRanges<View>
xr(
x
);
322
_firstRange =
new
(home)
RangeList
(xr.
min
(),xr.
max
(),NULL);
323
++xr;
324
RangeList
* cur = _firstRange;
325
for
(; xr(); ++xr) {
326
RangeList
* next =
new
(home)
RangeList
(xr.
min
(),xr.
max
(),NULL);
327
cur->
next
(next);
328
cur = next;
329
}
330
_lastRange = cur;
331
_size =
x
.size();
332
}
333
334
template
<
class
View>
335
forceinline
bool
336
CachedView<View>::modified
(
void
)
const
{
337
return
x
.size() != _size;
338
}
339
340
345
template
<
class
View>
346
class
ViewRanges
<
CachedView
<View> >
347
:
public
ViewRanges
<View> {
348
public
:
350
351
ViewRanges
(
void
);
354
ViewRanges
(
const
CachedView<View>
&
x
);
356
void
init(
const
CachedView<View>
&
x
);
358
};
359
360
template
<
class
View>
361
forceinline
362
ViewRanges<CachedView<View>
>
::ViewRanges
(
void
) {}
363
364
template
<
class
View>
365
forceinline
366
ViewRanges<CachedView<View>
>
::ViewRanges
(
const
CachedView<View>
&
x
) {
367
ViewRanges<IntView>::init
(
x
.base());
368
}
369
370
template
<
class
View>
371
forceinline
void
372
ViewRanges<CachedView<View>
>::init(
const
CachedView<View>
&
x
) {
373
ViewRanges<View>::init
(
x
.base());
374
}
375
376
template
<
class
View>
377
forceinline
378
ViewDiffRanges<View>::ViewDiffRanges
(
void
) {}
379
380
template
<
class
View>
381
forceinline
382
ViewDiffRanges<View>::ViewDiffRanges
(
const
CachedView<View>
&
x
)
383
: cr(
x
._firstRange), dr(
x
.
base
()) {
384
Super::init
(
cr
,
dr
);
385
}
386
387
template
<
class
View>
388
forceinline
void
389
ViewDiffRanges<View>::init
(
const
CachedView<View>
&
x
) {
390
cr.init(
x
._firstRange);
391
dr.init(
x
.base());
392
Super::init(cr,dr);
393
}
394
395
/*
396
* View comparison
397
*
398
*/
399
template
<
class
View>
400
forceinline
bool
401
operator ==
(
const
CachedView<View>
&
x
,
const
CachedView<View>
&
y
) {
402
return
(
x
.base() ==
y
.base()) && (
x
.offset() ==
y
.offset());
403
}
404
template
<
class
View>
405
forceinline
bool
406
operator !=
(
const
CachedView<View>
&
x
,
const
CachedView<View>
&
y
) {
407
return
!(
x
==
y
);
408
}
409
410
}}
411
412
// STATISTICS: int-var
413
Gecode::x
Post propagator for SetVar x
Definition:
set.hh:767
Gecode::y
Post propagator for SetVar SetOpType SetVar y
Definition:
set.hh:767
Gecode::IntSet::min
int min(int i) const
Return minimum of range at position i.
Definition:
int-set-1.hpp:152
Gecode::IntSet::max
int max(int i) const
Return maximum of range at position i.
Definition:
int-set-1.hpp:158
Gecode::Int::ViewRanges::min
int min(void) const
Return smallest value of range.
Gecode::Iter::Ranges::size
unsigned int size(I &i)
Size of all ranges of range iterator i.
Definition:
ranges-operations.hpp:74
Gecode::Float::Limits::min
const FloatNum min
Smallest allowed float value.
Definition:
float.hh:846
Gecode::range
void range(Home home, const IntVarArgs &x, SetVar y, SetVar z)
Post constraint .
Definition:
aliases.hpp:158
Gecode::Space
Computation spaces.
Definition:
core.hpp:1742
Gecode::Int::ViewDiffRanges::init
void init(const CachedView< View > &x)
Initialize with ranges for view x.
Definition:
cached.hpp:389
Gecode::Int::ViewDiffRanges::dr
ViewRanges< View > dr
Current domain iterator.
Definition:
view.hpp:1361
Gecode::IntSet::size
unsigned int size(void) const
Return size (cardinality) of set.
Definition:
int-set-1.hpp:198
Gecode::DerivedView
Base-class for derived views.
Definition:
view.hpp:230
Gecode
Gecode toplevel namespace
Gecode::Int::ViewRanges
Range iterator for integer views.
Definition:
view.hpp:54
Gecode::IntSet
Integer sets.
Definition:
int.hh:174
Gecode::Int::Count::update
void update(IntSet &y, Space &home, IntSet &py)
Definition:
rel.hpp:103
x
Node * x
Pointer to corresponding Boolean expression node.
Definition:
bool-expr.cpp:249
Gecode::Int::CachedView::CachedView
CachedView(void)
Default constructor.
Definition:
cached.hpp:46
Gecode::Delta
Generic domain change information to be supplied to advisors.
Definition:
core.hpp:204
Gecode::Int::ViewDiffRanges::cr
Iter::Ranges::RangeList cr
Cached domain iterator.
Definition:
view.hpp:1359
Gecode::Iter::Ranges::Diff< Iter::Ranges::RangeList, ViewRanges< View > >::init
void init(Iter::Ranges::RangeList &i, ViewRanges< View > &j)
Initialize with iterator i and j.
Definition:
ranges-diff.hpp:125
Gecode::Search::Config::base
const double base
Base for geometric restart sequence.
Definition:
search.hh:126
Gecode::ModEvent
int ModEvent
Type for modification events.
Definition:
core.hpp:62
Gecode::Int::ViewDiffRanges
Range iterator for cached integer views
Definition:
view.hpp:1153
Gecode::Float::Arithmetic::any
bool any(const View &x)
Test whether x is neither positive nor negative.
Definition:
mult.hpp:53
Test::Int::Distinct::d
Gecode::IntSet d(v, 7)
Gecode::Int::CachedView
Cached integer view.
Definition:
view.hpp:1166
Gecode::Int::ViewRanges::max
int max(void) const
Return largest value of range.
forceinline
#define forceinline
Definition:
config.hpp:185
Gecode::RangeList::next
RangeList * next(void) const
Return next element.
Definition:
range-list.hpp:141
n
int n
Number of negative literals for node type.
Definition:
bool-expr.cpp:234
Gecode::RangeList
Lists of ranges (intervals)
Definition:
range-list.hpp:49
Gecode::ModEventDelta
int ModEventDelta
Modification event deltas.
Definition:
core.hpp:89
Gecode::Int::operator!=
bool operator!=(const CachedView< View > &x, const CachedView< View > &y)
Definition:
cached.hpp:406
Test::Int::Basic::i
Gecode::IntArgs i({1, 2, 3, 4})
Gecode::Int::operator==
bool operator==(const CachedView< View > &x, const CachedView< View > &y)
Definition:
cached.hpp:401
Gecode::Float::Limits::max
const FloatNum max
Largest allowed float value.
Definition:
float.hh:844
Gecode::IntSet::ranges
int ranges(void) const
Return number of ranges of the specification.
Definition:
int-set-1.hpp:171