RhodeCode

/* -*- C++ -*-

 *

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

 *

 * 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

/* -*- C++ -*-

 *

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

 *

 * 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 create 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; }

  };

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

/* -*- C++ -*-

 *

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

 *

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

  };

/* -*- C++ -*-

 *

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

 *

 * 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 concept checking

// utility from BOOST.

// See the appropriate copyright notice below.

// (C) Copyright Jeremy Siek 2000.

// Distributed under 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)

//

// Revision History:

//   05 May   2001: Workarounds for HP aCC from Thomas Matelich. (Jeremy Siek)

//   02 April 2001: Removed limits header altogether. (Jeremy Siek)

//   01 April 2001: Modified to use new <boost/limits.hpp> header. (JMaddock)

//

// See http://www.boost.org/libs/concept_check for documentation.

#ifndef LEMON_CONCEPT_CHECKS_H

#define LEMON_CONCEPT_CHECKS_H

namespace lemon {

  /*

    "inline" is used for ignore_unused_variable_warning()

    and function_requires() to make sure there is no

    overtarget with g++.

  */

  template <class T> inline void ignore_unused_variable_warning(const T&) { }

  template <class Concept>

  inline void function_requires()

  {

#if !defined(NDEBUG)

    void (Concept::*x)() = & Concept::constraints;

    ignore_unused_variable_warning(x);

#endif

  }

  template <typename Concept, typename Type>

  inline void checkConcept() {

#if !defined(NDEBUG)

    typedef typename Concept::template Constraints<Type> ConceptCheck;

    void (ConceptCheck::*x)() = & ConceptCheck::constraints;

    ignore_unused_variable_warning(x);

#endif

  }

