RhodeCode

CMAKE_MINIMUM_REQUIRED(VERSION 2.6)

IF(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)

  INCLUDE(${CMAKE_SOURCE_DIR}/cmake/version.cmake)

ELSE(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)

  SET(PROJECT_NAME "LEMON")

  SET(PROJECT_VERSION "hg-tip" CACHE STRING "LEMON version string.")

ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)

PROJECT(${PROJECT_NAME})

INCLUDE(FindDoxygen)

INCLUDE(FindGhostscript)

FIND_PACKAGE(GLPK 4.33)

ADD_DEFINITIONS(-DHAVE_CONFIG_H)

IF(MSVC)

  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4250 /wd4355 /wd4800 /wd4996")

# Suppressed warnings:

# C4250: 'class1' : inherits 'class2::member' via dominance

# C4355: 'this' : used in base member initializer list

# C4800: 'type' : forcing value to bool 'true' or 'false' (performance warning)

# C4996: 'function': was declared deprecated

ENDIF(MSVC)

IF(GLPK_FOUND)

  SET(HAVE_LP TRUE)

  SET(HAVE_MIP TRUE)

  SET(HAVE_GLPK TRUE)

ENDIF(GLPK_FOUND)

INCLUDE(CheckTypeSize)

CHECK_TYPE_SIZE("long long" LONG_LONG)

ENABLE_TESTING()

ADD_SUBDIRECTORY(lemon)

copyright/license.

Copyright (C) 2003-2009 Egervary Jeno Kombinatorikus Optimalizalasi

Kutatocsoport (Egervary Combinatorial Optimization Research Group,

EGRES).

Permission is hereby granted, free of charge, to any person or organization

obtaining a copy of the software and accompanying documentation covered by

this license (the "Software") to use, reproduce, display, distribute,

execute, and transmit the Software, and to prepare derivative works of the

Software, and to permit third-parties to whom the Software is furnished to

do so, all subject to the following:

The copyright notices in the Software and this entire statement, including

the above license grant, this restriction and the following disclaimer,

must be included in all copies of the Software, in whole or in part, and

all derivative works of the Software, unless such copies or derivative

works are solely in the form of machine-executable object code generated by

a source language processor.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT

SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE

FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,

ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

DEALINGS IN THE SOFTWARE.

2008-10-13 Version 1.0 released

	This is the first stable release of LEMON. Compared to the 0.x

	release series, it features a considerably smaller but more

	matured set of tools. The API has also completely revised and

	changed in several places.

	* The major name changes compared to the 0.x series (see the

          Migration Guide in the doc for more details)

          * Graph -> Digraph, UGraph -> Graph

          * Edge -> Arc, UEdge -> Edge

	  * source(UEdge)/target(UEdge) -> u(Edge)/v(Edge)

	* Other improvements

	  * Better documentation

	  * Reviewed and cleaned up codebase

	  * CMake based build system (along with the autotools based one)

	* Contents of the library (ported from 0.x)

	  * Algorithms

       	    * breadth-first search (bfs.h)

       	    * depth-first search (dfs.h)

       	    * Dijkstra's algorithm (dijkstra.h)

       	    * Kruskal's algorithm (kruskal.h)

    	  * Data structures

       	    * graph data structures (list_graph.h, smart_graph.h)

       	    * path data structures (path.h)

       	    * binary heap data structure (bin_heap.h)

       	    * union-find data structures (unionfind.h)

       	    * miscellaneous property maps (maps.h)

       	    * two dimensional vector and bounding box (dim2.h)

          * Concepts

       	    * graph structure concepts (concepts/digraph.h, concepts/graph.h,

              concepts/graph_components.h)

       	    * concepts for other structures (concepts/heap.h, concepts/maps.h,

	      concepts/path.h)

    	  * Tools

       	    * Mersenne twister random number generator (random.h)

       	    * tools for measuring cpu and wall clock time (time_measure.h)

       	    * tools for counting steps and events (counter.h)

       	    * tool for parsing command line arguments (arg_parser.h)

       	    * tool for visualizing graphs (graph_to_eps.h)

       	    * tools for reading and writing data in LEMON Graph Format

              (lgf_reader.h, lgf_writer.h)

            * tools to handle the anomalies of calculations with

	      floating point numbers (tolerance.h)

            * tools to manage RGB colors (color.h)

    	  * Infrastructure

       	    * extended assertion handling (assert.h)

       	    * exception classes and error handling (error.h)

