float.hh

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *     Guido Tack <tack@gecode.org>
 *     Vincent Barichard <Vincent.Barichard@univ-angers.fr>
 *
 *  Copyright:
 *     Christian Schulte, 2002
 *     Guido Tack, 2004
 *     Vincent Barichard, 2012
 *
 *  Last modified:
 *     $Date: 2014-10-03 15:34:37 +0200 (Fri, 03 Oct 2014) $ by $Author: schulte $
 *     $Revision: 14241 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  Permission is hereby granted, free of charge, to any person obtaining
 *  a copy of this software and associated documentation files (the
 *  "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so, subject to
 *  the following conditions:
 *
 *  The above copyright notice and this permission notice shall be
 *  included in all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */

#ifndef __GECODE_FLOAT_HH__
#define __GECODE_FLOAT_HH__

#include <climits>
#include <cfloat>
#include <iostream>

#include <gecode/kernel.hh>
#include <gecode/int.hh>

/*
 * Configure linking
 *
 */
#if !defined(GECODE_STATIC_LIBS) && \
    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))

#ifdef GECODE_BUILD_FLOAT
#define GECODE_FLOAT_EXPORT __declspec( dllexport )
#else
#define GECODE_FLOAT_EXPORT __declspec( dllimport )
#endif

#else

#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
#define GECODE_FLOAT_EXPORT __attribute__ ((visibility("default")))
#else
#define GECODE_FLOAT_EXPORT
#endif

#endif

// Configure auto-linking
#ifndef GECODE_BUILD_FLOAT
#define GECODE_LIBRARY_NAME "Float"
#include <gecode/support/auto-link.hpp>
#endif

// Include interval implementation
#include <gecode/third-party/boost/numeric/interval.hpp>

#include <gecode/float/exception.hpp>

#include <gecode/float/nextafter.hpp>

namespace Gecode {

  typedef double FloatNum;

  FloatNum pi_half_lower(void);
  FloatNum pi_half_upper(void);
  FloatNum pi_lower(void);
  FloatNum pi_upper(void);
  FloatNum pi_twice_lower(void);
  FloatNum pi_twice_upper(void);

  // Forward declaration
  class FloatVal;

}

#include <gecode/float/num.hpp>

namespace Gecode { namespace Float {

