00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042 #ifndef __GECODE_FLOAT_ARITHMETIC_HH__
00043 #define __GECODE_FLOAT_ARITHMETIC_HH__
00044
00045 #include <gecode/int.hh>
00046 #include <gecode/float.hh>
00047 #include <gecode/float/rel.hh>
00048
00054 namespace Gecode { namespace Float { namespace Arithmetic {
00055
00061 template<class VA, class VB>
00062 class SqrPlus : public MixBinaryPropagator<VA,PC_FLOAT_BND,VB,PC_FLOAT_BND> {
00063 protected:
00064 using MixBinaryPropagator<VA,PC_FLOAT_BND,VB,PC_FLOAT_BND>::x0;
00065 using MixBinaryPropagator<VA,PC_FLOAT_BND,VB,PC_FLOAT_BND>::x1;
00067 SqrPlus(Home home, VA x0, VB x1);
00069 SqrPlus(Space& home, bool share, SqrPlus<VA,VB>& p);
00070 public:
00072 static ExecStatus post(Home home, VA x0, VB x1);
00074 virtual Actor* copy(Space& home, bool share);
00076 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00077 };
00078
00085 template<class View>
00086 class Sqr : public BinaryPropagator<View,PC_FLOAT_BND> {
00087 protected:
00088 using BinaryPropagator<View,PC_FLOAT_BND>::x0;
00089 using BinaryPropagator<View,PC_FLOAT_BND>::x1;
00090
00092 Sqr(Space& home, bool share, Sqr& p);
00094 Sqr(Home home, View x0, View x1);
00095 public:
00097 virtual Actor* copy(Space& home, bool share);
00099 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00101 static ExecStatus post(Home home, View x0, View x1);
00102 };
00103
00112 template<class A, class B>
00113 class Sqrt : public MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND> {
00114 protected:
00115 using MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND>::x0;
00116 using MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND>::x1;
00117
00119 Sqrt(Space& home, bool share, Sqrt& p);
00121 Sqrt(Home home, A x0, B x1);
00122 public:
00124 virtual Actor* copy(Space& home, bool share);
00126 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00128 static ExecStatus post(Home home, A x0, B x1);
00129 };
00130
00139 template<class A, class B>
00140 class Abs : public MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND> {
00141 protected:
00142 using MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND>::x0;
00143 using MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND>::x1;
00144
00146 Abs(Space& home, bool share, Abs& p);
00148 Abs(Home home, A x0, B x1);
00149 public:
00151 Abs(Space& home, bool share, Propagator& p, A x0, B x1);
00153 virtual Actor* copy(Space& home, bool share);
00155 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00157 static ExecStatus post(Home home, A x0, B x1);
00158 };
00159
00168 template<class A, class B>
00169 class Pow : public MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND> {
00170 protected:
00171 using MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND>::x0;
00172 using MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND>::x1;
00173 int m_n;
00174
00176 Pow(Space& home, bool share, Pow& p);
00178 Pow(Home home, A x0, B x1, int n);
00179 public:
00181 virtual Actor* copy(Space& home, bool share);
00183 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00185 static ExecStatus post(Home home, A x0, B x1, int n);
00186 };
00187
00196 template<class A, class B>
00197 class NthRoot : public MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND> {
00198 protected:
00199 using MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND>::x0;
00200 using MixBinaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND>::x1;
00201 int m_n;
00202
00204 NthRoot(Space& home, bool share, NthRoot& p);
00206 NthRoot(Home home, A x0, B x1, int n);
00207 public:
00209 virtual Actor* copy(Space& home, bool share);
00211 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00213 static ExecStatus post(Home home, A x0, B x1, int n);
00214 };
00215
00222 template<class View>
00223 class MultZeroOne : public BinaryPropagator<View,PC_FLOAT_BND> {
00224 protected:
00225 using BinaryPropagator<View,PC_FLOAT_BND>::x0;
00226 using BinaryPropagator<View,PC_FLOAT_BND>::x1;
00227
00229 MultZeroOne(Space& home, bool share, MultZeroOne<View>& p);
00231 MultZeroOne(Home home, View x0, View x1);
00232 public:
00234 virtual Actor* copy(Space& home, bool share);
00236 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00238 static ExecStatus post(Home home, View x0, View x1);
00239 };
00240
00241
00247 template<class VA, class VB, class VC>
00248 class MultPlus :
00249 public MixTernaryPropagator<VA,PC_FLOAT_BND,VB,PC_FLOAT_BND,VC,PC_FLOAT_BND> {
00250 protected:
00251 using MixTernaryPropagator<VA,PC_FLOAT_BND,VB,PC_FLOAT_BND,VC,PC_FLOAT_BND>::x0;
00252 using MixTernaryPropagator<VA,PC_FLOAT_BND,VB,PC_FLOAT_BND,VC,PC_FLOAT_BND>::x1;
00253 using MixTernaryPropagator<VA,PC_FLOAT_BND,VB,PC_FLOAT_BND,VC,PC_FLOAT_BND>::x2;
00254 public:
00256 MultPlus(Home home, VA x0, VB x1, VC x2);
00258 MultPlus(Space& home, bool share, MultPlus<VA,VB,VC>& p);
00260 static ExecStatus post(Home home, VA x0, VB x1, VC x2);
00262 virtual Actor* copy(Space& home, bool share);
00264 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00265 };
00266
00274 template<class View>
00275 class Mult : public TernaryPropagator<View,PC_FLOAT_BND> {
00276 protected:
00277 using TernaryPropagator<View,PC_FLOAT_BND>::x0;
00278 using TernaryPropagator<View,PC_FLOAT_BND>::x1;
00279 using TernaryPropagator<View,PC_FLOAT_BND>::x2;
00280
00282 Mult(Space& home, bool share, Mult<View>& p);
00283 public:
00285 Mult(Home home, View x0, View x1, View x2);
00287 static ExecStatus post(Home home, View x0, View x1, View x2);
00289 virtual Actor* copy(Space& home, bool share);
00291 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00292 };
00293
00294
00303
00304
00305
00306
00307
00308
00309
00311
00313
00314
00316
00318
00320
00321
00322
00323
00332 template<class A, class B, class C>
00333 class Div : public MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND> {
00334 protected:
00335 using MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND>::x0;
00336 using MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND>::x1;
00337 using MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND>::x2;
00339 Div(Space& home, bool share, Div& p);
00341 Div(Home home, A x0, B x1, C x2);
00342 public:
00344 virtual Actor* copy(Space& home, bool share);
00346 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00348 static ExecStatus post(Home home, A x0, B x1, C x2);
00349 };
00350
00359 template<class A, class B, class C>
00360 class Min : public MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND> {
00361 protected:
00362 using MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND>::x0;
00363 using MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND>::x1;
00364 using MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND>::x2;
00366 Min(Space& home, bool share, Min& p);
00368 Min(Home home, A x0, B x1, C x2);
00369 public:
00371 Min(Space& home, bool share, Propagator& p, A x0, B x1, C x2);
00373 virtual Actor* copy(Space& home, bool share);
00375 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00377 static ExecStatus post(Home home, A x0, B x1, C x2);
00378 };
00379
00388 template<class A, class B, class C>
00389 class Max : public MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND> {
00390 protected:
00391 using MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND>::x0;
00392 using MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND>::x1;
00393 using MixTernaryPropagator<A,PC_FLOAT_BND,B,PC_FLOAT_BND,C,PC_FLOAT_BND>::x2;
00395 Max(Space& home, bool share, Max& p);
00397 Max(Home home, A x0, B x1, C x2);
00398 public:
00400 Max(Space& home, bool share, Propagator& p, A x0, B x1, C x2);
00402 virtual Actor* copy(Space& home, bool share);
00404 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00406 static ExecStatus post(Home home, A x0, B x1, C x2);
00407 };
00408
00415 template<class View>
00416 class NaryMax : public NaryOnePropagator<View,PC_FLOAT_BND> {
00417 protected:
00418 using NaryOnePropagator<View,PC_FLOAT_BND>::x;
00419 using NaryOnePropagator<View,PC_FLOAT_BND>::y;
00420
00422 NaryMax(Space& home, bool share, NaryMax& p);
00424 NaryMax(Home home, ViewArray<View>& x, View y);
00425 public:
00427 virtual Actor* copy(Space& home, bool share);
00429 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00431 static ExecStatus post(Home home, ViewArray<View>& x, View y);
00432 };
00433
00440 template<class A, class B>
00441 class Channel :
00442 public MixBinaryPropagator<A,PC_FLOAT_BND,B,Gecode::Int::PC_INT_BND> {
00443 protected:
00444 using MixBinaryPropagator<A,PC_FLOAT_BND,B,Gecode::Int::PC_INT_BND>::x0;
00445 using MixBinaryPropagator<A,PC_FLOAT_BND,B,Gecode::Int::PC_INT_BND>::x1;
00446
00448 Channel(Space& home, bool share, Channel& p);
00450 Channel(Home home, A x0, B x1);
00451 public:
00453 virtual Actor* copy(Space& home, bool share);
00455 virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
00457 static ExecStatus post(Home home, A x0, B x1);
00458 };
00459
00460 }}}
00461
00462 #include <gecode/float/arithmetic/sqr-sqrt-abs.hpp>
00463 #include <gecode/float/arithmetic/pow-nroot.hpp>
00464 #include <gecode/float/arithmetic/mult.hpp>
00465 #include <gecode/float/arithmetic/div.hpp>
00466 #include <gecode/float/arithmetic/min-max-channel.hpp>
00467
00468 #endif
00469
00470