INCLUDE_DIRECTORIES(

)

SET(DEMOS

  arg_parser_demo

  graph_to_eps_demo

  lgf_demo)

FOREACH(DEMO_NAME ${DEMOS})

  ADD_EXECUTABLE(${DEMO_NAME} ${DEMO_NAME}.cc)

  TARGET_LINK_LIBRARIES(${DEMO_NAME} lemon)

ENDFOREACH(DEMO_NAME)

SET(PACKAGE_NAME ${PROJECT_NAME})

SET(PACKAGE_VERSION ${PROJECT_VERSION})

CONFIGURE_FILE(

  @ONLY)

IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE)

  FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/)

  IF(UNIX)

    ADD_CUSTOM_TARGET(html

      COMMAND rm -rf gen-images

      COMMAND mkdir gen-images

      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/grid_graph.png ${CMAKE_CURRENT_SOURCE_DIR}/images/grid_graph.eps

      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps

      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps

      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps

      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps

      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps

      COMMAND rm -rf html

      COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile

      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})

  ELSEIF(WIN32)

    ADD_CUSTOM_TARGET(html

      COMMAND if exist gen-images rmdir /s /q gen-images

      COMMAND mkdir gen-images

      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps

      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps

      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps

      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps

      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps

      COMMAND if exist html rmdir /s /q html

      COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile

      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})

  ENDIF(UNIX)

  INSTALL(

    DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/

    DESTINATION share/doc

    COMPONENT html_documentation)

ENDIF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE)

INCLUDE_DIRECTORIES(

)

CONFIGURE_FILE(

  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake

  ${CMAKE_CURRENT_BINARY_DIR}/config.h

)

SET(LEMON_SOURCES

  arg_parser.cc

  base.cc

  color.cc

  lp_base.cc

  lp_skeleton.cc

  random.cc

  bits/windows.cc

)

IF(HAVE_GLPK)

  SET(LEMON_SOURCES ${LEMON_SOURCES} glpk.cc)

  INCLUDE_DIRECTORIES(${GLPK_INCLUDE_DIR})

  IF(WIN32)

    INSTALL(FILES ${GLPK_BIN_DIR}/glpk.dll DESTINATION bin)

    INSTALL(FILES ${GLPK_BIN_DIR}/libltdl3.dll DESTINATION bin)

    INSTALL(FILES ${GLPK_BIN_DIR}/zlib1.dll DESTINATION bin)

  ENDIF(WIN32)

ENDIF(HAVE_GLPK)

ADD_LIBRARY(lemon ${LEMON_SOURCES})

INSTALL(

  TARGETS lemon

  ARCHIVE DESTINATION lib

  COMPONENT library)

INSTALL(

  DIRECTORY . bits concepts

  DESTINATION include/lemon

  COMPONENT headers

  FILES_MATCHING PATTERN "*.h")

EXTRA_DIST += \

	lemon/lemon.pc.in \

	lemon/CMakeLists.txt

pkgconfig_DATA += lemon/lemon.pc

lib_LTLIBRARIES += lemon/libemon.la

lemon_libemon_la_SOURCES = \

	lemon/arg_parser.cc \

	lemon/base.cc \

	lemon/color.cc \

	lemon/lp_base.cc \

	lemon/lp_skeleton.cc \

        lemon/random.cc \

	lemon/bits/windows.cc

lemon_libemon_la_CXXFLAGS = \

	$(GLPK_CFLAGS) \

	$(CPLEX_CFLAGS) \

	$(SOPLEX_CXXFLAGS) \

	$(CLP_CXXFLAGS)

