38 #ifndef __GECODE_FLOAT_HH__
39 #define __GECODE_FLOAT_HH__
54 #if !defined(GECODE_STATIC_LIBS) && \
55 (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
57 #ifdef GECODE_BUILD_FLOAT
58 #define GECODE_FLOAT_EXPORT __declspec( dllexport )
60 #define GECODE_FLOAT_EXPORT __declspec( dllimport )
65 #ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
66 #define GECODE_FLOAT_EXPORT __attribute__ ((visibility("default")))
68 #define GECODE_FLOAT_EXPORT
74 #ifndef GECODE_BUILD_FLOAT
75 #define GECODE_LIBRARY_NAME "Float"
80 #include <boost/numeric/interval.hpp>
128 namespace Gecode {
namespace Float {
131 #if defined(_MSC_VER) && (defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP > 0)))
138 typedef boost::numeric::interval_lib::save_state< boost::numeric::interval_lib::rounded_arith_std<FloatNum> >
144 typedef boost::numeric::interval_lib::rounded_arith_opp<FloatNum>
198 #ifdef GECODE_HAS_MPFR
281 namespace Gecode {
namespace Float {
287 bool subset(
const FloatVal&
x,
const FloatVal& y);
297 bool overlap(
const FloatVal&
x,
const FloatVal& y);
303 FloatVal
intersect(
const FloatVal&
x,
const FloatVal& y);
308 FloatVal
hull(
const FloatVal&
x,
const FloatVal& y);
369 template<
class Char,
class Traits>
370 friend std::basic_ostream<Char,Traits>&
386 #ifdef GECODE_HAS_MPFR
416 typedef boost::numeric::interval_lib::save_state<Float::Rounding>
R;
418 typedef boost::numeric::interval_lib::checking_strict<FloatNum>
P;
420 typedef boost::numeric::interval
422 boost::numeric::interval_lib::policies<R, P> >
463 bool tight(
void)
const;
677 template<
class Char,
class Traits>
678 std::basic_ostream<Char,Traits>&
738 #ifdef GECODE_HAS_MPFR
835 namespace Gecode {
namespace Float {
939 template<
class Char,
class Traits>
940 std::basic_ostream<Char,Traits>&
965 template<
class InputIterator>
996 template<
class InputIterator>
1086 dom(Home home, FloatVar
x, FloatVal
n);
1089 dom(Home home,
const FloatVarArgs&
x, FloatVal
n);
1098 dom(Home home, FloatVar
x, FloatVal
n, Reify
r);
1104 dom(Home home, FloatVar
x, FloatVar
d);
1107 dom(Home home,
const FloatVarArgs&
x,
const FloatVarArgs&
d);
1152 ite(Home home, BoolVar
b, FloatVar
x, FloatVar y, FloatVar z);
1168 min(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1173 min(Home home,
const FloatVarArgs&
x, FloatVar y);
1177 max(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1182 max(Home home,
const FloatVarArgs&
x, FloatVar y);
1187 abs(Home home, FloatVar x0, FloatVar x1);
1192 mult(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1197 sqr(Home home, FloatVar x0, FloatVar x1);
1202 sqrt(Home home, FloatVar x0, FloatVar x1);
1207 pow(Home home, FloatVar x0,
int n, FloatVar x1);
1212 nroot(Home home, FloatVar x0,
int n, FloatVar x1);
1217 div(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1218 #ifdef GECODE_HAS_MPFR
1222 exp(Home home, FloatVar x0, FloatVar x1);
1226 log(Home home, FloatVar x0, FloatVar x1);
1238 asin(Home home, FloatVar x0, FloatVar x1);
1242 sin(Home home, FloatVar x0, FloatVar x1);
1246 acos(Home home, FloatVar x0, FloatVar x1);
1250 cos(Home home, FloatVar x0, FloatVar x1);
1254 atan(Home home, FloatVar x0, FloatVar x1);
1258 tan(Home home, FloatVar x0, FloatVar x1);
1277 linear(Home home,
const FloatVarArgs&
x,
1290 linear(Home home,
const FloatVarArgs&
x,
1303 linear(Home home,
const FloatVarArgs&
x,
1316 linear(Home home,
const FloatVarArgs&
x,
1331 linear(Home home,
const FloatValArgs&
a,
const FloatVarArgs&
x,
1347 linear(Home home,
const FloatValArgs&
a,
const FloatVarArgs&
x,
1363 linear(Home home,
const FloatValArgs&
a,
const FloatVarArgs&
x,
1379 linear(Home home,
const FloatValArgs&
a,
const FloatVarArgs&
x,
1390 channel(Home home, FloatVar x0, IntVar x1);
1393 channel(Home home, IntVar x0, FloatVar x1);
1396 channel(Home home, FloatVar x0, BoolVar x1);
1399 channel(Home home, BoolVar x0, FloatVar x1);
1418 wait(Home home, FloatVar
x, std::function<
void(Space& home)>
c);
1421 wait(Home home,
const FloatVarArgs&
x, std::function<
void(Space& home)>
c);
1441 typedef std::function<bool(
const Space& home, FloatVar
x,
int i)>
1494 typedef std::function<void(
Space& home,
unsigned int a,
1653 typedef std::function<void(
const Space &home,
const Brancher&
b,
1655 FloatVar
x,
int i,
const FloatNumBranch&
n,
1928 branch(Home home,
const FloatVarArgs&
x,
1929 FloatVarBranch vars, FloatValBranch vals,
1931 FloatVarValPrint vvp=
nullptr);
1938 branch(Home home,
const FloatVarArgs&
x,
1939 TieBreak<FloatVarBranch> vars, FloatValBranch vals,
1941 FloatVarValPrint vvp=
nullptr);
1948 branch(Home home, FloatVar
x, FloatValBranch vals,
1949 FloatVarValPrint vvp=
nullptr);
1957 assign(Home home,
const FloatVarArgs&
x,
1958 FloatVarBranch vars, FloatAssign vals,
1960 FloatVarValPrint vvp=
nullptr);
1967 assign(Home home,
const FloatVarArgs&
x,
1968 TieBreak<FloatVarBranch> vars, FloatAssign vals,
1970 FloatVarValPrint vvp=
nullptr);
1977 assign(Home home, FloatVar
x, FloatAssign vals,
1978 FloatVarValPrint vvp=
nullptr);
1990 branch(Home home,
const FloatVarArgs&
x, FloatValBranch vals,
1992 FloatVarValPrint vvp=
nullptr);
1999 assign(Home home,
const FloatVarArgs&
x, FloatAssign vals,
2001 FloatVarValPrint vvp=
nullptr);
2031 relax(Home home,
const FloatVarArgs&
x,
const FloatVarArgs& sx,
struct Gecode::@602::NNF::@65::@66 b
For binary nodes (and, or, eqv)
int p
Number of positive literals for node type.
union Gecode::@602::NNF::@65 u
Union depending on nodetype t.
int n
Number of negative literals for node type.
Node * x
Pointer to corresponding Boolean expression node.
struct Gecode::@602::NNF::@65::@67 a
For atomic nodes.
Class for AFC (accumulated failure count) management.
Class for action management.
Argument array for non-primitive types.
Class for CHB management.
Generic domain change information to be supplied to advisors.
Recording AFC information for float variables.
void init(Home home, const FloatVarArgs &x, double d=1.0, bool share=true)
Initialize for float variables x with decay factor d.
FloatAFC(void)
Construct as not yet initialized.
FloatAFC & operator=(const FloatAFC &a)
Assignment operator.
Recording actions for float variables.
FloatAction & operator=(const FloatAction &a)
Assignment operator.
void init(Home home, const FloatVarArgs &x, double d=1.0, FloatBranchMerit bm=nullptr)
Initialize for float variables x with decay factor d.
FloatAction(void)
Construct as not yet initialized.
Which values to select for assignment.
Select
Which value selection.
@ SEL_MAX
Select median value of the upper part.
@ SEL_VAL_COMMIT
Select value according to user-defined functions.
@ SEL_RND
Select median value of a randomly chosen part.
@ SEL_MIN
Select median value of the lower part.
Select s
Which value to select.
FloatAssign(Select s=SEL_MIN)
Initialize with selection strategy s.
Select select(void) const
Return selection strategy.
Recording CHB for float variables.
FloatCHB & operator=(const FloatCHB &chb)
Assignment operator.
void init(Home home, const FloatVarArgs &x, FloatBranchMerit bm=nullptr)
Initialize for float variables x.
FloatCHB(void)
Construct as not yet initialized.
Value description class for branching.
bool l
Whether to try the lower or upper half first.
FloatNum n
The middle value for branching.
Trace delta information for float variables.
name Constructor Initialize with old trace view a new view a and delta a d FloatTraceDelta(Float::FloatTraceView o, Float::FloatView n, const Delta &d)
New view Float::FloatView n
Delta information const Delta & d
name Access Return minimum FloatNum min(void) const
name Constructor Initialize with old trace view a o
Return maximum FloatNum max(void) const
FloatValArgs(std::initializer_list< FloatVal > x)
Allocate array and copy elements from x.
static FloatValArgs create(int n, FloatVal start, int inc=1)
Allocate array with n elements such that for all .
FloatValArgs(void)
Allocate empty array.
Which values to select for branching first.
Select select(void) const
Return selection strategy.
Select
Which value selection.
@ SEL_SPLIT_RND
Select values randomly which are not greater or not smaller than mean of largest and smallest value.
@ SEL_SPLIT_MIN
Select values not greater than mean of smallest and largest value.
@ SEL_VAL_COMMIT
Select value according to user-defined functions.
@ SEL_SPLIT_MAX
Select values greater than mean of smallest and largest value.
Select s
Which value to select.
FloatValBranch(Select s=SEL_SPLIT_MIN)
Initialize with selection strategy s.
friend FloatVal cos(const FloatVal &x)
bool singleton(void) const
Test whether float is a singleton.
friend FloatVal exp(const FloatVal &x)
friend FloatVal acos(const FloatVal &x)
FloatVal & operator/=(const FloatNum &n)
Divide by n.
friend bool operator==(const FloatVal &x, const FloatVal &y)
boost::numeric::interval_lib::checking_strict< FloatNum > P
Used checking policy.
friend FloatVal atanh(const FloatVal &x)
static FloatVal pi(void)
Return lower bound of .
friend bool operator<(const FloatVal &x, const FloatVal &y)
friend bool operator<=(const FloatVal &x, const FloatVal &y)
friend FloatVal cosh(const FloatVal &x)
friend FloatVal operator-(const FloatVal &x)
boost::numeric::interval< FloatNum, boost::numeric::interval_lib::policies< R, P > > FloatValImpType
Implementation type for float value.
static FloatVal hull(FloatNum x, FloatNum y)
Return hull of x and y.
static FloatVal pi_twice(void)
Return .
friend FloatVal operator*(const FloatVal &x, const FloatVal &y)
friend FloatVal acosh(const FloatVal &x)
FloatValImpType x
Implementation of float value.
bool zero_in(void) const
Test whether zero is included.
friend FloatVal sqrt(const FloatVal &x)
FloatVal & operator-=(const FloatNum &n)
Subtract by n.
bool in(FloatNum n) const
Test whether n is included.
friend FloatVal pow(const FloatVal &x, int n)
friend FloatVal abs(const FloatVal &x)
friend FloatVal operator/(const FloatVal &x, const FloatVal &y)
friend FloatVal tanh(const FloatVal &x)
FloatVal & operator*=(const FloatNum &n)
Multiply by n.
FloatNum max(void) const
Return upper bound.
void assign(FloatNum const &l, FloatNum const &u)
Assign lower bound l and upper bound u.
friend FloatVal log(const FloatVal &x)
friend FloatVal sin(const FloatVal &x)
friend FloatVal sqr(const FloatVal &x)
friend FloatVal sinh(const FloatVal &x)
friend bool operator>=(const FloatVal &x, const FloatVal &y)
friend FloatVal asin(const FloatVal &x)
FloatVal & operator+=(const FloatNum &n)
Increment by n.
friend bool operator!=(const FloatVal &x, const FloatVal &y)
FloatNum med(void) const
Return median of float value.
FloatVal & operator=(const FloatNum &n)
Assignment operator.
friend bool operator>(const FloatVal &x, const FloatVal &y)
boost::numeric::interval_lib::save_state< Float::Rounding > R
Used rounding policies.
friend FloatVal atan(const FloatVal &x)
friend FloatVal asinh(const FloatVal &x)
bool tight(void) const
Test whether float is tight.
friend FloatVal nroot(const FloatVal &x, int n)
FloatNum size(void) const
Return size of float value (distance between maximum and minimum)
friend FloatVal operator+(const FloatVal &x)
friend FloatVal fmod(const FloatVal &x, const FloatVal &y)
static FloatVal pi_half(void)
Return .
friend std::basic_ostream< Char, Traits > & operator<<(std::basic_ostream< Char, Traits > &os, const FloatVal &x)
friend FloatVal tan(const FloatVal &x)
FloatVal(void)
Default constructor.
FloatNum min(void) const
Return lower bound.
FloatVarArgs(void)
Allocate empty array.
FloatVarArray(void)
Default constructor (array of size 0)
Which variable to select for branching.
Select select(void) const
Return selection strategy.
FloatVarBranch(void)
Initialize with strategy SEL_NONE.
void expand(Home home, const FloatVarArgs &x)
Expand AFC, action, and CHB.
Select
Which variable selection.
@ SEL_ACTION_SIZE_MIN
With smallest action divided by domain size.
@ SEL_ACTION_SIZE_MAX
With largest action divided by domain size.
@ SEL_MIN_MIN
With smallest min.
@ SEL_AFC_SIZE_MIN
With smallest accumulated failure count divided by domain size.
@ SEL_MAX_MAX
With largest max.
@ SEL_AFC_SIZE_MAX
With largest accumulated failure count divided by domain size.
@ SEL_CHB_MAX
With highest CHB Q-score.
@ SEL_DEGREE_SIZE_MIN
With smallest degree divided by domain size.
@ SEL_MIN_MAX
With largest min.
@ SEL_CHB_SIZE_MIN
With smallest CHB Q-score divided by domain size.
@ SEL_NONE
First unassigned.
@ SEL_MERIT_MIN
With least merit.
@ SEL_ACTION_MAX
With highest action.
@ SEL_CHB_MIN
With lowest CHB Q-score.
@ SEL_DEGREE_MAX
With largest degree.
@ SEL_DEGREE_SIZE_MAX
With largest degree divided by domain size.
@ SEL_DEGREE_MIN
With smallest degree.
@ SEL_MERIT_MAX
With highest merit.
@ SEL_MAX_MIN
With smallest max.
@ SEL_CHB_SIZE_MAX
With largest CHB Q-score divided by domain size.
@ SEL_RND
Random (uniform, for tie breaking)
@ SEL_AFC_MAX
With largest accumulated failure count.
@ SEL_SIZE_MAX
With largest domain size.
@ SEL_AFC_MIN
With smallest accumulated failure count.
@ SEL_ACTION_MIN
With lowest action.
@ SEL_SIZE_MIN
With smallest domain size.
Select s
Which variable to select.
bool in(const FloatVal &n) const
Test whether n is contained in domain.
FloatVal domain(void) const
Return domain.
FloatNum med(void) const
Return median of domain.
FloatNum size(void) const
Return size of domain (distance between maximum and minimum)
FloatNum min(void) const
Return minimum of domain.
FloatVar(void)
Default constructor.
FloatVal val(void) const
Return assigned value.
FloatNum max(void) const
Return maximum of domain.
Float view for float variables.
Floating point rounding policy.
FloatNum sin_down(FloatNum x)
Return lower bound of sine of x (domain: )
FloatNum tanh_up(FloatNum x)
Return upper bound of hyperbolic tangent of x (domain: )
FloatNum acosh_up(FloatNum x)
Return upper bound of hyperbolic arccosine of x (domain: )
~Rounding(void)
Destructor (restores previous rounding mode)
FloatNum tanh_down(FloatNum x)
Return lower bound of hyperbolic tangent of x (domain: )
FloatNum sinh_up(FloatNum x)
Return upper bound of hyperbolic sine of x (domain: )
FloatNum int_up(FloatNum x)
Return next upward-rounded integer of x (domain: )
FloatNum sqrt_up(FloatNum x)
Return upper bound of square root of x (domain: )
FloatNum atanh_down(FloatNum x)
Return lower bound of hyperbolic arctangent of x (domain: )
FloatNum cos_up(FloatNum x)
Return upper bound of cosine of x (domain: )
FloatNum sub_up(FloatNum x, FloatNum y)
Return upper bound of x minus y (domain: )
FloatNum int_down(FloatNum x)
Return next downward-rounded integer of x (domain: )
FloatNum median(FloatNum x, FloatNum y)
Return median of x and y (domain: )
FloatNum add_up(FloatNum x, FloatNum y)
Return upper bound of x plus y (domain: )
Rounding(void)
Default constructor (configures full rounding mode)
FloatNum sinh_down(FloatNum x)
Return lower bound of hyperbolic sine of x (domain: )
FloatNum tan_down(FloatNum x)
Return lower bound of tangent of x (domain: )
FloatNum sqrt_down(FloatNum x)
Return lower bound of square root of x (domain: )
FloatNum sub_down(FloatNum x, FloatNum y)
Return lower bound of x minus y (domain: )
FloatNum asin_down(FloatNum x)
Return lower bound of arcsine of x (domain: )
FloatNum mul_up(FloatNum x, FloatNum y)
Return upper bound of x times y (domain: )
FloatNum div_up(FloatNum x, FloatNum y)
Return upper bound of x divided y (domain: )
FloatNum exp_down(FloatNum x)
Return lower bound of exponential of x (domain: )
FloatNum div_down(FloatNum x, FloatNum y)
Return lower bound of x divided by y (domain: )
FloatNum mul_down(FloatNum x, FloatNum y)
Return lower bound of x times y (domain: )
FloatNum asin_up(FloatNum x)
Return upper bound of arcsine of x (domain: )
FloatNum acosh_down(FloatNum x)
Return lower bound of hyperbolic arccosine of x (domain: )
FloatNum atan_down(FloatNum x)
Return lower bound of arctangent of x (domain: )
FloatNum cosh_down(FloatNum x)
Return lower bound of hyperbolic cosine of x (domain: )
FloatNum log_up(FloatNum x)
Return upper bound of logarithm of x (domain: )
FloatNum asinh_down(FloatNum x)
Return lower bound of hyperbolic arcsine of x (domain: )
FloatNum sin_up(FloatNum x)
Return upper bound of sine of x (domain: )
FloatNum acos_up(FloatNum x)
Return upper bound of arccossine of x (domain: )
FloatNum cosh_up(FloatNum x)
Return upper bound of hyperbolic cosine of x (domain: )
FloatNum exp_up(FloatNum x)
Return upper bound of exponential of x (domain: )
FloatNum tan_up(FloatNum x)
Return upper bound of tangent of x (domain: )
FloatNum acos_down(FloatNum x)
Return lower bound of arccosine of x (domain: )
FloatNum atanh_up(FloatNum x)
Return upper bound of hyperbolic arctangent of x (domain: )
FloatNum log_down(FloatNum x)
Return lower bound of logarithm of x (domain: )
FloatNum atan_up(FloatNum x)
Return upper bound of arctangent of x (domain: )
FloatNum cos_down(FloatNum x)
Return lower bound of cosine of x (domain: )
FloatNum asinh_up(FloatNum x)
Return upper bound of hyperbolic arcsine of x (domain: )
FloatNum add_down(FloatNum x, FloatNum y)
Return lower bound of x plus y (domain: )
Home class for posting propagators
Shared array with arbitrary number of elements.
Standard float variable tracer.
Output stream to use std::ostream & os
Value branching information.
Rnd r
Random number generator.
Argument array for variables.
int n
Number of variables (size)
Variable branching information.
Variables as interfaces to variable implementations.
Propagator for recording view trace information.
Tracer that process view trace information.
FloatAssign FLOAT_ASSIGN(FloatBranchVal v, FloatBranchCommit c)
FloatAssign FLOAT_ASSIGN_MAX(void)
Select median value of the upper part.
FloatAssign FLOAT_ASSIGN_RND(Rnd r)
Select median value of a randomly chosen part.
FloatAssign FLOAT_ASSIGN_MIN(void)
Select median value of the lower part.
FloatValBranch FLOAT_VAL_SPLIT_MAX(void)
Select values greater than mean of smallest and largest value.
FloatValBranch FLOAT_VAL(FloatBranchVal v, FloatBranchCommit c)
FloatValBranch FLOAT_VAL_SPLIT_RND(Rnd r)
Select values randomly which are not greater or not smaller than mean of largest and smallest value.
FloatValBranch FLOAT_VAL_SPLIT_MIN(void)
Select values not greater than mean of smallest and largest value.
FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MAX(BranchTbl tbl)
Select variable with largest degree divided by domain size.
FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MIN(BranchTbl tbl)
Select variable with smallest degree divided by domain size.
FloatVarBranch FLOAT_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking)
FloatVarBranch FLOAT_VAR_AFC_MIN(double d, BranchTbl tbl)
Select variable with smallest accumulated failure count with decay factor d.
FloatVarBranch FLOAT_VAR_SIZE_MAX(BranchTbl tbl)
Select variable with largest domain size.
FloatVarBranch FLOAT_VAR_MAX_MAX(BranchTbl tbl)
Select variable with largest max.
FloatVarBranch FLOAT_VAR_AFC_SIZE_MIN(double d, BranchTbl tbl)
Select variable with smalllest accumulated failure count divided by domain size with decay factor d.
FloatVarBranch FLOAT_VAR_CHB_SIZE_MAX(BranchTbl tbl)
Select variable with largest CHB Q-score divided by domain size.
FloatVarBranch FLOAT_VAR_CHB_MIN(BranchTbl tbl)
Select variable with lowest CHB Q-score.
FloatVarBranch FLOAT_VAR_CHB_SIZE_MIN(BranchTbl tbl)
Select variable with smallest CHB Q-score divided by domain size.
FloatVarBranch FLOAT_VAR_ACTION_MAX(double d, BranchTbl tbl)
Select variable with highest action with decay factor d.
FloatVarBranch FLOAT_VAR_CHB_MAX(BranchTbl tbl)
Select variable with highest CHB Q-score.
FloatVarBranch FLOAT_VAR_MIN_MIN(BranchTbl tbl)
Select variable with smallest min.
FloatVarBranch FLOAT_VAR_MAX_MIN(BranchTbl tbl)
Select variable with smallest max.
FloatVarBranch FLOAT_VAR_ACTION_MIN(double d, BranchTbl tbl)
Select variable with lowest action with decay factor d.
FloatVarBranch FLOAT_VAR_NONE(void)
Select first unassigned variable.
FloatVarBranch FLOAT_VAR_DEGREE_MAX(BranchTbl tbl)
Select variable with largest degree.
FloatVarBranch FLOAT_VAR_ACTION_SIZE_MAX(double d, BranchTbl tbl)
Select variable with largest action divided by domain size with decay factor d.
FloatVarBranch FLOAT_VAR_MIN_MAX(BranchTbl tbl)
Select variable with largest min.
FloatVarBranch FLOAT_VAR_AFC_SIZE_MAX(double d, BranchTbl tbl)
Select variable with largest accumulated failure count divided by domain size with decay factor d.
FloatVarBranch FLOAT_VAR_MERIT_MIN(FloatBranchMerit bm, BranchTbl tbl)
Select variable with least merit according to branch merit function bm.
FloatVarBranch FLOAT_VAR_DEGREE_MIN(BranchTbl tbl)
Select variable with smallest degree.
FloatVarBranch FLOAT_VAR_SIZE_MIN(BranchTbl tbl)
Select variable with smallest domain size.
FloatVarBranch FLOAT_VAR_AFC_MAX(double d, BranchTbl tbl)
Select variable with largest accumulated failure count with decay factor d.
FloatVarBranch FLOAT_VAR_ACTION_SIZE_MIN(double d, BranchTbl tbl)
Select variable with smallest action divided by domain size with decay factor d.
FloatVarBranch FLOAT_VAR_MERIT_MAX(FloatBranchMerit bm, BranchTbl tbl)
Select variable with highest merit according to branch merit function bm.
void relax(Home home, const FloatVarArgs &x, const FloatVarArgs &sx, Rnd r, double p)
FloatVal asinh(const FloatVal &x)
FloatVal fmod(const FloatVal &x, const FloatVal &y)
FloatVal sinh(const FloatVal &x)
FloatVal acosh(const FloatVal &x)
FloatVal tanh(const FloatVal &x)
FloatVal atanh(const FloatVal &x)
FloatVal cosh(const FloatVal &x)
void branch(Home home, const IntVarArgs &x, const BoolVarArgs &y, IntBoolVarBranch vars, IntValBranch vals)
Branch function for integer and Boolean variables.
void sqr(Home home, FloatVar x0, FloatVar x1)
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 pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n\geq 0$.
void nroot(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n\geq 0$.
void channel(Home home, FloatVar x0, IntVar x1)
Post propagator for channeling a float and an integer variable .
void wait(Home home, FloatVar x, std::function< void(Space &home)> c)
Execute c when x becomes assigned.
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void exp(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void sin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void cos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void acos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void atan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void asin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void tan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
std::function< void(const Space &home, const Brancher &b, unsigned int a, FloatVar x, int i, const FloatNumBranch &n, std::ostream &o)> FloatVarValPrint
Function type for explaining branching alternatives for float variables.
#define GECODE_FLOAT_EXPORT
Post propagator for SetVar SetOpType SetVar y
ViewTracer< Float::FloatView > FloatTracer
Tracer for float variables.
ViewTraceRecorder< Float::FloatView > FloatTraceRecorder
Trace recorder for float variables.
void trace(Home home, const FloatVarArgs &x, TraceFilter tf, int te, FloatTracer &t)
Create a tracer for float variables.
std::function< double(const Space &home, double w, double b)> BranchTbl
Tie-break limit function.
std::function< FloatNumBranch(const Space &home, FloatVar x, int i)> FloatBranchVal
Branch value function type for float variables.
std::function< double(const Space &home, FloatVar x, int i)> FloatBranchMerit
Branch merit function type for float variables.
std::function< bool(const Space &home, FloatVar x, int i)> FloatBranchFilter
Branch filter function type for float variables.
void assign(Home home, const FloatVarArgs &x, FloatVarBranch vars, FloatAssign vals, FloatBranchFilter bf, FloatVarValPrint vvp)
Assign all x with variable selection vars and value selection vals.
std::function< void(Space &home, unsigned int a, FloatVar x, int i, FloatNumBranch nl)> FloatBranchCommit
Branch commit function type for float variables.
void linear(Home home, const FloatVarArgs &x, FloatRelType frt, FloatVal c)
Post propagator for .
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
void ite(Home home, BoolVar b, FloatVar x, FloatVar y, FloatVar z)
Post propagator for if-then-else constraint.
double FloatNum
Floating point number base type.
FloatRelType
Relation types for floats.
@ FRT_LQ
Less or equal ( )
@ FRT_GQ
Greater or equal ( )
@ TE_INIT
Trace init events.
@ TE_PRUNE
Trace prune events.
@ TE_FIX
Trace fixpoint events.
@ TE_FAIL
Trace fail events.
@ TE_DONE
Trace done events.
const FloatNum max
Largest allowed float value.
bool valid(const FloatVal &n)
Return whether float n is a valid number.
const FloatNum min
Smallest allowed float value.
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.
bool subset(const FloatVal &x, const FloatVal &y)
bool proper_subset(const FloatVal &x, const FloatVal &y)
FloatVal hull(const FloatVal &x, const FloatVal &y)
bool overlap(const FloatVal &x, const FloatVal &y)
FloatVal intersect(const FloatVal &x, const FloatVal &y)
boost::numeric::interval_lib::rounded_arith_opp< FloatNum > RoundingBase
Rounding Base class (optimized version)
ExecStatus prune(Space &home, ViewArray< VX > &x, ConstIntView)
const double base
Base for geometric restart sequence.
double tbl(const Gecode::Space &, double w, double b)
Test function for tie-break limit function.
Gecode::FloatVal c(-8, 8)
Gecode::IntArgs i({1, 2, 3, 4})
FloatNum pi_upper(void)
Return upper bound of .
FloatNum pi_lower(void)
Return lower bound of .
FloatNum pi_half_lower(void)
Return lower bound of .
FloatNum pi_twice_lower(void)
Return lower bound of .
FloatNum pi_half_upper(void)
Return upper bound of .
FloatNum pi_twice_upper(void)
Return upper bound of .
std::basic_ostream< Char, Traits > & operator<<(std::basic_ostream< Char, Traits > &os, const Dictionary &d)
Print statistics summary.