  class Rounding : 
    public gecode_boost::numeric::interval_lib::rounded_arith_opp<FloatNum> {
  protected:
    typedef gecode_boost::numeric::interval_lib::rounded_arith_opp<FloatNum> Base;
  public:


    Rounding(void);
    ~Rounding(void);
  


    FloatNum add_down(FloatNum x, FloatNum y);
    FloatNum add_up  (FloatNum x, FloatNum y);
    FloatNum sub_down(FloatNum x, FloatNum y);
    FloatNum sub_up  (FloatNum x, FloatNum y);
    FloatNum mul_down(FloatNum x, FloatNum y);
    FloatNum mul_up  (FloatNum x, FloatNum y);
    FloatNum div_down(FloatNum x, FloatNum y);
    FloatNum div_up  (FloatNum x, FloatNum y);
    FloatNum sqrt_down(FloatNum x);
    FloatNum sqrt_up  (FloatNum x);



    FloatNum median(FloatNum x, FloatNum y);
    FloatNum int_down(FloatNum x);
    FloatNum int_up  (FloatNum x);

#ifdef GECODE_HAS_MPFR



    GECODE_FLOAT_EXPORT FloatNum exp_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum exp_up  (FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum log_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum log_up  (FloatNum x);



    GECODE_FLOAT_EXPORT FloatNum sin_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum sin_up  (FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum cos_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum cos_up  (FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum tan_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum tan_up  (FloatNum x);



    GECODE_FLOAT_EXPORT FloatNum asin_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum asin_up  (FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum acos_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum acos_up  (FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum atan_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum atan_up  (FloatNum x);



    GECODE_FLOAT_EXPORT FloatNum sinh_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum sinh_up  (FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum cosh_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum cosh_up  (FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum tanh_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum tanh_up  (FloatNum x);



    GECODE_FLOAT_EXPORT FloatNum asinh_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum asinh_up  (FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum acosh_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum acosh_up  (FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum atanh_down(FloatNum x);
    GECODE_FLOAT_EXPORT FloatNum atanh_up  (FloatNum x);
#endif
  };

}}

#include <gecode/float/rounding.hpp>

namespace Gecode { namespace Float {

  bool subset(const FloatVal& x, const FloatVal& y);
  bool proper_subset(const FloatVal& x, const FloatVal& y);
  bool overlap(const FloatVal& x, const FloatVal& y);

  FloatVal intersect(const FloatVal& x, const FloatVal& y);
  FloatVal hull(const FloatVal& x, const FloatVal& y);
  FloatVal hull(const FloatVal& x, const FloatNum& y);
  FloatVal hull(const FloatNum& x, const FloatVal& y);
  FloatVal hull(const FloatNum& x, const FloatNum& y);

}}

namespace Gecode {

  class FloatVal {
    friend FloatVal operator +(const FloatVal& x);
    friend FloatVal operator -(const FloatVal& x);
    friend FloatVal operator +(const FloatVal& x, const FloatVal& y);
    friend FloatVal operator +(const FloatVal& x, const FloatNum& y);
    friend FloatVal operator +(const FloatNum& x, const FloatVal& y);
    friend FloatVal operator -(const FloatVal& x, const FloatVal& y);
    friend FloatVal operator -(const FloatVal& x, const FloatNum& y);
    friend FloatVal operator -(const FloatNum& x, const FloatVal& y);
    friend FloatVal operator *(const FloatVal& x, const FloatVal& y);
    friend FloatVal operator *(const FloatVal& x, const FloatNum& y);
    friend FloatVal operator *(const FloatNum& x, const FloatVal& y);
    friend FloatVal operator /(const FloatVal& x, const FloatVal& y);
    friend FloatVal operator /(const FloatVal& x, const FloatNum& y);
    friend FloatVal operator /(const FloatNum& x, const FloatVal& y);

    friend bool operator <(const FloatVal& x, const FloatVal& y);
    friend bool operator <(const FloatVal& x, const FloatNum& y);
    friend bool operator <(const FloatNum& x, const FloatVal& y);
    friend bool operator <=(const FloatVal& x, const FloatVal& y);
    friend bool operator <=(const FloatVal& x, const FloatNum& y);
    friend bool operator <=(const FloatNum& x, const FloatVal& y);
    friend bool operator >(const FloatVal& x, const FloatVal& y);
    friend bool operator >(const FloatVal& x, const FloatNum& y);
    friend bool operator >(const FloatNum& x, const FloatVal& y);
    friend bool operator >=(const FloatVal& x, const FloatVal& y);
    friend bool operator >=(const FloatVal& x, const FloatNum& y);
    friend bool operator >=(const FloatNum& x, const FloatVal& y);
    friend bool operator ==(const FloatVal& x, const FloatVal& y);
    friend bool operator ==(const FloatVal& x, const FloatNum& y);
    friend bool operator ==(const FloatNum& x, const FloatVal& y);
    friend bool operator !=(const FloatVal& x, const FloatVal& y);
    friend bool operator !=(const FloatVal& x, const FloatNum& y);
    friend bool operator !=(const FloatNum& x, const FloatVal& y);

    template<class Char, class Traits>
    friend std::basic_ostream<Char,Traits>&
    operator <<(std::basic_ostream<Char,Traits>& os, const FloatVal& x);

    friend FloatVal abs(const FloatVal& x);
    friend FloatVal sqrt(const FloatVal& x);
    friend FloatVal sqr(const FloatVal& x);
    friend FloatVal pow(const FloatVal& x, int n);
    friend FloatVal nroot(const FloatVal& x, int n);

    friend FloatVal max(const FloatVal& x, const FloatVal& y);
    friend FloatVal max(const FloatVal& x, const FloatNum& y);
    friend FloatVal max(const FloatNum& x, const FloatVal& y);
    friend FloatVal min(const FloatVal& x, const FloatVal& y);
    friend FloatVal min(const FloatVal& x, const FloatNum& y);
    friend FloatVal min(const FloatNum& x, const FloatVal& y);

#ifdef GECODE_HAS_MPFR
    friend FloatVal exp(const FloatVal& x);
    friend FloatVal log(const FloatVal& x);
    friend FloatVal fmod(const FloatVal& x, const FloatVal& y);
    friend FloatVal fmod(const FloatVal& x, const FloatNum& y);
    friend FloatVal fmod(const FloatNum& x, const FloatVal& y);
    friend FloatVal sin(const FloatVal& x);
    friend FloatVal cos(const FloatVal& x);
    friend FloatVal tan(const FloatVal& x);
    friend FloatVal asin(const FloatVal& x);
    friend FloatVal acos(const FloatVal& x);
    friend FloatVal atan(const FloatVal& x);
    friend FloatVal sinh(const FloatVal& x);
    friend FloatVal cosh(const FloatVal& x);
    friend FloatVal tanh(const FloatVal& x);
    friend FloatVal asinh(const FloatVal& x);
    friend FloatVal acosh(const FloatVal& x);
    friend FloatVal atanh(const FloatVal& x);
#endif

    friend bool Float::subset(const FloatVal& x, const FloatVal& y);
    friend bool Float::proper_subset(const FloatVal& x, const FloatVal& y);
    friend bool Float::overlap(const FloatVal& x, const FloatVal& y);
    friend FloatVal Float::intersect(const FloatVal& x, const FloatVal& y);
    friend FloatVal Float::hull(const FloatVal& x, const FloatVal& y);
    friend FloatVal Float::hull(const FloatVal& x, const FloatNum& y);
    friend FloatVal Float::hull(const FloatNum& x, const FloatVal& y);
    friend FloatVal Float::hull(const FloatNum& x, const FloatNum& y);
  protected:
    typedef gecode_boost::numeric::interval_lib::save_state<Float::Rounding> R;
    typedef gecode_boost::numeric::interval_lib::checking_strict<FloatNum> P;
    typedef gecode_boost::numeric::interval
      <FloatNum,
       gecode_boost::numeric::interval_lib::policies<R, P> >
    FloatValImpType;
    FloatValImpType x;
    explicit FloatVal(const FloatValImpType& i);
  public:


    FloatVal(void);
    FloatVal(const FloatNum& n);
    FloatVal(const FloatNum& l, const FloatNum& u);
    FloatVal(const FloatVal& v);

    FloatVal& operator =(const FloatNum& n);
    FloatVal& operator =(const FloatVal& v);
    
    void assign(FloatNum const &l, FloatNum const &u);



    FloatNum min(void) const;
    FloatNum max(void) const;
    FloatNum size(void) const;
    FloatNum med(void) const;



    bool tight(void) const;
    bool singleton(void) const;
    bool in(FloatNum n) const;
    bool zero_in(void) const;
    


    static FloatVal hull(FloatNum x, FloatNum y);
    static FloatVal pi_half(void);
    static FloatVal pi(void);
    static FloatVal pi_twice(void);
    


    FloatVal& operator +=(const FloatNum& n);
    FloatVal& operator -=(const FloatNum& n);
    FloatVal& operator *=(const FloatNum& n);
    FloatVal& operator /=(const FloatNum& n);
    FloatVal& operator +=(const FloatVal& v);
    FloatVal& operator -=(const FloatVal& v);
    FloatVal& operator *=(const FloatVal& v);
    FloatVal& operator /=(const FloatVal& v);
  };

  FloatVal operator +(const FloatVal& x);
  FloatVal operator -(const FloatVal& x);

  FloatVal operator +(const FloatVal& x, const FloatVal& y);
  FloatVal operator +(const FloatVal& x, const FloatNum& y);
  FloatVal operator +(const FloatNum& x, const FloatVal& y);
  FloatVal operator -(const FloatVal& x, const FloatVal& y);
  FloatVal operator -(const FloatVal& x, const FloatNum& y);
  FloatVal operator -(const FloatNum& x, const FloatVal& y);
  FloatVal operator *(const FloatVal& x, const FloatVal& y);
  FloatVal operator *(const FloatVal& x, const FloatNum& y);
  FloatVal operator *(const FloatNum& x, const FloatVal& y);
  FloatVal operator /(const FloatVal& x, const FloatVal& y);
  FloatVal operator /(const FloatVal& x, const FloatNum& y);
  FloatVal operator /(const FloatNum& r, const FloatVal& x);

  bool operator <(const FloatVal& x, const FloatVal& y);
  bool operator <(const FloatVal& x, const FloatNum& y);
  bool operator <(const FloatNum& x, const FloatVal& y);

  bool operator <=(const FloatVal& x, const FloatVal& y);
  bool operator <=(const FloatVal& x, const FloatNum& y);
  bool operator <=(const FloatNum& x, const FloatVal& y);

  bool operator >(const FloatVal& x, const FloatVal& y);
  bool operator >(const FloatVal& x, const FloatNum& y);
  bool operator >(const FloatNum& x, const FloatVal& y);

  bool operator >=(const FloatVal& x, const FloatVal& y);
  bool operator >=(const FloatVal& x, const FloatNum& y);
  bool operator >=(const FloatNum& x, const FloatVal& y);
  bool operator ==(const FloatVal& x, const FloatVal& y);
  bool operator ==(const FloatVal& x, const FloatNum& y);
  bool operator ==(const FloatNum& x, const FloatVal& y);

  bool operator !=(const FloatVal& x, const FloatVal& y);
  bool operator !=(const FloatVal& x, const FloatNum& y);
  bool operator !=(const FloatNum& x, const FloatVal& y);

  template<class Char, class Traits>
  std::basic_ostream<Char,Traits>&
  operator <<(std::basic_ostream<Char,Traits>& os, const FloatVal& x);

  FloatVal abs(const FloatVal& x);
  FloatVal sqrt(const FloatVal& x);
  FloatVal sqr(const FloatVal& x);
  FloatVal pow(const FloatVal& x, int n);
  FloatVal nroot(const FloatVal& x, int n);

  FloatVal max(const FloatVal& x, const FloatVal& y);
  FloatVal max(const FloatVal& x, const FloatNum& y);
  FloatVal max(const FloatNum& x, const FloatVal& y);
  FloatVal min(const FloatVal& x, const FloatVal& y);
  FloatVal min(const FloatVal& x, const FloatNum& y);
  FloatVal min(const FloatNum& x, const FloatVal& y);

#ifdef GECODE_HAS_MPFR
  /* transcendental functions: exp, log */
  FloatVal exp(const FloatVal& x);
  FloatVal log(const FloatVal& x);

  FloatVal fmod(const FloatVal& x, const FloatVal& y);
  FloatVal fmod(const FloatVal& x, const FloatNum& y);
  FloatVal fmod(const FloatNum& x, const FloatVal& y);

  FloatVal sin(const FloatVal& x);
  FloatVal cos(const FloatVal& x);
  FloatVal tan(const FloatVal& x);
  FloatVal asin(const FloatVal& x);
  FloatVal acos(const FloatVal& x);
  FloatVal atan(const FloatVal& x);

  FloatVal sinh(const FloatVal& x);
  FloatVal cosh(const FloatVal& x);
  FloatVal tanh(const FloatVal& x);
  FloatVal asinh(const FloatVal& x);
  FloatVal acosh(const FloatVal& x);
  FloatVal atanh(const FloatVal& x);

#endif

}

#include <gecode/float/val.hpp>

namespace Gecode { namespace Float {

  namespace Limits {
    const FloatNum max = std::numeric_limits<FloatNum>::max();
    const FloatNum min = -max;
    bool valid(const FloatVal& n);
    void check(const FloatVal& n, const char* l);
  }

}}

#include <gecode/float/limits.hpp>

#include <gecode/float/var-imp.hpp>

namespace Gecode {

  namespace Float {
    class FloatView;
  }

  class FloatVar : public VarImpVar<Float::FloatVarImp> {
    friend class FloatVarArray;
    friend class FloatVarArgs;
  private:
    using VarImpVar<Float::FloatVarImp>::x;
    void _init(Space& home, FloatNum min, FloatNum max);
  public:


    FloatVar(void);
    FloatVar(const FloatVar& y);
    FloatVar(const Float::FloatView& y);
    GECODE_FLOAT_EXPORT FloatVar(Space& home, FloatNum min, FloatNum max);



    FloatVal domain(void) const;
    FloatNum min(void) const;
    FloatNum max(void) const;
    FloatNum med(void) const;
    FloatNum size(void) const;
    FloatVal val(void) const;




    bool in(const FloatVal& n) const;
  };

  template<class Char, class Traits>
  std::basic_ostream<Char,Traits>&
  operator <<(std::basic_ostream<Char,Traits>& os, const FloatVar& x);
}

#include <gecode/float/view.hpp>
#include <gecode/float/array-traits.hpp>

namespace Gecode {

  class FloatValArgs : public PrimArgArray<FloatVal> {
  public:


    FloatValArgs(void);
    explicit FloatValArgs(int n);
    FloatValArgs(const SharedArray<FloatVal>& x);
    FloatValArgs(const std::vector<FloatVal>& x);
    template<class InputIterator>
    FloatValArgs(InputIterator first, InputIterator last);
    GECODE_FLOAT_EXPORT
    FloatValArgs(int n, int e0, ...);
    FloatValArgs(int n, const FloatVal* e);
    FloatValArgs(const PrimArgArray<FloatVal>& a);

    static FloatValArgs create(int n, FloatVal start, int inc=1);
  };

  class FloatVarArgs : public VarArgArray<FloatVar> {
  public:


    FloatVarArgs(void) {}
    explicit FloatVarArgs(int n) : VarArgArray<FloatVar>(n) {}
    FloatVarArgs(const FloatVarArgs& a) : VarArgArray<FloatVar>(a) {}
    FloatVarArgs(const VarArray<FloatVar>& a) : VarArgArray<FloatVar>(a) {}
    FloatVarArgs(const std::vector<FloatVar>& a) : VarArgArray<FloatVar>(a) {}
    template<class InputIterator>
    FloatVarArgs(InputIterator first, InputIterator last)
    : VarArgArray<FloatVar>(first,last) {}
    GECODE_FLOAT_EXPORT
    FloatVarArgs(Space& home, int n, FloatNum min, FloatNum max);
  };

  class FloatVarArray : public VarArray<FloatVar> {
  public:


    FloatVarArray(void);
    FloatVarArray(Space& home, int n);
    FloatVarArray(const FloatVarArray& a);
    FloatVarArray(Space& home, const FloatVarArgs& a);
    GECODE_FLOAT_EXPORT
    FloatVarArray(Space& home, int n, FloatNum min, FloatNum max);
  };

}

#include <gecode/float/array.hpp>

namespace Gecode {

  enum FloatRelType {
    FRT_EQ, 
    FRT_NQ, 
    FRT_LQ, 
    FRT_LE, 
    FRT_GQ, 
    FRT_GR 
  };


  GECODE_FLOAT_EXPORT void
  dom(Home home, FloatVar x, FloatVal n);
  GECODE_FLOAT_EXPORT void
  dom(Home home, const FloatVarArgs& x, FloatVal n);
  GECODE_FLOAT_EXPORT void
  dom(Home home, FloatVar x, FloatNum l, FloatNum m);
  GECODE_FLOAT_EXPORT void
  dom(Home home, const FloatVarArgs& x, FloatNum l, FloatNum u);
  GECODE_FLOAT_EXPORT void
  dom(Home home, FloatVar x, FloatVal n, Reify r);
  GECODE_FLOAT_EXPORT void
  dom(Home home, FloatVar x, FloatNum l, FloatNum u, Reify r);
  GECODE_FLOAT_EXPORT void
  dom(Home home, FloatVar x, FloatVar d);
  GECODE_FLOAT_EXPORT void
  dom(Home home, const FloatVarArgs& x, const FloatVarArgs& d);

  GECODE_FLOAT_EXPORT void
  rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1);
  GECODE_FLOAT_EXPORT void
  rel(Home home, FloatVar x, FloatRelType frt, FloatVal c);
  GECODE_FLOAT_EXPORT void
  rel(Home home, FloatVar x, FloatRelType frt, FloatVal c, Reify r);
  GECODE_FLOAT_EXPORT void
  rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1, Reify r);
  GECODE_FLOAT_EXPORT void
  rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVal c);
  GECODE_FLOAT_EXPORT void
  rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVar y);

}


namespace Gecode {

  GECODE_FLOAT_EXPORT void
  min(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
  GECODE_FLOAT_EXPORT void
  min(Home home, const FloatVarArgs& x, FloatVar y);
  GECODE_FLOAT_EXPORT void
  max(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
  GECODE_FLOAT_EXPORT void
  max(Home home, const FloatVarArgs& x, FloatVar y);

  GECODE_FLOAT_EXPORT void
  abs(Home home, FloatVar x0, FloatVar x1);

  GECODE_FLOAT_EXPORT void
  mult(Home home, FloatVar x0, FloatVar x1, FloatVar x2);

  GECODE_FLOAT_EXPORT void
  sqr(Home home, FloatVar x0, FloatVar x1);

  GECODE_FLOAT_EXPORT void
  sqrt(Home home, FloatVar x0, FloatVar x1);

  GECODE_FLOAT_EXPORT void
  pow(Home home, FloatVar x0, int n, FloatVar x1);

  GECODE_FLOAT_EXPORT void
  nroot(Home home, FloatVar x0, int n, FloatVar x1);

  GECODE_FLOAT_EXPORT void
  div(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
#ifdef GECODE_HAS_MPFR

  GECODE_FLOAT_EXPORT void
  exp(Home home, FloatVar x0, FloatVar x1);
  GECODE_FLOAT_EXPORT void
  log(Home home, FloatVar x0, FloatVar x1);
  GECODE_FLOAT_EXPORT void
  pow(Home home, FloatNum base, FloatVar x0, FloatVar x1);
  GECODE_FLOAT_EXPORT void
  log(Home home, FloatNum base, FloatVar x0, FloatVar x1);
  GECODE_FLOAT_EXPORT void
  asin(Home home, FloatVar x0, FloatVar x1);
  GECODE_FLOAT_EXPORT void
  sin(Home home, FloatVar x0, FloatVar x1);
  GECODE_FLOAT_EXPORT void
  acos(Home home, FloatVar x0, FloatVar x1);
  GECODE_FLOAT_EXPORT void
  cos(Home home, FloatVar x0, FloatVar x1);
  GECODE_FLOAT_EXPORT void
  atan(Home home, FloatVar x0, FloatVar x1);
  GECODE_FLOAT_EXPORT void
  tan(Home home, FloatVar x0, FloatVar x1);
#endif

  GECODE_FLOAT_EXPORT void
  linear(Home home, const FloatVarArgs& x,
         FloatRelType frt, FloatNum c);
  GECODE_FLOAT_EXPORT void
  linear(Home home, const FloatVarArgs& x,
         FloatRelType frt, FloatVar y);
  GECODE_FLOAT_EXPORT void
  linear(Home home, const FloatVarArgs& x,
         FloatRelType frt, FloatNum c, Reify r);
  GECODE_FLOAT_EXPORT void
  linear(Home home, const FloatVarArgs& x,
         FloatRelType frt, FloatVar y, Reify r);
  GECODE_FLOAT_EXPORT void
  linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
         FloatRelType frt, FloatNum c);
  GECODE_FLOAT_EXPORT void
  linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
         FloatRelType frt, FloatVar y);
  GECODE_FLOAT_EXPORT void
  linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
         FloatRelType frt, FloatNum c, Reify r);
  GECODE_FLOAT_EXPORT void
  linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
         FloatRelType frt, FloatVar y, Reify r);



  GECODE_FLOAT_EXPORT void
  channel(Home home, FloatVar x0, IntVar x1);
  GECODE_FLOAT_EXPORT void
  channel(Home home, IntVar x0, FloatVar x1);



  GECODE_FLOAT_EXPORT void
  wait(Home home, FloatVar x, void (*c)(Space& home));
  GECODE_FLOAT_EXPORT void
  wait(Home home, const FloatVarArgs& x, void (*c)(Space& home));

}

namespace Gecode {

  typedef bool (*FloatBranchFilter)(const Space& home, FloatVar x, int i);

  typedef double (*FloatBranchMerit)(const Space& home, FloatVar x, int i);

  class FloatNumBranch {
  public:
    FloatNum n;
    bool l;
  };

  typedef FloatNumBranch (*FloatBranchVal)(const Space& home, FloatVar x, int i);

  typedef void (*FloatBranchCommit)(Space& home, unsigned int a,
                                    FloatVar x, int i, FloatNumBranch nl);

}

#include <gecode/float/branch/traits.hpp>

namespace Gecode {

  class FloatAFC : public AFC {
  public:
    FloatAFC(void);
    FloatAFC(const FloatAFC& a);
    FloatAFC& operator =(const FloatAFC& a);      
    FloatAFC(Home home, const FloatVarArgs& x, double d=1.0);
    void init(Home, const FloatVarArgs& x, double d=1.0);
  };

}

#include <gecode/float/branch/afc.hpp>

namespace Gecode {

  class FloatActivity : public Activity {
  public:
    FloatActivity(void);
    FloatActivity(const FloatActivity& a);
    FloatActivity& operator =(const FloatActivity& a);      
    GECODE_FLOAT_EXPORT 
    FloatActivity(Home home, const FloatVarArgs& x, double d=1.0,
                  FloatBranchMerit bm=NULL);
    GECODE_FLOAT_EXPORT void
    init(Home, const FloatVarArgs& x, double d=1.0,
         FloatBranchMerit bm=NULL);
  };

}

#include <gecode/float/branch/activity.hpp>

namespace Gecode {

  typedef void (*FloatVarValPrint)(const Space &home, const BrancherHandle& bh,
                                   unsigned int a,
                                   FloatVar x, int i, const FloatNumBranch& n,
                                   std::ostream& o);

}

namespace Gecode {

  class FloatVarBranch : public VarBranch {
  public:
    enum Select {
      SEL_NONE = 0,        
      SEL_RND,             
      SEL_MERIT_MIN,       
      SEL_MERIT_MAX,       
      SEL_DEGREE_MIN,      
      SEL_DEGREE_MAX,      
      SEL_AFC_MIN,         
      SEL_AFC_MAX,         
      SEL_ACTIVITY_MIN,    
      SEL_ACTIVITY_MAX,    
      SEL_MIN_MIN,         
      SEL_MIN_MAX,         
      SEL_MAX_MIN,         
      SEL_MAX_MAX,         
      SEL_SIZE_MIN,        
      SEL_SIZE_MAX,        
      SEL_DEGREE_SIZE_MIN, 
      SEL_DEGREE_SIZE_MAX, 
      SEL_AFC_SIZE_MIN,    
      SEL_AFC_SIZE_MAX,    
      SEL_ACTIVITY_SIZE_MIN, 
      SEL_ACTIVITY_SIZE_MAX  
    };
  protected:
    Select s;
  public:
    FloatVarBranch(void);
    FloatVarBranch(Rnd r);
    FloatVarBranch(Select s, BranchTbl t);
    FloatVarBranch(Select s, double, BranchTbl t);
    FloatVarBranch(Select s, AFC a, BranchTbl t);
    FloatVarBranch(Select s, Activity a, BranchTbl t);
    FloatVarBranch(Select s, VoidFunction mf, BranchTbl t);
    Select select(void) const;
    void expand(Home home, const FloatVarArgs& x);
  };

  

  FloatVarBranch FLOAT_VAR_NONE(void);
  FloatVarBranch FLOAT_VAR_RND(Rnd r);
  FloatVarBranch FLOAT_VAR_MERIT_MIN(FloatBranchMerit bm, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_MERIT_MAX(FloatBranchMerit bm, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_DEGREE_MIN(BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_DEGREE_MAX(BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_AFC_MIN(FloatAFC a, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_AFC_MAX(FloatAFC a, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_ACTIVITY_MIN(double d=1.0, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_ACTIVITY_MIN(FloatActivity a, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_ACTIVITY_MAX(double d=1.0, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_ACTIVITY_MAX(FloatActivity a, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_MIN_MIN(BranchTbl tbl=NULL);         
  FloatVarBranch FLOAT_VAR_MIN_MAX(BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_MAX_MIN(BranchTbl tbl=NULL); 
  FloatVarBranch FLOAT_VAR_MAX_MAX(BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_SIZE_MIN(BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_SIZE_MAX(BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MIN(BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MAX(BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_AFC_SIZE_MIN(double d=1.0, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_AFC_SIZE_MIN(FloatAFC a, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_AFC_SIZE_MAX(double d=1.0, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_AFC_SIZE_MAX(FloatAFC a, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_ACTIVITY_SIZE_MIN(double d=1.0, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_ACTIVITY_SIZE_MIN(FloatActivity a, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_ACTIVITY_SIZE_MAX(double d=1.0, BranchTbl tbl=NULL);
  FloatVarBranch FLOAT_VAR_ACTIVITY_SIZE_MAX(FloatActivity a, BranchTbl tbl=NULL);

}

#include <gecode/float/branch/var.hpp>

namespace Gecode {

  class FloatValBranch : public ValBranch {
  public:
    enum Select {
      SEL_SPLIT_MIN, 
      SEL_SPLIT_MAX, 
      SEL_SPLIT_RND,  
      SEL_VAL_COMMIT  
    };
  protected:
    Select s;
  public:
    FloatValBranch(Select s = SEL_SPLIT_MIN);
    FloatValBranch(Rnd r);
    FloatValBranch(VoidFunction v, VoidFunction c);
    Select select(void) const;
  };


  FloatValBranch FLOAT_VAL_SPLIT_MIN(void);
  FloatValBranch FLOAT_VAL_SPLIT_MAX(void);
  FloatValBranch FLOAT_VAL_SPLIT_RND(Rnd r);
  FloatValBranch FLOAT_VAL(FloatBranchVal v, FloatBranchCommit c=NULL);

}

#include <gecode/float/branch/val.hpp>

namespace Gecode {

  class FloatAssign : public ValBranch {
  public:
    enum Select {
      SEL_MIN,       
      SEL_MAX,       
      SEL_RND,       
      SEL_VAL_COMMIT 
    };
  protected:
    Select s;
  public:
    FloatAssign(Select s = SEL_MIN);
    FloatAssign(Rnd r);
    FloatAssign(VoidFunction v, VoidFunction c);
    Select select(void) const;
  };


  FloatAssign FLOAT_ASSIGN_MIN(void);
  FloatAssign FLOAT_ASSIGN_MAX(void);
  FloatAssign FLOAT_ASSIGN_RND(Rnd r);
  FloatAssign FLOAT_ASSIGN(FloatBranchVal v, FloatBranchCommit c=NULL);

}

#include <gecode/float/branch/assign.hpp>

namespace Gecode {

  GECODE_FLOAT_EXPORT BrancherHandle
  branch(Home home, const FloatVarArgs& x,
         FloatVarBranch vars, FloatValBranch vals, 
         FloatBranchFilter bf=NULL,
         FloatVarValPrint vvp=NULL);
  GECODE_FLOAT_EXPORT BrancherHandle
  branch(Home home, const FloatVarArgs& x,
         TieBreak<FloatVarBranch> vars, FloatValBranch vals,
         FloatBranchFilter bf=NULL,
         FloatVarValPrint vvp=NULL);
  GECODE_FLOAT_EXPORT BrancherHandle
  branch(Home home, FloatVar x, FloatValBranch vals,
         FloatVarValPrint vvp=NULL);

  GECODE_FLOAT_EXPORT BrancherHandle
  assign(Home home, const FloatVarArgs& x, FloatAssign vals,
         FloatBranchFilter fbf=NULL,
         FloatVarValPrint vvp=NULL);
  GECODE_FLOAT_EXPORT BrancherHandle
  assign(Home home, FloatVar x, FloatAssign vals,
         FloatVarValPrint vvp=NULL);

}

#endif

// IFDEF: GECODE_HAS_FLOAT_VARS
// STATISTICS: float-post