lemon_libemon_la_LDFLAGS = \

	$(GLPK_LIBS) \

	$(CPLEX_LIBS) \

	$(SOPLEX_LIBS) \

	$(CLP_LIBS)

if HAVE_GLPK

lemon_libemon_la_SOURCES += lemon/glpk.cc

endif

if HAVE_CPLEX

lemon_libemon_la_SOURCES += lemon/cplex.cc

endif

if HAVE_SOPLEX

lemon_libemon_la_SOURCES += lemon/soplex.cc

endif

if HAVE_CLP

lemon_libemon_la_SOURCES += lemon/clp.cc

endif

lemon_HEADERS += \

	lemon/adaptors.h \

	lemon/arg_parser.h \

	lemon/assert.h \

	lemon/bfs.h \

	lemon/bin_heap.h \

	lemon/circulation.h \

	lemon/clp.h \

	lemon/color.h \

	lemon/concept_check.h \

	lemon/connectivity.h \

	lemon/counter.h \

	lemon/core.h \

	lemon/cplex.h \

	lemon/dfs.h \

	lemon/dijkstra.h \

	lemon/dim2.h \

	lemon/dimacs.h \

	lemon/edge_set.h \

	lemon/elevator.h \

	lemon/error.h \

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

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

#include <vector>

#include <cstring>

#include <lemon/cplex.h>

extern "C" {

#include <ilcplex/cplex.h>

}

///\file

///\brief Implementation of the LEMON-CPLEX lp solver interface.

namespace lemon {

  CplexEnv::LicenseError::LicenseError(int status) {

    if (!CPXgeterrorstring(0, status, _message)) {

      std::strcpy(_message, "Cplex unknown error");

    }

  }

  CplexEnv::CplexEnv() {

    int status;

    _cnt = new int;

    _env = CPXopenCPLEX(&status);

    if (_env == 0) {

      delete _cnt;

      _cnt = 0;

      throw LicenseError(status);

    }

  }

  CplexEnv::CplexEnv(const CplexEnv& other) {

    _env = other._env;

    _cnt = other._cnt;

  }

  void CplexBase::_setObjCoeff(int i, Value obj_coef)

  {

    CPXchgobj(cplexEnv(), _prob, 1, &i, &obj_coef);

  }

  CplexBase::Value CplexBase::_getObjCoeff(int i) const

  {

    Value x;

    CPXgetobj(cplexEnv(), _prob, &x, i, i);

    return x;

  }

  void CplexBase::_setSense(CplexBase::Sense sense) {

    switch (sense) {

    case MIN:

      CPXchgobjsen(cplexEnv(), _prob, CPX_MIN);

      break;

    case MAX:

      CPXchgobjsen(cplexEnv(), _prob, CPX_MAX);

      break;

    }

  }

  CplexBase::Sense CplexBase::_getSense() const {

    switch (CPXgetobjsen(cplexEnv(), _prob)) {

    case CPX_MIN:

      return MIN;

    case CPX_MAX:

      return MAX;

    default:

      LEMON_ASSERT(false, "Invalid sense");

      return CplexBase::Sense();

    }

  }

  void CplexBase::_clear() {

    CPXfreeprob(cplexEnv(),&_prob);

    int status;

    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");

    rows.clear();

    cols.clear();

  }

  // CplexLp members

  CplexLp::CplexLp()

  CplexLp::CplexLp(const CplexEnv& env)

  CplexLp::CplexLp(const CplexLp& other)

  CplexLp::~CplexLp() {}

  CplexLp* CplexLp::newSolver() const { return new CplexLp; }

  CplexLp* CplexLp::cloneSolver() const {return new CplexLp(*this); }

  const char* CplexLp::_solverName() const { return "CplexLp"; }

  void CplexLp::_clear_temporals() {

    _col_status.clear();

    _row_status.clear();

    _primal_ray.clear();

    _dual_ray.clear();

  }

  // The routine returns zero unless an error occurred during the

  // optimization. Examples of errors include exhausting available

  // memory (CPXERR_NO_MEMORY) or encountering invalid data in the

