source: lemon-0.x/lemon/lp_glpk.cc @ 2366:bfbdded3763a

/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2006
 * 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 solver interface.

#include <lemon/lp_glpk.h>
//#include <iostream>
namespace lemon {


  LpGlpk::LpGlpk() : Parent() {
    rows = _lp_bits::LpId(1);
    cols = _lp_bits::LpId(1);
    lp = lpx_create_prob();
    ///\todo control function for this:
    lpx_set_int_parm(lp, LPX_K_DUAL, 1);
    messageLevel(0);
  }
  
  LpGlpk::LpGlpk(const LpGlpk &glp) : Parent() {
    rows = _lp_bits::LpId(1);
    cols = _lp_bits::LpId(1);
    lp = lpx_create_prob();
    lpx_create_index(lp);
    ///\todo control function for this:
    lpx_set_int_parm(lp, LPX_K_DUAL, 1);
    messageLevel(0);
    //Coefficient matrix, row bounds
    lpx_add_rows(lp, lpx_get_num_rows(glp.lp));
    lpx_add_cols(lp, lpx_get_num_cols(glp.lp));
    int len;
    int ind[1+lpx_get_num_cols(glp.lp)];
    Value val[1+lpx_get_num_cols(glp.lp)];
    for (int i=1;i<=lpx_get_num_rows(glp.lp);++i)
      {
        len=lpx_get_mat_row(glp.lp,i,ind,val);
        lpx_set_mat_row(lp, i,len,ind,val);
        lpx_set_row_bnds(lp,i,lpx_get_row_type(glp.lp,i),
                         lpx_get_row_lb(glp.lp,i),lpx_get_row_ub(glp.lp,i));
      }

    //Objective function, coloumn bounds
    lpx_set_obj_dir(lp, lpx_get_obj_dir(glp.lp));
    //Objectif function's constant term treated separately
    lpx_set_obj_coef(lp,0,lpx_get_obj_coef(glp.lp,0));
    for (int i=1;i<=lpx_get_num_cols(glp.lp);++i)
      {
        lpx_set_obj_coef(lp,i,lpx_get_obj_coef(glp.lp,i));
        lpx_set_col_bnds(lp,i,lpx_get_col_type(glp.lp,i),
                         lpx_get_col_lb(glp.lp,i),lpx_get_col_ub(glp.lp,i));
      }
  }
  
  LpGlpk::~LpGlpk() {
    lpx_delete_prob(lp);
  }
  
  int LpGlpk::_addCol() { 
    int i=lpx_add_cols(lp, 1);
    _setColLowerBound(i, -INF);
    _setColUpperBound(i, INF);
    return i;
  }

  ///\e


  LpSolverBase &LpGlpk::_newLp()
  {
    LpGlpk* newlp=new LpGlpk;
    return *newlp;
  }
  
  ///\e

  LpSolverBase &LpGlpk::_copyLp()
  {
    LpGlpk* newlp=new LpGlpk(*this);
    return *newlp;
  }

  int LpGlpk::_addRow() { 
    int i=lpx_add_rows(lp, 1);
    return i;
  }

  
  void LpGlpk::_eraseCol(int i) {
    int cols[2];
    cols[1]=i;
    lpx_del_cols(lp, 1, cols);
  }
  
  void LpGlpk::_eraseRow(int i) {
    int rows[2];
    rows[1]=i;
    lpx_del_rows(lp, 1, rows);
  }

  void LpGlpk::_getColName(int col, std::string & name) const
  {
    
    char *n = lpx_get_col_name(lp,col);
    name = n?n:"";
  }
  
  
  void LpGlpk::_setColName(int col, const std::string & name)
  {
    lpx_set_col_name(lp,col,const_cast<char*>(name.c_str()));

  }

  int LpGlpk::_colByName(const std::string& name) const
  {
    int k = lpx_find_col(lp, const_cast<char*>(name.c_str()));
    return k > 0 ? k : -1; 
  }

  
  void LpGlpk::_setRowCoeffs(int i, ConstRowIterator b, ConstRowIterator e) 
  {
    std::vector<int> indices;
    std::vector<Value> values;

    indices.push_back(0);
    values.push_back(0);

    for(ConstRowIterator it=b; it!=e; ++it) {
      indices.push_back(it->first);
      values.push_back(it->second);
    }

    lpx_set_mat_row(lp, i, values.size() - 1, &indices[0], &values[0]);
  }

