package com.imsl.test.example.math;

import com.imsl.math.*;

/**
 * <p>
 * Solves a linear programming problem in \(5\) variables.</p>
 *
 * This example solves the following linear programming problem:
 *
 * <p>
 * $${\rm {max}} \,\, f(x) = 10x_1 + 15x_2 + 15x_3 + 13x_4 + 9x_5$$</p>
 * <p>
 * subject to the following set of constraints,
 * </p>
 * $$ \begin{array}{cc} 100x_1 + 50x_2 + 50x_3 + 40x_4 + 120x_5 &\le& 300\\
 * 40x_1 + 50x_2 + 50x_3 + 15x_4 + 30x_5 &\le& 40 \end{array} $$
 * <p>
 * and bounds: $$0.0 \le x_i \le 1.0, i=1,2,\ldots,5$$</p>
 *
 * <p>
 * Note that since <code>DenseLP</code> <i>minimizes</i>, the sign of the
 * objective function must be changed to compute this solution. The signs of the
 * dual solution components and the optimal value must also be changed. Because
 * \(x_2\) and \(x_3\) are not uniquely determined within the bounds, this
 * problem has a convex family of solutions. DenseLP issues an exception,
 * <code>MultipleSolutionsException</code>. A particular solution is available
 * and retrieved in the <code>finally</code> block.
 * </p>
 *
 * @see <a href="DenseLPEx3.java">Code</a>
 * @see <a href="doc-files/DenseLPEx3.out">Output</a>
 *
 */
public class DenseLPEx3 {

    public static void main(String[] args) throws Exception {

        int[] constraintType = {1, 1}; // Ax <= b 

        double[] lowerVariableBound = {0.0, 0.0, 0.0, 0.0, 0.0};
        double[] upperVariableBound = {1.0, 1.0, 1.0, 1.0, 1.0};

        double[][] A = {
            {100.0, 50.0, 50.0, 40.0, 120.0},
            {40.0, 50.0, 50.0, 15.0, 30.0}
        };
        double[] b = {300.0, 40.0};  // constraint type Ax <= b 

        double[] c = {10.0, 15.0, 15.0, 13.0, 9.0};

        /*  Since DenseLP minimizes, change signs of the
         objective coefficients. */
        double[] negC = new double[c.length];
        for (int i = 0; i < c.length; i++) {
            negC[i] = -c[i];
        }

        DenseLP zf = new DenseLP(A, b, negC);
        zf.setLowerBound(lowerVariableBound);
        zf.setConstraintType(constraintType);
        zf.setUpperBound(upperVariableBound);

        try {
            zf.solve();
        } catch (DenseLP.MultipleSolutionsException e) {
            /* x_2 and x_3 are not uniquely determined, expect multiple solutions. 
             * Catch the exception, but continue to print result found. */
            System.out.println("Multiple solutions giving "
                    + "essentially the same minimum exist.");
        } finally {
            double[] dSolution = zf.getDualSolution();
            /* Change the sign of the dual solution and optimal value 
             * since DenseLP minimizes. */
            for (int i = 0; i < dSolution.length; i++) {
                dSolution[i] = -dSolution[i];
            }
            double optimalValue = -zf.getOptimalValue();

            new PrintMatrix("Solution").print(zf.getPrimalSolution());
            new PrintMatrix("Dual Solution").print(dSolution);
            System.out.println("Optimal Value = " + optimalValue);
        }
    }
}