RhodeCode

CMAKE_MINIMUM_REQUIRED(VERSION 2.6)

IF(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)

  INCLUDE(${CMAKE_SOURCE_DIR}/cmake/version.cmake)

ELSE(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)

  SET(PROJECT_NAME "LEMON")

  SET(PROJECT_VERSION "hg-tip" CACHE STRING "LEMON version string.")

ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)

PROJECT(${PROJECT_NAME})

SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)

INCLUDE(FindDoxygen)

INCLUDE(FindGhostscript)

ENABLE_TESTING()

ADD_SUBDIRECTORY(lemon)

ADD_SUBDIRECTORY(demo)

ADD_SUBDIRECTORY(doc)

ADD_SUBDIRECTORY(test)

IF(WIN32)

  SET(CPACK_PACKAGE_NAME ${PROJECT_NAME})

  SET(CPACK_PACKAGE_VENDOR "EGRES")

  SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY

    "LEMON - Library of Efficient Models and Optimization in Networks")

  SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")

  SET(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})

  SET(CPACK_PACKAGE_INSTALL_DIRECTORY

    "${PROJECT_NAME} ${PROJECT_VERSION}")

  SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY

    "${PROJECT_NAME} ${PROJECT_VERSION}")

  SET(CPACK_COMPONENTS_ALL headers library html_documentation)

  SET(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C++ headers")

  SET(CPACK_COMPONENT_LIBRARY_DISPLAY_NAME "Dynamic-link library")

  SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DISPLAY_NAME "HTML documentation")

  SET(CPACK_COMPONENT_HEADERS_DESCRIPTION

    "C++ header files")

  SET(CPACK_COMPONENT_LIBRARY_DESCRIPTION

    "DLL and import library")

  SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DESCRIPTION

    "Doxygen generated documentation")

  SET(CPACK_COMPONENT_HEADERS_DEPENDS library)

  SET(CPACK_COMPONENT_HEADERS_GROUP "Development")

  SET(CPACK_COMPONENT_LIBRARY_GROUP "Development")

  SET(CPACK_COMPONENT_HTML_DOCUMENTATION_GROUP "Documentation")

  SET(CPACK_COMPONENT_GROUP_DEVELOPMENT_DESCRIPTION

    "Components needed to develop software using LEMON")

  SET(CPACK_COMPONENT_GROUP_DOCUMENTATION_DESCRIPTION

    "Documentation of LEMON")

  SET(CPACK_ALL_INSTALL_TYPES Full Developer)

  SET(CPACK_COMPONENT_HEADERS_INSTALL_TYPES Developer Full)

  SET(CPACK_COMPONENT_LIBRARY_INSTALL_TYPES Developer Full)

  SET(CPACK_COMPONENT_HTML_DOCUMENTATION_INSTALL_TYPES Full)

  SET(CPACK_GENERATOR "NSIS")

  SET(CPACK_NSIS_MUI_ICON "${CMAKE_SOURCE_DIR}/cmake/nsis/lemon.ico")

  SET(CPACK_NSIS_MUI_UNIICON "${CMAKE_SOURCE_DIR}/cmake/nsis/uninstall.ico")

  #SET(CPACK_PACKAGE_ICON "${CMAKE_SOURCE_DIR}/cmake/nsis\\\\installer.bmp")

  SET(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\\\lemon.ico")

  SET(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY} ${PROJECT_NAME}")

  SET(CPACK_NSIS_HELP_LINK "http:\\\\\\\\lemon.cs.elte.hu")

  SET(CPACK_NSIS_URL_INFO_ABOUT "http:\\\\\\\\lemon.cs.elte.hu")

  SET(CPACK_NSIS_CONTACT "lemon-user@lemon.cs.elte.hu")

  SET(CPACK_NSIS_CREATE_ICONS_EXTRA "

    CreateShortCut \\\"$SMPROGRAMS\\\\$STARTMENU_FOLDER\\\\Documentation.lnk\\\" \\\"$INSTDIR\\\\doc\\\\index.html\\\"

    ")

  SET(CPACK_NSIS_DELETE_ICONS_EXTRA "

    !insertmacro MUI_STARTMENU_GETFOLDER Application $MUI_TEMP

    Delete \\\"$SMPROGRAMS\\\\$MUI_TEMP\\\\Documentation.lnk\\\"

    ")

  INCLUDE(CPack)

ENDIF(WIN32)

dnl Process this file with autoconf to produce a configure script.

dnl Version information.

m4_define([lemon_version_number],

	[m4_normalize(esyscmd([echo ${LEMON_VERSION}]))])

dnl m4_define([lemon_version_number], [])

m4_define([lemon_hg_path], [m4_normalize(esyscmd([./scripts/chg-len.py]))])

m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i]))])

