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 boost::numeric::interval_lib::rounded_arith_opp<FloatNum> {
141 typedef 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>&
373 #ifdef GECODE_HAS_MPFR 403 typedef boost::numeric::interval_lib::save_state<Float::Rounding>
R;
405 typedef boost::numeric::interval_lib::checking_strict<FloatNum>
P;
407 typedef boost::numeric::interval
409 boost::numeric::interval_lib::policies<R, P> >
450 bool tight(
void)
const;
664 template<
class Char,
class Traits>
665 std::basic_ostream<Char,Traits>&
725 #ifdef GECODE_HAS_MPFR 822 namespace Gecode {
namespace Float {
926 template<
class Char,
class Traits>
927 std::basic_ostream<Char,Traits>&
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,
boost::numeric::interval_lib::checking_strict< FloatNum > P
Used checking policy.
#define GECODE_FLOAT_EXPORT
FloatNum pi_half_upper(void)
Return upper bound of .
Select values greater than mean of smallest and largest value.
With smallest degree divided by domain size.
With largest activity divided by domain size.
FloatVal operator -(const FloatVal &x)
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.
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: )
FloatVal & operator -=(const FloatNum &n)
Subtract by n.
Select
Which value selection.
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.
With smallest domain size.
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.
With largest domain size.
friend bool operator !=(const FloatVal &x, const FloatVal &y)
FloatNum cosh_down(FloatNum x)
Return lower bound of hyperbolic cosine of x (domain: )
bool subset(const FloatVal &x, const FloatVal &y)
With smallest accumulated failure count divided by domain size.
FloatNum asinh_up(FloatNum x)
Return upper bound of hyperbolic arcsine of x (domain: )
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
FloatVal 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)
Select select(void) const
Return selection strategy.
bool operator >=(const FloatVal &x, const FloatVal &y)
FloatAssign FLOAT_ASSIGN_MAX(void)
Select median value of the upper part.
FloatNum tanh_down(FloatNum x)
Return lower bound of hyperbolic tangent of x (domain: )
Argument array for primtive types.
FloatNum max(void) const
Return maximum of domain.
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\geq 0$.
boost::numeric::interval_lib::save_state< Float::Rounding > R
Used rounding policies.
bool overlap(const FloatVal &x, const FloatVal &y)
friend FloatVal sqr(const FloatVal &x)
Select median value of a randomly chosen part.
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n\geq 0$.
friend FloatVal operator -(const FloatVal &x)
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.
bool singleton(void) const
Test whether float is a singleton.
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.
bool(* FloatBranchFilter)(const Space &home, FloatVar x, int i)
Branch filter function type for float variables.
FloatVal hull(const FloatVal &x, const FloatVal &y)
bool zero_in(void) const
Test whether zero is included.
FloatNum sqrt_down(FloatNum x)
Return lower bound of square root of x (domain: )
friend FloatVal fmod(const FloatVal &x, const FloatVal &y)
With largest accumulated failure count.
friend bool operator >(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.
FloatVarBranch FLOAT_VAR_ACTIVITY_SIZE_MAX(double d, BranchTbl tbl)
Select variable with largest activity divided by domain size with decay factor d.
Select values randomly which are not greater or not smaller than mean of largest and smallest value.
friend bool operator >=(const FloatVal &x, const FloatVal &y)
Select select(void) const
Return selection strategy.
static FloatVal pi_twice(void)
Return .
Select
Which variable selection.
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.
FloatVal val(void) const
Return assigned value.
FloatValBranch FLOAT_VAL(FloatBranchVal v, FloatBranchCommit c)
bool in(FloatNum n) const
Test whether n is included.
FloatVarBranch FLOAT_VAR_NONE(void)
Select first unassigned variable.
FloatVal(void)
Default constructor.
friend bool operator<=(const FloatVal &x, const FloatVal &y)
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.
FloatNum min(void) const
Return minimum of domain.
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.
bool proper_subset(const FloatVal &x, const FloatVal &y)
const FloatNum min
Smallest allowed float value.
FloatNum size(void) const
Return size of domain (distance between maximum and minimum)
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: )
friend FloatVal operator *(const FloatVal &x, const FloatVal &y)
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: )
FloatVarArgs(const VarArray< FloatVar > &a)
Initialize from variable array a (copy elements)
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.
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: )
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)
bool tight(void) const
Test whether float is tight.
FloatVal domain(void) const
Return domain.
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.
friend FloatVal nroot(const FloatVal &x, int n)
FloatVal cosh(const FloatVal &x)
FloatVarArray(void)
Default constructor (array of size 0)
FloatNum pi_half_lower(void)
Return lower bound of .
FloatNum med(void) const
Return median of float value.
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 .
FloatNum med(void) const
Return median of domain.
FloatVal & operator=(const FloatNum &n)
Assignment operator.
friend FloatVal atanh(const FloatVal &x)
With largest accumulated failure count divided by domain size.
int n
Number of variables (size)
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)
friend std::basic_ostream< Char, Traits > & operator<<(std::basic_ostream< Char, Traits > &os, const FloatVal &x)
bool operator >(const FloatVal &x, const FloatVal &y)
FloatAFC(void)
Construct as not yet initialized.
Select values not greater than mean of smallest and largest value.
FloatVarArgs(InputIterator first, InputIterator last)
Initialize from InputIterator first and last.
Floating point rounding policy.
Random (uniform, for tie breaking)
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.
struct Gecode::@511::NNF::@54::@56 a
For atomic nodes.
With smallest activity divided by domain size.
bool in(const FloatVal &n) const
Test whether n is contained in domain.
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.
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: )
void cos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
friend FloatVal asinh(const FloatVal &x)
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 .
boost::numeric::interval_lib::rounded_arith_opp< FloatNum > Base
Base class.
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: )
FloatNum max(void) const
Return upper bound.
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: )
Select median value of the upper part.
FloatNum acosh_down(FloatNum x)
Return lower bound of hyperbolic arccosine of x (domain: )
union Gecode::@511::NNF::@54 u
Union depending on nodetype t.
void tan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
With smallest accumulated failure count.
Select
Which value selection.
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.
FloatVal acosh(const FloatVal &x)
friend FloatVal operator+(const FloatVal &x)
FloatNum div_down(FloatNum x, FloatNum y)
Return lower bound of x divided by y (domain: )
FloatNum min(void) const
Return lower bound.
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: )
With largest degree divided by domain size.
friend FloatVal acosh(const FloatVal &x)
FloatVal atanh(const FloatVal &x)
Select select(void) const
Return selection strategy.
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.
boost::numeric::interval< FloatNum, boost::numeric::interval_lib::policies< R, P > > FloatValImpType
Implementation type for float value.
Archive & operator<<(Archive &e, FloatNumBranch nl)
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)
FloatValBranch(Select s=SEL_SPLIT_MIN)
Initialize with selection strategy s.
Select median value of the lower part.
void init(Home, const FloatVarArgs &x, double d=1.0)
Initialize for float variables x with decay factor d.
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)
bool operator<(const FloatVal &x, const FloatVal &y)
bool operator==(const FloatVal &x, const FloatVal &y)
bool operator<=(const FloatVal &x, const FloatVal &y)
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.
FloatNum size(void) const
Return size of float value (distance between maximum and minimum)
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.
FloatVal & operator *=(const FloatNum &n)
Multiply by n.
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.
friend FloatVal atan(const FloatVal &x)
FloatVarBranch FLOAT_VAR_ACTIVITY_MIN(double d, BranchTbl tbl)
Select variable with lowest activity with decay factor d.
bool operator !=(const FloatVal &x, const FloatVal &y)
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.
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)
Home class for posting propagators
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.
Shared array with arbitrary number of elements.
~Rounding(void)
Destructor (restores previous rounding mode)
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: )
Recording AFC information for float variables.
FloatNum tan_down(FloatNum x)
Return lower bound of tangent of x (domain: )
FloatVal * a
Element array.
Select value according to user-defined functions.
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.
Select value according to user-defined functions.
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.