RhodeCode

#  COMMAND hg id -i

#  OUTPUT_VARIABLE HG_REVISION

#  OUTPUT_STRIP_TRAILING_WHITESPACE)

SET(PROJECT_VERSION_MAJOR "0")

SET(PROJECT_VERSION_MINOR "99")

SET(PROJECT_VERSION_PATCH "0")

SET(PROJECT_VERSION

  SET(CPACK_PACKAGE_NAME ${PROJECT_NAME})

  SET(CPACK_PACKAGE_VENDOR

    "EGRES - Egervary Research Group on Combinatorial Optimization")

  SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY

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

  SET(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})

  SET(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})

  #SET(CPACK_COMPONENT_LIBRARY_DISPLAY_NAME "Static library")

  #SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DISPLAY_NAME "HTML documentation")

  #SET(CPACK_COMPONENT_HEADERS_DESCRIPTION

  #SET(CPACK_COMPONENT_LIBRARY_DESCRIPTION

  #SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DESCRIPTION

  #  "Doxygen generated documentation")

  #SET(CPACK_COMPONENT_HEADERS_DEPENDS library)

  #SET(CPACK_COMPONENT_LIBRARY_GROUP "Development")

  #SET(CPACK_COMPONENT_HTML_DOCUMENTATION_GROUP "Documentation")

  #SET(CPACK_COMPONENT_GROUP_DEVELOPMENT_DESCRIPTION

  #SET(CPACK_COMPONENT_GROUP_DOCUMENTATION_DESCRIPTION

  #SET(CPACK_ALL_INSTALL_TYPES Full Developer)

  #SET(CPACK_COMPONENT_HEADERS_INSTALL_TYPES Developer Full)

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

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

AC_PREREQ([2.59])

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])

can be the finding maximum cardinality, maximum weight or minimum cost

matching. The search can be constrained to find perfect or

maximum cardinality matching.

- \ref lemon::MaxBipartiteMatching "MaxBipartiteMatching" Hopcroft-Karp

  augmenting path algorithm for calculate maximum cardinality matching in

  bipartite graphs

- \ref lemon::PrBipartiteMatching "PrBipartiteMatching" Push-Relabel

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

*/

/**

@ingroup io_group

This group describes methods for reading and writing

*/

/**

@defgroup eps_io Postscript exporting

/*!

The \e LGF is a <em>column oriented</em>

file format for storing graphs and associated data like

node and edge maps.

  /// does not store values directly they are just key continars for more

  /// value containers which are the node and edge maps.

  ///

  /// The graph's node and edge sets can be changed as we add or erase

  /// that the node and edge maps should contain values for all nodes or

  /// edges. If we want to check on every indicing if the map contains

  /// the current indicing key that cause a drawback in the performance

  /// in the library. We use another solution we notify all maps about

      /// Resets the path to an empty path.

      void clear() {}

      ///

      /// This class is used to iterate on the arcs of the paths.

      class ArcIt {

      public:

    /// The main purpose of this concept is that the shortest path

    /// algorithms can enumerate easily the arcs in reverse order.

    /// If we would like to give back a real path from these

    /// algorithms then we should create a temporarly path object. In

    /// assigned to a real path and the dumpers can be implemented as

    /// an adaptor class to the predecessor map.

    /// \tparam _Digraph  The digraph type in which the path is.

      /// ArcIt the RevArcIt iterator should be implemented in the

      /// dumper.

      typedef False RevPathTag;

      ///

      /// This class is used to iterate on the arcs of the paths.

      class ArcIt {

      public:

        bool operator<(const ArcIt&) const {return false;}

      };

      ///

      /// This class is used to iterate on the arcs of the paths in

      /// reverse direction.

      class RevArcIt {

 */

///\ingroup lemon_io

///\file

#ifndef LEMON_LGF_READER_H

#define LEMON_LGF_READER_H

  ///

  /// \brief Reader for the contents of the \ref lgf-format "LGF" file

  ///

  /// This class can be used to read the sections, the map names and

  /// that, which type of graph, which maps and which attributes

  /// should be read from a file, but in general tools (like glemon)

  /// the contents of an LGF file should be guessed somehow. This class

  /// reads the graph and stores the appropriate information for

 */

///\ingroup lemon_io

///\file

#ifndef LEMON_LGF_WRITER_H

#define LEMON_LGF_WRITER_H

      copyPath(*this, cpath);

      return *this;

    }

    ///

    /// This class is used to iterate on the arcs of the paths.

    class ArcIt {

      friend class Path;

      items[items[fdx].prev].next = firstFreeItem;

      firstFreeItem = fdx;

    }

    ///

    /// ClassIt is a lemon style iterator for the components. It iterates

    /// on the ids of the classes.

    class ClassIt {

      const UnionFindEnum* unionFind;

      int cdx;

    };

    ///

    /// ClassIt is a lemon style iterator for the components. It iterates

    /// on the items of a class. By example if you want to iterate on

    /// each items of each classes then you may write the next code.

      classes[cdx].next = firstFreeClass;

      firstFreeClass = cdx;

    }

    ///

    /// ClassIt is a lemon style iterator for the components. It iterates

    /// on the ids of classes.

    class ClassIt {

      const ExtendFindEnum* extendFind;

      int cdx;

    };

    ///

    /// ClassIt is a lemon style iterator for the components. It iterates

    /// on the items of a class. By example if you want to iterate on

    /// each items of each classes then you may write the next code.

      int parent = classes[id].parent;

      return nodes[parent >= 0 ? classes[id].depth : leftNode(id)].item;

    }

    ///

    /// ClassIt is a lemon style iterator for the components. It iterates

    /// on the items of a class. By example if you want to iterate on

    /// each items of each classes then you may write the next code.