/* -*- C++ -*-

  * src/lemon/lp_cplex.cc

  * - Part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2005 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"lp_cplex.h"

 ///\file

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

 namespace lemon {

   LpCplex::LpCplex() : LpSolverBase() {

     env = NULL;

     lp = NULL;

     env = CPXopenCPLEXdevelop(&status);     

 //     if (Env == NULL)

 //     {

 //          fprintf(stderr,"A CPLEX környezet megnyitása sikertelen.\n");

 // 	 CPXgeterrorstring(Env, Status, ErrorMsg);

 // 	 fprintf(stderr,"%s",ErrorMsg);

 // 	 goto Terminate;

 //     }

     // *** A problema létrehozása ***

     lp = CPXcreateprob(env, &status, "LP problem");

     //    if (Problem == NULL)

 //     {

 // 	fprintf(stderr,"Az LP létrehozása sikertelen");

 // 	goto Terminate;

 //     }

   }

   LpCplex::~LpCplex() {

     status = CPXfreeprob(env,&lp); 

     //       if (Status != 0)

     // 	{

 // 	  fprintf(stderr,"A CPLEX feladat törlése sikertelen.\n");

 // 	  CPXgeterrorstring(Env, Status, ErrorMsg);

 // 	  fprintf(stderr,"%s",ErrorMsg);

 // 	  goto Terminate;

 // 	}

     status = CPXcloseCPLEX(&env); 

     //       if (Status != 0)

     // 	{

     // 	  fprintf(stderr,"A CPLEX környezet bezárása sikertelen.\n");

 // 	  CPXgeterrorstring(Env, Status, ErrorMsg);

 // 	  fprintf(stderr,"%s",ErrorMsg);

 // 	  goto Terminate;

 // 	}

   }

   LpSolverBase &LpCplex::_newLp() {return *(LpSolverBase*)0;}

   LpSolverBase &LpCplex::_copyLp() {return *(LpSolverBase*)0;}

   int LpCplex::_addCol()

   {

     int i = CPXgetnumcols (env, lp);

     Value lb[1],ub[1];

     lb[0]=-INF;//-CPX_INFBOUND;

     ub[0]=INF;//CPX_INFBOUND;

     status = CPXnewcols (env, lp, 1, NULL, lb, ub, NULL, NULL);

     return i;

   }

   int LpCplex::_addRow() 

   {

     //We want a row that is not constrained

     char sense[1];

     sense[0]='L';//<= constraint

     Value rhs[1];

     rhs[0]=INF;

     int i = CPXgetnumrows (env, lp);

     status = CPXnewrows (env, lp, 1, rhs, sense, NULL, NULL);

     return i;

   }

   ///\warning Data at index 0 is ignored in the arrays.

   void LpCplex::_setRowCoeffs(int i, 

 			      int length,

 			      int  const * indices, 

 			      Value  const * values )

   {

     int rowlist[length+1];

     int* p=rowlist;

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

       rowlist[k]=i;

     }

     status = CPXchgcoeflist(env, lp, 

 			    length, 

 			    p+1, 

 			    const_cast<int * >(indices+1), 

 			    const_cast<Value * >(values+1));

   }

   void LpCplex::_setColCoeffs(int i, 

 			      int length,

 			      int  const * indices, 

 			      Value  const * values)

   {

     int collist[length+1];

     int* p=collist;

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

       collist[k]=i;

     }

     status = CPXchgcoeflist(env, lp, 

 			    length, 

 			    const_cast<int * >(indices+1), 

 			    p+1, 

 			    const_cast<Value * >(values+1));

   }

   void LpCplex::_setColLowerBound(int i, Value value)

   {

     int indices[1];

     indices[0]=i;

     char lu[1];

     lu[0]='L';

     Value bd[1];

     bd[0]=value;

     status = CPXchgbds (env, lp, 1, indices, lu, bd);

   }

   void LpCplex::_setColUpperBound(int i, Value value)

   {

     int indices[1];

     indices[0]=i;

     char lu[1];

     lu[0]='U';

     Value bd[1];

     bd[0]=value;

     status = CPXchgbds (env, lp, 1, indices, lu, bd);

   }

   //This will be easier to implement

   void LpCplex::_setRowBounds(int i, Value lb, Value ub)

   {

     //Bad parameter

     if (lb==INF || ub==-INF) {

       //FIXME error

     }

     int cnt=1;

     int indices[1];

     indices[0]=i;

     char sense[1];

     if (lb==-INF){

       sense[0]='L';

       CPXchgsense (env, lp, cnt, indices, sense);

       CPXchgcoef (env, lp, i, -1, ub);

     }

     else{

       if (ub==INF){

 	sense[0]='G';

 	CPXchgsense (env, lp, cnt, indices, sense);

 	CPXchgcoef (env, lp, i, -1, lb);

       }

       else{

 	if (lb == ub){

 	  sense[0]='E';

 	  CPXchgsense (env, lp, cnt, indices, sense);

 	  CPXchgcoef (env, lp, i, -1, lb);

 	}

 	else{

 	  sense[0]='R';

 	  CPXchgsense (env, lp, cnt, indices, sense);

 	  CPXchgcoef (env, lp, i, -1, lb);

 	  CPXchgcoef (env, lp, i, -2, ub-lb);	  

 	}

       }

     }

   }

   void LpCplex::_setRowLowerBound(int i, Value value)

   {

     //Not implemented, obsolete

   }

   void LpCplex::_setRowUpperBound(int i, Value value)

   {

     //Not implemented, obsolete

 //     //TODO Ezt kell meg megirni

 //     //type of the problem

 //     char sense[1];

 //     status = CPXgetsense (env, lp, sense, i, i);

 //     Value rhs[1];

 //     status = CPXgetrhs (env, lp, rhs, i, i);

 //     switch (sense[0]) {

 //     case 'L'://<= constraint

 //       break;

 //     case 'E'://= constraint

 //       break;

 //     case 'G'://>= constraint

 //       break;

 //     case 'R'://ranged constraint

 //       break;

 //     default: ;

 //       //FIXME error

 //     }

 //     status = CPXchgcoef (env, lp, i, -2, value_rng);

   }

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

   {

     CPXchgcoef (env, lp, -1, i, obj_coef);

   }

   void LpCplex::_clearObj()

   {

     for (int i=0;i< CPXgetnumcols (env, lp);++i){

       CPXchgcoef (env, lp, -1, i, 0);

     }

   }

   LpCplex::SolveExitStatus LpCplex::_solve()

   {

     status = CPXlpopt (env, lp);

     if (status == 0){

       return SOLVED;

     }

     else{

       return UNSOLVED;

     }

 //     int i=  lpx_simplex(lp);

 //     switch (i) {

 //     case LPX_E_OK: 

 //       return SOLVED;

 //       break;

 //     default:

 //       return UNSOLVED;

 //     }

   }

   LpCplex::SolutionStatus LpCplex::_getPrimalStatus()

   {

     //Unimplemented

     return OPTIMAL;

 //     int stat=  lpx_get_status(lp);

 //     switch (stat) {

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

 //       return UNDEFINED;

 //       break;

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

 //     case LPX_INFEAS://Infeasible 

 //       return INFEASIBLE;

 //       break;

 //     case LPX_UNBND://Unbounded

 //       return INFINITE;

 //       break;

 //     case LPX_FEAS://Feasible

 //       return FEASIBLE;

 //       break;

 //     case LPX_OPT://Feasible

 //       return OPTIMAL;

 //       break;

 //     default:

 //       return UNDEFINED; //to avoid gcc warning

 //       //FIXME error

 //     }

   }

   LpCplex::Value LpCplex::_getPrimal(int i)

   {

     Value x;

     CPXgetx (env, lp, &x, i, i);

     return x;

   }

   LpCplex::Value LpCplex::_getPrimalValue()

   {

     //Unimplemented

     return 0;

   }

   void LpCplex::_setMax()

   {

     CPXchgobjsen (env, lp, CPX_MAX);

    }

   void LpCplex::_setMin()

   {

     CPXchgobjsen (env, lp, CPX_MIN);

    }

 } //namespace lemon