  // CPLEX problem object (CPXERR_NO_PROBLEM). Exceeding a

  // user-specified CPLEX limit, or proving the model infeasible or

  // unbounded, are not considered errors. Note that a zero return

  // value does not necessarily mean that a solution exists. Use query

  // routines CPXsolninfo, CPXgetstat, and CPXsolution to obtain

  // further information about the status of the optimization.

  CplexLp::SolveExitStatus CplexLp::convertStatus(int status) {

#if CPX_VERSION >= 800

    if (status == 0) {

      switch (CPXgetstat(cplexEnv(), _prob)) {

      case CPX_STAT_OPTIMAL:

      case CPX_STAT_INFEASIBLE:

      case CPX_STAT_UNBOUNDED:

        return SOLVED;

      default:

        return UNSOLVED;

      }

    } else {

      return UNSOLVED;

    }

#else

    if (status == 0) {

      //We want to exclude some cases

      switch (CPXgetstat(cplexEnv(), _prob)) {

      case CPX_OBJ_LIM:

      case CPX_IT_LIM_FEAS:

      case CPX_IT_LIM_INFEAS:

      case CPX_TIME_LIM_FEAS:

      case CPX_TIME_LIM_INFEAS:

        return UNSOLVED;

  //9.0-as cplex verzio statusai

  // CPX_STAT_ABORT_DUAL_OBJ_LIM

  // CPX_STAT_ABORT_IT_LIM

  // CPX_STAT_ABORT_OBJ_LIM

  // CPX_STAT_ABORT_PRIM_OBJ_LIM

  // CPX_STAT_ABORT_TIME_LIM

  // CPX_STAT_ABORT_USER

  // CPX_STAT_FEASIBLE_RELAXED

  // CPX_STAT_INFEASIBLE

  // CPX_STAT_INForUNBD

  // CPX_STAT_NUM_BEST

  // CPX_STAT_OPTIMAL

  // CPX_STAT_OPTIMAL_FACE_UNBOUNDED

  // CPX_STAT_OPTIMAL_INFEAS

  // CPX_STAT_OPTIMAL_RELAXED

  // CPX_STAT_UNBOUNDED

  CplexLp::ProblemType CplexLp::_getDualType() const {

    int stat = CPXgetstat(cplexEnv(), _prob);

#if CPX_VERSION >= 800

    switch (stat) {

    case CPX_STAT_OPTIMAL:

      return OPTIMAL;

    case CPX_STAT_UNBOUNDED:

      return INFEASIBLE;

    default:

      return UNDEFINED;

    }

#else

    statusSwitch(cplexEnv(),stat);

    switch (stat) {

    case 0:

      return UNDEFINED; //Undefined

    case CPX_OPTIMAL://Optimal

      return OPTIMAL;

    case CPX_UNBOUNDED:

      return INFEASIBLE;

    default:

      return UNDEFINED; //Everything else comes here

      //FIXME error

    }

#endif

  }

  // CplexMip members

  CplexMip::CplexMip()

#if CPX_VERSION < 800

    CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MIP);

#else

    CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MILP);

#endif

  }

  CplexMip::CplexMip(const CplexEnv& env)

#if CPX_VERSION < 800

    CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MIP);

#else

    CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MILP);