  void LpGlpk::_getRowCoeffs(int i, RowIterator b) const
  {
    int length = lpx_get_mat_row(lp, i, 0, 0);
    
    std::vector<int> indices(length + 1);
    std::vector<Value> values(length + 1);
    
    lpx_get_mat_row(lp, i, &indices[0], &values[0]);
    
    for (int i = 1; i <= length; ++i) {
      *b = std::make_pair(indices[i], values[i]);
      ++b;
    }
  }
  
  void LpGlpk::_setColCoeffs(int i, ConstColIterator b, ConstColIterator e) {

    std::vector<int> indices;
    std::vector<Value> values;

    indices.push_back(0);
    values.push_back(0);

    for(ConstColIterator it=b; it!=e; ++it) {
      indices.push_back(it->first);
      values.push_back(it->second);
    }
    
    lpx_set_mat_col(lp, i, values.size() - 1, &indices[0], &values[0]);
  }

  void LpGlpk::_getColCoeffs(int i, ColIterator b) const
  {
    int length = lpx_get_mat_col(lp, i, 0, 0);
    
    std::vector<int> indices(length + 1);
    std::vector<Value> values(length + 1);
    
    lpx_get_mat_col(lp, i, &indices[0], &values[0]);
    
    for (int i = 1; i <= length; ++i) {
      *b = std::make_pair(indices[i], values[i]);
      ++b;
    }
  }

  void LpGlpk::_setCoeff(int row, int col, Value value) 
  {

    if (lpx_get_num_cols(lp) < lpx_get_num_rows(lp)) {

      int length=lpx_get_mat_row(lp, row, 0, 0);
      
      std::vector<int> indices(length + 2);
      std::vector<Value> values(length + 2);
      
      lpx_get_mat_row(lp, row, &indices[0], &values[0]);
      
      //The following code does not suppose that the elements of the
      //array indices are sorted
      bool found=false;
      for (int i = 1; i <= length; ++i) {
        if (indices[i]==col){
          found=true;
          values[i]=value;
          break;
        }
      }
      if (!found){
        ++length;
        indices[length]=col;
        values[length]=value;
      }
    
      lpx_set_mat_row(lp, row, length, &indices[0], &values[0]);

    } else {

      int length=lpx_get_mat_col(lp, col, 0, 0);
      
      std::vector<int> indices(length + 2);
      std::vector<Value> values(length + 2);
      
      lpx_get_mat_col(lp, col, &indices[0], &values[0]);
      
      //The following code does not suppose that the elements of the
      //array indices are sorted
      bool found=false;
      for (int i = 1; i <= length; ++i) {
        if (indices[i]==col){
          found=true;
          values[i]=value;
          break;
        }
      }
      if (!found){
        ++length;
        indices[length]=row;
        values[length]=value;
      }
    
      lpx_set_mat_col(lp, col, length, &indices[0], &values[0]);
    }
  }

  LpGlpk::Value LpGlpk::_getCoeff(int row, int col) const
  {

    int length=lpx_get_mat_row(lp, row, 0, 0);
    
    std::vector<int> indices(length + 1);
    std::vector<Value> values(length + 1);
    
    lpx_get_mat_row(lp, row, &indices[0], &values[0]);
    
    //The following code does not suppose that the elements of the
    //array indices are sorted
    for (int i = 1; i <= length; ++i) {
      if (indices[i]==col){
        return values[i];
      }
    }
    return 0;

  }