m4_define([lemon_version], [ifelse(lemon_version_number(),

			   [],

			   [lemon_hg_path().lemon_hg_revision()],

			   [lemon_version_number()])])

AC_PREREQ([2.59])

AC_INIT([LEMON], [lemon_version()], [lemon-user@lemon.cs.elte.hu], [lemon])

AC_CONFIG_AUX_DIR([build-aux])

AC_CONFIG_MACRO_DIR([m4])

AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects nostdinc])

AC_CONFIG_SRCDIR([lemon/list_graph.h])

AC_CONFIG_HEADERS([config.h lemon/config.h])

lx_cmdline_cxxflags_set=${CXXFLAGS+set}

dnl Do compilation tests using the C++ compiler.

AC_LANG([C++])

dnl Checks for programs.

AC_PROG_CXX

AC_PROG_CXXCPP

AC_PROG_INSTALL

AC_DISABLE_SHARED

AC_PROG_LIBTOOL

AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no])

AC_CHECK_PROG([gs_found],[gs],[yes],[no])

dnl Detect Intel compiler.

AC_MSG_CHECKING([whether we are using the Intel C++ compiler])

AC_COMPILE_IFELSE([#ifndef __INTEL_COMPILER

choke me

#endif], [ICC=[yes]], [ICC=[no]])

if test x"$ICC" = x"yes"; then

  AC_MSG_RESULT([yes])

else

  AC_MSG_RESULT([no])

fi

dnl Set custom compiler flags when using g++.

if test x"$lx_cmdline_cxxflags_set" != x"set" -a "$GXX" = yes -a "$ICC" = no; then

  CXXFLAGS="$CXXFLAGS -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas"

fi

dnl Checks for libraries.

#LX_CHECK_GLPK

#LX_CHECK_CPLEX

#LX_CHECK_SOPLEX

dnl Disable/enable building the demo programs.

AC_ARG_ENABLE([demo],

AS_HELP_STRING([--enable-demo], [build the demo programs])

AS_HELP_STRING([--disable-demo], [do not build the demo programs @<:@default@:>@]),

              [], [enable_demo=no])

AC_MSG_CHECKING([whether to build the demo programs])

if test x"$enable_demo" != x"no"; then

  AC_MSG_RESULT([yes])

else

  AC_MSG_RESULT([no])

fi

AM_CONDITIONAL([WANT_DEMO], [test x"$enable_demo" != x"no"])

dnl Disable/enable building the binary tools.

AC_ARG_ENABLE([tools],

AS_HELP_STRING([--enable-tools], [build additional tools @<:@default@:>@])

AS_HELP_STRING([--disable-tools], [do not build additional tools]),

              [], [enable_tools=yes])

AC_MSG_CHECKING([whether to build the additional tools])

if test x"$enable_tools" != x"no"; then

  AC_MSG_RESULT([yes])

else

  AC_MSG_RESULT([no])

fi

AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"])

dnl Checks for header files.

AC_CHECK_HEADERS(limits.h sys/time.h sys/times.h unistd.h)

dnl Checks for typedefs, structures, and compiler characteristics.

AC_C_CONST

AC_C_INLINE

AC_TYPE_SIZE_T

AC_HEADER_TIME

AC_STRUCT_TM

dnl Checks for library functions.

AC_HEADER_STDC

AC_CHECK_FUNCS(gettimeofday times ctime_r)

dnl Add dependencies on files generated by configure.

AC_SUBST([CONFIG_STATUS_DEPENDENCIES],

  ['$(top_srcdir)/doc/Doxyfile.in $(top_srcdir)/lemon/lemon.pc.in $(top_srcdir)/cmake/version.cmake.in'])

AC_CONFIG_FILES([

Makefile

cmake/version.cmake

doc/Doxyfile

lemon/lemon.pc

])

AC_OUTPUT

echo

echo '****************************** SUMMARY ******************************'

echo

echo Package version............... : $PACKAGE-$VERSION

echo

echo C++ compiler.................. : $CXX

echo C++ compiles flags............ : $CXXFLAGS

echo

#echo GLPK support.................. : $lx_glpk_found

#echo CPLEX support................. : $lx_cplex_found

#echo SOPLEX support................ : $lx_soplex_found

#echo

echo Build demo programs........... : $enable_demo

echo Build additional tools........ : $enable_tools

echo

echo The packace will be installed in

echo -n '  '

echo $prefix.

echo

echo '*********************************************************************'

echo

echo Configure complete, now type \'make\' and then \'make install\'.

echo

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_BITS_DEFAULT_MAP_H

#define LEMON_BITS_DEFAULT_MAP_H

#include <lemon/bits/array_map.h>

#include <lemon/bits/vector_map.h>

//#include <lemon/bits/debug_map.h>

//\ingroup graphbits

//\file

//\brief Graph maps that construct and destruct their elements dynamically.

namespace lemon {

  //#ifndef LEMON_USE_DEBUG_MAP

  template <typename _Graph, typename _Item, typename _Value>

  struct DefaultMapSelector {

    typedef ArrayMap<_Graph, _Item, _Value> Map;

  };

  // bool

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, bool> {

    typedef VectorMap<_Graph, _Item, bool> Map;

  };

  // char

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, char> {

    typedef VectorMap<_Graph, _Item, char> Map;

  };

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, signed char> {

    typedef VectorMap<_Graph, _Item, signed char> Map;

  };

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, unsigned char> {

    typedef VectorMap<_Graph, _Item, unsigned char> Map;

  };

  // int

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, signed int> {

    typedef VectorMap<_Graph, _Item, signed int> Map;

  };

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, unsigned int> {

    typedef VectorMap<_Graph, _Item, unsigned int> Map;

  };

  // short

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, signed short> {

    typedef VectorMap<_Graph, _Item, signed short> Map;

  };

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, unsigned short> {

    typedef VectorMap<_Graph, _Item, unsigned short> Map;

  };

  // long

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, signed long> {

    typedef VectorMap<_Graph, _Item, signed long> Map;

  };

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, unsigned long> {

    typedef VectorMap<_Graph, _Item, unsigned long> Map;

  };

  // long long

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, signed long long> {

    typedef VectorMap<_Graph, _Item, signed long long> Map;

  };

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, unsigned long long> {

    typedef VectorMap<_Graph, _Item, unsigned long long> Map;

  };

#endif

  // float

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, float> {

    typedef VectorMap<_Graph, _Item, float> Map;

  };

  // double

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, double> {

    typedef VectorMap<_Graph, _Item,  double> Map;

  };

  // long double

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, long double> {

    typedef VectorMap<_Graph, _Item, long double> Map;

  };

  // pointer

  template <typename _Graph, typename _Item, typename _Ptr>

  struct DefaultMapSelector<_Graph, _Item, _Ptr*> {

    typedef VectorMap<_Graph, _Item, _Ptr*> Map;

  };

// #else

//   template <typename _Graph, typename _Item, typename _Value>

//   struct DefaultMapSelector {

//     typedef DebugMap<_Graph, _Item, _Value> Map;

//   };

// #endif

  // DefaultMap class

  template <typename _Graph, typename _Item, typename _Value>

  class DefaultMap

    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {

  public:

    typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;

    typedef DefaultMap<_Graph, _Item, _Value> Map;

    typedef typename Parent::Graph Graph;

    typedef typename Parent::Value Value;

    explicit DefaultMap(const Graph& graph) : Parent(graph) {}

    DefaultMap(const Graph& graph, const Value& value)

      : Parent(graph, value) {}

    DefaultMap& operator=(const DefaultMap& cmap) {

      return operator=<DefaultMap>(cmap);

    }

    template <typename CMap>

    DefaultMap& operator=(const CMap& cmap) {

      Parent::operator=(cmap);

      return *this;

    }

  };

}

#endif

/* Define to 1 if you have CPLEX. */

#undef HAVE_CPLEX

/* Define to 1 if you have GLPK. */

#undef HAVE_GLPK

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_TOLERANCE_H

#define LEMON_TOLERANCE_H

///\ingroup misc

///\file

///\brief A basic tool to handle the anomalies of calculation with

///floating point numbers.

///

namespace lemon {

  /// \addtogroup misc

  /// @{

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

  ///

  ///\ref Tolerance is a class to provide a basic way to

  ///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 data types. These specialized classes like

  ///Tolerance<double> 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 concept is that these bool functions return \c true only if

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

    ///during the computations.

    ///@{

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

    static bool less(Value a,Value b) {return false;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) {return false;}

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) {return false;}

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value a) {return false;}

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) {return false;}

    ///@}

    ///Returns the zero value.

    static Value zero() {return T();}

    //   static bool finite(Value a) {}

    //   static Value big() {}

    //   static Value negativeBig() {}

  };

  ///Float specialization of Tolerance.

  ///Float specialization of Tolerance.

  ///\sa Tolerance

  ///\relates Tolerance

  template<>

  class Tolerance<float>

  {

    static float def_epsilon;

    float _epsilon;

  public:

    ///\e

    typedef float Value;

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

    Tolerance() : _epsilon(def_epsilon) {}

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

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

    ///Returns the epsilon value.

    Value epsilon() const {return _epsilon;}

    ///Sets the epsilon value.

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

    ///Returns the default epsilon value.

    static Value defaultEpsilon() {return def_epsilon;}

    ///Sets the default epsilon value.

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

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

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

    bool less(Value a,Value b) const {return a+_epsilon<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    bool different(Value a,Value b) const { return less(a,b)||less(b,a); }

    ///Returns \c true if \c a is \e surely positive

    bool positive(Value a) const { return _epsilon<a; }

    ///Returns \c true if \c a is \e surely negative

    bool negative(Value a) const { return -_epsilon>a; }

    ///Returns \c true if \c a is \e surely non-zero

    bool nonZero(Value a) const { return positive(a)||negative(a); }

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Double specialization of Tolerance.

  ///Double specialization of Tolerance.

  ///\sa Tolerance

  ///\relates Tolerance

  template<>

  class Tolerance<double>

  {

    static double def_epsilon;

    double _epsilon;

  public:

    ///\e

    typedef double Value;

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

    Tolerance() : _epsilon(def_epsilon) {}

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

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

    ///Returns the epsilon value.

    Value epsilon() const {return _epsilon;}

    ///Sets the epsilon value.

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

    ///Returns the default epsilon value.

    static Value defaultEpsilon() {return def_epsilon;}

    ///Sets the default epsilon value.

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

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

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

    bool less(Value a,Value b) const {return a+_epsilon<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    bool different(Value a,Value b) const { return less(a,b)||less(b,a); }

    ///Returns \c true if \c a is \e surely positive

    bool positive(Value a) const { return _epsilon<a; }

    ///Returns \c true if \c a is \e surely negative

    bool negative(Value a) const { return -_epsilon>a; }

    ///Returns \c true if \c a is \e surely non-zero

    bool nonZero(Value a) const { return positive(a)||negative(a); }

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Long double specialization of Tolerance.

  ///Long double specialization of Tolerance.

  ///\sa Tolerance

  ///\relates Tolerance

  template<>

  class Tolerance<long double>

  {

    static long double def_epsilon;

    long double _epsilon;

  public:

    ///\e

    typedef long double Value;

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

    Tolerance() : _epsilon(def_epsilon) {}

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

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

    ///Returns the epsilon value.

    Value epsilon() const {return _epsilon;}

    ///Sets the epsilon value.

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

    ///Returns the default epsilon value.

    static Value defaultEpsilon() {return def_epsilon;}

    ///Sets the default epsilon value.

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

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

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

    bool less(Value a,Value b) const {return a+_epsilon<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    bool different(Value a,Value b) const { return less(a,b)||less(b,a); }

    ///Returns \c true if \c a is \e surely positive

    bool positive(Value a) const { return _epsilon<a; }

    ///Returns \c true if \c a is \e surely negative

    bool negative(Value a) const { return -_epsilon>a; }

    ///Returns \c true if \c a is \e surely non-zero

    bool nonZero(Value a) const { return positive(a)||negative(a); }

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Integer specialization of Tolerance.

  ///Integer specialization of Tolerance.

  ///\sa Tolerance

  template<>

  class Tolerance<int>

  {

  public:

    ///\e

    typedef int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

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

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value a) { return 0>a; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0; }

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Unsigned integer specialization of Tolerance.

  ///Unsigned integer specialization of Tolerance.

  ///\sa Tolerance

  template<>

  class Tolerance<unsigned int>

  {

  public:

    ///\e

    typedef unsigned int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

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

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value) { return false; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0; }

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Long integer specialization of Tolerance.

  ///Long integer specialization of Tolerance.

  ///\sa Tolerance

  template<>

  class Tolerance<long int>

  {

  public:

    ///\e

    typedef long int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

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

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value a) { return 0>a; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0;}

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Unsigned long integer specialization of Tolerance.

  ///Unsigned long integer specialization of Tolerance.

  ///\sa Tolerance

  template<>

  class Tolerance<unsigned long int>

  {

  public:

    ///\e

    typedef unsigned long int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

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

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value) { return false; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0;}

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Long long integer specialization of Tolerance.

  ///Long long integer specialization of Tolerance.

  ///\warning This class (more exactly, type <tt>long long</tt>)

  ///is not ansi compatible.

  ///\sa Tolerance

  template<>

  class Tolerance<long long int>

  {

  public:

    ///\e

    typedef long long int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

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

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value a) { return 0>a; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0;}

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Unsigned long long integer specialization of Tolerance.

  ///Unsigned long long integer specialization of Tolerance.

  ///\warning This class (more exactly, type <tt>unsigned long long</tt>)

  ///is not ansi compatible.

  ///\sa Tolerance

  template<>

  class Tolerance<unsigned long long int>

  {

  public:

    ///\e

    typedef unsigned long long int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

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

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value) { return false; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0;}

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

#endif

  /// @}

} //namespace lemon

#endif //LEMON_TOLERANCE_H