# HG changeset patch
# User Alpar Juttner <alpar@cs.elte.hu>
# Date 1198166346 0
# Node ID 4d461e9867da55e340da4353b59a73b1a1875451
# Parent 3f411aa35bd7dfecf640bb3f0b5558a24e1d828c
Port invalid.h utility.h tolerance.h from svn -r3422
diff -r 3f411aa35bd7 -r 4d461e9867da lemon/Makefile.am
--- a/lemon/Makefile.am Wed Dec 19 11:33:49 2007 +0000
+++ b/lemon/Makefile.am Thu Dec 20 15:59:06 2007 +0000
@@ -6,14 +6,18 @@
lib_LTLIBRARIES += lemon/libemon.la
-lemon_libemon_la_SOURCES =
+lemon_libemon_la_SOURCES = \
+ lemon/base.cc
lemon_libemon_la_CXXFLAGS = $(GLPK_CFLAGS) $(CPLEX_CFLAGS) $(SOPLEX_CXXFLAGS)
lemon_libemon_la_LDFLAGS = $(GLPK_LIBS) $(CPLEX_LIBS) $(SOPLEX_LIBS)
lemon_HEADERS += \
- lemon/list_graph.h
+ lemon/list_graph.h \
+ lemon/tolerance.h
-bits_HEADERS +=
+bits_HEADERS += \
+ lemon/bits/invalid.h \
+ lemon/bits/utility.h
concept_HEADERS +=
diff -r 3f411aa35bd7 -r 4d461e9867da lemon/base.cc
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/base.cc Thu Dec 20 15:59:06 2007 +0000
@@ -0,0 +1,34 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2007
+ * 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.
+ *
+ */
+
+///\file
+///\brief Some basic non inline function and static global data.
+
+#include<lemon/tolerance.h>
+#include<lemon/bits/invalid.h>
+namespace lemon {
+
+ float Tolerance<float>::def_epsilon = 1e-4;
+ double Tolerance<double>::def_epsilon = 1e-10;
+ long double Tolerance<long double>::def_epsilon = 1e-14;
+
+#ifndef LEMON_ONLY_TEMPLATES
+ const Invalid INVALID = Invalid();
+#endif
+
+} //namespace lemon
diff -r 3f411aa35bd7 -r 4d461e9867da lemon/bits/invalid.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/bits/invalid.h Thu Dec 20 15:59:06 2007 +0000
@@ -0,0 +1,54 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2007
+ * 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_INVALID_H
+#define LEMON_BITS_INVALID_H
+
+///\file
+///\brief Definition of INVALID.
+
+namespace lemon {
+
+ /// \brief Dummy type to make it easier to make invalid iterators.
+ ///
+ /// See \ref INVALID for the usage.
+ struct Invalid {
+ public:
+ bool operator==(Invalid) { return true; }
+ bool operator!=(Invalid) { return false; }
+ bool operator< (Invalid) { return false; }
+ };
+
+ /// Invalid iterators.
+
+ /// \ref Invalid is a global type that converts to each iterator
+ /// in such a way that the value of the target iterator will be invalid.
+
+ //Some people didn't like this:
+ //const Invalid &INVALID = *(Invalid *)0;
+
+#ifdef LEMON_ONLY_TEMPLATES
+ const Invalid INVALID = Invalid();
+#else
+ extern const Invalid INVALID;
+#endif
+
+} //namespace lemon
+
+#endif
+
diff -r 3f411aa35bd7 -r 4d461e9867da lemon/bits/utility.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/bits/utility.h Thu Dec 20 15:59:06 2007 +0000
@@ -0,0 +1,140 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2007
+ * 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.
+ *
+ */
+
+// This file contains a modified version of the enable_if library from BOOST.
+// See the appropriate copyright notice below.
+
+// Boost enable_if library
+
+// Copyright 2003 © The Trustees of Indiana University.
+
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Authors: Jaakko Järvi (jajarvi at osl.iu.edu)
+// Jeremiah Willcock (jewillco at osl.iu.edu)
+// Andrew Lumsdaine (lums at osl.iu.edu)
+
+
+#ifndef LEMON_BITS_UTILITY_H
+#define LEMON_BITS_UTILITY_H
+
+///\file
+///\brief Miscellaneous basic utilities
+///
+///\todo Please rethink the organisation of the basic files like this.
+///E.g. this file might be merged with invalid.h.
+
+
+namespace lemon
+{
+
+ /// Basic type for defining "tags". A "YES" condition for \c enable_if.
+
+ /// Basic type for defining "tags". A "YES" condition for \c enable_if.
+ ///
+ ///\sa False
+ ///
+ /// \todo This should go to a separate "basic_types.h" (or something)
+ /// file.
+ struct True {
+ ///\e
+ static const bool value = true;
+ };
+
+ /// Basic type for defining "tags". A "NO" condition for \c enable_if.
+
+ /// Basic type for defining "tags". A "NO" condition for \c enable_if.
+ ///
+ ///\sa True
+ struct False {
+ ///\e
+ static const bool value = false;
+ };
+
+
+ struct InvalidType {
+ };
+
+ template <typename T>
+ struct Wrap {
+ const T &value;
+ Wrap(const T &t) : value(t) {}
+ };
+
+ /**************** dummy class to avoid ambiguity ****************/
+
+ template<int T> struct dummy { dummy(int) {} };
+
+ /**************** enable_if from BOOST ****************/
+
+ template <typename Type, typename T = void>
+ struct exists {
+ typedef T type;
+ };
+
+
+ template <bool B, class T = void>
+ struct enable_if_c {
+ typedef T type;
+ };
+
+ template <class T>
+ struct enable_if_c<false, T> {};
+
+ template <class Cond, class T = void>
+ struct enable_if : public enable_if_c<Cond::value, T> {};
+
+ template <bool B, class T>
+ struct lazy_enable_if_c {
+ typedef typename T::type type;
+ };
+
+ template <class T>
+ struct lazy_enable_if_c<false, T> {};
+
+ template <class Cond, class T>
+ struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
+
+
+ template <bool B, class T = void>
+ struct disable_if_c {
+ typedef T type;
+ };
+
+ template <class T>
+ struct disable_if_c<true, T> {};
+
+ template <class Cond, class T = void>
+ struct disable_if : public disable_if_c<Cond::value, T> {};
+
+ template <bool B, class T>
+ struct lazy_disable_if_c {
+ typedef typename T::type type;
+ };
+
+ template <class T>
+ struct lazy_disable_if_c<true, T> {};
+
+ template <class Cond, class T>
+ struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
+
+} // namespace lemon
+
+#endif
diff -r 3f411aa35bd7 -r 4d461e9867da lemon/tolerance.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/tolerance.h Thu Dec 20 15:59:06 2007 +0000
@@ -0,0 +1,454 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2007
+ * 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.
+ ///
+ ///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 \ref 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 with \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 \ref Tolerance.
+
+ ///Float specialization of \ref 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.
+ Tolerance(float e) : _epsilon(e) {}
+
+ ///Return the epsilon value.
+ Value epsilon() const {return _epsilon;}
+ ///Set the epsilon value.
+ void epsilon(Value e) {_epsilon=e;}
+
+ ///Return the default epsilon value.
+ static Value defaultEpsilon() {return def_epsilon;}
+ ///Set the default epsilon value.
+ static void defaultEpsilon(Value e) {def_epsilon=e;}
+
+ ///\name Comparisons
+ ///See class 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 \ref Tolerance.
+
+ ///Double specialization of \ref 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.
+ Tolerance(double e) : _epsilon(e) {}
+
+ ///Return the epsilon value.
+ Value epsilon() const {return _epsilon;}
+ ///Set the epsilon value.
+ void epsilon(Value e) {_epsilon=e;}
+
+ ///Return the default epsilon value.
+ static Value defaultEpsilon() {return def_epsilon;}
+ ///Set the default epsilon value.
+ static void defaultEpsilon(Value e) {def_epsilon=e;}
+
+ ///\name Comparisons
+ ///See class 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 \ref Tolerance.
+
+ ///Long double specialization of \ref 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.
+ Tolerance(long double e) : _epsilon(e) {}
+
+ ///Return the epsilon value.
+ Value epsilon() const {return _epsilon;}
+ ///Set the epsilon value.
+ void epsilon(Value e) {_epsilon=e;}
+
+ ///Return the default epsilon value.
+ static Value defaultEpsilon() {return def_epsilon;}
+ ///Set the default epsilon value.
+ static void defaultEpsilon(Value e) {def_epsilon=e;}
+
+ ///\name Comparisons
+ ///See class 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 \ref Tolerance.
+
+ ///Integer specialization of \ref Tolerance.
+ ///\sa Tolerance
+ template<>
+ class Tolerance<int>
+ {
+ public:
+ ///\e
+ typedef int Value;
+
+ ///\name Comparisons
+ ///See \ref 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 \ref Tolerance.
+
+ ///Unsigned integer specialization of \ref Tolerance.
+ ///\sa Tolerance
+ template<>
+ class Tolerance<unsigned int>
+ {
+ public:
+ ///\e
+ typedef unsigned int Value;
+
+ ///\name Comparisons
+ ///See \ref 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 \ref Tolerance.
+
+ ///Long integer specialization of \ref Tolerance.
+ ///\sa Tolerance
+ template<>
+ class Tolerance<long int>
+ {
+ public:
+ ///\e
+ typedef long int Value;
+
+ ///\name Comparisons
+ ///See \ref 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 \ref Tolerance.
+
+ ///Unsigned long integer specialization of \ref Tolerance.
+ ///\sa Tolerance
+ template<>
+ class Tolerance<unsigned long int>
+ {
+ public:
+ ///\e
+ typedef unsigned long int Value;
+
+ ///\name Comparisons
+ ///See \ref 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;}
+ };
+
+#if defined __GNUC__ && !defined __STRICT_ANSI__
+
+ ///Long long integer specialization of \ref Tolerance.
+
+ ///Long long integer specialization of \ref 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 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 \ref Tolerance.
+
+ ///Unsigned long long integer specialization of \ref 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 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