RhodeCode

 *

 */

///\file

#include<lemon/tolerance.h>

#include<lemon/bits/invalid.h>

namespace lemon {

namespace lemon {

  /// \brief Dummy type to make it easier to create invalid iterators.

  ///

  /// See \ref INVALID for the usage.

  struct Invalid {

  public:

    bool operator==(Invalid) { return true;  }

///\file

///\brief A simple two dimensional vector and a bounding box implementation 

///

/// The class \ref lemon::dim2::Point "dim2::Point" implements

///

/// The class \ref lemon::dim2::BoundingBox "dim2::BoundingBox"

/// can be used to determine

/// the rectangular bounding box of a set of

  /// A simple two dimensional vector (plainvector) implementation

  /// A simple two dimensional vector (plainvector) implementation

  template<typename T>

    class Point {

    public:

      ///Construct an instance from coordinates

      Point(T a, T b) : x(a), y(b) { }

      ///The dimension of the vector.

      ///This function always returns 2. 

      int size() const { return 2; }

      T normSquare() const {

        return x*x+y*y;

      }

      Point<T>& operator +=(const Point<T>& u) {

        x += u.x;

        y += u.y;

        return *this;

      }

      Point<T>& operator -=(const Point<T>& u) {

        x -= u.x;

        y -= u.y;

        return *this;

      ///Return \c true if the bounding box is empty (i.e. return \c false

      ///if at least one point was added to the box or the coordinates of

      ///the box were set).

      ///The coordinates of an empty bounding box are not defined. 

      bool empty() const {

        return _empty;

      }

      void clear() {

        _empty=1;

      }

      ///If the bounding box is empty, then the return value is not defined.

      Point<T> bottomLeft() const {

        return bottom_left;

      }

      ///It should only be used for non-empty box.

      void bottomLeft(Point<T> p) {

	bottom_left = p;

      }

      ///If the bounding box is empty, then the return value is not defined.

      Point<T> topRight() const {

        return top_right;

      }

      ///It should only be used for non-empty box.

      void topRight(Point<T> p) {

	top_right = p;

      }

      ///If the bounding box is empty, then the return value is not defined.

      Point<T> bottomRight() const {

        return Point<T>(top_right.x,bottom_left.y);

      }

      ///It should only be used for non-empty box.

      void bottomRight(Point<T> p) {

	top_right.x = p.x;

	bottom_left.y = p.y;

      }

      ///If the bounding box is empty, then the return value is not defined.

      Point<T> topLeft() const {

        return Point<T>(bottom_left.x,top_right.y);

      }

      ///It should only be used for non-empty box.

      void topLeft(Point<T> p) {

	top_right.y = p.y;

	bottom_left.x = p.x;

    };//class Boundingbox

  ///\ingroup maps

  ///

  template<class M>

  class XMap 

  {

  {

    return XMap<M>(m);

  }

  ///\ingroup maps

  ///Constant (read only) version of \ref XMap

  ///

  {

    return ConstXMap<M>(m);

  }

  ///\ingroup maps

  ///Map of y-coordinates of a \ref Point "Point"-map.

  ///

  {

    return YMap<M>(m);

  }

  ///\ingroup maps

  ///Constant (read only) version of \ref YMap

  ///

    return ConstYMap<M>(m);

  }

  template<class M>

  class NormSquareMap 

  {

    const M& _map;

  /// bool g = rnd.boolean();               // P(g = true) = 0.5

  /// bool h = rnd.boolean(0.8);            // P(h = true) = 0.8

  ///\endcode

  ///

  /// generator which name is \ref lemon::rnd "rnd". Usually it is a

  /// good programming convenience to use this global generator to get

  /// random numbers.

  class Random {

  public:

    ///

    /// Constructor with constant seeding.

    Random() { core.initState(); }

    ///

    /// Constructor with seed. The current number type will be converted

    /// to the architecture word type.

    template <typename Number>

    Random(Number seed) { 

      _random_bits::Initializer<Number, Word>::init(core, seed);

    }

    ///

    /// Constructor with array seeding. The given range should contain

    /// any number type and the numbers will be converted to the

    /// architecture word type.

    /// \brief Returns a random real number from the range [0, 1)

    ///

    /// It returns a random real number from the range [0, 1). The

    template <typename Number>

    Number real() {

      return _random_bits::RealConversion<Number, Word>::convert(core);

    }

    /// \brief Returns a random non-negative integer

    ///

    /// It returns a random non-negative integer uniformly from the

    template <typename Number>

    Number uinteger() {

      return _random_bits::IntConversion<Number, Word>::convert(core);

    }

    /// \brief Returns a random integer

    ///

    /// It returns a random integer uniformly from the whole range of

    /// the current \c Number type. The default result type of this

    template <typename Number>

    Number integer() {

      static const int nb = std::numeric_limits<Number>::digits + 

        (std::numeric_limits<Number>::is_signed ? 1 : 0);

    bool boolean() {

      return bool_producer.convert(core);

    }

    ///

    ///@{

  ///\brief A class to provide a basic way to

  ///handle the comparison of numbers that are obtained

  ///as a result of a probably inexact computation.

  ///

  ///handle the comparison of numbers that are obtained

  ///as a result of a probably inexact computation.

  ///

  ///This is an abstract class, it should be specialized for all numerical

  ///may offer additional tuning parameters.

  ///

  ///\sa Tolerance<float>

  ///\sa Tolerance<double>

  ///\sa Tolerance<long double>

  ///\sa Tolerance<int>

  ///\sa Tolerance<long long int>

  ///\sa Tolerance<unsigned int>

  ///\sa Tolerance<unsigned long long int>

  template<class T>

  class Tolerance

  {

  public:

    typedef T Value;

    ///\name Comparisons

    ///the related comparisons hold even if some numerical error appeared

    ///during the computations.

    ///@{

    typedef float Value;

    ///Constructor setting the epsilon tolerance to the default value.

    Tolerance() : _epsilon(def_epsilon) {}

    Tolerance(float e) : _epsilon(e) {}

    Value epsilon() const {return _epsilon;}

    void epsilon(Value e) {_epsilon=e;}

    static Value defaultEpsilon() {return def_epsilon;}

    static void defaultEpsilon(Value e) {def_epsilon=e;}

    ///\name Comparisons

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    typedef double Value;

    ///Constructor setting the epsilon tolerance to the default value.

    Tolerance() : _epsilon(def_epsilon) {}

    Tolerance(double e) : _epsilon(e) {}

    Value epsilon() const {return _epsilon;}

    void epsilon(Value e) {_epsilon=e;}

    static Value defaultEpsilon() {return def_epsilon;}

    static void defaultEpsilon(Value e) {def_epsilon=e;}

    ///\name Comparisons

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    typedef long double Value;

    ///Constructor setting the epsilon tolerance to the default value.

    Tolerance() : _epsilon(def_epsilon) {}

    Tolerance(long double e) : _epsilon(e) {}

    Value epsilon() const {return _epsilon;}

    void epsilon(Value e) {_epsilon=e;}

    static Value defaultEpsilon() {return def_epsilon;}

    static void defaultEpsilon(Value e) {def_epsilon=e;}

    ///\name Comparisons

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    ///\e

    typedef int Value;

    ///\name Comparisons

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    ///\e

    typedef unsigned int Value;

    ///\name Comparisons

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    ///\e

    typedef long int Value;

    ///\name Comparisons

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    ///\e

    typedef unsigned long int Value;

    ///\name Comparisons

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b