/*

     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.test.mathprog.lp;

 import junit.framework.TestCase;

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

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

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

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

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

 /**

  * @author schickin

  *

  */

 public abstract class AbstractTestLPSolver extends TestCase {

     /*

      * @see TestCase#setUp()

      */

     protected void setUp() throws Exception {

         super.setUp();

         this.lp = createEmptyLPProblem();

     }

     /*

      * @see TestCase#tearDown()

      */

     protected void tearDown() throws Exception {

         super.tearDown();

     }

     /**

      * Constructor for AbstractTestLPSolver.

      * @param name

      */

     public AbstractTestLPSolver(String name) {

         super(name);

     }

     protected abstract LPSolver createEmptyLPProblem();

     private LPSolver lp = null;

     private static final byte[] codeToRelation = {

                 LPConstraint.REL_LESS,

                 LPConstraint.REL_EQUAL,

                 LPConstraint.REL_GREATER

         };

     /* Static data for feasible problem 1 */

     private static final double[][] constrFeas1 = {

                 {2, 1, -1 , 200},

                 {2, 3, -1 , 300}

         };

     // variant with maximization

     private static final double[] varsFeas1Max = {4.0, 3.0};

     private static final double zFeas1Max = 450;

     private static final double[] solFeas1Max = {75, 50};

     // variant with minimization

     private static final double[] varsFeas1Min = {-4.0, 3.0};

     private static final double zFeas1Min = -400;

     private static final double[] solFeas1Min = {100, 0};

     // columnwise representation

     private static final double[][] colFeas1 = {

             {2, 2},

             {1, 3}

     };

     /* Static data for feasible problem 2 (sparse representation) */

     private static final double[][] constrFeas2 = {

             {-1, 100},

             {-1, 50},

             {-1, 80}

     };

     private static final int[][] rowIndFeas2 = {

             {0, 1},

             {1, 2},

             {0, 2}

     };

     private static final double[][] rowValFeas2 = {

             {2, 4},

             {8, 4},

             {10, 6}

     };

     private static final double[] varsFeas2 = {4.0, 12.0, 6.0};

     private static final double zFeas2 = 107.0;

     private static final double[] solFeas2 = {8, 6.25, 0};

     // variant with unsorted indices

     private static final int[][] rowIndFeas2Unordered = {

             {1, 0},

             {1, 2},

             {2, 0}

     };

     private static final double[][] rowValFeas2Unordered = {

             {4, 2},

             {8, 4},

             {6, 10}

     };

     /* Static data for an unbounded problem */

     private static final double[][] constrUnbounded = {

                 {2, 1, 1 , 200},

                 {2, 3, 1 , 300}

         };

     private static final double[] varsUnbounded = {-4.0, 3.0};

     /* Static data for an infeasible problem */

     private static final double[][] constrInfeas = {

                 {2, 3, -1 , 200},

                 {2, 1, 1 , 300}

         };

     private static final double[] varsInfeas = {4.0, 3.0};

     // dummy array (whenever we need an array but the content does not matter)

     private static final double[] dummyArr = {1.0, 2.0};

     protected double getPrecision() {

         return 0.0;

     }

     private void solveAndCheckLP(byte expectedStatus, double expectedZ, double[] expectedSol) {

         solveAndCheckLP(expectedStatus);

         double z = this.lp.getSolutionValue();

         assertEquals(expectedZ, z, getPrecision());

         SparseVector solution = this.lp.getSolution();

         double[] solutionAsDoubles =

             SparseVectorConverter.convertToDoubleArray(

                     this.lp.getNumColumns(), solution);

         Check.compareDoubleArrays(expectedSol, solutionAsDoubles,

                 getPrecision());

     }

     private void solveAndCheckLP(byte expectedStatus) {

         this.lp.freeze();

         this.lp.solve();

         byte solutionStatus = this.lp.getSolutionStatus();

         assertEquals(expectedStatus, solutionStatus);

     }

     private void setupLP(LPSolver lp, byte objective,

             double[][] constraints, double[] variables) {

         lp.setInitialDimensions(constraints.length, variables.length);

         lp.setObjective(objective);

         setupVariables(lp, variables, 0, Double.POSITIVE_INFINITY);

         setupConstraintsAndRows(lp, constraints);

     }

     private void setupSparseLP(LPSolver lp, byte objective,

             double[][] constraints,

             int[][] rowIndices, double[][] rowValues,

             double[] variables) {

         lp.setInitialDimensions(constraints.length, variables.length);

         lp.setObjective(objective);

         setupVariables(lp, variables, 0, Double.POSITIVE_INFINITY);

         setupConstraintsAndSparseRows(lp, constraints,

                 variables.length, rowIndices, rowValues);

     }

 /*

     private void setupLPColumnwise(LPSolver lp, byte objective,

             double[][] constraints, double[][] variables, double[][] columns) {

         lp.setInitialDimensions(constraints.length, variables.length);

         lp.setObjective(objective);

         setupConstraints(lp, constraints);

         setupVariablesAndColumns(lp, variables, columns);

     }

 */

     private void setupLPColumnwise(LPSolver lp, byte objective,

             double[][] constraints, double[] variables, double[][] columns) {

         lp.setInitialDimensions(constraints.length, variables.length);

         lp.setObjective(objective);

         setupConstraints(lp, constraints);

         setupVariablesAndColumns(lp, variables, columns);

     }

 /*

     private void setupVariables(LPSolver lpToSetup, double[][] variables) {

         for (int i = 0; i < variables.length; i++) {

             LPVariable var = new DoubleLPVariable("var" + i,

                     variables[i][0], variables[i][1], variables[i][2]);

             lpToSetup.addVariable(var);

         }

     }

 */

     private void setupVariables(LPSolver lpToSetup, double[] variables, double uniformLowerBound, double uniformUpperBound) {

         for (int i = 0; i < variables.length; i++) {

             LPVariable var = new DoubleLPVariable("var" + i,

                     variables[i], uniformLowerBound, uniformUpperBound);

             lpToSetup.addVariable(var);

         }

     }

 /*

     private void setupVariablesAndColumns(LPSolver lpToSetup, double[][] variables, double[][] columns) {

         for (int i = 0; i < variables.length; i++) {

             LPVariable variable = new DoubleLPVariable("var" + i,

                     variables[i][0], variables[i][1], variables[i][2]);

             SparseVector colVec = new DoubleVector(columns[i]);

             lpToSetup.addColumn(variable, colVec);

         }

     }

 */

     private void setupVariablesAndColumns(LPSolver lpToSetup, double[] variables, double[][] columns) {

         for (int i = 0; i < variables.length; i++) {

             LPVariable variable = new DoubleLPVariable("var" + i,

                     variables[i], 0, Double.POSITIVE_INFINITY);

             SparseVector colVec = new DoubleVector(columns[i]);

             lpToSetup.addColumn(variable, colVec);

         }

     }

     private void setupConstraintsAndRows(LPSolver lpToSetup,

             double[][] constraints) {

       for (int i = 0; i < constraints.length; i++) {

           LPConstraint constraint = new DoubleLPConstraint("constr" + i,

                   calcRelation(constraints[i]),

                   calcRhs(constraints[i]));

           SparseVector rowVec =

               new DoubleVector(calcRow(constraints[i]));

           lpToSetup.addRow(constraint, rowVec);

       }

     }

     private void setupConstraintsAndSparseRows(LPSolver lpToSetup,

             double[][] constraints,

             int numColumns, int[][] rowIndices, double[][] rowValues) {

       for (int i = 0; i < constraints.length; i++) {

           LPConstraint constraint = new DoubleLPConstraint("constr" + i,

                   calcRelation(constraints[i]),

                   calcRhs(constraints[i]));

           SparseVector rowVec =

               new SparseDoubleVector(numColumns, rowIndices[i], rowValues[i]);

           lpToSetup.addRow(constraint, rowVec);

       }

     }

     private void setupConstraints(LPSolver lpToSetup, double[][] constraints) {

       for (int i = 0; i < constraints.length; i++) {

           LPConstraint constr = new DoubleLPConstraint("constr" + i,

                   calcRelation(constraints[i]),

                   calcRhs(constraints[i]));

           lpToSetup.addConstraint(constr);

       }

     }

     private byte calcRelation(double[] constraint) {

         int code = (int) constraint[constraint.length-2];

         return codeToRelation[code+1];

     }

     private double calcRhs(double[] constraint) {

         return constraint[constraint.length-1];

     }

     private double[] calcRow(double[] constraint) {

         double[] result = new double[constraint.length-2];

         for (int i = 0; i < result.length; i++) {

             result[i] = constraint[i];

         }

         return result;

     }

     public void testAddVariable() {

         this.lp.setInitialDimensions(2, 2);

         assertEquals(0, this.lp.getNumColumns());

         assertEquals(0, this.lp.getNumRows());

         int columnIndex = this.lp.addVariable(

                 new DoubleLPVariable("a", 0.0, 0, Double.POSITIVE_INFINITY));

         assertEquals("numbering of columns starts with 0", 0, columnIndex);

         assertEquals(1, this.lp.getNumColumns());

         assertEquals(0, this.lp.getNumRows());

         columnIndex = this.lp.addVariable(

                 new DoubleLPVariable("b", 0.0, 0, Double.POSITIVE_INFINITY));

         assertEquals("numbering of columns continues with 1", 1, columnIndex);

         assertEquals(2, this.lp.getNumColumns());

         assertEquals(0, this.lp.getNumRows());

     }

     public void testAddConstraint() {

         this.lp.setInitialDimensions(2, 2);

         assertEquals(0, this.lp.getNumColumns());

         assertEquals(0, this.lp.getNumRows());

         int constrIndex =

             this.lp.addConstraint(new DoubleLPConstraint("a",

                     LPConstraint.REL_EQUAL, 1.0));

         assertEquals("numbering of rows starts with 0", 0, constrIndex);

         assertEquals(0, this.lp.getNumColumns());

         assertEquals(1, this.lp.getNumRows());

         constrIndex =

             this.lp.addConstraint(new DoubleLPConstraint("b",

                     LPConstraint.REL_LESS, -1.0));

         assertEquals("numbering of rows continues with 1", 1, constrIndex);

         assertEquals(0, this.lp.getNumColumns());

         assertEquals(2, this.lp.getNumRows());

     }

     public void testAddRow() {

         this.lp.setInitialDimensions(2, 2);

         this.lp.addVariable(

                 new DoubleLPVariable("a", 0.0, 0, Double.POSITIVE_INFINITY));

         this.lp.addVariable(

                 new DoubleLPVariable("b", 0.0, 0, Double.POSITIVE_INFINITY));

         assertEquals(2, this.lp.getNumColumns());

         assertEquals(0, this.lp.getNumRows());

         int rowIndex = this.lp.addRow(

                 new DoubleLPConstraint("a", LPConstraint.REL_EQUAL, 0.0),

                 new DoubleVector(dummyArr));

         assertEquals("numbering of columns starts with 0", 0, rowIndex);

         assertEquals(2, this.lp.getNumColumns());

         assertEquals(1, this.lp.getNumRows());

         rowIndex = this.lp.addRow(

                 new DoubleLPConstraint("b", LPConstraint.REL_LESS, 1.0),

                 new DoubleVector(dummyArr));

         assertEquals("numbering of columns starts with 0", 1, rowIndex);

         assertEquals(2, this.lp.getNumColumns());

         assertEquals(2, this.lp.getNumRows());

     }

     public void testAddColumn() {

         this.lp.setInitialDimensions(2, 2);

         this.lp.addConstraint(new DoubleLPConstraint("a",

                 LPConstraint.REL_EQUAL, 1.0));

         this.lp.addConstraint(new DoubleLPConstraint("b",

                 LPConstraint.REL_LESS, -1.0));

         assertEquals(0, this.lp.getNumColumns());

         assertEquals(2, this.lp.getNumRows());

         int columnIndex =

             this.lp.addColumn(new DoubleLPVariable("a", 0.0,

                     0, Double.POSITIVE_INFINITY),

                     new DoubleVector(dummyArr));

         assertEquals("numbering of columns starts with 0", 0, columnIndex);

         assertEquals(1, this.lp.getNumColumns());

         assertEquals(2, this.lp.getNumRows());

         columnIndex =

             this.lp.addColumn(new DoubleLPVariable("b", 1.0,

                     0, Double.POSITIVE_INFINITY),

                     new DoubleVector(dummyArr));

         assertEquals("numbering of columns starts with 0", 1, columnIndex);

         assertEquals(2, this.lp.getNumColumns());

         assertEquals(2, this.lp.getNumRows());

     }

     public void testSolveFeasibleLPMax() {

         setupLP(this.lp, LPSolver.LPOBJ_MAX, constrFeas1, varsFeas1Max);

         solveAndCheckLP(LPSolver.LPSTAT_SOLVED, zFeas1Max, solFeas1Max);

     }

     public void testSolveFeasibleLPMin() {

         setupLP(this.lp, LPSolver.LPOBJ_MIN, constrFeas1, varsFeas1Min);

         solveAndCheckLP(LPSolver.LPSTAT_SOLVED, zFeas1Min, solFeas1Min);

     }

     public void testSolveSparseLP() {

         setupSparseLP(this.lp, LPSolver.LPOBJ_MAX, constrFeas2,

                 rowIndFeas2, rowValFeas2, varsFeas2);

         solveAndCheckLP(LPSolver.LPSTAT_SOLVED, zFeas2, solFeas2);

     }

     public void testSolveSparseLPWithUnsortedIndices() {

         setupSparseLP(this.lp, LPSolver.LPOBJ_MAX, constrFeas2,

                 rowIndFeas2Unordered, rowValFeas2Unordered, varsFeas2);

         solveAndCheckLP(LPSolver.LPSTAT_SOLVED, zFeas2, solFeas2);

     }

     public void testSolveUnboundedLP() {

         setupLP(this.lp, LPSolver.LPOBJ_MIN, constrUnbounded, varsUnbounded);

         solveAndCheckLP(LPSolver.LPSTAT_UNBOUNDED);

     }

     public void testSolveInfeasibleLP() {

         setupLP(this.lp, LPSolver.LPOBJ_MAX, constrInfeas, varsInfeas);

         solveAndCheckLP(LPSolver.LPSTAT_INFEASIBLE);

     }

     public void testSolveFeasibleLPBuildColumnWise() {

         setupLPColumnwise(this.lp, LPSolver.LPOBJ_MAX,

                 constrFeas1, varsFeas1Max, colFeas1);

         solveAndCheckLP(LPSolver.LPSTAT_SOLVED, zFeas1Max, solFeas1Max);

     }

 }