#define BOOST_CLASS_REQUIRE(type_var, ns, concept) \

  typedef void (ns::concept <type_var>::* func##type_var##concept)(); \

  template <func##type_var##concept Tp1_> \

/* -*- C++ -*-

 *

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

 *

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

#define LEMON_CONCEPT_MAPS_H

#include <lemon/bits/utility.h>

#include <lemon/concept_check.h>

///\ingroup concept

///\file

///\brief Map concepts checking classes for testing and documenting.

namespace lemon {

  namespace concepts {

    /// \addtogroup concept

    /// @{

    /// Readable map concept

    /// Readable map concept.

    ///

    template<typename K, typename T>

    class ReadMap

    {

    public:

      /// The key type of the map.

      typedef K Key;    

      /// The value type of the map. (The type of objects associated with the keys).

      typedef T Value;

      /// Returns the value associated with a key.

      /// \bug Value shouldn't need to be default constructible.

      ///

      Value operator[](const Key &) const {return Value();}

      template<typename _ReadMap>

      struct Constraints {

	void constraints() {

	  Value val = m[key];

	  val = m[key];

	  typename _ReadMap::Value own_val = m[own_key]; 

	  own_val = m[own_key]; 

	  ignore_unused_variable_warning(val);

	  ignore_unused_variable_warning(own_val);

	  ignore_unused_variable_warning(key);

	}

	Key& key;

	typename _ReadMap::Key& own_key;

/* -*- C++ -*-

 *

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

 *

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

#define LEMON_DIM2_H

#include <iostream>

#include <lemon/bits/utility.h>

///\ingroup misc

///\file

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

///

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

///a two dimensional vector with the usual

/// operations.

///

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

/// can be used to determine

/// the rectangular bounding box of a set of

/// \ref lemon::dim2::Point "dim2::Point"'s.

namespace lemon {

  ///Tools for handling two dimensional coordinates

  ///This namespace is a storage of several

  ///tools for handling two dimensional coordinates

  namespace dim2 {

  /// \addtogroup misc

  /// @{

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

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

  ///with the usual vector

  /// operators.

  ///

  template<typename T>

    class Point {

    public:

      typedef T Value;

      ///First coordinate

      T x;

      ///Second coordinate

      T y;     

      ///Default constructor

      Point() {}

/* -*- C++ -*-

 *

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

 *

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

#define LEMON_MAPS_H

#include <iterator>

#include <functional>

#include <vector>

#include <lemon/bits/utility.h>

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

///\file

///\ingroup maps

///\brief Miscellaneous property maps

///

#include <map>

namespace lemon {

  /// \addtogroup maps

  /// @{

  /// Base class of maps.

  /// Base class of maps.

  /// It provides the necessary <tt>typedef</tt>s required by the map concept.

  template<typename K, typename T>

  class MapBase {

  public:

    /// The key type of the map.

    typedef K Key;

    /// The value type of the map. (The type of objects associated with the keys).

    typedef T Value;

  };

  /// Null map. (a.k.a. DoNothingMap)

  /// This map can be used if you have to provide a map only for

  /// its type definitions, or if you have to provide a writable map, 

  /// but data written to it is not required (i.e. it will be sent to 

  /// <tt>/dev/null</tt>).

  template<typename K, typename T>

  class NullMap : public MapBase<K, T> {

  public:

    typedef MapBase<K, T> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    /// Gives back a default constructed element.

    T operator[](const K&) const { return T(); }

    /// Absorbs the value.

    void set(const K&, const T&) {}

/* -*- C++ -*-

 *

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

 *

 * 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 Instantiation of the Random class.

#include <lemon/random.h>

namespace lemon {

  /// \brief Global random number generator instance

  ///

  /// A global Mersenne Twister random number generator instance.

  Random rnd;

}

/* -*- C++ -*-

 *

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

 *

 * 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 the reimplemented version of the Mersenne Twister

 * Generator of Matsumoto and Nishimura.

 *

 * See the appropriate copyright notice below.

 * 

 * Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,

 * All rights reserved.                          

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 *

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * 3. The names of its contributors may not be used to endorse or promote 

 *    products derived from this software without specific prior written 

 *    permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE

 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED

 * OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 *

 * Any feedback is very welcome.

 * http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html

 * email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)

 */

#ifndef LEMON_RANDOM_H

#define LEMON_RANDOM_H

#include <algorithm>

#include <iterator>

#include <vector>

#include <ctime>

/* -*- C++ -*-

 *

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

 *

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

#if defined __GNUC__ && !defined __STRICT_ANSI__  

  ///\sa Tolerance<long long int>

#endif

  ///\sa Tolerance<unsigned int>

#if defined __GNUC__ && !defined __STRICT_ANSI__  

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

#endif

  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.

/* -*- C++ -*-

 *

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

 *

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

 *

 */

#include <lemon/dim2.h>

#include <iostream>

#include "test_tools.h"

using namespace std;

using namespace lemon;

int main()

{

  cout << "Testing classes 'dim2::Point' and 'dim2::BoundingBox'." << endl;

  typedef dim2::Point<int> Point;

  Point p;

  check(p.size()==2, "Wrong vector initialization.");

  Point a(1,2);

  Point b(3,4);

  check(a[0]==1 && a[1]==2, "Wrong vector initialization.");

  p = a+b;

  check(p.x==4 && p.y==6, "Wrong vector addition.");

  p = a-b;

  check(p.x==-2 && p.y==-2, "Wrong vector subtraction.");

  check(a.normSquare()==5,"Wrong vector norm calculation.");

  check(a*b==11, "Wrong vector scalar product.");

  int l=2;

  p = a*l;

  check(p.x==2 && p.y==4, "Wrong vector multiplication by a scalar.");

  p = b/l;

  check(p.x==1 && p.y==2, "Wrong vector division by a scalar.");

  typedef dim2::BoundingBox<int> BB;

  BB box1;

  check(box1.empty(), "It should be empty.");

  box1.add(a);

  check(!box1.empty(), "It should not be empty.");

  box1.add(b);

  check(box1.bottomLeft().x==1 &&

        box1.bottomLeft().y==2 &&

        box1.topRight().x==3 &&

        box1.topRight().y==4,

        "Wrong addition of points to box.");

  p.x=2; p.y=3;

/* -*- C++ -*-

 *

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

 *

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

 *

 */

#include <deque>

#include <set>

#include <lemon/concept_check.h>

#include <lemon/concepts/maps.h>

#include <lemon/maps.h>

#include "test_tools.h"

using namespace lemon;

using namespace lemon::concepts;

struct A {};

inline bool operator<(A, A) { return true; }

struct B {};

class F {

public:

  typedef A argument_type;

  typedef B result_type;

  B operator()(const A &) const {return B();}

};

int func(A) {return 3;}

int binc(int, B) {return 4;}

typedef ReadMap<A,double> DoubleMap;

typedef ReadWriteMap<A, double> WriteDoubleMap;

typedef ReadMap<A,bool> BoolMap;

typedef ReadWriteMap<A, bool> BoolWriteMap;

int main()

{ // checking graph components

  checkConcept<ReadMap<A,B>, ReadMap<A,B> >();

  checkConcept<WriteMap<A,B>, WriteMap<A,B> >();

  checkConcept<ReadWriteMap<A,B>, ReadWriteMap<A,B> >();

  checkConcept<ReferenceMap<A,B,B&,const B&>, ReferenceMap<A,B,B&,const B&> >();

  checkConcept<ReadMap<A,double>, AddMap<DoubleMap,DoubleMap> >();

  checkConcept<ReadMap<A,double>, SubMap<DoubleMap,DoubleMap> >();

  checkConcept<ReadMap<A,double>, MulMap<DoubleMap,DoubleMap> >();

  checkConcept<ReadMap<A,double>, DivMap<DoubleMap,DoubleMap> >();

  checkConcept<ReadMap<A,double>, NegMap<DoubleMap> >();

  checkConcept<ReadWriteMap<A,double>, NegWriteMap<WriteDoubleMap> >();

  checkConcept<ReadMap<A,double>, AbsMap<DoubleMap> >();

  checkConcept<ReadMap<A,double>, ShiftMap<DoubleMap> >();

  checkConcept<ReadWriteMap<A,double>, ShiftWriteMap<WriteDoubleMap> >();

/* -*- C++ -*-

 *

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

 *

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

 *

 */

#include <lemon/random.h>

#include "test_tools.h"

///\file \brief Test cases for random.h

///

///\todo To be extended

///

int main()

{

  double a=lemon::rnd();

  check(a<1.0&&a>0.0,"This should be in [0,1)");

  a=lemon::rnd.gauss();

  a=lemon::rnd.gamma(3.45,0);

  a=lemon::rnd.gamma(4);

  //Does gamma work with integer k?

  a=lemon::rnd.gamma(4.0,0);

}

/* -*- C++ -*-

 *

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

 *

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

#define LEMON_TEST_TEST_TOOLS_H

#include <iostream>

//! \ingroup misc

//! \file

//! \brief Some utilities to write test programs.

///If \c rc is fail, writes an error message end exit.

///If \c rc is fail, writes an error message end exit.

///The error message contains the file name and the line number of the

///source code in a standard from, which makes it possible to go there

///using good source browsers like e.g. \c emacs.

///

///For example

///\code check(0==1,"This is obviously false.");\endcode will

///print this (and then exits).

///\verbatim graph_test.cc:123: error: This is obviously false. \endverbatim

///

///\todo It should be in \c error.h

#define check(rc, msg) \

  if(!(rc)) { \

    std::cerr << __FILE__ ":" << __LINE__ << ": error: " << msg << std::endl; \

    abort(); \

  } else { } \

#endif

/* -*- C++ -*-

 *

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

 *

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

 *

 */

#include "test_tools.h"

int main() 

{

  check(false, "Don't panic. Failing is the right behaviour here.");

  return 0;

}

/* -*- C++ -*-

 *

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

 *

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

 *

 */

#include "test_tools.h"

int main() 

{

  check(true, "It should pass.");

  return 0;

}