Generated on Sat Feb 7 2015 02:01:16 for Gecode by doxygen 1.8.9.1
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  * Last modified:
12  * $Date: 2013-02-12 20:48:02 +0100 (Tue, 12 Feb 2013) $ by $Author: vbarichard $
13  * $Revision: 13281 $
14  *
15  * This file is part of Gecode, the generic constraint
16  * development environment:
17  * http://www.gecode.org
18  *
19  * Permission is hereby granted, free of charge, to any person obtaining
20  * a copy of this software and associated documentation files (the
21  * "Software"), to deal in the Software without restriction, including
22  * without limitation the rights to use, copy, modify, merge, publish,
23  * distribute, sublicense, and/or sell copies of the Software, and to
24  * permit persons to whom the Software is furnished to do so, subject to
25  * the following conditions:
26  *
27  * The above copyright notice and this permission notice shall be
28  * included in all copies or substantial portions of the Software.
29  *
30  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
31  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
32  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
33  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
34  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
35  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
36  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
37  *
38  */
39 
40 #include <gecode/float/rel.hh>
41 
42 #include <algorithm>
43 
44 namespace Gecode {
45 
46  void
47  rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n) {
48  using namespace Float;
49  Limits::check(n,"Float::rel");
50  if (home.failed()) return;
51  FloatView x(x0);
52  switch (frt) {
53  case FRT_EQ: GECODE_ME_FAIL(x.eq(home,n)); break;
54  case FRT_NQ:
56  break;
57  case FRT_LQ: GECODE_ME_FAIL(x.lq(home,n)); break;
58  case FRT_LE:
59  GECODE_ME_FAIL(x.lq(home,n));
61  break;
62  case FRT_GQ: GECODE_ME_FAIL(x.gq(home,n)); break;
63  case FRT_GR:
64  GECODE_ME_FAIL(x.gq(home,n));
66  break;
67  default: throw UnknownRelation("Float::rel");
68  }
69  }
70 
71  void
72  rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1) {
73  using namespace Float;
74  if (home.failed()) return;
75  switch (frt) {
76  case FRT_EQ:
78  break;
79  case FRT_NQ:
81  break;
82  case FRT_GQ:
83  std::swap(x0,x1); // Fall through
84  case FRT_LQ:
85  GECODE_ES_FAIL((Rel::Lq<FloatView>::post(home,x0,x1))); break;
86  case FRT_GR:
87  std::swap(x0,x1); // Fall through
88  case FRT_LE:
89  GECODE_ES_FAIL((Rel::Le<FloatView>::post(home,x0,x1))); break;
90  default:
91  throw UnknownRelation("Float::rel");
92  }
93  }
94 
95  void
96  rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1, Reify r) {
97  using namespace Float;
98  if (home.failed()) return;
99  switch (frt) {
100  case FRT_EQ:
101  switch (r.mode()) {
102  case RM_EQV:
104  post(home,x0,x1,r.var())));
105  break;
106  case RM_IMP:
108  post(home,x0,x1,r.var())));
109  break;
110  case RM_PMI:
112  post(home,x0,x1,r.var())));
113  break;
114  default: throw Int::UnknownReifyMode("Float::rel");
115  }
116  break;
117  case FRT_NQ:
118  {
119  Int::NegBoolView n(r.var());
120  switch (r.mode()) {
121  case RM_EQV:
123  post(home,x0,x1,n)));
124  break;
125  case RM_IMP:
127  post(home,x0,x1,n)));
128  break;
129  case RM_PMI:
131  post(home,x0,x1,n)));
132  break;
133  default: throw Int::UnknownReifyMode("Float::rel");
134  }
135  break;
136  }
137  case FRT_GQ:
138  std::swap(x0,x1); // Fall through
139  case FRT_LQ:
140  switch (r.mode()) {
141  case RM_EQV:
143  post(home,x0,x1,r.var())));
144  break;
145  case RM_IMP:
147  post(home,x0,x1,r.var())));
148  break;
149  case RM_PMI:
151  post(home,x0,x1,r.var())));
152  break;
153  default: throw Int::UnknownReifyMode("Float::rel");
154  }
155  break;
156  case FRT_LE:
157  std::swap(x0,x1); // Fall through
158  case FRT_GR:
159  {
160  Int::NegBoolView n(r.var());
161  switch (r.mode()) {
162  case RM_EQV:
164  post(home,x0,x1,n)));
165  break;
166  case RM_IMP:
168  post(home,x0,x1,n)));
169  break;
170  case RM_PMI:
172  post(home,x0,x1,n)));
173  break;
174  default: throw Int::UnknownReifyMode("Float::rel");
175  }
176  break;
177  }
178  default:
179  throw Int::UnknownRelation("Float::rel");
180  }
181  }
182 
183  void
185  using namespace Float;
186  Limits::check(n,"Float::rel");
187  if (home.failed()) return;
188  switch (frt) {
189  case FRT_EQ:
190  switch (r.mode()) {
191  case RM_EQV:
192  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::BoolView,RM_EQV>::
193  post(home,x,n,r.var())));
194  break;
195  case RM_IMP:
196  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::BoolView,RM_IMP>::
197  post(home,x,n,r.var())));
198  break;
199  case RM_PMI:
200  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::BoolView,RM_PMI>::
201  post(home,x,n,r.var())));
202  break;
203  default: throw Int::UnknownReifyMode("Float::rel");
204  }
205  break;
206  case FRT_NQ:
207  {
208  Int::NegBoolView nb(r.var());
209  switch (r.mode()) {
210  case RM_EQV:
211  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::NegBoolView,RM_EQV>::
212  post(home,x,n,nb)));
213  break;
214  case RM_IMP:
215  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::NegBoolView,RM_PMI>::
216  post(home,x,n,nb)));
217  break;
218  case RM_PMI:
219  GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::NegBoolView,RM_IMP>::
220  post(home,x,n,nb)));
221  break;
222  default: throw Int::UnknownReifyMode("Float::rel");
223  }
224  break;
225  }
226  case FRT_LQ:
227  switch (r.mode()) {
228  case RM_EQV:
229  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::BoolView,RM_EQV>::
230  post(home,x,n,r.var())));
231  break;
232  case RM_IMP:
233  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::BoolView,RM_IMP>::
234  post(home,x,n,r.var())));
235  break;
236  case RM_PMI:
237  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::BoolView,RM_PMI>::
238  post(home,x,n,r.var())));
239  break;
240  default: throw Int::UnknownReifyMode("Float::rel");
241  }
242  break;
243  case FRT_LE:
244  switch (r.mode()) {
245  case RM_EQV:
246  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::BoolView,RM_EQV>::
247  post(home,x,n,r.var())));
248  break;
249  case RM_IMP:
250  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::BoolView,RM_IMP>::
251  post(home,x,n,r.var())));
252  break;
253  case RM_PMI:
254  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::BoolView,RM_PMI>::
255  post(home,x,n,r.var())));
256  break;
257  default: throw Int::UnknownReifyMode("Float::rel");
258  }
259  break;
260  case FRT_GQ:
261  {
262  Int::NegBoolView nb(r.var());
263  switch (r.mode()) {
264  case RM_EQV:
265  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::NegBoolView,RM_EQV>::
266  post(home,x,n,nb)));
267  break;
268  case RM_IMP:
269  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::NegBoolView,RM_PMI>::
270  post(home,x,n,nb)));
271  break;
272  case RM_PMI:
273  GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::NegBoolView,RM_IMP>::
274  post(home,x,n,nb)));
275  break;
276  default: throw Int::UnknownReifyMode("Float::rel");
277  }
278  break;
279  }
280  case FRT_GR:
281  {
282  Int::NegBoolView nb(r.var());
283  switch (r.mode()) {
284  case RM_EQV:
285  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::NegBoolView,RM_EQV>::
286  post(home,x,n,nb)));
287  break;
288  case RM_IMP:
289  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::NegBoolView,RM_PMI>::
290  post(home,x,n,nb)));
291  break;
292  case RM_PMI:
293  GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::NegBoolView,RM_IMP>::
294  post(home,x,n,nb)));
295  break;
296  default: throw Int::UnknownReifyMode("Float::rel");
297  }
298  break;
299  }
300  default:
301  throw Int::UnknownRelation("Float::rel");
302  }
303  }
304 
305  void
306  rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVal c) {
307  using namespace Float;
308  Limits::check(c,"Float::rel");
309  if (home.failed()) return;
310  switch (frt) {
311  case FRT_EQ:
312  for (int i=x.size(); i--; ) {
313  FloatView xi(x[i]); GECODE_ME_FAIL(xi.eq(home,c));
314  }
315  break;
316  case FRT_NQ:
317  for (int i=x.size(); i--; ) {
318  FloatView xi(x[i]); GECODE_ES_FAIL((Rel::NqFloat<FloatView>::post(home,xi,c)));
319  }
320  break;
321  case FRT_LQ:
322  for (int i=x.size(); i--; ) {
323  FloatView xi(x[i]); GECODE_ME_FAIL(xi.lq(home,c));
324  }
325  break;
326  case FRT_LE:
327  for (int i=x.size(); i--; ) {
328  FloatView xi(x[i]); GECODE_ME_FAIL(xi.lq(home,c));
330  }
331  break;
332  case FRT_GQ:
333  for (int i=x.size(); i--; ) {
334  FloatView xi(x[i]); GECODE_ME_FAIL(xi.gq(home,c));
335  }
336  break;
337  case FRT_GR:
338  for (int i=x.size(); i--; ) {
339  FloatView xi(x[i]); GECODE_ME_FAIL(xi.gq(home,c));
341  }
342  break;
343  default:
344  throw UnknownRelation("Float::rel");
345  }
346  }
347 
348  void
349  rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVar y) {
350  using namespace Float;
351  if (home.failed()) return;
352  switch (frt) {
353  case FRT_EQ:
354  for (int i=x.size(); i--; ) {
356  }
357  break;
358  case FRT_NQ:
359  for (int i=x.size(); i--; ) {
361  }
362  break;
363  case FRT_GQ:
364  for (int i=x.size(); i--; ) {
366  }
367  break;
368  case FRT_GR:
369  for (int i=x.size(); i--; ) {
371  }
372  break;
373  case FRT_LQ:
374  for (int i=x.size(); i--; ) {
376  }
377  break;
378  case FRT_LE:
379  for (int i=x.size(); i--; ) {
381  }
382  break;
383  default:
384  throw UnknownRelation("Float::rel");
385  }
386  }
387 }
388 
389 // STATISTICS: float-post
bool failed(void) const
Check whether corresponding space is failed.
Definition: core.hpp:3446
Inverse implication for reification.
Definition: int.hh:847
ReifyMode mode(void) const
Return reification mode.
Definition: reify.hpp:60
void post(Home home, Term *t, int n, FloatRelType frt, FloatVal c)
Post propagator for linear constraint over floats.
Definition: post.cpp:228
BoolVar var(void) const
Return Boolean control variable.
Definition: reify.hpp:52
Negated Boolean view.
Definition: view.hpp:1503
Disequality ( )
Definition: float.hh:1056
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1662
Less or equal ( )
Definition: float.hh:1057
Passing float variables.
Definition: float.hh:966
Less ( )
Definition: float.hh:1058
Reified less or equal propagator.
Definition: rel.hh:522
Greater or equal ( )
Definition: float.hh:1059
Exception: Unknown relation passed as argument
Definition: exception.hpp:91
Reified equality propagator
Definition: rel.hh:170
Gecode::IntArgs i(4, 1, 2, 3, 4)
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:238
NNF * r
Right subtree.
Definition: bool-expr.cpp:246
FloatRelType
Relation types for floats.
Definition: float.hh:1054
Reification specification.
Definition: int.hh:854
Less or equal propagator.
Definition: rel.hh:465
Equality ( )
Definition: float.hh:1055
Greater ( )
Definition: float.hh:1060
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:48
Create c
Definition: rel.cpp:562
Float value type.
Definition: float.hh:321
Node * x
Pointer to corresponding Boolean expression node.
Definition: bool-expr.cpp:253
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:47
Propagator for set equality
Definition: rel.hh:146
Binary disequality propagator.
Definition: rel.hh:432
#define GECODE_ME_FAIL(me)
Check whether modification event me is failed, and fail space home.
Definition: macros.hpp:70
Float variables.
Definition: float.hh:857
Exception: Unknown reification mode passed as argument
Definition: exception.hpp:119
Gecode toplevel namespace
Implication for reification.
Definition: int.hh:840
Less propagator.
Definition: rel.hh:490
Home class for posting propagators
Definition: core.hpp:717
#define GECODE_ES_FAIL(es)
Check whether execution status es is failed, and fail space home.
Definition: macros.hpp:96
Equivalence for reification (default)
Definition: int.hh:833