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

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2008

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

extern "C" {

#include <glpk.h>

}

#if GLP_MAJOR_VERSION > 4 || (GLP_MAJOR_VERSION == 4 && GLP_MINOR_VERSION > 15)

#define LEMON_glp(func) (glp_##func)

#define LEMON_lpx(func) (lpx_##func)

#define LEMON_GLP(def) (GLP_##def)

#define LEMON_LPX(def) (LPX_##def)

#else

#define LEMON_glp(func) (lpx_##func)

#define LEMON_lpx(func) (lpx_##func)

#define LEMON_GLP(def) (LPX_##def)

#define LEMON_LPX(def) (LPX_##def)

#endif

namespace lemon {

  LpGlpk::LpGlpk() : Parent() {

    solved = false;

    rows = _lp_bits::LpId(1);

    cols = _lp_bits::LpId(1);

    lp = LEMON_glp(create_prob)();

    LEMON_glp(create_index)(lp);

    messageLevel(0);

  }

  LpGlpk::LpGlpk(const LpGlpk &glp) : Parent() {

    solved = false;

    rows = _lp_bits::LpId(1);

    cols = _lp_bits::LpId(1);

    lp = LEMON_glp(create_prob)();

    LEMON_glp(create_index)(lp);

    messageLevel(0);

    //Coefficient matrix, row bounds

    LEMON_glp(add_rows)(lp, LEMON_glp(get_num_rows)(glp.lp));

    LEMON_glp(add_cols)(lp, LEMON_glp(get_num_cols)(glp.lp));

    int len;

    std::vector<int> ind(1+LEMON_glp(get_num_cols)(glp.lp));

    std::vector<Value> val(1+LEMON_glp(get_num_cols)(glp.lp));

    for (int i=1;i<=LEMON_glp(get_num_rows)(glp.lp);++i)

      {

        len=LEMON_glp(get_mat_row)(glp.lp,i,&*ind.begin(),&*val.begin());

        LEMON_glp(set_mat_row)(lp, i,len,&*ind.begin(),&*val.begin());

        LEMON_glp(set_row_bnds)(lp,i,

                                LEMON_glp(get_row_type)(glp.lp,i),

                                LEMON_glp(get_row_lb)(glp.lp,i),

                                LEMON_glp(get_row_ub)(glp.lp,i));

      }

    //Objective function, coloumn bounds

    LEMON_glp(set_obj_dir)(lp, LEMON_glp(get_obj_dir)(glp.lp));

    //Objectif function's constant term treated separately

    LEMON_glp(set_obj_coef)(lp,0,LEMON_glp(get_obj_coef)(glp.lp,0));

    for (int i=1;i<=LEMON_glp(get_num_cols)(glp.lp);++i)

      {

        LEMON_glp(set_obj_coef)(lp,i,

                                LEMON_glp(get_obj_coef)(glp.lp,i));

        LEMON_glp(set_col_bnds)(lp,i,

                                LEMON_glp(get_col_type)(glp.lp,i),

                                LEMON_glp(get_col_lb)(glp.lp,i),

                                LEMON_glp(get_col_ub)(glp.lp,i));

      }

    rows = glp.rows;

    cols = glp.cols;

  }

  LpGlpk::~LpGlpk() {

    LEMON_glp(delete_prob)(lp);

  }

  int LpGlpk::_addCol() {

    int i=LEMON_glp(add_cols)(lp, 1);

    LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(FR), 0.0, 0.0);

    solved = false;

    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=LEMON_glp(add_rows)(lp, 1);

    solved = false;

