RhodeCode

This group describes Lp and Mip solver interfaces for LEMON. The

various LP solvers could be used in the same manner with this

interface.

*/

/** 

@defgroup lp_utils Tools for Lp and Mip solvers 

@ingroup lp_group

\brief Helper tools to the Lp and Mip solvers.

This group adds some helper tools to general optimization framework

implemented in LEMON.

*/

/**

@defgroup metah Metaheuristics

@ingroup gen_opt_group

\brief Metaheuristics for LEMON library.

This group describes some metaheuristic optimization tools.

*/

/**

@defgroup utils Tools and Utilities 

\brief Tools and utilities for programming in LEMON

Tools and utilities for programming in LEMON.

*/

/**

@defgroup gutils Basic Graph Utilities

@ingroup utils

\brief Simple basic graph utilities.

This group describes some simple basic graph utilities.

*/

/**

@defgroup misc Miscellaneous Tools

@ingroup utils

\brief Tools for development, debugging and testing.

This group describes several useful tools for development,

debugging and testing.

*/

/**

@defgroup timecount Time measuring and Counting

@ingroup misc

\brief Simple tools for measuring the performance of algorithms.

This group describes simple tools for measuring the performance

of algorithms.

*/

/**

@defgroup graphbits Tools for Graph Implementation

@ingroup utils

\brief Tools to make it easier to create graphs.

This group describes the tools that makes it easier to create graphs and

the maps that dynamically update with the graph changes.

*/

/**

@defgroup exceptions Exceptions

@ingroup utils

\brief Exceptions defined in LEMON.

This group describes the exceptions defined in LEMON.

*/

/**

@defgroup io_group Input-Output

\brief Graph Input-Output methods

This group describes the tools for importing and exporting graphs 

and graph related data. Now it supports the LEMON format, the

\c DIMACS format and the encapsulated postscript (EPS) format.

*/

/**

@defgroup lemon_io Lemon Input-Output

@ingroup io_group

\brief Reading and writing LEMON format

This group describes methods for reading and writing LEMON format. 

You can find more about this format on the \ref graph-io-page "Graph Input-Output"

tutorial pages.

*/

/**

@defgroup section_io Section readers and writers

@ingroup lemon_io

*/

/**

@ingroup lemon_io

*/

/**

@defgroup eps_io Postscript exporting

@ingroup io_group

\brief General \c EPS drawer and graph exporter

This group describes general \c EPS drawing methods and special

graph exporting tools. 

*/

/**

@defgroup concept Concepts

\brief Skeleton classes and concept checking classes

This group describes the data/algorithm skeletons and concept checking

classes implemented in LEMON.

The purpose of the classes in this group is fourfold.

- These classes contain the documentations of the concepts. In order

  to avoid document multiplications, an implementation of a concept

  simply refers to the corresponding concept class.

- These classes declare every functions, <tt>typedef</tt>s etc. an

  implementation of the concepts should provide, however completely

  without implementations and real data structures behind the

  interface. On the other hand they should provide nothing else. All

  the algorithms working on a data structure meeting a certain concept

  should compile with these classes. (Though it will not run properly,

  of course.) In this way it is easily to check if an algorithm

  doesn't use any extra feature of a certain implementation.

- The concept descriptor classes also provide a <em>checker class</em>

  that makes it possible to check whether a certain implementation of a

  concept indeed provides all the required features.

- Finally, They can serve as a skeleton of a new implementation of a concept.

*/

/**

@defgroup graph_concepts Graph Structure Concepts

@ingroup concept

\brief Skeleton and concept checking classes for graph structures

This group describes the skeletons and concept checking classes of LEMON's

graph structures and helper classes used to implement these.

*/

/* --- Unused group

@defgroup experimental Experimental Structures and Algorithms

This group describes some Experimental structures and algorithms.

The stuff here is subject to change.

*/

/**

\anchor demoprograms

@defgroup demos Demo programs

Some demo programs are listed here. Their full source codes can be found in

the \c demo subdirectory of the source tree.

It order to compile them, use <tt>--enable-demo</tt> configure option when

build the library.

*/

/**

@defgroup tools Standalone utility applications

Some utility applications are listed here. 

The standard compilation procedure (<tt>./configure;make</tt>) will compile

them, as well. 

*/

/* -*- C++ -*-

 *

 * 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.

///

///\todo It should be in a module like "Basic tools"

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.

  ///

  ///

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

    ///@{

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

    ///@{

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

    ///@{

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

    ///@{

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

  ///\sa Tolerance

  template<>

  class Tolerance<unsigned int>

  {

  public:

    ///\e

    typedef unsigned int Value;

    ///\name Comparisons

    ///@{

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

    ///@{

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

  ///\sa Tolerance

  template<>

  class Tolerance<unsigned long int>

  {

  public:

    ///\e

    typedef unsigned long int Value;

    ///\name Comparisons

    ///@{

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

  };

#if defined __GNUC__ && !defined __STRICT_ANSI__

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

    ///@{

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

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

    ///@{

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