#endif

  }

  CplexMip::CplexMip(const CplexMip& other)

  CplexMip::~CplexMip() {}

  CplexMip* CplexMip::newSolver() const { return new CplexMip; }

  CplexMip* CplexMip::cloneSolver() const {return new CplexMip(*this); }

  const char* CplexMip::_solverName() const { return "CplexMip"; }

  void CplexMip::_setColType(int i, CplexMip::ColTypes col_type) {

    // Note If a variable is to be changed to binary, a call to CPXchgbds

    // should also be made to change the bounds to 0 and 1.

    switch (col_type){

    case INTEGER: {

      const char t = 'I';

      CPXchgctype (cplexEnv(), _prob, 1, &i, &t);

    } break;

    case REAL: {

      const char t = 'C';

      CPXchgctype (cplexEnv(), _prob, 1, &i, &t);

    } break;

    default:

      break;

    }

  }

  CplexMip::ColTypes CplexMip::_getColType(int i) const {

    char t;

    CPXgetctype (cplexEnv(), _prob, &t, i, i);

    switch (t) {

    case 'I':

      return INTEGER;

    case 'C':

      return REAL;

    default:

      LEMON_ASSERT(false, "Invalid column type");

      return ColTypes();

    }

  }

  CplexMip::SolveExitStatus CplexMip::_solve() {

    int status;

    status = CPXmipopt (cplexEnv(), _prob);

    if (status==0)

      return SOLVED;

    else

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

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

#define LEMON_CPLEX_H

///\file

///\brief Header of the LEMON-CPLEX lp solver interface.

#include <lemon/lp_base.h>

struct cpxenv;

struct cpxlp;

namespace lemon {

  /// \brief Reference counted wrapper around cpxenv pointer

  ///

  /// The cplex uses environment object which is responsible for

  /// checking the proper license usage. This class provides a simple

  /// interface for share the environment object between different

  /// problems.

  class CplexEnv {

    friend class CplexBase;

  private:

    cpxenv* _env;

    mutable int* _cnt;

  public:

    /// \brief This exception is thrown when the license check is not

    /// sufficient

    class LicenseError : public Exception {

      friend class CplexEnv;

    private:

      LicenseError(int status);

      char _message[510];

    public:

      /// The short error message

      virtual const char* what() const throw() {

        return _message;

      }

    };

    /// Constructor

    CplexEnv();

    /// Shallow copy constructor

    CplexEnv(const CplexEnv&);

    /// Shallow assignement

    CplexEnv& operator=(const CplexEnv&);

    /// Destructor

    virtual ~CplexEnv();

  protected:

    cpxenv* cplexEnv() { return _env; }

    const cpxenv* cplexEnv() const { return _env; }

  };

  /// \brief Base interface for the CPLEX LP and MIP solver

  ///

  /// This class implements the common interface of the CPLEX LP and

  /// \ingroup lp_group

  class CplexBase : virtual public LpBase {

  protected:

    CplexEnv _env;

    cpxlp* _prob;

    CplexBase();

    CplexBase(const CplexEnv&);

    CplexBase(const CplexBase &);

    virtual ~CplexBase();

    virtual int _addCol();

    virtual int _addRow();

    virtual void _eraseCol(int i);

    virtual void _eraseRow(int i);

    virtual void _eraseColId(int i);

    virtual void _eraseRowId(int i);

    virtual void _getColName(int col, std::string& name) const;

    virtual void _setColName(int col, const std::string& name);

    virtual int _colByName(const std::string& name) const;

    virtual void _getRowName(int row, std::string& name) const;

    virtual void _setRowName(int row, const std::string& name);

    virtual int _rowByName(const std::string& name) const;

    virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e);

    virtual void _getRowCoeffs(int i, InsertIterator b) const;

    virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e);

    virtual void _getColCoeffs(int i, InsertIterator b) const;

    virtual void _setCoeff(int row, int col, Value value);

    virtual Value _getCoeff(int row, int col) const;

    virtual void _setColLowerBound(int i, Value value);

    virtual Value _getColLowerBound(int i) const;

    virtual void _setColUpperBound(int i, Value value);

    virtual Value _getColUpperBound(int i) const;

  private:

    void _set_row_bounds(int i, Value lb, Value ub);

  protected:

    SolveExitStatus convertStatus(int status);

  protected:

    virtual const char* _solverName() const;

    virtual SolveExitStatus _solve();

    virtual Value _getPrimal(int i) const;

    virtual Value _getDual(int i) const;

    virtual Value _getPrimalValue() const;

    virtual VarStatus _getColStatus(int i) const;

    virtual VarStatus _getRowStatus(int i) const;

    virtual Value _getPrimalRay(int i) const;

    virtual Value _getDualRay(int i) const;

    virtual ProblemType _getPrimalType() const;

    virtual ProblemType _getDualType() const;

  public:

    /// Solve with primal simplex method

    SolveExitStatus solvePrimal();

    /// Solve with dual simplex method

    SolveExitStatus solveDual();

    /// Solve with barrier method

    SolveExitStatus solveBarrier();

  };

  /// \brief Interface for the CPLEX MIP solver

  ///

  /// This class implements an interface for the CPLEX MIP solver.

  ///\ingroup lp_group

  class CplexMip : public MipSolver, public CplexBase {

  public:

    /// \e

    CplexMip();

    /// \e

    CplexMip(const CplexEnv&);

    /// \e

    CplexMip(const CplexMip&);

    /// \e

    virtual ~CplexMip();

  protected:

    virtual const char* _solverName() const;

    virtual ColTypes _getColType(int col) const;

    virtual void _setColType(int col, ColTypes col_type);

    virtual SolveExitStatus _solve();

    virtual ProblemType _getType() const;

    virtual Value _getSol(int i) const;

    virtual Value _getSolValue() const;

  };

} //END OF NAMESPACE LEMON