    return i;

  }

  void LpGlpk::_eraseCol(int i) {

    int ca[2];

    ca[1]=i;

    LEMON_glp(del_cols)(lp, 1, ca);

    solved = false;

  }

  void LpGlpk::_eraseRow(int i) {

    int ra[2];

    ra[1]=i;

    LEMON_glp(del_rows)(lp, 1, ra);

    solved = false;

  }

  void LpGlpk::_getColName(int c, std::string & name) const

  {

    const char *n = LEMON_glp(get_col_name)(lp,c);

    name = n?n:"";

  }

  void LpGlpk::_setColName(int c, const std::string & name)

  {

    LEMON_glp(set_col_name)(lp,c,const_cast<char*>(name.c_str()));

  }

  int LpGlpk::_colByName(const std::string& name) const

  {

    int k = LEMON_glp(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);

    }

    LEMON_glp(set_mat_row)(lp, i, values.size() - 1,

                                &indices[0], &values[0]);

    solved = false;

  }

  void LpGlpk::_getRowCoeffs(int ix, RowIterator b) const

  {

    int length = LEMON_glp(get_mat_row)(lp, ix, 0, 0);

    std::vector<int> indices(length + 1);

    std::vector<Value> values(length + 1);

    LEMON_glp(get_mat_row)(lp, ix, &indices[0], &values[0]);

    for (int i = 1; i <= length; ++i) {

      *b = std::make_pair(indices[i], values[i]);

      ++b;

    }

  }

  void LpGlpk::_setColCoeffs(int ix, 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);

    }

    LEMON_glp(set_mat_col)(lp, ix, values.size() - 1,

                                &indices[0], &values[0]);

    solved = false;

  }

  void LpGlpk::_getColCoeffs(int ix, ColIterator b) const

  {

    int length = LEMON_glp(get_mat_col)(lp, ix, 0, 0);

    std::vector<int> indices(length + 1);

    std::vector<Value> values(length + 1);

    LEMON_glp(get_mat_col)(lp, ix, &indices[0], &values[0]);

    for (int i = 1; i <= length; ++i) {

      *b = std::make_pair(indices[i], values[i]);

      ++b;

    }

  }

  void LpGlpk::_setCoeff(int ix, int jx, Value value)

  {

    if (LEMON_glp(get_num_cols)(lp) < LEMON_glp(get_num_rows)(lp)) {

      int length=LEMON_glp(get_mat_row)(lp, ix, 0, 0);

      std::vector<int> indices(length + 2);

      std::vector<Value> values(length + 2);

      LEMON_glp(get_mat_row)(lp, ix, &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]==jx){

          found=true;

          values[i]=value;

          break;

        }

      }

      if (!found){

        ++length;

        indices[length]=jx;

        values[length]=value;

      }

      LEMON_glp(set_mat_row)(lp, ix, length, &indices[0], &values[0]);

    } else {

      int length=LEMON_glp(get_mat_col)(lp, jx, 0, 0);

      std::vector<int> indices(length + 2);

      std::vector<Value> values(length + 2);

      LEMON_glp(get_mat_col)(lp, jx, &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]==ix){

          found=true;

          values[i]=value;

          break;

        }

      }

      if (!found){

        ++length;

        indices[length]=ix;

        values[length]=value;

      }

      LEMON_glp(set_mat_col)(lp, jx, length, &indices[0], &values[0]);

    }

    solved = false;

  }

  LpGlpk::Value LpGlpk::_getCoeff(int ix, int jx) const

  {

    int length=LEMON_glp(get_mat_row)(lp, ix, 0, 0);

    std::vector<int> indices(length + 1);

    std::vector<Value> values(length + 1);

    LEMON_glp(get_mat_row)(lp, ix, &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]==jx){

        return values[i];

      }

    }

    return 0;

  }

  void LpGlpk::_setColLowerBound(int i, Value lo)

  {

    if (lo==INF) {

      //FIXME error

    }

    int b=LEMON_glp(get_col_type)(lp, i);

    double up=LEMON_glp(get_col_ub)(lp, i);

    if (lo==-INF) {

      switch (b) {

      case LEMON_GLP(FR):

      case LEMON_GLP(LO):

        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(FR), lo, up);

        break;

      case LEMON_GLP(UP):

        break;

      case LEMON_GLP(DB):

      case LEMON_GLP(FX):

        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(UP), lo, up);

        break;

      default: ;

        //FIXME error

      }

    } else {

      switch (b) {

      case LEMON_GLP(FR):

      case LEMON_GLP(LO):

        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(LO), lo, up);

        break;

      case LEMON_GLP(UP):

      case LEMON_GLP(DB):

      case LEMON_GLP(FX):

        if (lo==up)

          LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(FX), lo, up);

        else

          LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(DB), lo, up);

        break;

      default: ;

        //FIXME error

      }

    }

    solved = false;

  }

  LpGlpk::Value LpGlpk::_getColLowerBound(int i) const

  {

    int b=LEMON_glp(get_col_type)(lp, i);

      switch (b) {

      case LEMON_GLP(LO):

      case LEMON_GLP(DB):

      case LEMON_GLP(FX):

        return LEMON_glp(get_col_lb)(lp, i);

      default: ;

        return -INF;

      }

  }

  void LpGlpk::_setColUpperBound(int i, Value up)

  {

    if (up==-INF) {

      //FIXME error

    }

    int b=LEMON_glp(get_col_type)(lp, i);

    double lo=LEMON_glp(get_col_lb)(lp, i);

    if (up==INF) {

      switch (b) {

      case LEMON_GLP(FR):

      case LEMON_GLP(LO):

        break;

      case LEMON_GLP(UP):

        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(FR), lo, up);

        break;

      case LEMON_GLP(DB):

      case LEMON_GLP(FX):

        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(LO), lo, up);

        break;

      default: ;

        //FIXME error

      }

    } else {

      switch (b) {

      case LEMON_GLP(FR):

        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(UP), lo, up);

        break;

      case LEMON_GLP(UP):

        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(UP), lo, up);

        break;

      case LEMON_GLP(LO):

      case LEMON_GLP(DB):

      case LEMON_GLP(FX):

        if (lo==up)

          LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(FX), lo, up);

        else

          LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(DB), lo, up);

        break;

      default: ;

        //FIXME error

      }

    }

    solved = false;

  }

  LpGlpk::Value LpGlpk::_getColUpperBound(int i) const

  {

    int b=LEMON_glp(get_col_type)(lp, i);

      switch (b) {

      case LEMON_GLP(UP):

      case LEMON_GLP(DB):

      case LEMON_GLP(FX):

        return LEMON_glp(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){

        LEMON_glp(set_row_bnds)(lp, i, LEMON_GLP(FR), lb, ub);

      }

      else{

        LEMON_glp(set_row_bnds)(lp, i, LEMON_GLP(UP), lb, ub);

      }

    }

    else{

      if (ub==INF){

        LEMON_glp(set_row_bnds)(lp, i, LEMON_GLP(LO), lb, ub);

      }

      else{

        if (lb == ub){

          LEMON_glp(set_row_bnds)(lp, i, LEMON_GLP(FX), lb, ub);

        }

        else{

          LEMON_glp(set_row_bnds)(lp, i, LEMON_GLP(DB), lb, ub);

        }

      }

    }

    solved = false;

  }

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

  {

    int b=LEMON_glp(get_row_type)(lp, i);

    switch (b) {

    case LEMON_GLP(FR):

    case LEMON_GLP(UP):

      lb = -INF;

        break;

    default:

      lb=LEMON_glp(get_row_lb)(lp, i);

    }

    switch (b) {

    case LEMON_GLP(FR):

    case LEMON_GLP(LO):

      ub = INF;

        break;

    default:

      ub=LEMON_glp(get_row_ub)(lp, i);

    }

  }

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

  {

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

    LEMON_glp(set_obj_coef)(lp, i, obj_coef);

    solved = false;

  }

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

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

    return LEMON_glp(get_obj_coef)(lp, i);

  }

  void LpGlpk::_clearObj()

  {

    for (int i=0;i<=LEMON_glp(get_num_cols)(lp);++i){

      LEMON_glp(set_obj_coef)(lp, i, 0);

    }

    solved = false;

  }

  LpGlpk::SolveExitStatus LpGlpk::_solve()

  {

    // A way to check the problem to be solved

    //LEMON_glp(write_cpxlp(lp,"naittvan.cpx");

    LEMON_lpx(std_basis)(lp);

    int i =  LEMON_lpx(simplex)(lp);

    switch (i) {

    case LEMON_LPX(E_OK):

      solved = true;

      return SOLVED;

    default:

      return UNSOLVED;

    }

  }

  LpGlpk::Value LpGlpk::_getPrimal(int i) const

  {

    return LEMON_glp(get_col_prim)(lp,i);

  }

  LpGlpk::Value LpGlpk::_getDual(int i) const

  {

    return LEMON_glp(get_row_dual)(lp,i);

  }

  LpGlpk::Value LpGlpk::_getPrimalValue() const

  {

    return LEMON_glp(get_obj_val)(lp);

  }

  bool LpGlpk::_isBasicCol(int i) const

  {

    return (LEMON_glp(get_col_stat)(lp, i)==LEMON_GLP(BS));

  }

  LpGlpk::SolutionStatus LpGlpk::_getPrimalStatus() const

  {

    if (!solved) return UNDEFINED;

    int stat=  LEMON_lpx(get_status)(lp);

    switch (stat) {

    case LEMON_LPX(UNDEF)://Undefined (no solve has been run yet)

      return UNDEFINED;

    case LEMON_LPX(NOFEAS)://There is no feasible solution (primal, I guess)

    case LEMON_LPX(INFEAS)://Infeasible

      return INFEASIBLE;

    case LEMON_LPX(UNBND)://Unbounded

      return INFINITE;

    case LEMON_LPX(FEAS)://Feasible

      return FEASIBLE;

    case LEMON_LPX(OPT)://Feasible

      return OPTIMAL;

    default:

      return UNDEFINED; //to avoid gcc warning

      //FIXME error

    }

  }

  LpGlpk::SolutionStatus LpGlpk::_getDualStatus() const

  {

    if (!solved) return UNDEFINED;

    switch (LEMON_lpx(get_dual_stat)(lp)) {

    case LEMON_LPX(D_UNDEF)://Undefined (no solve has been run yet)

      return UNDEFINED;

    case LEMON_LPX(D_NOFEAS)://There is no dual feasible solution

//    case LEMON_LPX(D_INFEAS://Infeasible

      return INFEASIBLE;

    case LEMON_LPX(D_FEAS)://Feasible

      switch (LEMON_lpx(get_status)(lp)) {

      case LEMON_LPX(NOFEAS):

        return INFINITE;

      case LEMON_LPX(OPT):

        return OPTIMAL;

      default:

        return FEASIBLE;

      }

    default:

      return UNDEFINED; //to avoid gcc warning

      //FIXME error

    }

  }

  LpGlpk::ProblemTypes LpGlpk::_getProblemType() const

  {

    if (!solved) return UNKNOWN;

      //int stat=  LEMON_glp(get_status(lp);

    int statp=  LEMON_lpx(get_prim_stat)(lp);

    int statd=  LEMON_lpx(get_dual_stat)(lp);

    if (statp==LEMON_LPX(P_FEAS) && statd==LEMON_LPX(D_FEAS))

        return PRIMAL_DUAL_FEASIBLE;

    if (statp==LEMON_LPX(P_FEAS) && statd==LEMON_LPX(D_NOFEAS))

        return PRIMAL_FEASIBLE_DUAL_INFEASIBLE;

    if (statp==LEMON_LPX(P_NOFEAS) && statd==LEMON_LPX(D_FEAS))

        return PRIMAL_INFEASIBLE_DUAL_FEASIBLE;

    if (statp==LEMON_LPX(P_NOFEAS) && statd==LEMON_LPX(D_NOFEAS))

        return PRIMAL_DUAL_INFEASIBLE;

    //In all other cases

    return UNKNOWN;

  }

  void LpGlpk::_setMax()

  {

    solved = false;

    LEMON_glp(set_obj_dir)(lp, LEMON_GLP(MAX));

  }

  void LpGlpk::_setMin()

  {

    solved = false;

    LEMON_glp(set_obj_dir)(lp, LEMON_GLP(MIN));

  }

  bool LpGlpk::_isMax() const

  {

    return (LEMON_glp(get_obj_dir)(lp)==LEMON_GLP(MAX));

  }

  void LpGlpk::messageLevel(int m)

  {

    LEMON_lpx(set_int_parm)(lp, LEMON_LPX(K_MSGLEV), m);

  }

  void LpGlpk::presolver(bool b)

  {

    LEMON_lpx(set_int_parm)(lp, LEMON_LPX(K_PRESOL), b);

  }

} //END OF NAMESPACE LEMON