RhodeCode

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

}

  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.

    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;

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

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

      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();

  }

  GlpkLp::SolveExitStatus GlpkLp::solvePrimal() {

    _clear_temporals();

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    switch (_message_level) {

      if (glp_get_prim_stat(lp) == GLP_NOFEAS) {

        return UNBOUNDED;

      } else {

        return UNDEFINED;

      }

    case GLP_NOFEAS:

      return INFEASIBLE;

    default:

      LEMON_ASSERT(false, "Wrong primal type");

      return  GlpkLp::ProblemType();

    }

  }

  void GlpkLp::presolver(bool b) {

    lpx_set_int_parm(lp, LPX_K_PRESOL, b ? 1 : 0);

  }

  void GlpkLp::messageLevel(MessageLevel m) {

    _message_level = m;

  }

  // GlpkMip members

  GlpkMip::GlpkMip()

    messageLevel(MESSAGE_NO_OUTPUT);

  }

  GlpkMip::GlpkMip(const GlpkMip& other)

    messageLevel(MESSAGE_NO_OUTPUT);

  }

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

    switch (col_type) {

    case INTEGER:

      glp_set_col_kind(lp, i, GLP_IV);

      break;

    case REAL:

      glp_set_col_kind(lp, i, GLP_CV);

      break;

    }

  }

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

    switch (glp_get_col_kind(lp, i)) {

    case GLP_IV:

    case GLP_BV:

      return INTEGER;

    default:

      return REAL;

    }

  }

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

#include <lemon/lp_skeleton.h>

#include "test_tools.h"

#include <lemon/tolerance.h>

#ifdef HAVE_CONFIG_H

#include <lemon/config.h>

#endif

#ifdef HAVE_GLPK

#include <lemon/glpk.h>

  delete lp;

  delete lpnew;

  delete lpclone;

}

int main()

{

  LpSkeleton lp_skel;

  lpTest(lp_skel);

#ifdef HAVE_GLPK

  {

    GlpkLp lp_glpk1,lp_glpk2;

    lpTest(lp_glpk1);

    aTest(lp_glpk2);

    cloneTest<GlpkLp>();

  }

#endif

#ifdef HAVE_CPLEX

  try {

    CplexLp lp_cplex1,lp_cplex2;

    lpTest(lp_cplex1);

    aTest(lp_cplex2);

  } catch (CplexEnv::LicenseError& error) {

#ifdef LEMON_FORCE_CPLEX_CHECK

    check(false, error.what());

#else

    std::cerr << error.what() << std::endl;

    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;

#endif

  }

#endif

#ifdef HAVE_SOPLEX

  {

    SoplexLp lp_soplex1,lp_soplex2;

    lpTest(lp_soplex1);

    aTest(lp_soplex2);

    cloneTest<SoplexLp>();

  }

#endif

#ifdef HAVE_CLP

  {

    ClpLp lp_clp1,lp_clp2;

    lpTest(lp_clp1);

    aTest(lp_clp2);

    cloneTest<ClpLp>();

  }

#endif

  return 0;

}

/* -*- 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 "test_tools.h"

#ifdef HAVE_CONFIG_H

#include <lemon/config.h>

#endif

#ifdef HAVE_CPLEX

#include <lemon/cplex.h>

#endif

  MIP* mip = new MIP();

  MIP* mipnew = mip->newSolver();

  MIP* mipclone = mip->cloneSolver();

  delete mip;

  delete mipnew;

  delete mipclone;

}

int main()

{

#ifdef HAVE_GLPK

  {

    GlpkMip mip1;

    aTest(mip1);

    cloneTest<GlpkMip>();

  }

#endif

#ifdef HAVE_CPLEX

  try {

    CplexMip mip2;

    aTest(mip2);

  } catch (CplexEnv::LicenseError& error) {

#ifdef LEMON_FORCE_CPLEX_CHECK

    check(false, error.what());

#else

    std::cerr << error.what() << std::endl;

    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;

#endif

  }

#endif

  return 0;

}