/*

     This file is part of Combean.

     Combean is free software; you can redistribute it and/or modify

     it under the terms of the GNU General Public License as published by

     the Free Software Foundation; either version 2 of the License, or

     (at your option) any later version.

     Combean is distributed in the hope that it will be useful,

     but WITHOUT ANY WARRANTY; without even the implied warranty of

     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License

     along with Combean; if not, write to the Free Software

     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

 /*

  * Created on 22.04.2005

  *

  */

 package net.sourceforge.combean.adapters.drasys.lp;

 import java.util.Enumeration;

 import net.sourceforge.combean.interfaces.mathprog.linalg.SparseVector;

 import net.sourceforge.combean.interfaces.mathprog.linalg.VectorIterator;

 import net.sourceforge.combean.interfaces.mathprog.linalg.VectorValue;

 import net.sourceforge.combean.interfaces.mathprog.lp.LPConstraint;

 import net.sourceforge.combean.interfaces.mathprog.lp.LPSolver;

 import net.sourceforge.combean.interfaces.mathprog.lp.LPVariable;

 import net.sourceforge.combean.interfaces.mathprog.lp.model.NoLabel;

 import net.sourceforge.combean.util.except.IllegalParameterException;

 import drasys.or.matrix.VectorI;

 import drasys.or.mp.ConstraintI;

 import drasys.or.mp.ConvergenceException;

 import drasys.or.mp.DuplicateException;

 import drasys.or.mp.InfeasibleException;

 import drasys.or.mp.InvalidException;

 import drasys.or.mp.NoSolutionException;

 import drasys.or.mp.Problem;

 import drasys.or.mp.ScaleException;

 import drasys.or.mp.SizableProblemI;

 import drasys.or.mp.UnboundedException;

 import drasys.or.mp.VariableI;

 import drasys.or.mp.lp.DenseSimplex;

 import drasys.or.mp.lp.LinearProgrammingI;

 /**

  * @author schickin

  *

  */

 public class SizableProblemIAsLPSolver implements LPSolver {

     private static final int DEFAULT_DIMENSION = 100;

     private LinearProgrammingI draLP = null;

     private SizableProblemI draProblem = null;

     private byte objective = LPSolver.LPOBJ_UNDEFINED;

     private byte lpStatus = LPSolver.LPOBJ_UNDEFINED;

     /**

      * 

      */

     public SizableProblemIAsLPSolver() {

         super();

         this.draLP = new DenseSimplex();

         this.draProblem = new Problem(DEFAULT_DIMENSION, DEFAULT_DIMENSION);

     }

     /**

      * 

      */

     public SizableProblemIAsLPSolver(LinearProgrammingI draLP) {

         super();

         this.draLP = draLP;

         this.draProblem = new Problem(DEFAULT_DIMENSION, DEFAULT_DIMENSION);

     }

     /**

      * 

      * 

      */

     public SizableProblemIAsLPSolver(

             LinearProgrammingI draLP,

             SizableProblemI draProblem) {

         super();

         this.draLP = draLP;

         this.draProblem = draProblem;

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#setInitialDimensions(int, int)

      */

     public void setInitialDimensions(int numRows, int numColumns) {

         this.draProblem.setCapacity(numRows, numColumns);

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#addVariable(net.sourceforge.combean.interfaces.mathprog.lp.LPVariable)

      */

     public int addVariable(LPVariable variable) {

         VariableI draVar = null;

         try {

             draVar = this.draProblem.newVariable(variable.getName());

             draVar.setObjectiveCoefficient(variable.getCoeff());

             if (variable.getLowerBound() != 0 ||

                     variable.getUpperBound() != Double.POSITIVE_INFINITY) {

                 throw new IllegalParameterException(

                         "OR-Objects simplex only supports variables with bounds [0, infinity]");

             }

             draVar.setLowerBound(variable.getLowerBound());

             draVar.setUpperBound(variable.getUpperBound());

         } catch (DuplicateException e) {

             throw new IllegalParameterException("duplicate variable id", e);

         }

         return draVar.getColumnIndex();

     }

     private static final byte[] relationCodeToDrasys =

         new byte[LPConstraint.REL_COUNT];

     static {

         relationCodeToDrasys[LPConstraint.REL_EQUAL] = ConstraintI.EQUAL;

         relationCodeToDrasys[LPConstraint.REL_GREATER] = ConstraintI.GREATER;

         relationCodeToDrasys[LPConstraint.REL_LESS] = ConstraintI.LESS;

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#addConstraint(net.sourceforge.combean.interfaces.mathprog.lp.LPConstraint)

      */

     public int addConstraint(LPConstraint constraint) {

         ConstraintI draConstr = null;

         try {

             draConstr = this.draProblem.newConstraint(constraint.getName());

             draConstr.setRightHandSide(constraint.getRhs());

             draConstr.setType(

                     relationCodeToDrasys[constraint.getRelation()]);

             draConstr.setUpperRange(Double.POSITIVE_INFINITY);

             draConstr.setLowerRange(Double.NEGATIVE_INFINITY);

         } catch (DuplicateException e) {

             throw new IllegalParameterException("duplicate constraint id", e);

         }

         return draConstr.getRowIndex();

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#addRow(net.sourceforge.combean.interfaces.mathprog.lp.LPRow)

      */

     public int addRow(LPConstraint constraint, SparseVector rowVec) {

         int rowIdx = addConstraint(constraint);

         VectorIterator<NoLabel> itRowVec = rowVec.iterator();

         while (itRowVec.hasNext()) {

             VectorValue<NoLabel> val = itRowVec.next();

             this.draProblem.setCoefficientAt(rowIdx, val.index(),

                     val.doubleValue());

         }

         return rowIdx;

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#addColumn(net.sourceforge.combean.interfaces.mathprog.lp.LPColumn)

      */

     public int addColumn(LPVariable variable, SparseVector colVec) {

         int colIdx = addVariable(variable);

         VectorIterator<NoLabel> itColVec = colVec.iterator();

         while (itColVec.hasNext()) {

             VectorValue<NoLabel> val = itColVec.next();

             this.draProblem.setCoefficientAt(val.index(), colIdx,

                     val.doubleValue());

         }

         return colIdx;

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#setObjective(byte)

      */

     public void setObjective(byte objective) {

         this.objective = objective;

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#freeze()

      */

     public void freeze() {

         if (this.objective == LPSolver.LPOBJ_UNDEFINED) {

             throw new IllegalParameterException("objective (min/max) must be set");

         }

         if (this.objective == LPSolver.LPOBJ_MAX) {

             adaptObjectiveFunction();

         }

         try {

             this.draLP.setProblem(this.draProblem);

         }

         catch (InvalidException e) {

             throw new IllegalParameterException(

                     "OR-Objects LinearProgrammingI object can handle problem",

                     e);

         }

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#getNumColumns()

      */

     public int getNumColumns() {

          return this.draProblem.sizeOfVariables();

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#getNumRows()

      */

     public int getNumRows() {

          return this.draProblem.sizeOfConstraints();

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#getSolutionStatus()

      */

     public byte getSolutionStatus() {

          return this.lpStatus;

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#getSolutionValue()

      */

     public double getSolutionValue() {

          double result = 0.0;

          try {

              result = this.draLP.getObjectiveValue();

          }

          catch (NoSolutionException e) {

              throw new IllegalParameterException(

                      "OR-Objects LinearProgrammingI object can not find a solution",

                      e);

          }

          if (this.objective == LPSolver.LPOBJ_MAX) {

              result = -result;

          }

          return result;

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#solve()

      */

     public void solve() {

         try {

             this.draLP.solve();

             this.lpStatus = LPSolver.LPSTAT_SOLVED;

         }

         catch (InfeasibleException e) {

             this.lpStatus = LPSolver.LPSTAT_INFEASIBLE;

         }

         catch (UnboundedException e) {

             this.lpStatus = LPSolver.LPSTAT_UNBOUNDED;

         }

         catch (InvalidException e) {

             throw new IllegalParameterException(

                     "OR-Objects LinearProgrammingI object can handle problem",

                     e);

         }

         catch (NoSolutionException e) {

             throw new IllegalParameterException(

                     "OR-Objects LinearProgrammingI object can not find a solution",

                     e);

         }

         catch (ScaleException e) {

             throw new IllegalParameterException(

                     "value out of numerically feasible bounds",

                     e);

         }

         catch (ConvergenceException e) {

             throw new IllegalParameterException(

                     "algorithm does not converge after max. number of iterations",

                     e);

         }

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.LPSolver#getSolution()

      */

     public SparseVector getSolution() {

         VectorI solVec = null;

         try {

             solVec = this.draLP.getSolution();

         }

         catch (NoSolutionException e) {

             throw new IllegalParameterException(

                     "OR-Objects LinearProgrammingI object cannot find a solution",

                     e);

         }

         return new VectorIAsSparseVector(solVec);

     }

     /**

      * @return Returns the draLP.

      */

     public LinearProgrammingI getDraLP() {

         return this.draLP;

     }

     /**

      * @return Returns the draProblem.

      */

     public SizableProblemI getDraProblem() {

         return this.draProblem;

     }

     public String toString() {

         return getClass().getName() +

         " with embedded DRA-Problem: " + this.draProblem.toString();

     }

     private void adaptObjectiveFunction() {

         Enumeration variables = this.draProblem.variables();

         while (variables.hasMoreElements()) {

             VariableI var = (VariableI) variables.nextElement();

             var.setObjectiveCoefficient(-var.getObjectiveCoefficient());

         }

     }

 }