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

     lpx_create_index(lp);

     ///\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 ca[2];

     ca[1]=i;

     lpx_del_cols(lp, 1, ca);

   }

   void LpGlpk::_eraseRow(int i) {

     int ra[2];

     ra[1]=i;

     lpx_del_rows(lp, 1, ra);

   }

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

   {

     char *n = lpx_get_col_name(lp,c);

     name = n?n:"";

   }

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

   {

     lpx_set_col_name(lp,c,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 ix, RowIterator b) const

   {

     int length = lpx_get_mat_row(lp, ix, 0, 0);

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

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

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

     }

     lpx_set_mat_col(lp, ix, values.size() - 1, &indices[0], &values[0]);

   }

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

   {

     int length = lpx_get_mat_col(lp, ix, 0, 0);

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

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

     lpx_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 (lpx_get_num_cols(lp) < lpx_get_num_rows(lp)) {

       int length=lpx_get_mat_row(lp, ix, 0, 0);

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

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

       lpx_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;

       }

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

     } else {

       int length=lpx_get_mat_col(lp, jx, 0, 0);

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

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

       lpx_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]==jx){

           found=true;

           values[i]=value;

           break;

         }

       }

       if (!found){

         ++length;

         indices[length]=ix;

         values[length]=value;

       }

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

     }

   }

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

   {

     int length=lpx_get_mat_row(lp, ix, 0, 0);

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

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

     lpx_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=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