Generated on Sat Jan 12 2019 20:58:51 for Gecode by doxygen 1.8.13
rel.cpp
Go to the documentation of this file.
1 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2 /*
3  * Main authors:
4  * Christian Schulte <schulte@gecode.org>
5  * Vincent Barichard <Vincent.Barichard@univ-angers.fr>
6  *
7  * Copyright:
8  * Christian Schulte, 2002
9  * Vincent Barichard, 2012
10  *
11  * This file is part of Gecode, the generic constraint
12  * development environment:
13  * http://www.gecode.org
14  *
15  * Permission is hereby granted, free of charge, to any person obtaining
16  * a copy of this software and associated documentation files (the
17  * "Software"), to deal in the Software without restriction, including
18  * without limitation the rights to use, copy, modify, merge, publish,
19  * distribute, sublicense, and/or sell copies of the Software, and to
20  * permit persons to whom the Software is furnished to do so, subject to
21  * the following conditions:
22  *
23  * The above copyright notice and this permission notice shall be
24  * included in all copies or substantial portions of the Software.
25  *
26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
30  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
31  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
32  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
33  *
34  */
35 
36 #include <gecode/float/rel.hh>
37 
38 #include <algorithm>
39 
40 namespace Gecode {
41 
42  void
43  rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n) {
44  using namespace Float;
45  Limits::check(n,"Float::rel");
47  FloatView x(x0);
48  switch (frt) {
49  case FRT_EQ: GECODE_ME_FAIL(x.eq(home,n)); break;
50  case FRT_NQ:
52  break;
53  case FRT_LQ: GECODE_ME_FAIL(x.lq(home,n)); break;
54  case FRT_LE:
55  GECODE_ME_FAIL(x.lq(home,n));
57  break;
58  case FRT_GQ: GECODE_ME_FAIL(x.gq(home,n)); break;
59  case FRT_GR:
60  GECODE_ME_FAIL(x.gq(home,n));
62  break;
63  default: throw UnknownRelation("Float::rel");
64  }
65  }
66 
67  void
68  rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1) {
69  using namespace Float;
71  switch (frt) {
72  case FRT_EQ:
74  break;
75  case FRT_NQ:
77  break;
78  case FRT_GQ:
79  std::swap(x0,x1); // Fall through
80  case FRT_LQ:
81  GECODE_ES_FAIL((Rel::Lq<FloatView>::post(home,x0,x1))); break;
82  case FRT_GR:
83  std::swap(x0,x1); // Fall through
84  case FRT_LE:
85  GECODE_ES_FAIL((Rel::Le<FloatView>::post(home,x0,x1))); break;
86  default:
87  throw UnknownRelation("Float::rel");
88  }
89  }
90 
91  void
92  rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1, Reify r) {
93  using namespace Float;
95  switch (frt) {
96  case FRT_EQ:
97  switch (r.mode()) {
98  case RM_EQV:
100  post(home,x0,x1,r.var())));
101  break;
102  case RM_IMP:
104  post(home,x0,x1,r.var())));
105  break;
106  case RM_PMI:
108  post(home,x0,x1,r.var())));
109  break;
110  default: throw Int::UnknownReifyMode("Float::rel");
111  }
112  break;
113  case FRT_NQ:
114  {
115  Int::NegBoolView n(r.var());
116  switch (r.mode()) {
117  case RM_EQV:
119  post(home,x0,x1,n)));
120  break;
121  case RM_IMP:
123  post(home,x0,x1,n)));
124  break;
125  case RM_PMI:
127  post(home,x0,x1,n)));
128  break;
129  default: throw Int::UnknownReifyMode("Float::rel");
130  }
131  break;
132  }
133  case FRT_GQ:
134  std::swap(x0,x1); // Fall through
135  case FRT_LQ:
136  switch (r.mode()) {
137  case RM_EQV:
139  post(home,x0,x1,r.var())));
140  break;
141  case RM_IMP:
143  post(home,x0,x1,r.var())));
144  break;
145  case RM_PMI:
147  post(home,x0,x1,r.var())));
148  break;
149  default: throw Int::UnknownReifyMode("Float::rel");
150  }
151  break;
152  case FRT_LE:
153  std::swap(x0,x1); // Fall through
154  case FRT_GR:
155  {
156  Int::NegBoolView n(r.var());
157  switch (r.mode()) {
158  case RM_EQV:
160  post(home,x0,x1,n)));
161  break;
162  case RM_IMP:
164  post(home,x0,x1,n)));
165  break;
166  case RM_PMI:
168  post(home,x0,x1,n)));
169  break;
170  default: throw Int::UnknownReifyMode("Float::rel");
171  }
172  break;
173  }
174  default:
175  throw Int::UnknownRelation("Float::rel");
176  }
177  }
178 
179  void
181  using namespace Float;
182  Limits::check(n,"Float::rel");
183  GECODE_POST;
184  switch (frt) {
185  case FRT_EQ:
186  switch (r.mode()) {
187  case RM_EQV:
188  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::BoolView,RM_EQV>::
189  post(home,x,n,r.var())));
190  break;
191  case RM_IMP:
192  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::BoolView,RM_IMP>::
193  post(home,x,n,r.var())));
194  break;
195  case RM_PMI:
196  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::BoolView,RM_PMI>::
197  post(home,x,n,r.var())));
198  break;
199  default: throw Int::UnknownReifyMode("Float::rel");
200  }
201  break;
202  case FRT_NQ:
203  {
204  Int::NegBoolView nb(r.var());
205  switch (r.mode()) {
206  case RM_EQV:
207  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::NegBoolView,RM_EQV>::
208  post(home,x,n,nb)));
209  break;
210  case RM_IMP:
211  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::NegBoolView,RM_PMI>::
212  post(home,x,n,nb)));
213  break;
214  case RM_PMI:
215  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::NegBoolView,RM_IMP>::
216  post(home,x,n,nb)));
217  break;
218  default: throw Int::UnknownReifyMode("Float::rel");
219  }
220  break;
221  }
222  case FRT_LQ:
223  switch (r.mode()) {
224  case RM_EQV:
225  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::BoolView,RM_EQV>::
226  post(home,x,n,r.var())));
227  break;
228  case RM_IMP:
229  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::BoolView,RM_IMP>::
230  post(home,x,n,r.var())));
231  break;
232  case RM_PMI:
233  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::BoolView,RM_PMI>::
234  post(home,x,n,r.var())));
235  break;
236  default: throw Int::UnknownReifyMode("Float::rel");
237  }
238  break;
239  case FRT_LE:
240  switch (r.mode()) {
241  case RM_EQV:
242  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::BoolView,RM_EQV>::
243  post(home,x,n,r.var())));
244  break;
245  case RM_IMP:
246  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::BoolView,RM_IMP>::
247  post(home,x,n,r.var())));
248  break;
249  case RM_PMI:
250  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::BoolView,RM_PMI>::
251  post(home,x,n,r.var())));
252  break;
253  default: throw Int::UnknownReifyMode("Float::rel");
254  }
255  break;
256  case FRT_GQ:
257  {
258  Int::NegBoolView nb(r.var());
259  switch (r.mode()) {
260  case RM_EQV:
261  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::NegBoolView,RM_EQV>::
262  post(home,x,n,nb)));
263  break;
264  case RM_IMP:
265  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::NegBoolView,RM_PMI>::
266  post(home,x,n,nb)));
267  break;
268  case RM_PMI:
269  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::NegBoolView,RM_IMP>::
270  post(home,x,n,nb)));
271  break;
272  default: throw Int::UnknownReifyMode("Float::rel");
273  }
274  break;
275  }
276  case FRT_GR:
277  {
278  Int::NegBoolView nb(r.var());
279  switch (r.mode()) {
280  case RM_EQV:
281  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::NegBoolView,RM_EQV>::
282  post(home,x,n,nb)));
283  break;
284  case RM_IMP:
285  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::NegBoolView,RM_PMI>::
286  post(home,x,n,nb)));
287  break;
288  case RM_PMI:
289  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::NegBoolView,RM_IMP>::
290  post(home,x,n,nb)));
291  break;
292  default: throw Int::UnknownReifyMode("Float::rel");
293  }
294  break;
295  }
296  default:
297  throw Int::UnknownRelation("Float::rel");
298  }
299  }
300 
301  void
302  rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVal c) {
303  using namespace Float;
304  Limits::check(c,"Float::rel");
305  GECODE_POST;
306  switch (frt) {
307  case FRT_EQ:
308  for (int i=x.size(); i--; ) {
309  FloatView xi(x[i]); GECODE_ME_FAIL(xi.eq(home,c));
310  }
311  break;
312  case FRT_NQ:
313  for (int i=x.size(); i--; ) {
314  FloatView xi(x[i]); GECODE_ES_FAIL((Rel::NqFloat<FloatView>::post(home,xi,c)));
315  }
316  break;
317  case FRT_LQ:
318  for (int i=x.size(); i--; ) {
319  FloatView xi(x[i]); GECODE_ME_FAIL(xi.lq(home,c));
320  }
321  break;
322  case FRT_LE:
323  for (int i=x.size(); i--; ) {
324  FloatView xi(x[i]); GECODE_ME_FAIL(xi.lq(home,c));
326  }
327  break;
328  case FRT_GQ:
329  for (int i=x.size(); i--; ) {
330  FloatView xi(x[i]); GECODE_ME_FAIL(xi.gq(home,c));
331  }
332  break;
333  case FRT_GR:
334  for (int i=x.size(); i--; ) {
335  FloatView xi(x[i]); GECODE_ME_FAIL(xi.gq(home,c));
337  }
338  break;
339  default:
340  throw UnknownRelation("Float::rel");
341  }
342  }
343 
344  void
345  rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVar y) {
346  using namespace Float;
347  GECODE_POST;
348  switch (frt) {
349  case FRT_EQ:
350  for (int i=x.size(); i--; ) {
352  }
353  break;
354  case FRT_NQ:
355  for (int i=x.size(); i--; ) {
357  }
358  break;
359  case FRT_GQ:
360  for (int i=x.size(); i--; ) {
362  }
363  break;
364  case FRT_GR:
365  for (int i=x.size(); i--; ) {
367  }
368  break;
369  case FRT_LQ:
370  for (int i=x.size(); i--; ) {
372  }
373  break;
374  case FRT_LE:
375  for (int i=x.size(); i--; ) {
377  }
378  break;
379  default:
380  throw UnknownRelation("Float::rel");
381  }
382  }
383 }
384 
385 // STATISTICS: float-post
Inverse implication for reification.
Definition: int.hh:869
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1569
ReifyMode mode(void) const
Return reification mode.
Definition: reify.hpp:56
Negated Boolean view.
Definition: view.hpp:1574
Disequality ( )
Definition: float.hh:1070
Less or equal ( )
Definition: float.hh:1071
Passing float variables.
Definition: float.hh:979
Less ( )
Definition: float.hh:1072
static ExecStatus post(Home home, View x0, FloatVal c)
Post bounds consistent propagator .
Definition: nq.hpp:92
Reified less or equal propagator.
Definition: rel.hh:548
Greater or equal ( )
Definition: float.hh:1073
Exception: Unknown relation passed as argument
Definition: exception.hpp:87
Reified equality propagator
Definition: rel.hh:174
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:234
Gecode::IntArgs i({1, 2, 3, 4})
FloatRelType
Relation types for floats.
Definition: float.hh:1068
Reification specification.
Definition: int.hh:876
Less or equal propagator.
Definition: rel.hh:493
Equality ( )
Definition: float.hh:1069
Greater ( )
Definition: float.hh:1074
Post propagator for SetVar SetOpType SetVar SetRelType r
Definition: set.hh:767
void check(const FloatVal &n, const char *l)
Check whether float n is a valid number, otherwise throw out of limits exception with information l...
Definition: limits.hpp:44
Create c
Definition: rel.cpp:621
Post propagator for SetVar SetOpType SetVar y
Definition: set.hh:767
Float value type.
Definition: float.hh:334
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:43
BoolVar var(void) const
Return Boolean control variable.
Definition: reify.hpp:48
Propagator for set equality
Definition: rel.hh:150
Binary disequality propagator.
Definition: rel.hh:460
Post propagator for SetVar x
Definition: set.hh:767
#define GECODE_ME_FAIL(me)
Check whether modification event me is failed, and fail space home.
Definition: macros.hpp:77
Float variables.
Definition: float.hh:870
Exception: Unknown reification mode passed as argument
Definition: exception.hpp:115
Gecode toplevel namespace
Implication for reification.
Definition: int.hh:862
Less propagator.
Definition: rel.hh:517
#define GECODE_POST
Check for failure in a constraint post function.
Definition: macros.hpp:40
Home class for posting propagators
Definition: core.hpp:853
#define GECODE_ES_FAIL(es)
Check whether execution status es is failed, and fail space home.
Definition: macros.hpp:103
TFE post(PropagatorGroup g)
Only post functions (but not propagators) from g are considered.
Definition: filter.cpp:138
Equivalence for reification (default)
Definition: int.hh:855
IntRelType swap(IntRelType irt)
Return swapped relation type of irt.
Definition: irt.hpp:37