Generated on for Gecode by doxygen 1.17.0
transcendental.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.dev>
5 * Vincent Barichard <Vincent.Barichard@univ-angers.fr>
6 *
7 * Copyright:
8 * Christian Schulte, 2005
9 * Vincent Barichard, 2012
10 *
11 * This file is part of Gecode, the generic constraint
12 * development environment:
13 * http://www.gecode.dev
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 "test/float.hh"
37#include <gecode/minimodel.hh>
38
39#ifdef GECODE_HAS_MPFR
40
41#include <cmath>
42#include <algorithm>
43
44namespace Test { namespace Float {
45
47 namespace Transcendental {
48
50 class PowBaseConsistency : public Test {
51 protected:
56 bool shared;
58 public:
60 Gecode::FloatNum y, bool log, bool share, bool valid)
61 : Test("Transcendental::PowBaseConsistency::"+str(b)+"::"+
62 str(x)+"::"+str(y)+(log ? "::Log" : "::Pow")+
63 (share ? "::Shared" : "::Separate"),
64 share ? 1 : 2,-4.0,8.0,1.0,CPLT_ASSIGNMENT,false),
65 base(b), input(x), output(y), logarithm(log), shared(share),
66 expected(valid) {
67 testsearch = false;
68 }
69
70 virtual Assignment* assignment(void) const {
72 a->set(0,input);
73 if (!shared)
74 a->set(1,output);
75 return a;
76 }
77
78 virtual MaybeType solution(const Assignment&) const {
79 return expected ? MT_TRUE : MT_FALSE;
80 }
81 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
82 Gecode::FloatVar y = shared ? x[0] : x[1];
83 if (!shared)
84 Gecode::rel(home,y,Gecode::FRT_GQ,0.0);
85 if (logarithm)
86 Gecode::log(home,base,y,x[0]);
87 else
88 Gecode::pow(home,base,x[0],y);
89 }
90 };
91
94 public:
96 for (int logarithm=0; logarithm<2; logarithm++) {
97 (void) new PowBaseConsistency(2.0,3.0,8.0,logarithm,false,true);
98 (void) new PowBaseConsistency(2.0,3.0,7.0,logarithm,false,false);
99 (void) new PowBaseConsistency(0.5,3.0,0.125,logarithm,false,true);
100 (void) new PowBaseConsistency(1.0,3.0,1.0,logarithm,false,true);
101 (void) new PowBaseConsistency(2.0,0.0,0.0,logarithm,true,false);
102 (void) new PowBaseConsistency(0.25,0.5,0.5,logarithm,true,true);
103 }
104 }
106
108 class ExpXY : public Test {
109 public:
111 ExpXY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
112 : Test(TestTags::sweep(),"Transcendental::Exp::XY::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
113
114 virtual MaybeType solution(const Assignment& x) const {
115 return eq(exp(x[0]), x[1]);
116 }
117
118 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
119 if (flip())
120 Gecode::exp(home, x[0], x[1]);
121 else
122 Gecode::rel(home, exp(x[0]) == x[1]);
123 }
124 };
125
127 class ExpXYSol : public Test {
128 public:
130 ExpXYSol(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
131 : Test(TestTags::sweep(),"Transcendental::Exp::XY::Sol::"+s,2,d,st,EXTEND_ASSIGNMENT,false) {}
132
133 virtual MaybeType solution(const Assignment& x) const {
134 return eq(exp(x[0]), x[1]);
135 }
136
137 virtual bool extendAssignment(Assignment& x) const {
138 Gecode::FloatVal d = exp(x[0]);
139 if (Gecode::Float::subset(d, dom)) {
140 x.set(1, d);
141 return true;
142 } else {
143 return false;
144 }
145 }
146
147 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
148 Gecode::exp(home, x[0], x[1]);
149 }
150 };
151
153 class ExpXX : public Test {
154 public:
156 ExpXX(TestTags tags, const std::string& s,
158 : Test(tags,"Transcendental::Exp::XX::"+s,
159 1,d,st,CPLT_ASSIGNMENT,false) {}
160
161 virtual MaybeType solution(const Assignment& x) const {
162 return eq(exp(x[0]), x[0]);
163 }
164
165 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
166 Gecode::exp(home, x[0], x[0]);
167 }
168 };
169
171 class LogXY : public Test {
172 public:
174 LogXY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
175 : Test(TestTags::sweep(),"Transcendental::Log::XY::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
176
177 virtual MaybeType solution(const Assignment& x) const {
178 if (x[0].max() < 0.0)
179 return MT_FALSE;
180 return eq(log(x[0]), x[1]);
181 }
182
183 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
184 if (flip())
185 Gecode::log(home, x[0], x[1]);
186 else
187 Gecode::rel(home, log(x[0]) == x[1]);
188 }
189 };
190
192 class LogXYSol : public Test {
193 public:
195 LogXYSol(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
196 : Test(TestTags::sweep(),"Transcendental::Log::XY::Sol::"+s,2,d,st,EXTEND_ASSIGNMENT,false) {}
197
198 virtual MaybeType solution(const Assignment& x) const {
199 if (x[0].max() < 0.0)
200 return MT_FALSE;
201 return eq(log(x[0]), x[1]);
202 }
203
204 virtual bool extendAssignment(Assignment& x) const {
205 if (x[0].max() < 0.0) return false;
206 Gecode::FloatVal d = log(x[0]);
207 if (Gecode::Float::subset(d, dom)) {
208 x.set(1, d);
209 return true;
210 } else {
211 return false;
212 }
213 }
214
215 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
216 Gecode::log(home, x[0], x[1]);
217 }
218 };
219
221 class LogXX : public Test {
222 public:
224 LogXX(TestTags tags, const std::string& s,
226 : Test(tags,"Transcendental::Log::XX::"+s,
227 1,d,st,CPLT_ASSIGNMENT,false) {}
228
229 virtual MaybeType solution(const Assignment& x) const {
230 if (x[0].max() < 0.0)
231 return MT_FALSE;
232 return eq(log(x[0]), x[0]);
233 }
234
235 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
236 Gecode::log(home, x[0], x[0]);
237 }
238 };
239
241 class LogNXY : public Test {
242 Gecode::FloatNum base;
243 public:
245 LogNXY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum _base, Gecode::FloatNum st)
246 : Test(TestTags::sweep(),"Transcendental::Log::N::"+str(_base)+"::XY::"+s,2,d,st,CPLT_ASSIGNMENT,false), base(_base) {}
247
248 virtual MaybeType solution(const Assignment& x) const {
249 if ((x[0].max() <= 0.0) || (base <= 0.0))
250 return MT_FALSE;
251 return eq(log(x[0]) / log(Gecode::FloatVal(base)), x[1]);
252 }
253
254 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
255 Gecode::log(home, base, x[0], x[1]);
256 }
257 };
258
260 class LogNXYSol : public Test {
261 Gecode::FloatNum base;
262 public:
264 LogNXYSol(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum _base, Gecode::FloatNum st)
265 : Test(TestTags::sweep(),"Transcendental::Log::N::"+str(_base)+"::XY::Sol::"+s,2,d,st,EXTEND_ASSIGNMENT,false), base(_base) {}
266
267 virtual MaybeType solution(const Assignment& x) const {
268 if ((x[0].max() <= 0.0) || (base <= 0.0))
269 return MT_FALSE;
270 return eq(log(x[0]) / log(Gecode::FloatVal(base)), x[1]);
271 }
272
273 virtual bool extendAssignment(Assignment& x) const {
274 if ((x[0].max() <= 0.0) || (base <= 0.0))
275 return false;
276 Gecode::FloatVal d = log(x[0])/log(Gecode::FloatVal(base));
277 if (Gecode::Float::subset(d, dom)) {
278 x.set(1, d);
279 return true;
280 } else {
281 return false;
282 }
283 }
284
285 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
286 Gecode::log(home, base, x[0], x[1]);
287 }
288 };
289
291 class LogNXX : public Test {
292 Gecode::FloatNum base;
293 public:
295 LogNXX(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum _base, Gecode::FloatNum st)
296 : Test(TestTags::sweep(),"Transcendental::Log::N::"+str(_base)+"::XX::"+s,1,d,st,CPLT_ASSIGNMENT,false), base(_base) {}
297
298 virtual MaybeType solution(const Assignment& x) const {
299 if ((x[0].max() <= 0.0) || (base <= 0.0))
300 return MT_FALSE;
301 return eq(log(x[0]) / log(Gecode::FloatVal(base)), x[0]);
302 }
303
304 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
305 Gecode::log(home, base, x[0], x[0]);
306 }
307 };
308
310 class PowXY : public Test {
311 Gecode::FloatNum base;
312 public:
314 PowXY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum _base, Gecode::FloatNum st)
315 : Test(TestTags::sweep(),"Transcendental::Pow::N::"+str(_base)+"::XY::"+s,2,d,st,CPLT_ASSIGNMENT,false), base(_base) {}
316
317 virtual MaybeType solution(const Assignment& x) const {
318 if (base <= 0.0)
319 return MT_FALSE;
320 return eq(exp(x[0] * log(Gecode::FloatVal(base))), x[1]);
321 }
322
323 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
324 Gecode::pow(home, base, x[0], x[1]);
325 }
326 };
327
329 class PowXYSol : public Test {
330 Gecode::FloatNum base;
331 public:
333 PowXYSol(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum _base, Gecode::FloatNum st)
334 : Test(TestTags::sweep(),"Transcendental::Pow::N::"+str(_base)+"::XY::Sol::"+s,2,d,st,EXTEND_ASSIGNMENT,false), base(_base) {}
335
336 virtual MaybeType solution(const Assignment& x) const {
337 if (base <= 0.0)
338 return MT_FALSE;
339 return eq(exp(x[0] * log(Gecode::FloatVal(base))), x[1]);
340 }
341
342 virtual bool extendAssignment(Assignment& x) const {
343 if (base <= 0.0) return false;
344 Gecode::FloatVal d = exp(x[0]*log(Gecode::FloatVal(base)));
345 if (Gecode::Float::subset(d, dom)) {
346 x.set(1, d);
347 return true;
348 } else {
349 return false;
350 }
351 }
352
353 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
354 Gecode::pow(home, base, x[0], x[1]);
355 }
356 };
357
359 class PowXX : public Test {
360 Gecode::FloatNum base;
361 public:
363 PowXX(TestTags tags, const std::string& s,
364 const Gecode::FloatVal& d, Gecode::FloatNum _base,
366 : Test(tags,
367 "Transcendental::Pow::N::"+str(_base)+"::XX::"+s,
368 1,d,st,CPLT_ASSIGNMENT,false), base(_base) {}
369
370 virtual MaybeType solution(const Assignment& x) const {
371 if ((x[0].max() <= 0.0) || (base <= 0.0))
372 return MT_FALSE;
373 return eq(exp(x[0] * log(Gecode::FloatVal(base))), x[0]);
374 }
375
376 virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
377 Gecode::pow(home, base, x[0], x[0]);
378 }
379 };
380
381 const Gecode::FloatNum step = 0.15;
382
386
390
394
398
402
406
410
414
418
422
426
430
434
438
442
446
450
454
458
462
466
470
474
478
482
484
485 }
486}}
487
488#endif
489// STATISTICS: test-float
Float value type.
Definition float.hh:329
Float variable array.
Definition float.hh:1030
Float variables.
Definition float.hh:865
Computation spaces.
Definition core.hpp:1787
Gecode::Support::RandomGenerator _rand
Random number generator.
Definition test.hh:238
TestTags tags(void) const
Return tags for test.
Definition test.hpp:95
Base class for assignments
Definition float.hh:94
virtual void set(int i, const Gecode::FloatVal &val)=0
Set assignment to value val for variable i.
Generate random selection of assignments.
Definition float.hh:159
static MaybeType eq(Gecode::FloatVal x, Gecode::FloatVal y)
Whether x and y are equal.
Definition float.hpp:281
int arity
Number of variables.
Definition float.hh:262
static std::string str(Gecode::FloatRelType frt)
Map float relation to string.
Definition float.hpp:207
bool flip(void)
Flip a coin and return true or false randomly.
Definition float.hpp:286
bool testsearch
Whether to perform search test.
Definition float.hh:274
Gecode::FloatVal dom
Domain of variables.
Definition float.hh:264
Test for exponent constraint with shared variables
ExpXX(TestTags tags, const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Test for exponent constraint where solution is ensured
virtual bool extendAssignment(Assignment &x) const
Extend assignment x.
ExpXYSol(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Test for exponent constraint
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
ExpXY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Test for logarithm base n constraint with shared variables
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
LogNXX(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum _base, Gecode::FloatNum st)
Create and register test.
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Test for logarithm base n constraint where solution is ensured
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
virtual bool extendAssignment(Assignment &x) const
Extend assignment x.
LogNXYSol(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum _base, Gecode::FloatNum st)
Create and register test.
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Test for logarithm base n constraint
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
LogNXY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum _base, Gecode::FloatNum st)
Create and register test.
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Test for logarithm constraint with shared variables
LogXX(TestTags tags, const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Test for logarithm constraint where solution is ensured
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
virtual bool extendAssignment(Assignment &x) const
Extend assignment x.
LogXYSol(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Test for logarithm constraint
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
LogXY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Exact fixed-base powers, inverse logarithms, and shared variables.
PowBaseConsistency(Gecode::FloatNum b, Gecode::FloatNum x, Gecode::FloatNum y, bool log, bool share, bool valid)
virtual MaybeType solution(const Assignment &) const
Use exact expected results instead of computing them with exp/log.
virtual Assignment * assignment(void) const
Check one exact example through the standard posting/assignment tests.
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint.
Test for pow exponent n constraint with shared variables
PowXX(TestTags tags, const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum _base, Gecode::FloatNum st)
Create and register test.
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Test for pow exponent n constraint where solution is ensured
PowXYSol(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum _base, Gecode::FloatNum st)
Create and register test.
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
virtual bool extendAssignment(Assignment &x) const
Extend assignment x.
Test for pow exponent n constraint
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
PowXY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum _base, Gecode::FloatNum st)
Create and register test.
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Set of test tags.
Definition test.hh:105
static TestTags sweep(void)
Expensive parameter sweeps.
Definition test.hpp:59
static TestTags standard(void)
Standard suite without expensive sweeps.
Definition test.hpp:55
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1)
Post propagator for .
Definition rel.cpp:68
double FloatNum
Floating point number base type.
Definition float.hh:106
@ FRT_GQ
Greater or equal ( ).
Definition float.hh:1075
bool subset(const FloatVal &x, const FloatVal &y)
Definition val.hpp:491
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void exp(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for .
Tests for transcendental constraints
LogNXYSol logn_xy_sol_b_1("B", b,-1.5, step)
LogNXYSol logn_xy_sol_c_1("C", c,-1.5, step)
LogNXX logn_xx_b_1("B", b,-1.5, step)
ExpXYSol exp_xy_sol_a("A", a, step)
LogNXY logn_xy_a_2("A", a, 1.5, step)
LogXY log_xy_c("C", c, step)
ExpXY exp_xy_b("B", b, step)
PowXY pow_xy_a_2("A", a, 1.5, step)
LogNXYSol logn_xy_sol_b_3("B", b, 0, step)
LogXYSol log_xy_sol_c("C", c, step)
PowXX pow_xx_c_1(TestTags::sweep(),"C", c,-1.5, step)
PowXX pow_xx_a_2(TestTags::standard(),"A", a, 1.5, step)
PowXYSol pow_xy_sol_a_1("A", a,-1.5, step)
ExpXYSol exp_xy_sol_c("C", c, step)
LogNXY logn_xy_b_3("B", b, 0, step)
PowXY pow_xy_a_1("A", a,-1.5, step)
LogNXY logn_xy_a_3("A", a, 0, step)
LogXY log_xy_b("B", b, step)
LogNXYSol logn_xy_sol_a_3("A", a, 0, step)
PowXX pow_xx_b_1(TestTags::sweep(),"B", b,-1.5, step)
PowXY pow_xy_b_3("B", b, 0, step)
LogNXX logn_xx_a_2("A", a, 1.5, step)
LogXYSol log_xy_sol_a("A", a, step)
PowXX pow_xx_b_3(TestTags::sweep(),"B", b, 0, step)
LogNXYSol logn_xy_sol_b_2("B", b, 1.5, step)
ExpXX exp_xx_c(TestTags::sweep(),"C", c, step)
LogNXY logn_xy_c_1("C", c,-1.5, step)
PowXYSol pow_xy_sol_c_1("C", c,-1.5, step)
PowXYSol pow_xy_sol_c_2("C", c, 1.5, step)
LogNXY logn_xy_b_2("B", b, 1.5, step)
LogNXY logn_xy_c_3("C", c, 0, step)
PowXY pow_xy_b_1("B", b,-1.5, step)
LogXX log_xx_a(TestTags::standard(),"A", a, step)
LogNXY logn_xy_b_1("B", b,-1.5, step)
PowXYSol pow_xy_sol_c_3("C", c, 0, step)
PowXYSol pow_xy_sol_b_2("B", b, 1.5, step)
LogNXX logn_xx_c_1("C", c,-1.5, step)
PowXY pow_xy_c_3("C", c, 0, step)
ExpXYSol exp_xy_sol_b("B", b, step)
ExpXX exp_xx_b(TestTags::sweep(),"B", b, step)
PowXX pow_xx_a_1(TestTags::sweep(),"A", a,-1.5, step)
PowXX pow_xx_c_2(TestTags::sweep(),"C", c, 1.5, step)
LogNXX logn_xx_c_2("C", c, 1.5, step)
LogNXYSol logn_xy_sol_a_1("A", a,-1.5, step)
LogNXYSol logn_xy_sol_a_2("A", a, 1.5, step)
LogNXYSol logn_xy_sol_c_2("C", c, 1.5, step)
PowXYSol pow_xy_sol_a_2("A", a, 1.5, step)
LogXX log_xx_b(TestTags::sweep(),"B", b, step)
LogNXX logn_xx_b_2("B", b, 1.5, step)
LogNXY logn_xy_c_2("C", c, 1.5, step)
LogNXYSol logn_xy_sol_c_3("C", c, 0, step)
LogNXX logn_xx_c_3("C", c, 0, step)
LogNXX logn_xx_a_1("A", a,-1.5, step)
ExpXY exp_xy_c("C", c, step)
PowXY pow_xy_b_2("B", b, 1.5, step)
PowXYSol pow_xy_sol_a_3("A", a, 0, step)
LogNXX logn_xx_a_3("A", a, 0, step)
PowXYSol pow_xy_sol_b_3("B", b, 0, step)
Gecode::FloatVal c(-8, 8)
ExpXX exp_xx_a(TestTags::standard(),"A", a, step)
LogNXY logn_xy_a_1("A", a,-1.5, step)
Gecode::FloatVal a(-8, 5)
PowXY pow_xy_c_2("C", c, 1.5, step)
PowXX pow_xx_b_2(TestTags::sweep(),"B", b, 1.5, step)
class Test::Float::Transcendental::PowBaseExamples pow_base_examples
LogNXX logn_xx_b_3("B", b, 0, step)
Gecode::FloatVal b(9, 12)
LogXYSol log_xy_sol_b("B", b, step)
PowXY pow_xy_c_1("C", c,-1.5, step)
PowXYSol pow_xy_sol_b_1("B", b,-1.5, step)
const Gecode::FloatNum step
ExpXY exp_xy_a("A", a, step)
PowXY pow_xy_a_3("A", a, 0, step)
LogXX log_xx_c(TestTags::sweep(),"C", c, step)
LogXY log_xy_a("A", a, step)
PowXX pow_xx_c_3(TestTags::sweep(),"C", c, 0, step)
PowXX pow_xx_a_3(TestTags::sweep(),"A", a, 0, step)
Testing domain floats.
Definition float.cpp:43
@ EXTEND_ASSIGNMENT
Definition float.hh:78
@ CPLT_ASSIGNMENT
Definition float.hh:76
MaybeType
Type for comparisons and solutions.
Definition float.hh:65
General test support.
Definition afc.cpp:41
@ sweep
Really heavy sweep tests.
Definition test.hh:101