RhodeCode

///\file

#include<lemon/tolerance.h>

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

  ///

  /// See \ref INVALID for the usage.

  struct Invalid {

///

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

///

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

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

  template<typename T>

    class Point {

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

      ///The dimension of the vector.

      }

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

        x += u.x;

      }

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

        x -= u.x;

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

      }

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

      Point<T> bottomLeft() const {

      }

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

      void bottomLeft(Point<T> p) {

      }

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

      Point<T> topRight() const {

      }

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

      void topRight(Point<T> p) {

      }

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

      Point<T> bottomRight() const {

      }

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

      void bottomRight(Point<T> p) {

      }

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

      Point<T> topLeft() const {

      }

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

      void topLeft(Point<T> p) {

  ///\ingroup maps

  ///

  template<class M>

  }

  ///\ingroup maps

  }

  ///\ingroup maps

  }

  ///\ingroup maps

  template<class M>

  class NormSquareMap 

  ///\endcode

  ///

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

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

  public:

    ///

    /// Constructor with constant seeding.

    Random() { core.initState(); }

    ///

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

    }

    ///

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

    ///

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

    template <typename Number>

    Number real() {

    ///

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

    template <typename Number>

    Number uinteger() {

    /// 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() {

    }

    ///

  ///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<long double>

  ///\sa Tolerance<int>

  ///\sa Tolerance<long long int>

  ///\sa Tolerance<unsigned int>

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

  template<class T>

    ///\name Comparisons

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

    ///during the computations.

    ///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

    ///@{

    ///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

    ///@{

    ///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

    ///@{

    ///\name Comparisons

    ///@{

    ///\name Comparisons

    ///@{

    ///\name Comparisons

    ///@{

    ///\name Comparisons

    ///@{