/*

     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 03.09.2005

  *

  */

 package net.sourceforge.combean.test.mathprog.lp.model;

 import junit.framework.TestCase;

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

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

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

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

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

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

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

 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.LPVariableSequence;

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

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

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

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

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

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

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

 import net.sourceforge.combean.test.helpers.checks.CheckMathProg;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 /**

  * @author schickin

  *

  */

 public abstract class AbstractTestLPModelSolver extends TestCase {

     private static final Log log =

         LogFactory.getLog(AbstractTestLPModelSolver.class);

     private ConstructableLPModel lpModel = null;

     private LPSolver lpSolver = null;

     private LPModelSolver modelSolver = null;

     private static final double[] simpleCoeffs = {4, 10};

     private static final double[] simpleRhs = {

             2,

             2,

             10

     };

     private static final double[][] feasibleMatrix = {

             {1, 0},

             {0, 1},

             {2, 5}

     };

     private static final double[] halvedRhs = {

             1,

             1,

             5

     };

     private static final double[] tripleCoeffs = {12, 30};

     private static final double simpleSolution = 20;

     /**

      * Constructor for AbstractTestLPModelSolver.

      * @param name

      */

     public AbstractTestLPModelSolver(String name) {

         super(name);

     }

     /*

      * @see TestCase#setUp()

      */

     protected void setUp() throws Exception {

         super.setUp();

         this.lpModel = new ConstructableLPModel();

         this.lpSolver = CheckMathProg.constructLPSolver();

         this.lpSolver.setObjective(LPSolver.LPOBJ_MAX);

         this.modelSolver = createLPModelSolver();

         this.modelSolver.setLPSolver(this.lpSolver);

     }

     /*

      * @see TestCase#tearDown()

      */

     protected void tearDown() throws Exception {

         super.tearDown();

     }

     protected abstract LPModelSolver createLPModelSolver();

     public void testColumnwiseConstructionOfFeasibleLPWithOneComponent() {

         if (log.isDebugEnabled()) {

             log.debug("testColumnwiseConstructionOfFeasibleLPWithOneComponent");

         }

         LPModelComponent component =

             constructSimpleModel(VectorOrientation.ROWWISE);

         this.lpModel.appendModelComponent(component);

         this.modelSolver.loadModel(this.lpModel);

         this.modelSolver.solve();

         if (log.isDebugEnabled()) {

             log.debug("solution: " + this.lpSolver.getSolution());

         }

         assertEquals(this.lpSolver.getNumRows(), feasibleMatrix.length);

         assertEquals(this.lpSolver.getNumColumns(), feasibleMatrix[0].length);

         assertEquals(LPSolver.LPSTAT_SOLVED,

                 this.lpSolver.getSolutionStatus());

         assertEquals(simpleSolution, this.lpSolver.getSolutionValue(), 0.0);

     }

     public void testRowwiseConstructionOfFeasibleLPWithOneComponent() {

         if (log.isDebugEnabled()) {

             log.debug("testRowwiseConstructionOfFeasibleLPWithOneComponent");

         }

         LPModelComponent component =

             constructSimpleModel(VectorOrientation.ROWWISE);

         this.lpModel.appendModelComponent(component);

         this.modelSolver.loadModel(this.lpModel);

         this.modelSolver.solve();

         if (log.isDebugEnabled()) {

             log.debug("solution: " + this.lpSolver.getSolution());

         }

         assertEquals(this.lpSolver.getNumRows(), feasibleMatrix.length);

         assertEquals(this.lpSolver.getNumColumns(), feasibleMatrix[0].length);

         assertEquals(LPSolver.LPSTAT_SOLVED,

                 this.lpSolver.getSolutionStatus());

         assertEquals(simpleSolution, this.lpSolver.getSolutionValue(), 0.0);

     }

     public void testTwoStackedRowwiseFeasibleMatrices() {

         if (log.isDebugEnabled()) {

             log.debug("testTwoStackedRowwiseFeasibleMatrices");

         }

         LPModelComponent component =

             constructSimpleModel(VectorOrientation.ROWWISE);

         this.lpModel.appendModelComponent(component);

         component =

             constructRowsWithHalvedRhs(VectorOrientation.ROWWISE);

         this.lpModel.appendModelComponent(component);

         this.modelSolver.loadModel(this.lpModel);

         this.modelSolver.solve();

         if (log.isDebugEnabled()) {

             log.debug("solution: " + this.lpSolver.getSolution());

         }

         assertEquals(this.lpSolver.getNumRows(), feasibleMatrix.length*2);

         assertEquals(this.lpSolver.getNumColumns(), feasibleMatrix[0].length);

         assertEquals(LPSolver.LPSTAT_SOLVED,

                 this.lpSolver.getSolutionStatus());

         assertEquals(simpleSolution/2, this.lpSolver.getSolutionValue(), 0.0);

     }

     public void testTwoStackedColumnwiseFeasibleMatrices() {

         if (log.isDebugEnabled()) {

             log.debug("testTwoStackedColumnwiseFeasibleMatrices");

         }

         ConcatenatedLPModelColumns concatenatedCols =

             new ConcatenatedLPModelColumns();

         LPModelComponent component =

             constructSimpleModel(VectorOrientation.COLUMNWISE);

         concatenatedCols.concatenateColumns((LPModelColumns) component);

         component = constructRowsWithHalvedRhs(VectorOrientation.COLUMNWISE);

         concatenatedCols.concatenateColumns((LPModelColumns) component);

         this.lpModel.appendModelComponent(concatenatedCols);

         this.modelSolver.loadModel(this.lpModel);

         this.modelSolver.solve();

         if (log.isDebugEnabled()) {

             log.debug("solution: " + this.lpSolver.getSolution());

         }

         assertEquals(this.lpSolver.getNumRows(), feasibleMatrix.length*2);

         assertEquals(this.lpSolver.getNumColumns(), feasibleMatrix[0].length);

         assertEquals(LPSolver.LPSTAT_SOLVED,

                 this.lpSolver.getSolutionStatus());

         assertEquals(simpleSolution/2, this.lpSolver.getSolutionValue(), 0.0);

     }

     public void testTwoAdjacentColumnwiseFeasibleMatrices() {

         if (log.isDebugEnabled()) {

             log.debug("testTwoAdjacentColumnwiseFeasibleMatrices");

         }

         LPModelComponent component =

             constructSimpleModel(VectorOrientation.COLUMNWISE);

         this.lpModel.appendModelComponent(component);

         component = constructColumnsWithTripleCoefficient(VectorOrientation.COLUMNWISE);

         this.lpModel.appendModelComponent(component);

         this.modelSolver.loadModel(this.lpModel);

         this.modelSolver.solve();

         if (log.isDebugEnabled()) {

             log.debug("solution: " + this.lpSolver.getSolution());

         }

         assertEquals(this.lpSolver.getNumRows(), feasibleMatrix.length);

         assertEquals(this.lpSolver.getNumColumns(), feasibleMatrix[0].length*2);

         assertEquals(LPSolver.LPSTAT_SOLVED,

                 this.lpSolver.getSolutionStatus());

         assertEquals(simpleSolution*3, this.lpSolver.getSolutionValue(),

                 0.000000001);

     }

     public void testTwoAdjacentRowwiseFeasibleMatrices() {

         if (log.isDebugEnabled()) {

             log.debug("testTwoAdjacentRowwiseFeasibleMatrices");

         }

         ConcatenatedLPModelRows concatenatedRows =

             new ConcatenatedLPModelRows();

         LPModelComponent component =

             constructSimpleModel(VectorOrientation.ROWWISE);

         concatenatedRows.concatenateRows((LPModelRows) component);

         component = constructColumnsWithTripleCoefficient(VectorOrientation.ROWWISE);

         concatenatedRows.concatenateRows((LPModelRows) component);

         this.lpModel.appendModelComponent(concatenatedRows);

         this.modelSolver.loadModel(this.lpModel);

         this.modelSolver.solve();

         if (log.isDebugEnabled()) {

             log.debug("solution: " + this.lpSolver.getSolution());

         }

         assertEquals(this.lpSolver.getNumRows(), feasibleMatrix.length);

         assertEquals(this.lpSolver.getNumColumns(), feasibleMatrix[0].length*2);

         assertEquals(LPSolver.LPSTAT_SOLVED,

                 this.lpSolver.getSolutionStatus());

         assertEquals(simpleSolution*3, this.lpSolver.getSolutionValue(), 0.00000001);

     }

     private LPModelComponent constructSimpleModel(VectorOrientation orientation) {

         LPConstraintSequence constraints = 

             new DoubleLPConstraintSequence("constr",

                     LPConstraint.REL_LESS, simpleRhs);

         this.lpModel.addConstraintSequence(constraints);

         DoubleLPVariableSequence variables =

             new DoubleLPVariableSequence("var", simpleCoeffs,

                     0, Double.POSITIVE_INFINITY);

         this.lpModel.addVariableSequence(variables);

         LPModelMatrix model =

             new MatrixAsLPModelMatrix(orientation, "constr", "var",

                     new DoubleMatrix(feasibleMatrix));

         return model;

     }

     private LPModelComponent constructRowsWithHalvedRhs(VectorOrientation orientation) {

         LPConstraintSequence constraints = 

             new DoubleLPConstraintSequence("halved",

                     LPConstraint.REL_LESS, halvedRhs);

         this.lpModel.addConstraintSequence(constraints);

         MatrixAsLPModelMatrix model =

             new MatrixAsLPModelMatrix(orientation, "halved", "var",

                     new DoubleMatrix(feasibleMatrix));

         return model;

     }

     private LPModelComponent constructColumnsWithTripleCoefficient(

             VectorOrientation orientation) {

         LPVariableSequence variables =

             new DoubleLPVariableSequence("tripled", tripleCoeffs,

                     0, Double.POSITIVE_INFINITY);

         this.lpModel.addVariableSequence(variables);

         MatrixAsLPModelMatrix model =

             new MatrixAsLPModelMatrix(orientation, "constr", "tripled",

                     new DoubleMatrix(feasibleMatrix));

         model.setOrientation(VectorOrientation.COLUMNWISE);

         return model;

     }

 }