42 #ifndef __GECODE_FLOAT_HH__
43 #define __GECODE_FLOAT_HH__
56 #if !defined(GECODE_STATIC_LIBS) && \
57 (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
59 #ifdef GECODE_BUILD_FLOAT
60 #define GECODE_FLOAT_EXPORT __declspec( dllexport )
62 #define GECODE_FLOAT_EXPORT __declspec( dllimport )
67 #ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
68 #define GECODE_FLOAT_EXPORT __attribute__ ((visibility("default")))
70 #define GECODE_FLOAT_EXPORT
76 #ifndef GECODE_BUILD_FLOAT
77 #define GECODE_LIBRARY_NAME "Float"
82 #include <gecode/third-party/boost/numeric/interval.hpp>
130 namespace Gecode {
namespace Float {
138 public gecode_boost::numeric::interval_lib::rounded_arith_opp<FloatNum> {
141 typedef gecode_boost::numeric::interval_lib::rounded_arith_opp<FloatNum>
Base;
185 #ifdef GECODE_HAS_MPFR
268 namespace Gecode {
namespace Float {
274 bool subset(
const FloatVal&
x,
const FloatVal& y);
284 bool overlap(
const FloatVal&
x,
const FloatVal& y);
290 FloatVal
intersect(
const FloatVal&
x,
const FloatVal& y);
295 FloatVal
hull(
const FloatVal&
x,
const FloatVal& y);
356 template<
class Char,
class Traits>
357 friend std::basic_ostream<Char,Traits>&
358 operator <<(std::basic_ostream<Char,Traits>& os,
const FloatVal&
x);
373 #ifdef GECODE_HAS_MPFR
403 typedef gecode_boost::numeric::interval_lib::save_state<Float::Rounding>
R;
405 typedef gecode_boost::numeric::interval_lib::checking_strict<FloatNum>
P;
407 typedef gecode_boost::numeric::interval
409 gecode_boost::numeric::interval_lib::policies<R, P> >
423 FloatVal(
const FloatNum&
l,
const FloatNum&
u);
433 void assign(FloatNum
const &
l, FloatNum
const &
u);
438 FloatNum
min(
void)
const;
441 FloatNum
max(
void)
const;
443 FloatNum
size(
void)
const;
445 FloatNum
med(
void)
const;
450 bool tight(
void)
const;
455 bool in(FloatNum n)
const;
664 template<
class Char,
class Traits>
665 std::basic_ostream<Char,Traits>&
666 operator <<(std::basic_ostream<Char,Traits>& os,
const FloatVal&
x);
725 #ifdef GECODE_HAS_MPFR
822 namespace Gecode {
namespace Float {
926 template<
class Char,
class Traits>
927 std::basic_ostream<Char,Traits>&
928 operator <<(std::basic_ostream<Char,Traits>& os,
const FloatVar&
x);
950 template<
class InputIterator>
981 template<
class InputIterator>
1072 dom(Home home, FloatVar
x, FloatVal
n);
1075 dom(Home home,
const FloatVarArgs&
x, FloatVal
n);
1084 dom(Home home, FloatVar
x, FloatVal
n, Reify
r);
1090 dom(Home home, FloatVar
x, FloatVar
d);
1093 dom(Home home,
const FloatVarArgs&
x,
const FloatVarArgs&
d);
1146 min(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1151 min(Home home,
const FloatVarArgs&
x, FloatVar y);
1155 max(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1160 max(Home home,
const FloatVarArgs&
x, FloatVar y);
1165 abs(Home home, FloatVar x0, FloatVar x1);
1170 mult(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1175 sqr(Home home, FloatVar x0, FloatVar x1);
1180 sqrt(Home home, FloatVar x0, FloatVar x1);
1185 pow(Home home, FloatVar x0,
int n, FloatVar x1);
1190 nroot(Home home, FloatVar x0,
int n, FloatVar x1);
1195 div(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1196 #ifdef GECODE_HAS_MPFR
1200 exp(Home home, FloatVar x0, FloatVar x1);
1204 log(Home home, FloatVar x0, FloatVar x1);
1208 pow(Home home,
FloatNum base, FloatVar x0, FloatVar x1);
1212 log(Home home,
FloatNum base, FloatVar x0, FloatVar x1);
1216 asin(Home home, FloatVar x0, FloatVar x1);
1220 sin(Home home, FloatVar x0, FloatVar x1);
1224 acos(Home home, FloatVar x0, FloatVar x1);
1228 cos(Home home, FloatVar x0, FloatVar x1);
1232 atan(Home home, FloatVar x0, FloatVar x1);
1236 tan(Home home, FloatVar x0, FloatVar x1);
1248 linear(Home home,
const FloatVarArgs&
x,
1254 linear(Home home,
const FloatVarArgs&
x,
1260 linear(Home home,
const FloatVarArgs&
x,
1266 linear(Home home,
const FloatVarArgs&
x,
1275 linear(Home home,
const FloatValArgs&
a,
const FloatVarArgs&
x,
1284 linear(Home home,
const FloatValArgs&
a,
const FloatVarArgs&
x,
1293 linear(Home home,
const FloatValArgs&
a,
const FloatVarArgs&
x,
1302 linear(Home home,
const FloatValArgs&
a,
const FloatVarArgs&
x,
1313 channel(Home home, FloatVar x0, IntVar x1);
1316 channel(Home home, IntVar x0, FloatVar x1);
1330 wait(Home home, FloatVar
x,
void (*
c)(Space& home));
1333 wait(Home home,
const FloatVarArgs& x,
void (*
c)(Space& home));
1754 branch(Home home,
const FloatVarArgs& x,
1755 FloatVarBranch vars, FloatValBranch vals,
1764 branch(Home home,
const FloatVarArgs& x,
1765 TieBreak<FloatVarBranch> vars, FloatValBranch vals,
1774 branch(Home home, FloatVar x, FloatValBranch vals,
1783 assign(Home home,
const FloatVarArgs& x, FloatAssign vals,
1792 assign(Home home, FloatVar x, FloatAssign vals,
#define GECODE_FLOAT_EXPORT
FloatNum pi_half_upper(void)
Return upper bound of .
FloatVal operator-(const FloatVal &x)
Select median value of the upper part.
FloatNum atanh_down(FloatNum x)
Return lower bound of hyperbolic arctangent of x (domain: )
FloatVarBranch FLOAT_VAR_DEGREE_MAX(BranchTbl tbl)
Select variable with largest degree.
FloatNum tanh_up(FloatNum x)
Return upper bound of hyperbolic tangent of x (domain: )
Variables as interfaces to variable implementations.
Select
Which value selection.
FloatNum add_down(FloatNum x, FloatNum y)
Return lower bound of x plus y (domain: )
FloatNum asinh_down(FloatNum x)
Return lower bound of hyperbolic arcsine of x (domain: )
FloatVarArgs(int n)
Allocate array with n elements.
Which values to select for branching first.
void mult(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
FloatVarArgs(const std::vector< FloatVar > &a)
Initialize from vector a.
FloatNum div_up(FloatNum x, FloatNum y)
Return upper bound of x divided y (domain: )
void linear(Home home, const FloatVarArgs &x, FloatRelType frt, FloatNum c)
Post propagator for .
FloatVarBranch(void)
Initialize with strategy SEL_NONE.
FloatNum mul_down(FloatNum x, FloatNum y)
Return lower bound of x times y (domain: )
FloatValBranch FLOAT_VAL_SPLIT_MAX(void)
Select values greater than mean of smallest and largest value.
FloatVarArgs(const FloatVarArgs &a)
Initialize from variable argument array a (copy elements)
bool valid(const FloatVal &n)
Return whether float n is a valid number.
void init(Home, const FloatVarArgs &x, double d=1.0, FloatBranchMerit bm=NULL)
Initialize for float variables x with decay factor d.
FloatNum cosh_down(FloatNum x)
Return lower bound of hyperbolic cosine of x (domain: )
bool subset(const FloatVal &x, const FloatVal &y)
FloatNum asinh_up(FloatNum x)
Return upper bound of hyperbolic arcsine of x (domain: )
FloatNum med(void) const
Return median of domain.
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
friend bool operator>(const FloatVal &x, const FloatVal &y)
void channel(Home home, FloatVar x0, IntVar x1)
Post propagator for channeling a float and an integer variable .
FloatNumBranch(* FloatBranchVal)(const Space &home, FloatVar x, int i)
Branch value function type for float variables.
const FloatNum max
Largest allowed float value.
FloatNum int_down(FloatNum x)
Return next downward-rounded integer of x (domain: )
FloatVal operator/(const FloatVal &x, const FloatVal &y)
With smallest accumulated failure count.
FloatAssign FLOAT_ASSIGN_MAX(void)
Select median value of the upper part.
With smallest domain size.
FloatNum tanh_down(FloatNum x)
Return lower bound of hyperbolic tangent of x (domain: )
Argument array for primtive types.
friend FloatVal cosh(const FloatVal &x)
FloatVal fmod(const FloatVal &x, const FloatVal &y)
friend FloatVal exp(const FloatVal &x)
FloatVal & operator/=(const FloatNum &n)
Divide by n.
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
void abs(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void nroot(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n 0$.
gecode_boost::numeric::interval_lib::rounded_arith_opp< FloatNum > Base
Base class.
bool overlap(const FloatVal &x, const FloatVal &y)
friend FloatVal sqr(const FloatVal &x)
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n 0$.
FloatActivity(void)
Construct as not yet initialized.
FloatVar(void)
Default constructor.
FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MAX(BranchTbl tbl)
Select variable with largest degree divided by domain size.
FloatAssign FLOAT_ASSIGN_MIN(void)
Select median value of the lower part.
friend FloatVal sinh(const FloatVal &x)
Select s
Which value to select.
void dom(Home home, FloatVar x, FloatVal n)
Propagates .
double(* FloatBranchMerit)(const Space &home, FloatVar x, int i)
Branch merit function type for float variables.
void expand(Home home, const FloatVarArgs &x)
Expand decay factor into AFC or activity.
Select
Which value selection.
bool(* FloatBranchFilter)(const Space &home, FloatVar x, int i)
Branch filter function type for float variables.
FloatVal hull(const FloatVal &x, const FloatVal &y)
FloatNum size(void) const
Return size of domain (distance between maximum and minimum)
FloatNum sqrt_down(FloatNum x)
Return lower bound of square root of x (domain: )
friend FloatVal fmod(const FloatVal &x, const FloatVal &y)
FloatVarBranch FLOAT_VAR_AFC_MIN(double d, BranchTbl tbl)
Select variable with smallest accumulated failure count with decay factor d.
FloatNum asin_up(FloatNum x)
Return upper bound of arcsine of x (domain: )
Which variable to select for branching.
FloatVal & operator-=(const FloatNum &n)
Subtract by n.
gecode_boost::numeric::interval_lib::checking_strict< FloatNum > P
Used checking policy.
FloatVarBranch FLOAT_VAR_ACTIVITY_SIZE_MAX(double d, BranchTbl tbl)
Select variable with largest activity divided by domain size with decay factor d. ...
static FloatVal pi_twice(void)
Return .
FloatNum sinh_up(FloatNum x)
Return upper bound of hyperbolic sine of x (domain: )
friend FloatVal acos(const FloatVal &x)
FloatNum sqrt_up(FloatNum x)
Return upper bound of square root of x (domain: )
friend FloatVal asin(const FloatVal &x)
FloatVarBranch FLOAT_VAR_ACTIVITY_MAX(double d, BranchTbl tbl)
Select variable with highest activity with decay factor d.
gecode_boost::numeric::interval< FloatNum, gecode_boost::numeric::interval_lib::policies< R, P > > FloatValImpType
Implementation type for float value.
FloatValBranch FLOAT_VAL(FloatBranchVal v, FloatBranchCommit c)
Select median value of the lower part.
Select select(void) const
Return selection strategy.
FloatVarBranch FLOAT_VAR_NONE(void)
Select first unassigned variable.
FloatVal(void)
Default constructor.
friend bool operator<=(const FloatVal &x, const FloatVal &y)
FloatNum max(void) const
Return maximum of domain.
FloatActivity & operator=(const FloatActivity &a)
Assignment operator.
static FloatVal hull(FloatNum x, FloatNum y)
Return hull of x and y.
Select s
Which value to select.
FloatValBranch FLOAT_VAL_SPLIT_RND(Rnd r)
Select values randomly which are not greater or not smaller than mean of largest and smallest value...
FloatValImpType x
Implementation of float value.
bool tight(void) const
Test whether float is tight.
FloatNum pi_twice_lower(void)
Return lower bound of .
Gecode::FloatVal c(-8, 8)
FloatNum log_down(FloatNum x)
Return lower bound of logarithm of x (domain: )
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...
With smallest accumulated failure count divided by domain size.
bool singleton(void) const
Test whether float is a singleton.
bool proper_subset(const FloatVal &x, const FloatVal &y)
const FloatNum min
Smallest allowed float value.
Gecode::IntArgs i(4, 1, 2, 3, 4)
FloatNum n
The middle value for branching.
Class for AFC (accumulated failure count) management.
FloatNum asin_down(FloatNum x)
Return lower bound of arcsine of x (domain: )
FloatVal domain(void) const
Return domain.
FloatNum med(void) const
Return median of float value.
int n
Number of negative literals for node type.
FloatNum sin_up(FloatNum x)
Return upper bound of sine of x (domain: )
FloatNum int_up(FloatNum x)
Return next upward-rounded integer of x (domain: )
Select values not greater than mean of smallest and largest value.
Select values randomly which are not greater or not smaller than mean of largest and smallest value...
FloatVarArgs(const VarArray< FloatVar > &a)
Initialize from variable array a (copy elements)
FloatVal & operator*=(const FloatNum &n)
Multiply by n.
FloatAssign FLOAT_ASSIGN_RND(Rnd r)
Select median value of a randomly chosen part.
FloatVal sinh(const FloatVal &x)
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_DEGREE_MIN(BranchTbl tbl)
Select variable with smallest degree.
Select select(void) const
Return selection strategy.
FloatNum min(void) const
Return lower bound.
FloatNum pi_twice_upper(void)
Return upper bound of .
FloatVal intersect(const FloatVal &x, const FloatVal &y)
Value description class for branching.
friend bool operator==(const FloatVal &x, const FloatVal &y)
FloatValArgs(void)
Allocate empty array.
FloatVal operator+(const FloatVal &x)
void sqr(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
FloatRelType
Relation types for floats.
FloatNum log_up(FloatNum x)
Return upper bound of logarithm of x (domain: )
bool operator!=(const FloatVal &x, const FloatVal &y)
static FloatValArgs create(int n, FloatVal start, int inc=1)
Allocate array with n elements such that for all .
friend FloatVal cos(const FloatVal &x)
Select select(void) const
Return selection strategy.
FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MIN(BranchTbl tbl)
Select variable with smallest degree divided by domain size.
FloatNum cos_down(FloatNum x)
Return lower bound of cosine of x (domain: )
void sqrt(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
bool l
Whether to try the lower or upper half first.
With smallest degree divided by domain size.
friend FloatVal nroot(const FloatVal &x, int n)
FloatVal cosh(const FloatVal &x)
FloatVarArray(void)
Default constructor (array of size 0)
friend FloatVal operator*(const FloatVal &x, const FloatVal &y)
With largest accumulated failure count.
FloatNum pi_half_lower(void)
Return lower bound of .
FloatValBranch FLOAT_VAL_SPLIT_MIN(void)
Select values not greater than mean of smallest and largest value.
void(* VoidFunction)(void)
Base type for any function pointer.
FloatVarBranch FLOAT_VAR_MERIT_MAX(FloatBranchMerit bm, BranchTbl tbl)
Select variable with highest merit according to branch merit function bm.
FloatNum atanh_up(FloatNum x)
Return upper bound of hyperbolic arctangent of x (domain: )
static FloatVal pi(void)
Return lower bound of .
FloatVal & operator=(const FloatNum &n)
Assignment operator.
friend FloatVal atanh(const FloatVal &x)
Random (uniform, for tie breaking)
int n
Number of variables (size)
Select
Which variable selection.
friend FloatVal tanh(const FloatVal &x)
FloatVarBranch FLOAT_VAR_MAX_MAX(BranchTbl tbl)
Select variable with largest max.
void asin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
FloatVarBranch FLOAT_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking)
FloatAFC(void)
Construct as not yet initialized.
FloatVarArgs(InputIterator first, InputIterator last)
Initialize from InputIterator first and last.
Floating point rounding policy.
FloatNum tan_up(FloatNum x)
Return upper bound of tangent of x (domain: )
Recording activities for float variables.
FloatNum atan_up(FloatNum x)
Return upper bound of arctangent of x (domain: )
Float view for float variables.
FloatVal & operator+=(const FloatNum &n)
Increment by n.
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...
union Gecode::@518::NNF::@57 u
Union depending on nodetype t.
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
FloatNum cos_up(FloatNum x)
Return upper bound of cosine of x (domain: )
Select median value of a randomly chosen part.
void cos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
friend FloatVal asinh(const FloatVal &x)
bool in(const FloatVal &n) const
Test whether n is contained in domain.
FloatNum acosh_up(FloatNum x)
Return upper bound of hyperbolic arccosine of x (domain: )
friend FloatVal abs(const FloatVal &x)
Value branching information.
void div(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Select value according to user-defined functions.
FloatVal operator*(const FloatVal &x, const FloatVal &y)
Variable branching information.
BrancherHandle assign(Home home, const FloatVarArgs &x, FloatAssign fa, FloatBranchFilter bf, FloatVarValPrint vvp)
Assign all x with value selection vals.
FloatNum atan_down(FloatNum x)
Return lower bound of arctangent of x (domain: )
Node * x
Pointer to corresponding Boolean expression node.
FloatVarBranch FLOAT_VAR_MIN_MIN(BranchTbl tbl)
Select variable with smallest min.
Rounding(void)
Default constructor (configures full rounding mode)
FloatNum sub_down(FloatNum x, FloatNum y)
Return lower bound of x minus y (domain: )
FloatNum acosh_down(FloatNum x)
Return lower bound of hyperbolic arccosine of x (domain: )
void tan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
FloatNum min(void) const
Return minimum of domain.
With smallest activity divided by domain size.
bool in(FloatNum n) const
Test whether n is included.
Select s
Which variable to select.
static FloatVal pi_half(void)
Return .
friend FloatVal tan(const FloatVal &x)
FloatVarBranch FLOAT_VAR_MAX_MIN(BranchTbl tbl)
Select variable with smallest max.
bool operator>=(const FloatVal &x, const FloatVal &y)
FloatVal acosh(const FloatVal &x)
friend FloatVal operator+(const FloatVal &x)
FloatVal val(void) const
Return assigned value.
FloatNum div_down(FloatNum x, FloatNum y)
Return lower bound of x divided by y (domain: )
FloatNum exp_up(FloatNum x)
Return upper bound of exponential of x (domain: )
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
FloatNum acos_up(FloatNum x)
Return upper bound of arccossine of x (domain: )
bool zero_in(void) const
Test whether zero is included.
friend FloatVal acosh(const FloatVal &x)
FloatVal atanh(const FloatVal &x)
friend bool operator<(const FloatVal &x, const FloatVal &y)
FloatVal asinh(const FloatVal &x)
friend FloatVal pow(const FloatVal &x, int n)
Which values to select for assignment.
FloatNum cosh_up(FloatNum x)
Return upper bound of hyperbolic cosine of x (domain: )
friend FloatVal sqrt(const FloatVal &x)
FloatNum exp_down(FloatNum x)
Return lower bound of exponential of x (domain: )
void assign(FloatNum const &l, FloatNum const &u)
Assign lower bound l and upper bound u.
FloatAssign FLOAT_ASSIGN(FloatBranchVal v, FloatBranchCommit c)
With largest domain size.
FloatValBranch(Select s=SEL_SPLIT_MIN)
Initialize with selection strategy s.
gecode_boost::numeric::interval_lib::save_state< Float::Rounding > R
Used rounding policies.
With largest accumulated failure count divided by domain size.
void init(Home, const FloatVarArgs &x, double d=1.0)
Initialize for float variables x with decay factor d.
bool operator>(const FloatVal &x, const FloatVal &y)
FloatNum sinh_down(FloatNum x)
Return lower bound of hyperbolic sine of x (domain: )
FloatNum sub_up(FloatNum x, FloatNum y)
Return upper bound of x minus y (domain: )
friend FloatVal operator/(const FloatVal &x, const FloatVal &y)
friend bool operator!=(const FloatVal &x, const FloatVal &y)
bool operator<(const FloatVal &x, const FloatVal &y)
bool operator==(const FloatVal &x, const FloatVal &y)
With largest activity divided by domain size.
bool operator<=(const FloatVal &x, const FloatVal &y)
FloatNum size(void) const
Return size of float value (distance between maximum and minimum)
FloatNum add_up(FloatNum x, FloatNum y)
Return upper bound of x plus y (domain: )
Gecode toplevel namespace
Argument array for variables.
friend FloatVal log(const FloatVal &x)
void wait(Home home, FloatVar x, void(*c)(Space &home))
Execute c when x becomes assigned.
void sin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
FloatNum acos_down(FloatNum x)
Return lower bound of arccosine of x (domain: )
FloatVarArgs(void)
Allocate empty array.
friend FloatVal sin(const FloatVal &x)
BrancherHandle branch(Home home, const FloatVarArgs &x, FloatVarBranch vars, FloatValBranch vals, FloatBranchFilter bf, FloatVarValPrint vvp)
Branch over x with variable selection vars and value selection vals.
Select value according to user-defined functions.
friend FloatVal atan(const FloatVal &x)
FloatVarBranch FLOAT_VAR_ACTIVITY_MIN(double d, BranchTbl tbl)
Select variable with lowest activity with decay factor d.
void(* FloatVarValPrint)(const Space &home, const BrancherHandle &bh, unsigned int a, FloatVar x, int i, const FloatNumBranch &n, std::ostream &o)
Function type for explaining branching alternatives for set variables.
FloatVarBranch FLOAT_VAR_ACTIVITY_SIZE_MIN(double d, BranchTbl tbl)
Select variable with smallest activity divided by domain size with decay factor d.
void acos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Class for activity management.
With largest degree divided by domain size.
void exp(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
FloatVarBranch FLOAT_VAR_SIZE_MAX(BranchTbl tbl)
Select variable with largest domain size.
FloatNum pi_lower(void)
Return lower bound of .
FloatNum mul_up(FloatNum x, FloatNum y)
Return upper bound of x times y (domain: )
FloatAFC & operator=(const FloatAFC &a)
Assignment operator.
FloatVal tanh(const FloatVal &x)
Select values greater than mean of smallest and largest value.
Home class for posting propagators
FloatNum max(void) const
Return upper bound.
double tbl(const Gecode::Space &, double w, double b)
Test function for tie-break limit function.
double FloatNum
Floating point number base type.
FloatVarBranch FLOAT_VAR_MIN_MAX(BranchTbl tbl)
Select variable with largest min.
friend FloatVal operator-(const FloatVal &x)
Shared array with arbitrary number of elements.
~Rounding(void)
Destructor (restores previous rounding mode)
struct Gecode::@518::NNF::@57::@59 a
For atomic nodes.
FloatVarBranch FLOAT_VAR_MERIT_MIN(FloatBranchMerit bm, BranchTbl tbl)
Select variable with least merit according to branch merit function bm.
FloatVarBranch FLOAT_VAR_AFC_MAX(double d, BranchTbl tbl)
Select variable with largest accumulated failure count with decay factor d.
FloatAssign(Select s=SEL_MIN)
Initialize with selection strategy s.
FloatNum median(FloatNum x, FloatNum y)
Return median of x and y (domain: )
void atan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
FloatNum sin_down(FloatNum x)
Return lower bound of sine of x (domain: )
friend bool operator>=(const FloatVal &x, const FloatVal &y)
Recording AFC information for float variables.
FloatNum tan_down(FloatNum x)
Return lower bound of tangent of x (domain: )
FloatVal * a
Element array.
FloatNum pi_upper(void)
Return upper bound of .
void(* FloatBranchCommit)(Space &home, unsigned int a, FloatVar x, int i, FloatNumBranch nl)
Branch commit function type for float variables.
FloatVarBranch FLOAT_VAR_SIZE_MIN(BranchTbl tbl)
Select variable with smallest domain size.
Rnd r
Random number generator.
double(* BranchTbl)(const Space &home, double w, double b)
Tie-break limit function.