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: 2017-04-10 13:21:37 +0200 (Mon, 10 Apr 2017) $ by $Author: schulte $
 *     $Revision: 15631 $
 *
 *  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 <functional>

#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 {


#if defined(_MSC_VER) && (defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP > 0)))

  /*
   * This is used for the MSVC compiler for x64 or x86 with SSE enabled.
   *
   */
  typedef gecode_boost::numeric::interval_lib::rounded_arith_std<FloatNum>
    RoundingBase;

#else

  typedef gecode_boost::numeric::interval_lib::rounded_arith_opp<FloatNum>
    RoundingBase;

#endif

  class Rounding : public RoundingBase {
  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 ArgArray<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);
    FloatValArgs(int n, const FloatVal* e);
    FloatValArgs(const ArgArray<FloatVal>& a);

    GECODE_FLOAT_EXPORT
    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);
  GECODE_FLOAT_EXPORT void
  ite(Home home, BoolVar b, FloatVar x, FloatVar y, FloatVar z);

}


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, FloatVal 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, FloatVal 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, FloatVal 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, FloatVal 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);
  void
  channel(Home home, IntVar x0, FloatVar x1);
  GECODE_FLOAT_EXPORT void
  channel(Home home, FloatVar x0, BoolVar x1);
  void
  channel(Home home, BoolVar x0, FloatVar x1);

}

#include <gecode/float/channel.hpp>

namespace Gecode {


  GECODE_FLOAT_EXPORT void
  wait(Home home, FloatVar x, std::function<void(Space& home)> c);
  GECODE_FLOAT_EXPORT void
  wait(Home home, const FloatVarArgs& x, std::function<void(Space& home)> c);

}

namespace Gecode {

  typedef std::function<bool(const Space& home, FloatVar x, int i)>
    FloatBranchFilter;

  typedef std::function<double(const Space& home, FloatVar x, int i)>
    FloatBranchMerit;

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

  typedef std::function<FloatNumBranch(const Space& home, FloatVar x, int i)>
    FloatBranchVal;

  typedef std::function<void(Space& home, unsigned int a,
                             FloatVar x, int i, FloatNumBranch nl)>
    FloatBranchCommit;

}

#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 home, const FloatVarArgs& x, double d=1.0);
  };

}

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

namespace Gecode {

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

}

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

namespace Gecode {

  class FloatCHB : public CHB {
  public:
    FloatCHB(void);
    FloatCHB(const FloatCHB& chb);
    FloatCHB& operator =(const FloatCHB& chb);
    GECODE_FLOAT_EXPORT
    FloatCHB(Home home, const FloatVarArgs& x, FloatBranchMerit bm=nullptr);
    GECODE_FLOAT_EXPORT void
    init(Home home, const FloatVarArgs& x, FloatBranchMerit bm=nullptr);
  };

}

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

namespace Gecode {

  typedef std::function<void(const Space &home, const Brancher& b,
                             unsigned int a,
                             FloatVar x, int i, const FloatNumBranch& n,
                             std::ostream& o)>
    FloatVarValPrint;

}

namespace Gecode {

