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

  *

  */

 #include<iostream>

 #include<lemon/lp_soplex.h>

 #include <soplex/soplex.h>

 ///\file

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

 namespace lemon {

   LpSoplex::LpSoplex() : LpSolverBase() {

     soplex = new soplex::SoPlex;

   }

   LpSoplex::~LpSoplex() {

     delete soplex;

   }

   LpSolverBase &LpSoplex::_newLp() {

     LpSoplex* newlp = new LpSoplex();

     return *newlp;

   }

   LpSolverBase &LpSoplex::_copyLp() {

     LpSoplex* newlp = new LpSoplex();

     ((soplex::SPxLP&)*(newlp->soplex)) = *soplex;

     return *newlp;

   }

   int LpSoplex::_addCol() {

     soplex::LPCol col;

     soplex->addCol(col);

     colNames.push_back(std::string());

     primal.push_back(0.0);

     return soplex->nCols() - 1;

   }

   int LpSoplex::_addRow() {

     soplex::LPRow row;

     soplex->addRow(row);

     dual.push_back(0.0);

     return soplex->nRows() - 1;

   }

   void LpSoplex::_eraseCol(int i) {

     soplex->removeCol(i);

     primal[i] = primal.back();

     primal.pop_back();

   }

   void LpSoplex::_eraseRow(int i) {

     soplex->removeRow(i);

     dual[i] = dual.back();

     dual.pop_back();

   }

   void LpSoplex::_getColName(int col, std::string &name) {

     name = colNames[col]; 

   }

   void LpSoplex::_setColName(int col, const std::string &name) {

     colNames[col] = name; 

   }

   void LpSoplex::_setRowCoeffs(int i, LpRowIterator b, LpRowIterator e) {

     for (int j = 0; j < soplex->nCols(); ++j) {

       soplex->changeElement(i, j, 0.0);

     }

     for(LpRowIterator it = b; it != e; ++it) {

       soplex->changeElement(i, it->first, it->second);

     }

   }

   void LpSoplex::_setColCoeffs(int j, LpColIterator b, LpColIterator e) {

     for (int i = 0; i < soplex->nRows(); ++i) {

       soplex->changeElement(i, j, 0.0);

     }

     for(LpColIterator it = b; it != e; ++it) {

       soplex->changeElement(it->first, j, it->second);

     }

   }

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

     soplex->changeElement(row, col, value);

   }

   void LpSoplex::_setColLowerBound(int i, Value value) {

     soplex->changeLower(i, value); 

   }

   void LpSoplex::_setColUpperBound(int i, Value value) {

     soplex->changeUpper(i, value); 

   }

   void LpSoplex::_setRowBounds(int i, Value lb, Value ub) {

     soplex->changeRange(i, lb, ub);

   }

   void LpSoplex::_setObjCoeff(int i, Value obj_coef) {

     soplex->changeObj(i, obj_coef);

   }

   void LpSoplex::_clearObj() {

     for (int i = 0; i < soplex->nCols(); ++i) {

       soplex->changeObj(i, 0.0);

     }

   }

   LpSoplex::SolveExitStatus LpSoplex::_solve() {

     soplex::SPxSolver::Status status = soplex->solve();

     soplex::Vector pv(primal.size(), &primal[0]);

     soplex->getPrimal(pv);

     soplex::Vector dv(dual.size(), &dual[0]);

     soplex->getDual(dv);

     switch (status) {

     case soplex::SPxSolver::OPTIMAL:

     case soplex::SPxSolver::INFEASIBLE:

     case soplex::SPxSolver::UNBOUNDED:

       return SOLVED;

     default:

       return UNSOLVED;

     }

   }

   LpSoplex::Value LpSoplex::_getPrimal(int i) {

     return primal[i];

   }

   LpSoplex::Value LpSoplex::_getDual(int i) {

     return dual[i];

   }

   LpSoplex::Value LpSoplex::_getPrimalValue() {

     return soplex->objValue();

   }

   bool LpSoplex::_isBasicCol(int i) {

     return soplex->getBasisColStatus(i) == soplex::SPxSolver::BASIC;

   }  

   LpSoplex::SolutionStatus LpSoplex::_getPrimalStatus() {

     switch (soplex->status()) {

     case soplex::SPxSolver::OPTIMAL:

       return OPTIMAL;

     case soplex::SPxSolver::UNBOUNDED:

       return INFINITE;

     case soplex::SPxSolver::INFEASIBLE:

       return INFEASIBLE;

     default:

       return UNDEFINED;

     }

   }

   LpSoplex::SolutionStatus LpSoplex::_getDualStatus() {

     switch (0) {

     case 0:

       return UNDEFINED;

       return OPTIMAL;

       return INFEASIBLE;

       return UNDEFINED;

     }

   }

   LpSoplex::ProblemTypes LpSoplex::_getProblemType() {

     switch (0) {

     case 0:

       return PRIMAL_DUAL_FEASIBLE;

       return PRIMAL_FEASIBLE_DUAL_INFEASIBLE;

       return UNKNOWN;

     }

   }

   void LpSoplex::_setMax() {

     soplex->changeSense(soplex::SPxSolver::MAXIMIZE);

   }

   void LpSoplex::_setMin() {

     soplex->changeSense(soplex::SPxSolver::MINIMIZE);

   }

 } //namespace lemon