/*

     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 04.08.2006

  *

  */

 package net.sourceforge.combean.samples.mathprog.lp.matrixrounding;

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

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

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

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

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

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

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

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

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

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

 import net.sourceforge.combean.mathprog.linalg.SparseVectorWithConstantPattern;

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

 import net.sourceforge.combean.mathprog.lp.DoubleLPConstraint;

 import net.sourceforge.combean.mathprog.lp.DoubleLPVariable;

 import net.sourceforge.combean.mathprog.lp.model.AbstractSimpleIndexLPConstrainedRowsWithVars;

 import net.sourceforge.combean.mathprog.lp.model.SparseVectorAsLPVector;

 /**

  * A matrix rounding problem as linear program.

  * 

  * @author schickin

  *

  */

 public class MatrixToRoundAsLP

 extends AbstractSimpleIndexLPConstrainedRowsWithVars

 implements LPModelRows, LPConstraintSequence, LPVariableSequence {

     private Matrix m = null;

     private double[] rowsums = null;

     private double[] colsums = null;

     /**

      * Constructor

      * 

      * @param matrixToRound the matrix to be rounded

      */

     public MatrixToRoundAsLP(Matrix matrixToRound) {

         super("", "");

         this.m = matrixToRound;

         this.rowsums = new double[this.m.getNumRows()];

         for (int row = 0; row < this.rowsums.length; row++) {

             this.rowsums[row] =

                 SparseVectorUtil.sum(this.m.getRowVector(row));

         }

         this.colsums = new double[this.m.getNumColumns()];

         for (int col = 0; col < this.colsums.length; col++) {

             this.colsums[col] =

                 SparseVectorUtil.sum(this.m.getColumnVector(col));

         }

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.linalg.AbstractMatrix#getNumColumns()

      */

     public int getNumColumns() {

         // one variable/column for each element of the matrix

         return this.m.getNumColumns() * this.m.getNumRows();

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.linalg.AbstractMatrix#getNumRows()

      */

     public int getNumRows() {

         // two constraints (<= and >= for each column and row of the matrix

         return 2 * (this.m.getNumColumns() + this.m.getNumRows());

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.model.LPVariableSequence#getLPVariable(int)

      */

     public LPVariable getLPVariable(int localColumn) {

         double val = this.m.getDoubleAt(

                 localColumn / this.m.getNumColumns(),

                 localColumn % this.m.getNumColumns());

         // this funny objective functions assigns high values to the variables

         // with low column numbers and thus forces a solution where these

         // variables are as small or big as possible (depending on the

         // objective function, i.e., whether we are maximizing or minimizing).

         // In any case the resulting solution is unique (which is important for

         // automated unit testing)..

         return new DoubleLPVariable((localColumn + 1.0)*(localColumn + 1.0)

                 + getNumVars()*getNumVars()*getNumVars(),

                 Math.floor(val), Math.ceil(val));

         // for a non-unique solution it would suffixe to set:

         // return new DoubleLPVariable(1.0, Math.floor(val), Math.ceil(val));

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.linalg.RowMatrix#getRowVector(int)

      */

     public LPSparseVector getRowVector(int localRow) {

         SparseVector result = null;

         if (localRow >= 2*this.m.getNumRows()) {

             // constraints for columns

             int colInOrigM = localRow/2 - this.m.getNumRows();

             result = new SparseVectorWithConstantPattern(

                     getNumColumns(),

                     1.0,

                     colInOrigM,

                     colInOrigM + this.m.getNumColumns()*(this.m.getNumRows()-1),

                     this.m.getNumColumns());

         }

         else {

             // constraints for rows

             int rowInOrigM = localRow / 2;

             result = new SparseVectorWithConstantPattern (

                     getNumColumns(),

                     1.0,

                     rowInOrigM * this.m.getNumColumns(),

                     (rowInOrigM+1) * this.m.getNumColumns() - 1,

                     1);

         }

         return new SparseVectorAsLPVector(result, "",

                 VectorOrientation.ROWWISE);

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.lp.model.LPConstraintSequence#getLPConstraint(int)

      */

     public LPConstraint getLPConstraint(int localRow) {

         byte rel = (localRow % 2 == 0) ? LPConstraint.REL_GREATER : LPConstraint.REL_LESS;

         double val = 0.0;

         if (localRow >= 2*this.m.getNumRows()) {

             // constraints for columns

             val = this.colsums[localRow/2 - this.m.getNumRows()];

         }

         else {

             // constraints for rows

             val = this.rowsums[localRow/2];

         }

         if (rel == LPConstraint.REL_GREATER) {

             val = Math.floor(val);

         }

         else {

             val = Math.ceil(val);

         }

         return new DoubleLPConstraint("row", rel, val);

     }

     /**

      * Translate the result of the solver back into a matrix of doubles

      * 

      * @param solver the solver which has solved the model "this".

      * @return the result given by the solver converted to a matrix of doubles.

      */

     public double[][] getRoundedMatrix(LPModelSolver solver) {

         double[][] result =

             new double[this.m.getNumRows()][this.m.getNumColumns()];

         for (int row = 0; row < this.m.getNumRows(); row++) {

             for (int col = 0; col < this.m.getNumColumns(); col++) {

                 result[row][col] =

                     solver.getSolution(getColumnModelIndex(

                             row * this.m.getNumColumns() + col));

             }

         }

         return result;

     }

 }