/*

     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 23.04.2005

  *

  */

 package net.sourceforge.combean.adapters.qsopt;

 import java.io.ByteArrayOutputStream;

 import java.io.PrintStream;

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

 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.mathprog.linalg.DoubleVector;

 import net.sourceforge.combean.mathprog.linalg.statics.SparseVectorConverter;

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

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import qs.Problem;

 import qs.QS;

 import qs.QSException;

 import qs.Reporter;

 /**

  * @author schickin

  *

  */

 public class QSOptProblemAsLPSolver implements LPSolver {

     private static Log log = LogFactory.getLog(QSOptProblemAsLPSolver.class); 

     private Problem qsProblem = null;

     public static final byte QSOPT_DUAL_SIMPLEX = 1;

     public static final byte QSOPT_PRIMAL_SIMPLEX = 2;

     private byte simplexKind = QSOPT_PRIMAL_SIMPLEX;

     private long varCounter = 0;

     private long rowUniqueIdSeq = 0;

     private byte solverStatus = LPSolver.LPSTAT_UNDEFINED;

     /**

      * 

      */

     public QSOptProblemAsLPSolver() {

         super();

         this.qsProblem = new Problem();

         this.varCounter = 0;

         this.rowUniqueIdSeq = 0;

     }

     /**

      * 

      */

     public QSOptProblemAsLPSolver(Problem qsProblem) {

         super();

         this.qsProblem = qsProblem;

     }

     /* (non-Javadoc)

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

      */

     public void setInitialDimensions(int numRows, int numColumns) {

         /*

          nothing to do

          */

     }

     private static final int[] cmatcntForZeroVec = {0};

     private static final int[] emptyIndexVec = {1};

     private static final double[] emptyValueVec = {0.0};

     /* (non-Javadoc)

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

      */

     public int addVariable(LPVariable variable) {

         this.solverStatus = LPOBJ_UNDEFINED;

         if (log.isDebugEnabled()) {

             log.debug("Adding variable: " + variable);

         }

         double[] coeff = createOneElementArray(variable.getCoeff());

         double[] upper = createOneElementArray(variable.getUpperBound());

         double[] lower = createOneElementArray(variable.getLowerBound());

         String[] name = createOneElementArray(generateVariableName(variable));

         if (log.isDebugEnabled()) {

             log.debug("coeff=" + coeff[0] + " upper=" + upper[0] + " name=" + name[0]);

         }

         try {

             this.qsProblem.add_cols(1,

                 cmatcntForZeroVec, emptyIndexVec, emptyIndexVec, emptyValueVec,

                 coeff, lower, upper, name);

         }

         catch (QSException e) {

             throw new IllegalParameterException("cannot add variable to QSOpt problem", e);

         }

         return this.qsProblem.get_colcount()-1;

     }

     private static final char[] codeToQSOptSense =

         new char[LPConstraint.REL_COUNT];

     static {

         codeToQSOptSense[LPConstraint.REL_EQUAL] = 'E';

         codeToQSOptSense[LPConstraint.REL_LESS] = 'L';

         codeToQSOptSense[LPConstraint.REL_GREATER] = 'G';

     }

     /* (non-Javadoc)

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

      */

     public int addConstraint(LPConstraint constraint) {

         this.solverStatus = LPOBJ_UNDEFINED;

         try {

             this.qsProblem.new_row(constraint.getRhs(),

                     codeToQSOptSense[constraint.getRelation()],

                     generateConstraintName(constraint));

         }

         catch (QSException e) {

             throw new IllegalParameterException("cannot add constraint to QSOpt problem", e);

         }

         return this.qsProblem.get_rowcount()-1;

     }

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

         this.solverStatus = LPOBJ_UNDEFINED;

         double[] rhs = createOneElementArray(constraint.getRhs());

         char[] sense = createOneElementArray(

                 codeToQSOptSense[constraint.getRelation()]);

         String[] name = createOneElementArray(generateConstraintName(constraint));

         int[] begin = createOneElementArray(0);

         int numNonzeroEntries = rowVec.getNumIterations();

         int[] rowLength = createOneElementArray(numNonzeroEntries);

         int[] indexVec = new int[numNonzeroEntries];

         double[] valueVec = new double[numNonzeroEntries];

         SparseVectorConverter.convertToIndexAndDoubleArray(rowVec,

                 indexVec, valueVec);

         try {

             this.qsProblem.add_rows(1,

                 rowLength, begin, indexVec, valueVec,

                 rhs, sense, name);

         }

         catch (QSException e) {

             throw new IllegalParameterException("cannot add column to QSOpt problem", e);

         }

         return this.qsProblem.get_rowcount()-1;

     }

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

         this.solverStatus = LPOBJ_UNDEFINED;

         double[] coeff = createOneElementArray(variable.getCoeff());

         double[] upper = createOneElementArray(variable.getUpperBound());

         double[] lower = createOneElementArray(variable.getLowerBound());

         String[] name = createOneElementArray(generateVariableName(variable));

         int[] begin = createOneElementArray(0);

         int numNonzeroEntries = colVec.getNumIterations();

         int[] columnLength = createOneElementArray(numNonzeroEntries);

         int[] indexVec = new int[numNonzeroEntries];

         double[] valueVec = new double[numNonzeroEntries];

         SparseVectorConverter.convertToIndexAndDoubleArray(colVec,

                 indexVec, valueVec);

         try {

             this.qsProblem.add_cols(1,

                 columnLength, begin, indexVec, valueVec,

                 coeff, lower, upper, name);

         }

         catch (QSException e) {

             throw new IllegalParameterException("cannot add column to QSOpt problem", e);

         }

         return this.qsProblem.get_colcount()-1;

     }

     private static final int[] objectiveToQSCode =

         new int[LPSolver.LPOBJ_COUNT];

     static {

         objectiveToQSCode[LPSolver.LPOBJ_MAX] = QS.MAX;

         objectiveToQSCode[LPSolver.LPOBJ_MIN] = QS.MIN;

     }

     /* (non-Javadoc)

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

      */

     public void setObjective(byte objective) {

         this.solverStatus = LPOBJ_UNDEFINED;

         this.qsProblem.change_objsense(objectiveToQSCode[objective]);

     }

     /* (non-Javadoc)

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

      */

     public void freeze() {

         this.solverStatus = LPOBJ_UNDEFINED;

     }

     /* (non-Javadoc)

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

      */

     public int getNumRows() {

          return this.qsProblem.get_rowcount();

     }

     /* (non-Javadoc)

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

      */

     public int getNumColumns() {

          return this.qsProblem.get_colcount();

     }

     /* (non-Javadoc)

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

      */

     public void solve() {

         try {

             switch (this.simplexKind) {

                 case QSOPT_DUAL_SIMPLEX:

                     this.qsProblem.opt_dual();

                     break;

                 case QSOPT_PRIMAL_SIMPLEX:

                     this.qsProblem.opt_primal();

                     break;

                 default:

                     throw new IllegalParameterException("unexpected alternative");    

             }

         }

         catch (QSException e) {

             throw new IllegalParameterException("exception during solve()");

         }

         this.solverStatus = getQSSolutionStatus();

     }

     /* (non-Javadoc)

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

      */

     public byte getSolutionStatus() {

         return this.solverStatus;

     }

     /**

      * Obtain status of solver and convert it to LPSolver-status.

      * 

      * Status value is cached internally because QSOpt-solver returns wrong values

      * if status is not queried immediately after the solver has been run.

      * 

      * @return

      */

     private byte getQSSolutionStatus() {

         int qsStatus = this.qsProblem.get_status();

         switch (qsStatus) {

         case QS.LP_OPTIMAL:

         case QS.LP_SOLVED:

             return LPSolver.LPSTAT_SOLVED;

         case QS.LP_PRIMAL_INFEASIBLE:

             return LPSolver.LPSTAT_INFEASIBLE;

         case QS.LP_DUAL_UNBOUNDED:

             return LPSolver.LPSTAT_INFEASIBLE;

         case QS.LP_PRIMAL_UNBOUNDED:

             return LPSolver.LPSTAT_UNBOUNDED;

         case QS.LP_DUAL_INFEASIBLE:

             return LPSolver.LPSTAT_UNBOUNDED;

         case QS.NO_STATUS:

             return LPSolver.LPSTAT_UNDEFINED;

         default:

             throw new IllegalParameterException("unexpected status of QSOpt solver: "

                     + qsStatus);

         }

     }

     /* (non-Javadoc)

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

      */

     public double getSolutionValue() {

         double result = 0.0;

         try {

             result = this.qsProblem.get_objval();

         }

         catch (QSException e) {

             throw new IllegalParameterException("exception during get_objval");

         }

         return result;

     }

     /* (non-Javadoc)

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

      */

     public SparseVector getSolution() {

         double[] solVec = new double[getNumColumns()];

         try {

             this.qsProblem.get_x_array(solVec);

         }

         catch (QSException e) {

             throw new IllegalParameterException("exception while fetching solution");

         }

         return new DoubleVector(solVec);

     }

     public String toString() {

         int estimateForOutputSize =

             getNumColumns() * getNumRows() * 10;

         ByteArrayOutputStream ostream =

             new ByteArrayOutputStream(estimateForOutputSize);

         Reporter rep = new Reporter(new PrintStream(ostream));

         try {

             this.qsProblem.write(rep, false /* is_mps */);

         }

         catch (QSException e) {

             throw new IllegalParameterException("exception while printing LP", e);

         }

         return ostream.toString();

     }

     private char[] createOneElementArray(char val) {

         char[] result = new char[1];

         result[0] = val;

         return result;

     }

     private int[] createOneElementArray(int val) {

         int[] result = new int[1];

         result[0] = val;

         return result;

     }

     private double[] createOneElementArray(double val) {

         double[] result = new double[1];

         result[0] = val;

         return result;

     }

     private String[] createOneElementArray(String val) {

         String[] result = new String[1];

         result[0] = val;

         return result;

     }

     /**

      * Generate a name for a variable of the format x + <consecutive number>.

      * 

      * QSOpt requires the variable names to be set. Otherwise, it throws

      * NullPointerExceptions or ArrayOutOfBoundsExceptions.

      * 

      * @param variable

      * @return

      */

     private String generateVariableName(LPVariable variable) {

         String result = variable.getName();

         if (result == null || result.length() == 0) {

             result = "x" + this.varCounter++;

         }

         else if (!Character.isLetter(result.charAt(0))) {

             result = "x" + result;

         }

         return result;

     }

     /**

      * Generate a new for a constraint of the format c + <consecutive number>.

      * 

      * QSOpt requires the constraint names to be set. Otherwise, it throws

      * NullPointerExceptions or ArrayOutOfBoundsExceptions.

      * 

      * @param variable

      * @return

      */

     private String generateConstraintName(LPConstraint constr) {

         String result = constr.getName();

         if (result == null || result.length() == 0) {

             result = "c" + this.rowUniqueIdSeq++;

         }

         else if (!Character.isLetter(result.charAt(0))) {

             result = "c" + result;

         }

         return result;

     }

     /**

      * @return Returns the simplexKind.

      */

     public byte getSimplexKind() {

         return this.simplexKind;

     }

     /**

      * @param simplexKind The simplexKind to set.

      */

     // TODO: implement support for dual simplex 

 //    public void setSimplexKind(byte simplexKind) {

 //        this.simplexKind = simplexKind;

 //    }

 }