  class FloatVarBranch : public VarBranch<FloatVar> {
  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_ACTION_MIN,      
      SEL_ACTION_MAX,      
      SEL_CHB_MIN,         
      SEL_CHB_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_ACTION_SIZE_MIN, 
      SEL_ACTION_SIZE_MAX, 
      SEL_CHB_SIZE_MIN,    
      SEL_CHB_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, FloatAFC a, BranchTbl t);
    FloatVarBranch(Select s, FloatAction a, BranchTbl t);
    FloatVarBranch(Select s, FloatCHB c, BranchTbl t);
    FloatVarBranch(Select s, FloatBranchMerit 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=nullptr);
  FloatVarBranch FLOAT_VAR_MERIT_MAX(FloatBranchMerit bm, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_DEGREE_MIN(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_DEGREE_MAX(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_AFC_MIN(FloatAFC a, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_AFC_MAX(FloatAFC a, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_ACTION_MIN(double d=1.0, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_ACTION_MIN(FloatAction a, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_ACTION_MAX(double d=1.0, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_ACTION_MAX(FloatAction a, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_CHB_MIN(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_CHB_MIN(FloatCHB a, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_CHB_MAX(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_CHB_MAX(FloatCHB a, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_MIN_MIN(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_MIN_MAX(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_MAX_MIN(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_MAX_MAX(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_SIZE_MIN(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_SIZE_MAX(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MIN(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MAX(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_AFC_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_AFC_SIZE_MIN(FloatAFC a, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_AFC_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_AFC_SIZE_MAX(FloatAFC a, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_ACTION_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_ACTION_SIZE_MIN(FloatAction a, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_ACTION_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_ACTION_SIZE_MAX(FloatAction a, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_CHB_SIZE_MIN(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_CHB_SIZE_MIN(FloatCHB c, BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_CHB_SIZE_MAX(BranchTbl tbl=nullptr);
  FloatVarBranch FLOAT_VAR_CHB_SIZE_MAX(FloatCHB a, BranchTbl tbl=nullptr);

}

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

namespace Gecode {

  class FloatValBranch : public ValBranch<FloatVar> {
  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(FloatBranchVal v, FloatBranchCommit 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=nullptr);

}

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

namespace Gecode {

  class FloatAssign : public ValBranch<FloatVar> {
  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(FloatBranchVal v, FloatBranchCommit 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=nullptr);

}

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

namespace Gecode {

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

  GECODE_FLOAT_EXPORT void
  assign(Home home, const FloatVarArgs& x, FloatAssign vals,
         FloatBranchFilter bf=nullptr,
         FloatVarValPrint vvp=nullptr);
  GECODE_FLOAT_EXPORT void
  assign(Home home, FloatVar x, FloatAssign vals,
         FloatVarValPrint vvp=nullptr);

}

namespace Gecode {

  /*
   * \brief Relaxed assignment of variables in \a x from values in \a sx
   *
   * The variables in \a x are assigned values from the assigned variables
   * in the solution \a sx with a relaxation probability \a p. That is,
   * if \$fp=0.1\f$ approximately 10% of the variables in \a x will be
   * assigned a value from \a sx.
   *
   * The random numbers are generated from the generator \a r. At least
   * one variable will not be assigned: in case the relaxation attempt
   * would suggest that all variables should be assigned, a single
   * variable will be selected randomly to remain unassigned.
   *
   * Throws an exception of type Float::ArgumentSizeMismatch, if \a x and
   * \a sx are of different size.
   *
   * Throws an exception of type Float::OutOfLimits, if \a p is not between
   * \a 0.0 and \a 1.0.
   *
   * \ingroup TaskModeFloat
   */
  GECODE_FLOAT_EXPORT void
  relax(Home home, const FloatVarArgs& x, const FloatVarArgs& sx,
        Rnd r, double p);

}

#include <gecode/float/trace/trace-view.hpp>

namespace Gecode {

  class FloatTraceDelta {
  protected:
    Float::FloatView n;
    const Delta& d;
  public:


    FloatTraceDelta(Float::FloatTraceView o, Float::FloatView n,
                    const Delta& d);



    FloatNum min(void) const;
    FloatNum max(void) const;
  };

}

#include <gecode/float/trace/delta.hpp>

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

namespace Gecode {

  typedef ViewTracer<Float::FloatView> FloatTracer;
  typedef ViewTraceRecorder<Float::FloatView> FloatTraceRecorder;

  class GECODE_FLOAT_EXPORT StdFloatTracer : public FloatTracer {
  protected:
    std::ostream& os;
  public:
    StdFloatTracer(std::ostream& os0 = std::cerr);
    virtual void init(const Space& home, const FloatTraceRecorder& t);
    virtual void prune(const Space& home, const FloatTraceRecorder& t,
                       const ViewTraceInfo& vti, int i, FloatTraceDelta& d);
    virtual void fix(const Space& home, const FloatTraceRecorder& t);
    virtual void fail(const Space& home, const FloatTraceRecorder& t);
    virtual void done(const Space& home, const FloatTraceRecorder& t);
    static StdFloatTracer def;
  };


  GECODE_FLOAT_EXPORT void
  trace(Home home, const FloatVarArgs& x,
        TraceFilter tf,
        int te = (TE_INIT | TE_PRUNE | TE_FIX | TE_FAIL | TE_DONE),
        FloatTracer& t = StdFloatTracer::def);
  void
  trace(Home home, const FloatVarArgs& x,
        int te = (TE_INIT | TE_PRUNE | TE_FIX | TE_FAIL | TE_DONE),
        FloatTracer& t = StdFloatTracer::def);

}

#include <gecode/float/trace.hpp>

#endif

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