#endif //LEMON_CPLEX_H

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * 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 Implementation of the LEMON GLPK LP and MIP solver interface.

#include <lemon/glpk.h>

#include <glpk.h>

#include <lemon/assert.h>

namespace lemon {

  // GlpkBase members

  GlpkBase::GlpkBase() : LpBase() {

    lp = glp_create_prob();

    glp_create_index(lp);

  }

  GlpkBase::GlpkBase(const GlpkBase &other) : LpBase() {

    lp = glp_create_prob();

    glp_copy_prob(lp, other.lp, GLP_ON);

    glp_create_index(lp);

    rows = other.rows;

    cols = other.cols;

  }

  GlpkBase::~GlpkBase() {

    glp_delete_prob(lp);

  }

  int GlpkBase::_addCol() {

    int i = glp_add_cols(lp, 1);

    glp_set_col_bnds(lp, i, GLP_FR, 0.0, 0.0);

    return i;

  }

  void GlpkBase::_setObjCoeff(int i, Value obj_coef) {

    //i = 0 means the constant term (shift)

    glp_set_obj_coef(lp, i, obj_coef);

  }

  GlpkBase::Value GlpkBase::_getObjCoeff(int i) const {

    //i = 0 means the constant term (shift)

    return glp_get_obj_coef(lp, i);

  }

  void GlpkBase::_setSense(GlpkBase::Sense sense) {

    switch (sense) {

    case MIN:

      glp_set_obj_dir(lp, GLP_MIN);

      break;

    case MAX:

      glp_set_obj_dir(lp, GLP_MAX);

      break;

    }

  }

  GlpkBase::Sense GlpkBase::_getSense() const {

    switch(glp_get_obj_dir(lp)) {

    case GLP_MIN:

      return MIN;

    case GLP_MAX:

      return MAX;

    default:

      LEMON_ASSERT(false, "Wrong sense");

      return GlpkBase::Sense();

    }

  }

  void GlpkBase::_clear() {

    glp_erase_prob(lp);

    rows.clear();

    cols.clear();

  }

  void GlpkBase::freeEnv() {

    glp_free_env();

  }

  GlpkBase::FreeEnvHelper GlpkBase::freeEnvHelper;

  // GlpkLp members

  GlpkLp::GlpkLp()

    messageLevel(MESSAGE_NO_OUTPUT);

  }

  GlpkLp::GlpkLp(const GlpkLp& other)

    messageLevel(MESSAGE_NO_OUTPUT);

  }

  GlpkLp* GlpkLp::newSolver() const { return new GlpkLp; }

  GlpkLp* GlpkLp::cloneSolver() const { return new GlpkLp(*this); }

  const char* GlpkLp::_solverName() const { return "GlpkLp"; }

  void GlpkLp::_clear_temporals() {

    _primal_ray.clear();

    _dual_ray.clear();

  }

  GlpkLp::SolveExitStatus GlpkLp::_solve() {

    return solvePrimal();

  }