  void LpGlpk::_setColLowerBound(int i, Value lo)
  {
    if (lo==INF) {
      //FIXME error
    }
    int b=lpx_get_col_type(lp, i);
    double up=lpx_get_col_ub(lp, i);    
    if (lo==-INF) {
      switch (b) {
      case LPX_FR:
      case LPX_LO:
        lpx_set_col_bnds(lp, i, LPX_FR, lo, up);
        break;
      case LPX_UP:
        break;
      case LPX_DB:
      case LPX_FX:
        lpx_set_col_bnds(lp, i, LPX_UP, lo, up);
        break;
      default: ;
        //FIXME error
      }
    } else {
      switch (b) {
      case LPX_FR:
      case LPX_LO:
        lpx_set_col_bnds(lp, i, LPX_LO, lo, up);
        break;
      case LPX_UP:        
      case LPX_DB:
      case LPX_FX:
        if (lo==up) 
          lpx_set_col_bnds(lp, i, LPX_FX, lo, up);
        else 
          lpx_set_col_bnds(lp, i, LPX_DB, lo, up);
        break;
      default: ;
        //FIXME error
      }
    }

  }

  LpGlpk::Value LpGlpk::_getColLowerBound(int i) const
  {
    int b=lpx_get_col_type(lp, i);
      switch (b) {
      case LPX_LO:
      case LPX_DB:
      case LPX_FX:
        return lpx_get_col_lb(lp, i);   
      default: ;
        return -INF;
      }
  }
  
  void LpGlpk::_setColUpperBound(int i, Value up)
  {
    if (up==-INF) {
      //FIXME error
    }
    int b=lpx_get_col_type(lp, i);
    double lo=lpx_get_col_lb(lp, i);
    if (up==INF) {
      switch (b) {
      case LPX_FR:
      case LPX_LO:
        break;
      case LPX_UP:
        lpx_set_col_bnds(lp, i, LPX_FR, lo, up);
        break;
      case LPX_DB:
      case LPX_FX:
        lpx_set_col_bnds(lp, i, LPX_LO, lo, up);
        break;
      default: ;
        //FIXME error
      }
    } else {
      switch (b) {
      case LPX_FR:
        lpx_set_col_bnds(lp, i, LPX_UP, lo, up);
        break;
      case LPX_UP:
        lpx_set_col_bnds(lp, i, LPX_UP, lo, up);
        break;
      case LPX_LO:
      case LPX_DB:
      case LPX_FX:
        if (lo==up) 
          lpx_set_col_bnds(lp, i, LPX_FX, lo, up);
        else 
          lpx_set_col_bnds(lp, i, LPX_DB, lo, up);
        break;
      default: ;
        //FIXME error
      }
    }
  }

  LpGlpk::Value LpGlpk::_getColUpperBound(int i) const
  {
    int b=lpx_get_col_type(lp, i);
      switch (b) {
      case LPX_UP:
      case LPX_DB:
      case LPX_FX:
        return lpx_get_col_ub(lp, i);   
      default: ;
        return INF;
      }
  }
  
  void LpGlpk::_setRowBounds(int i, Value lb, Value ub)
  {
    //Bad parameter
    if (lb==INF || ub==-INF) {
      //FIXME error
    }

    if (lb == -INF){
      if (ub == INF){
        lpx_set_row_bnds(lp, i, LPX_FR, lb, ub);
      }
      else{
        lpx_set_row_bnds(lp, i, LPX_UP, lb, ub);
      }
    }
    else{
      if (ub==INF){
        lpx_set_row_bnds(lp, i, LPX_LO, lb, ub);

      }
      else{
        if (lb == ub){
          lpx_set_row_bnds(lp, i, LPX_FX, lb, ub);
        }
        else{
          lpx_set_row_bnds(lp, i, LPX_DB, lb, ub);
        }
      }
    }

  }

  void LpGlpk::_getRowBounds(int i, Value &lb, Value &ub) const
  {

    int b=lpx_get_row_type(lp, i);
    switch (b) {
    case LPX_FR:
    case LPX_UP:
      lb = -INF;
        break;
    default: 
      lb=lpx_get_row_lb(lp, i);
    }

    switch (b) {
    case LPX_FR:
    case LPX_LO:
      ub = INF;
        break;
    default: 
      ub=lpx_get_row_ub(lp, i);
    }
    
  }
  
  void LpGlpk::_setObjCoeff(int i, Value obj_coef)
  {
    //i=0 means the constant term (shift)
    lpx_set_obj_coef(lp, i, obj_coef);
  }

  LpGlpk::Value LpGlpk::_getObjCoeff(int i) const {
    //i=0 means the constant term (shift)
    return lpx_get_obj_coef(lp, i);
  }

