Generated on for Gecode by doxygen 1.17.0
registry-float.cpp
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.dev>
5 *
6 * Contributing authors:
7 * Mikael Zayenz Lagerkvist <lagerkvist@gmail.com>
8 *
9 * Copyright:
10 * Guido Tack, 2007
11 * Mikael Zayenz Lagerkvist, 2009
12 *
13 * This file is part of Gecode, the generic constraint
14 * development environment:
15 * http://www.gecode.dev
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
39#include <gecode/minimodel.hh>
40#ifdef GECODE_HAS_FLOAT_VARS
41#include <gecode/float.hh>
42#endif
43
44namespace Gecode { namespace FlatZinc {
45
46#ifdef GECODE_HAS_FLOAT_VARS
47 namespace {
48
49 void p_int2float(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
50 IntVar x0 = s.arg2IntVar(ce[0]);
51 FloatVar x1 = s.arg2FloatVar(ce[1]);
52 channel(s, x0, x1);
53 }
54
55 void p_float_lin_cmp(FlatZincSpace& s, FloatRelType frt,
56 const ConExpr& ce, AST::Node*) {
57 FloatValArgs fa = s.arg2floatargs(ce[0]);
58 FloatVarArgs fv = s.arg2floatvarargs(ce[1]);
59 linear(s, fa, fv, frt, ce[2]->getFloat());
60 }
61 void p_float_lin_cmp_reif(FlatZincSpace& s, FloatRelType frt,
62 const ConExpr& ce, AST::Node*) {
63 FloatValArgs fa = s.arg2floatargs(ce[0]);
64 FloatVarArgs fv = s.arg2floatvarargs(ce[1]);
65 linear(s, fa, fv, frt, ce[2]->getFloat(), s.arg2BoolVar(ce[3]));
66 }
67 void p_float_lin_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
68 p_float_lin_cmp(s,FRT_EQ,ce,ann);
69 }
70 void p_float_lin_eq_reif(FlatZincSpace& s, const ConExpr& ce,
71 AST::Node* ann) {
72 p_float_lin_cmp_reif(s,FRT_EQ,ce,ann);
73 }
74 void p_float_lin_le(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
75 p_float_lin_cmp(s,FRT_LQ,ce,ann);
76 }
77 void p_float_lin_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
78 p_float_lin_cmp(s,FRT_LE,ce,ann);
79 }
80 void p_float_lin_le_reif(FlatZincSpace& s, const ConExpr& ce,
81 AST::Node* ann) {
82 p_float_lin_cmp_reif(s,FRT_LQ,ce,ann);
83 }
84 void p_float_lin_lt_reif(FlatZincSpace& s, const ConExpr& ce,
85 AST::Node* ann) {
86 p_float_lin_cmp_reif(s,FRT_LE,ce,ann);
87 }
88
89 void p_float_times(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
90 FloatVar x = s.arg2FloatVar(ce[0]);
91 FloatVar y = s.arg2FloatVar(ce[1]);
92 FloatVar z = s.arg2FloatVar(ce[2]);
93 mult(s,x,y,z);
94 }
95
96 void p_float_div(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
97 FloatVar x = s.arg2FloatVar(ce[0]);
98 FloatVar y = s.arg2FloatVar(ce[1]);
99 FloatVar z = s.arg2FloatVar(ce[2]);
100 div(s,x,y,z);
101 }
102
103 void p_float_plus(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
104 FloatVar x = s.arg2FloatVar(ce[0]);
105 FloatVar y = s.arg2FloatVar(ce[1]);
106 FloatVar z = s.arg2FloatVar(ce[2]);
107 rel(s,x+y==z);
108 }
109
110 void p_float_sqrt(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
111 FloatVar x = s.arg2FloatVar(ce[0]);
112 FloatVar y = s.arg2FloatVar(ce[1]);
113 sqrt(s,x,y);
114 }
115
116 void p_float_abs(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
117 FloatVar x = s.arg2FloatVar(ce[0]);
118 FloatVar y = s.arg2FloatVar(ce[1]);
119 abs(s,x,y);
120 }
121
122 void p_float_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
123 FloatVar x = s.arg2FloatVar(ce[0]);
124 FloatVar y = s.arg2FloatVar(ce[1]);
125 rel(s,x,FRT_EQ,y);
126 }
127 void p_float_eq_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
128 FloatVar x = s.arg2FloatVar(ce[0]);
129 FloatVar y = s.arg2FloatVar(ce[1]);
130 BoolVar b = s.arg2BoolVar(ce[2]);
131 rel(s,x,FRT_EQ,y,b);
132 }
133 void p_float_le(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
134 FloatVar x = s.arg2FloatVar(ce[0]);
135 FloatVar y = s.arg2FloatVar(ce[1]);
136 rel(s,x,FRT_LQ,y);
137 }
138 void p_float_le_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
139 FloatVar x = s.arg2FloatVar(ce[0]);
140 FloatVar y = s.arg2FloatVar(ce[1]);
141 BoolVar b = s.arg2BoolVar(ce[2]);
142 rel(s,x,FRT_LQ,y,b);
143 }
144 void p_float_max(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
145 FloatVar x = s.arg2FloatVar(ce[0]);
146 FloatVar y = s.arg2FloatVar(ce[1]);
147 FloatVar z = s.arg2FloatVar(ce[2]);
148 max(s,x,y,z);
149 }
150 void p_float_min(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
151 FloatVar x = s.arg2FloatVar(ce[0]);
152 FloatVar y = s.arg2FloatVar(ce[1]);
153 FloatVar z = s.arg2FloatVar(ce[2]);
154 min(s,x,y,z);
155 }
156 void p_float_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
157 FloatVar x = s.arg2FloatVar(ce[0]);
158 FloatVar y = s.arg2FloatVar(ce[1]);
159 rel(s, x, FRT_LQ, y);
160 rel(s, x, FRT_EQ, y, BoolVar(s,0,0));
161 }
162
163 void p_float_lt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
164 FloatVar x = s.arg2FloatVar(ce[0]);
165 FloatVar y = s.arg2FloatVar(ce[1]);
166 BoolVar b = s.arg2BoolVar(ce[2]);
167 BoolVar b0(s,0,1);
168 BoolVar b1(s,0,1);
169 rel(s, b == (b0 && !b1));
170 rel(s, x, FRT_LQ, y, b0);
171 rel(s, x, FRT_EQ, y, b1);
172 }
173
174 void p_float_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
175 FloatVar x = s.arg2FloatVar(ce[0]);
176 FloatVar y = s.arg2FloatVar(ce[1]);
177 rel(s, x, FRT_EQ, y, BoolVar(s,0,0));
178 }
179
180#ifdef GECODE_HAS_MPFR
181#define P_FLOAT_OP(Op) \
182 void p_float_ ## Op (FlatZincSpace& s, const ConExpr& ce, AST::Node*) {\
183 FloatVar x = s.arg2FloatVar(ce[0]);\
184 FloatVar y = s.arg2FloatVar(ce[1]);\
185 Op(s,x,y);\
186 }
194 // P_FLOAT_OP(sinh)
195 // P_FLOAT_OP(tanh)
196 // P_FLOAT_OP(cosh)
197#undef P_FLOAT_OP
198
199 void p_float_ln(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
200 FloatVar x = s.arg2FloatVar(ce[0]);
201 FloatVar y = s.arg2FloatVar(ce[1]);
202 log(s,x,y);
203 }
204 void p_float_log10(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
205 FloatVar x = s.arg2FloatVar(ce[0]);
206 FloatVar y = s.arg2FloatVar(ce[1]);
207 log(s,10.0,x,y);
208 }
209 void p_float_log2(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
210 FloatVar x = s.arg2FloatVar(ce[0]);
211 FloatVar y = s.arg2FloatVar(ce[1]);
212 log(s,2.0,x,y);
213 }
214
215#endif
216
217
218 void p_float_ite(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
219 ite(s, s.arg2BoolVar(ce[0]), s.arg2FloatVar(ce[1]), s.arg2FloatVar(ce[2]),
220 s.arg2FloatVar(ce[3]));
221 }
222 void p_float_pow(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
223 pow(s, s.arg2FloatVar(ce[0]), ce[1]->getInt(), s.arg2FloatVar(ce[2]));
224 }
225 void p_float_array_min(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
226 min(s, s.arg2floatvarargs(ce[0]), s.arg2FloatVar(ce[1]));
227 }
228 void p_float_array_max(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
229 max(s, s.arg2floatvarargs(ce[0]), s.arg2FloatVar(ce[1]));
230 }
231#ifdef GECODE_HAS_MPFR
232 void p_float_pow_base(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
233 pow(s, ce[0]->getFloat(), s.arg2FloatVar(ce[1]), s.arg2FloatVar(ce[2]));
234 }
235#endif
236
237 void p_float_rel_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
239 switch (ce[1]->getInt()) {
240 case 1: r = FRT_EQ; break;
241 case 2: r = FRT_NQ; break;
242 case 3: r = FRT_LQ; break;
243 case 4: r = FRT_LE; break;
244 case 5: r = FRT_GQ; break;
245 case 6: r = FRT_GR; break;
246 default: throw FlatZinc::Error("Registry", "invalid float relation");
247 }
248 rel(s, s.arg2FloatVar(ce[0]), r, s.arg2FloatVar(ce[2]),
249 Reify(s.arg2BoolVar(ce[3]), RM_IMP));
250 }
251
252 }
253
254 namespace RegistryDetail {
255
257 r.add("int2float",&p_int2float);
258
259 r.add("gecode_float_rel_imp_fzn", &p_float_rel_imp);
260 r.add("gecode_float_ite", &p_float_ite);
261 r.add("gecode_float_pow", &p_float_pow);
262 r.add("gecode_float_array_min", &p_float_array_min);
263 r.add("gecode_float_array_max", &p_float_array_max);
264
265 r.add("float_abs",&p_float_abs);
266 r.add("float_sqrt",&p_float_sqrt);
267 r.add("float_eq",&p_float_eq);
268 r.add("float_eq_reif",&p_float_eq_reif);
269 r.add("float_le",&p_float_le);
270 r.add("float_le_reif",&p_float_le_reif);
271 r.add("float_lt",&p_float_lt);
272 r.add("float_lt_reif",&p_float_lt_reif);
273 r.add("float_ne",&p_float_ne);
274 r.add("float_times",&p_float_times);
275 r.add("float_div",&p_float_div);
276 r.add("float_plus",&p_float_plus);
277 r.add("float_max",&p_float_max);
278 r.add("float_min",&p_float_min);
279
280 r.add("float_lin_eq",&p_float_lin_eq);
281 r.add("float_lin_eq_reif",&p_float_lin_eq_reif);
282 r.add("float_lin_le",&p_float_lin_le);
283 r.add("float_lin_lt",&p_float_lin_lt);
284 r.add("float_lin_le_reif",&p_float_lin_le_reif);
285 r.add("float_lin_lt_reif",&p_float_lin_lt_reif);
286
287#ifdef GECODE_HAS_MPFR
288 r.add("gecode_float_pow_base", &p_float_pow_base);
289 r.add("float_acos",&p_float_acos);
290 r.add("float_asin",&p_float_asin);
291 r.add("float_atan",&p_float_atan);
292 r.add("float_cos",&p_float_cos);
293 // r.add("float_cosh",&p_float_cosh);
294 r.add("float_exp",&p_float_exp);
295 r.add("float_ln",&p_float_ln);
296 r.add("float_log10",&p_float_log10);
297 r.add("float_log2",&p_float_log2);
298 r.add("float_sin",&p_float_sin);
299 // r.add("float_sinh",&p_float_sinh);
300 r.add("float_tan",&p_float_tan);
301 // r.add("float_tanh",&p_float_tanh);
302#endif
303 }
304
305 }
306#endif
307
308}}
309
310// STATISTICS: flatzinc-any
A node in a FlatZinc abstract syntax tree.
Definition ast.hh:67
Abstract representation of a constraint.
Definition conexpr.hh:43
A space that can be initialized with a FlatZinc model.
Definition flatzinc.hh:424
Map from constraint identifier to constraint posting functions.
Definition registry.hh:44
void linear(Home home, const FloatVarArgs &x, FloatRelType frt, FloatVal c)
Post propagator for .
Definition linear.cpp:41
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1)
Post propagator for .
Definition rel.cpp:68
void ite(Home home, BoolVar b, FloatVar x, FloatVar y, FloatVar z)
Post propagator for if-then-else constraint.
Definition bool.cpp:39
FloatRelType
Relation types for floats.
Definition float.hh:1070
@ FRT_EQ
Equality ( ).
Definition float.hh:1071
@ FRT_GR
Greater ( ).
Definition float.hh:1076
@ FRT_NQ
Disequality ( ).
Definition float.hh:1072
@ FRT_LE
Less ( ).
Definition float.hh:1074
@ FRT_LQ
Less or equal ( ).
Definition float.hh:1073
@ FRT_GQ
Greater or equal ( ).
Definition float.hh:1075
@ RM_IMP
Implication for reification.
Definition int.hh:1162
Interpreter for the FlatZinc language.
Gecode toplevel namespace
void sin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void channel(Home home, FloatVar x0, IntVar x1)
Post propagator for channeling a float and an integer variable .
Definition channel.cpp:41
void cos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
void abs(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void div(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
void mult(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
void sqrt(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void acos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void exp(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void atan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
void asin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for .
void tan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Gecode::FloatVal b(9, 12)
const int r[4][2]
Definition dom.cpp:152
#define P_FLOAT_OP(Op)