Since you are reading this I assume you already obtained one of the release

 This file contains instructions for building and installing LEMON from

 tarballs and successfully extracted it. The latest version of LEMON is

 source on Linux. The process on Windows is similar.

 available at our web page (http://lemon.cs.elte.hu/).

 LEMON provides two different build environments, one is based on "autotool",

 Note that it is not necessary to install LEMON in order to use

 while the other is based on "cmake". This file contains instructions only for

 it. Instead, you can easily integrate it with your own code

 the former one, which is the recommended build environment on Linux, Mac OSX

 directly. For instructions, see

 and other unices or if you use Cygwin on Windows. For cmake installation

 https://lemon.cs.elte.hu/trac/lemon/wiki/HowToCompile

 instructions visit http://lemon.cs.elte.hu.

    1. `cd lemon-x.y.z'

    1. Step into the root of the source directory.

       This command changes to the directory which was created when you

       $ cd lemon-x.y.z

       extracted the sources. The x.y.z part is a version number.

    2. `./configure'

    2. Create a build subdirectory and step into it.

       This command runs the configure shell script, which does some checks and

       $ mkdir build

       creates the makefiles.

       $ cd build

    3. `make'

    3. Perform system checks and create the makefiles.

       This command compiles the non-template part of LEMON into libemon.a

       $ cmake ..

       file. It also compiles the programs in the tools subdirectory by

       default.

    4. `make check'

    4. Build LEMON.

       This step is optional, but recommended. It runs the test programs that

       $ make 

       we developed for LEMON to check whether the library works properly on

       your platform.

    5. `make install'

       This command compiles the non-template part of LEMON into

       libemon.a file. It also compiles the programs in the 'tools' and

       'demo' subdirectories.

    5. [Optional] Compile and run the self-tests.

       $ make check

    5. [Optional] Generate the user documentation.

       $ make html

       The release tarballs already include the documentation.

       Note that for this step you need to have the following tools

       installed: Python, Doxygen, Graphviz, Ghostscript, LaTeX.

    6. [Optional] Install LEMON

       $ make install

       privileges to be able to do that). If you want to install it to some

       privileges to be able to do that). If you want to install it to

       other location, then pass the --prefix=DIRECTORY flag to configure in

       some other location, then pass the

       step 2. For example: `./configure --prefix=/home/username/lemon'.

       -DCMAKE_INSTALL_PREFIX=DIRECTORY flag to cmake in Step 3.

       For example:

    6. `make install-html'

       $ cmake -DCMAKE_INSTALL_PREFIX=/home/username/lemon'

       This command installs the documentation under share/doc/lemon/docs. The

       generated documentation is included in the tarball. If you want to

       generate it yourself, then run `make html'. Note that for this you need

       to have the following programs installed: Doxygen, Graphviz, Ghostscript,

       Latex.

 In step 2 you can customize the actions of configure by setting variables

 In Step 3, you can customize the build process by passing options to CMAKE.

 and passing options to it. This can be done like this:

 `./configure [OPTION]... [VARIABLE=VALUE]...'

 Below you will find some useful variables and options (see `./configure --help'

 $ cmake [OPTIONS] ..

 for more):

 CXX='comp'

 You find a list of the most useful options below.

   Change the C++ compiler to 'comp'.

 -DCMAKE_INSTALL_PREFIX=PREFIX

 CXXFLAGS='flags'

   Pass the 'flags' to the compiler. For example CXXFLAGS='-O3 -march=pentium-m'

   turns on generation of aggressively optimized Pentium-M specific code.

 --prefix=PREFIX

 --enable-tools

 -DCMAKE_BUILD_TYPE=[Release|Debug|Maintainer|...]

    Build the programs in the tools subdirectory (default).

   This sets the compiler options. The choices are the following

 --disable-tools

   'Release': A strong optimization is turned on (-O3 with gcc). This

     is the default setting and we strongly recommend using this for

     the final compilation.

    Do not build the programs in the tools subdirectory.

   'Debug': Optimization is turned off and debug info is added (-O0

     -ggdb with gcc). If is recommended during the development.

 --with-glpk[=PREFIX]

   'Maintainer': The same as 'Debug' but the compiler warnings are

     converted to errors (-Werror with gcc). In addition, 'make' will

     also automatically compile and execute the test codes. It is the

     best way of ensuring that LEMON codebase is clean and safe.

    Enable GLPK support (default). You should specify the prefix too if

   'RelWithDebInfo': Optimized build with debug info.

    you installed GLPK to some non-standard location (e.g. your home

    directory). If it is not found, GLPK support will be disabled.

 --with-glpk-includedir=DIR

   'MinSizeRel': Size optimized build (-Os with gcc)

    The directory where the GLPK header files are located. This is only

 -DTEST_WITH_VALGRIND=YES

    useful when the GLPK headers and libraries are not under the same

    prefix (which is unlikely).

 --with-glpk-libdir=DIR

   Using this, the test codes will be executed using valgrind. It is a

   very effective way of identifying indexing problems and memory leaks.

    The directory where the GLPK libraries are located. This is only

 -DCMAKE_CXX_COMPILER=path-to-compiler

    useful when the GLPK headers and libraries are not under the same

    prefix (which is unlikely).

 --without-glpk

   Change the compiler to be used.

    Disable GLPK support.

 -DBUILD_SHARED_LIBS=TRUE

 --with-cplex[=PREFIX]

   Build shared library instead of static one. Think twice if you

   really want to use this option.

    Enable CPLEX support (default). You should specify the prefix too

 -DGLPK_ROOT_DIR=DIRECTORY

    if you installed CPLEX to some non-standard location

 -DCOIN_ROOT_DIR=DIRECTORY

    (e.g. /opt/ilog/cplex75). If it is not found, CPLEX support will be

 -DCPLEX_ROOT_DIR=DIRECTORY

    disabled.

 --with-cplex-includedir=DIR

   Install root directory prefixes of optional third party libraries.

    The directory where the CPLEX header files are located. This is

    only useful when the CPLEX headers and libraries are not under the

    same prefix (e.g.  /usr/local/cplex/cplex75/include).

 --with-cplex-libdir=DIR

    The directory where the CPLEX libraries are located. This is only

    useful when the CPLEX headers and libraries are not under the same

    prefix (e.g.

    /usr/local/cplex/cplex75/lib/i86_linux2_glibc2.2_gcc3.0/static_pic_mt).

 --without-cplex

    Disable CPLEX support.

 --with-soplex[=PREFIX]

    Enable SoPlex support (default). You should specify the prefix too if

    you installed SoPlex to some non-standard location (e.g. your home

    directory). If it is not found, SoPlex support will be disabled.

 --with-soplex-includedir=DIR

    The directory where the SoPlex header files are located. This is only

    useful when the SoPlex headers and libraries are not under the same

    prefix (which is unlikely).

 --with-soplex-libdir=DIR

    The directory where the SoPlex libraries are located. This is only

    useful when the SoPlex headers and libraries are not under the same

    prefix (which is unlikely).

 --without-soplex

    Disable SoPlex support.

 --with-coin[=PREFIX]

    Enable support for COIN-OR solvers (CLP and CBC). You should

    specify the prefix too. (by default, COIN-OR tools install

    themselves to the source code directory). This command enables the

    solvers that are actually found.

 --with-coin-includedir=DIR

    The directory where the COIN-OR header files are located. This is

    only useful when the COIN-OR headers and libraries are not under

    the same prefix (which is unlikely).

 --with-coin-libdir=DIR

    The directory where the COIN-OR libraries are located. This is only

    useful when the COIN-OR headers and libraries are not under the

    same prefix (which is unlikely).

 --without-coin

    Disable COIN-OR support.

 Some Makefile variables are reserved by the GNU Coding Standards for

 make VERBOSE=1

 the use of the "user" - the person building the package. For instance,

 CXX and CXXFLAGS are such variables, and have the same meaning as

 explained in the previous section. These variables can be set on the

 command line when invoking `make' like this:

 `make [VARIABLE=VALUE]...'

 WARNINGCXXFLAGS is a non-standard Makefile variable introduced by us

    This results in a more verbose output by showing the full

 to hold several compiler flags related to warnings. Its default value

    compiler and linker commands.

 can be overridden when invoking `make'. For example to disable all

 warning flags use `make WARNINGCXXFLAGS='.

 In order to turn off a single flag from the default set of warning

 flags, you can use the CXXFLAGS variable, since this is passed after

 WARNINGCXXFLAGS. For example to turn off `-Wold-style-cast' (which is

 used by default when g++ is detected) you can use

 `make CXXFLAGS="-g -O2 -Wno-old-style-cast"'.