  void LpGlpk::_clearObj()
  {
    for (int i=0;i<=lpx_get_num_cols(lp);++i){
      lpx_set_obj_coef(lp, i, 0);
    }
  }

  LpGlpk::SolveExitStatus LpGlpk::_solve()
  {
    // A way to check the problem to be solved
    //lpx_write_cpxlp(lp,"naittvan.cpx");    

    lpx_std_basis(lp);
    int i =  lpx_simplex(lp);
    
    switch (i) {
    case LPX_E_OK: 
      return SOLVED;
    default:
      return UNSOLVED;
    }
  }

  LpGlpk::Value LpGlpk::_getPrimal(int i) const
  {
    return lpx_get_col_prim(lp,i);
  }

  LpGlpk::Value LpGlpk::_getDual(int i) const
  {
    return lpx_get_row_dual(lp,i);
  }
  
  LpGlpk::Value LpGlpk::_getPrimalValue() const
  {
    return lpx_get_obj_val(lp);
  }
  bool LpGlpk::_isBasicCol(int i) const
  {
    return (lpx_get_col_stat(lp, i)==LPX_BS);
  }
  
 
  LpGlpk::SolutionStatus LpGlpk::_getPrimalStatus() const
  {
    int stat=  lpx_get_status(lp);
    switch (stat) {
    case LPX_UNDEF://Undefined (no solve has been run yet)
      return UNDEFINED;
    case LPX_NOFEAS://There is no feasible solution (primal, I guess)
    case LPX_INFEAS://Infeasible 
      return INFEASIBLE;
    case LPX_UNBND://Unbounded
      return INFINITE;
    case LPX_FEAS://Feasible
      return FEASIBLE;
    case LPX_OPT://Feasible
      return OPTIMAL;
    default:
      return UNDEFINED; //to avoid gcc warning
      //FIXME error
    }
  }

  LpGlpk::SolutionStatus LpGlpk::_getDualStatus() const
  {
    switch (lpx_get_dual_stat(lp)) {
    case LPX_D_UNDEF://Undefined (no solve has been run yet)
      return UNDEFINED;
    case LPX_D_NOFEAS://There is no dual feasible solution 
//    case LPX_D_INFEAS://Infeasible 
      return INFEASIBLE;
    case LPX_D_FEAS://Feasible    
      switch (lpx_get_status(lp)) {
      case LPX_NOFEAS:
        return INFINITE;
      case LPX_OPT:
        return OPTIMAL;
      default:
        return FEASIBLE;
      }
    default:
      return UNDEFINED; //to avoid gcc warning
      //FIXME error
    }
  }

  LpGlpk::ProblemTypes LpGlpk::_getProblemType() const
  {
      //int stat=  lpx_get_status(lp);
    int statp=  lpx_get_prim_stat(lp);
    int statd=  lpx_get_dual_stat(lp);
    if (statp==LPX_P_FEAS && statd==LPX_D_FEAS)
        return PRIMAL_DUAL_FEASIBLE;
    if (statp==LPX_P_FEAS && statd==LPX_D_NOFEAS)
        return PRIMAL_FEASIBLE_DUAL_INFEASIBLE;
    if (statp==LPX_P_NOFEAS && statd==LPX_D_FEAS)
        return PRIMAL_INFEASIBLE_DUAL_FEASIBLE;
    if (statp==LPX_P_NOFEAS && statd==LPX_D_NOFEAS)
        return PRIMAL_DUAL_INFEASIBLE;
    //In all other cases
    return UNKNOWN;
  }

  void LpGlpk::_setMax()
  {
    lpx_set_obj_dir(lp, LPX_MAX);
  }

  void LpGlpk::_setMin()
  {
    lpx_set_obj_dir(lp, LPX_MIN);
  }

  bool LpGlpk::_isMax() const
  {
    return (lpx_get_obj_dir(lp)==LPX_MAX);
  }

 

  void LpGlpk::messageLevel(int m)
  {
    lpx_set_int_parm(lp, LPX_K_MSGLEV, m);
  }

  void LpGlpk::presolver(bool b)
  {
    lpx_set_int_parm(lp, LPX_K_PRESOL, b);
  }

 
} //END OF NAMESPACE LEMON