Examples with Result org.ojalgo.optimisation.Optimisation.Result used on opensource projects

Example 21 with Result

use of org.ojalgo.optimisation.Optimisation.Result in project ojAlgo by optimatika.

the class IntegerProblems method testP20130409b.

/**
 * Test case sent in by the user / problem reporter
 * <a href="http://bugzilla.optimatika.se/show_bug.cgi?id=178">BugZilla</a>
 */
@Test
public void testP20130409b() {
    final Variable x1 = Variable.make("x1");
    final Variable x2013 = Variable.make("x2013");
    final Variable x2014 = Variable.make("x2014");
    final Variable x2015 = Variable.make("x2015");
    x2013.setInteger(true);
    x2014.setInteger(true);
    x2015.setInteger(true);
    final ExpressionsBasedModel tmpModel = new ExpressionsBasedModel();
    tmpModel.addVariable(x1);
    tmpModel.addVariable(x2013);
    tmpModel.addVariable(x2014);
    tmpModel.addVariable(x2015);
    final Expression obj = tmpModel.addExpression("obj");
    obj.set(x1, 1);
    obj.weight(BigDecimal.valueOf(1));
    final Expression c1 = tmpModel.addExpression("c1");
    c1.set(x1, 1);
    c1.lower(BigDecimal.valueOf(0));
    final Expression c2 = tmpModel.addExpression("c2");
    c2.set(x2014, -5000);
    c2.set(x2013, 5100);
    c2.set(x1, -1);
    c2.upper(BigDecimal.valueOf(0));
    final Expression c3 = tmpModel.addExpression("c3");
    c3.set(x2014, -5000);
    c3.set(x2013, 5100);
    c3.set(x1, 1);
    c3.lower(BigDecimal.valueOf(0));
    final Expression c4 = tmpModel.addExpression("c4");
    c4.set(x2014, 150);
    c4.set(x2013, 5100);
    c4.set(x2015, -5000);
    c4.set(x1, -1);
    c4.upper(BigDecimal.valueOf(0));
    final Expression c5 = tmpModel.addExpression("c5");
    c5.set(x2014, 150);
    c5.set(x2013, 5100);
    c5.set(x2015, -5000);
    c5.set(x1, 1);
    c5.lower(BigDecimal.valueOf(0));
    final Expression c6 = tmpModel.addExpression("c6");
    c6.set(x2015, 5000);
    c6.set(x2014, 5000);
    c6.set(x2013, 5000);
    c6.level(BigDecimal.valueOf(19105000));
    final BigArray tmpExpSol = BigArray.wrap(new BigDecimal[] { BigDecimal.valueOf(4849.999999997941), BigDecimal.valueOf(1245), BigDecimal.valueOf(1269), BigDecimal.valueOf(1307) });
    TestUtils.assertTrue("Expected Solution Not Valid", tmpModel.validate(tmpExpSol));
    // tmpModel.options.debug(IntegerSolver.class);
    // tmpModel.options.problem = NumberContext.getGeneral(8);
    final Result tmpResult = tmpModel.minimise();
    // BasicLogger.debug(tmpResult.toString());
    TestUtils.assertEquals("Solution Not Correct", tmpExpSol, tmpResult, new NumberContext(8, 8));
    TestUtils.assertTrue("Solver State Not Optimal", tmpResult.getState().isOptimal());
}

Example 22 with Result

use of org.ojalgo.optimisation.Optimisation.Result in project ojAlgo by optimatika.

the class IntegerProblems method testP20140819.

/**
 * <a href="http://bugzilla.optimatika.se/show_bug.cgi?id=211">BugZilla-211</a>
 */
@Test
public void testP20140819() {
    final ExpressionsBasedModel tmpModel = new ExpressionsBasedModel();
    final double[] tmpWeights = new double[] { 2691.5357279536333, 2600.760150603986, 2605.8958795795374, 2606.7208332501104, 2715.0757845953835, 2602.194912040238, 2606.0069468717575, 2609.0385816244316, 2750.0520522057927, 2602.048261785581, 2600.507229973181, 2602.046307869504, 2721.343937605796, 2601.7367414553805, 2600.595318433882, 2599.405979211142 };
    for (int v = 0; v < tmpWeights.length; v++) {
        tmpModel.addVariable(Variable.make("x" + v).integer(true).lower(0).upper(414).weight(tmpWeights[v]));
    }
    // 117 <= 30 30 30 30 0 4 0 0 0 4 0 0 0 4 0 0 <= 14868
    // 36 <= 0 4 0 0 40 40 40 40 0 0 4 0 0 0 4 0 <= 170569
    // 341 <= 0 0 8 0 0 0 8 0 68 68 68 68 0 0 0 5 <= 140833
    // 413 <= 0 0 0 8 0 0 0 9 0 0 0 6 59 59 59 59 <= 48321
    final int[] tmpLower = new int[] { 117, 36, 341, 413 };
    final int[] tmpUpper = new int[] { 14868, 170569, 140833, 48321 };
    final int[][] tmpFactors = new int[4][];
    tmpFactors[0] = new int[] { 30, 30, 30, 30, 0, 4, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0 };
    tmpFactors[1] = new int[] { 0, 4, 0, 0, 40, 40, 40, 40, 0, 0, 4, 0, 0, 0, 4, 0 };
    tmpFactors[2] = new int[] { 0, 0, 8, 0, 0, 0, 8, 0, 68, 68, 68, 68, 0, 0, 0, 5 };
    tmpFactors[3] = new int[] { 0, 0, 0, 8, 0, 0, 0, 9, 0, 0, 0, 6, 59, 59, 59, 59 };
    for (int c = 0; c < tmpFactors.length; c++) {
        final Expression tmpExpr = tmpModel.addExpression("C" + c);
        tmpExpr.lower(tmpLower[c]).upper(tmpUpper[c]);
        for (int v = 0; v < tmpFactors[c].length; v++) {
            tmpExpr.set(v, tmpFactors[c][v]);
        }
    }
    // tmpModel.options.debug(IntegerSolver.class);
    final Result tmpResult = tmpModel.minimise();
    if (OptimisationIntegerTests.DEBUG) {
        BasicLogger.debug(tmpResult);
        BasicLogger.debug(tmpModel);
    }
    TestUtils.assertStateNotLessThanOptimal(tmpResult);
    TestUtils.assertTrue(tmpModel.validate(tmpResult));
}

Example 23 with Result

use of org.ojalgo.optimisation.Optimisation.Result in project ojAlgo by optimatika.

the class ExpressionsBasedModelTest method testMPStestprob.

@Test
public void testMPStestprob() {
    final Variable tmpXONE = new Variable("XONE").weight(ONE).lower(ZERO).upper(FOUR);
    final Variable tmpYTWO = new Variable("YTWO").weight(FOUR).lower(NEG).upper(ONE);
    final Variable tmpZTHREE = new Variable("ZTHREE").weight(NINE).lower(ZERO).upper(null);
    final Variable[] tmpVariables = new Variable[] { tmpXONE, tmpYTWO, tmpZTHREE };
    final ExpressionsBasedModel tmpModel = new ExpressionsBasedModel(tmpVariables);
    final BigDecimal[] tmpFactorsLIM1 = new BigDecimal[] { ONE, ONE, ZERO };
    final Expression tmpLIM1 = tmpModel.addExpression("LIM1");
    for (int v = 0; v < tmpVariables.length; v++) {
        tmpLIM1.set(v, tmpFactorsLIM1[v]);
    }
    tmpLIM1.upper(FIVE.add(TENTH));
    final BigDecimal[] tmpFactorsLIM2 = new BigDecimal[] { ONE, ZERO, ONE };
    final Expression tmpLIM2 = tmpModel.addExpression("LIM2");
    for (int v = 0; v < tmpVariables.length; v++) {
        tmpLIM2.set(v, tmpFactorsLIM2[v]);
    }
    tmpLIM2.lower(TEN.add(TENTH));
    final BigDecimal[] tmpFactorsMYEQN = new BigDecimal[] { ZERO, ONE.negate(), ONE };
    final Expression tmpMYEQN = tmpModel.addExpression("MYEQN");
    for (int v = 0; v < tmpVariables.length; v++) {
        tmpMYEQN.set(v, tmpFactorsMYEQN[v]);
    }
    tmpMYEQN.level(SEVEN);
    TestUtils.assertTrue(tmpModel.validate());
    final Result tmpMinRes = tmpModel.minimise();
    final Result tmpMaxRes = tmpModel.maximise();
    if (OptimisationTests.DEBUG) {
        BasicLogger.debug(tmpMinRes);
        BasicLogger.debug(tmpMaxRes);
    }
    TestUtils.assertTrue(tmpModel.validate(tmpMinRes));
    TestUtils.assertTrue(tmpModel.validate(tmpMaxRes));
    tmpXONE.integer(true);
    tmpYTWO.integer(true);
    tmpZTHREE.integer(true);
    // Not integer solution
    TestUtils.assertFalse(tmpModel.validate(tmpMinRes));
    // Integer solution
    TestUtils.assertTrue(tmpModel.validate(tmpMaxRes));
    tmpYTWO.lower(ONE).upper(NEG);
    TestUtils.assertFalse(tmpModel.validate());
}

Example 24 with Result

use of org.ojalgo.optimisation.Optimisation.Result in project ojAlgo by optimatika.

the class OJAlgoTest3 method main.

/**
 * @param args the command line arguments Objective: allocate the maximum qty, and try to keep
 *        proportionality between customer.
 */
public static void main(final String[] args) {
    /*
         * 5 Products with associated Qty.
         */
    final Map<String, Integer> constraintsProduct = new HashMap<>();
    constraintsProduct.put("PRODUCT_1", 296_000);
    constraintsProduct.put("PRODUCT_2", 888_000);
    constraintsProduct.put("PRODUCT_3", 636_000);
    constraintsProduct.put("PRODUCT_4", 220_000);
    constraintsProduct.put("PRODUCT_5", 0);
    final double stockTotal = constraintsProduct.values().stream().mapToDouble(e -> e.doubleValue()).sum();
    BasicLogger.debug("STOCK_TOTAL " + stockTotal);
    /*
         * Demand of each Customers
         */
    final Map<String, Integer> constraintsCustomer = new LinkedHashMap<>();
    constraintsCustomer.put("CUSTOMER_A_1", 72_000);
    constraintsCustomer.put("CUSTOMER_A_2", 44_000);
    constraintsCustomer.put("CUSTOMER_A_3", 12_000);
    constraintsCustomer.put("CUSTOMER_A_4", 36_000);
    constraintsCustomer.put("CUSTOMER_A_5", 0);
    constraintsCustomer.put("CUSTOMER_A_6", 36_000);
    constraintsCustomer.put("CUSTOMER_A_7", 12_000);
    constraintsCustomer.put("CUSTOMER_A_8", 0);
    constraintsCustomer.put("CUSTOMER_A_9", 0);
    constraintsCustomer.put("CUSTOMER_A_10", 12_000);
    constraintsCustomer.put("CUSTOMER_A_11", 12_000);
    constraintsCustomer.put("CUSTOMER_A_12", 0);
    constraintsCustomer.put("CUSTOMER_A_13", 0);
    constraintsCustomer.put("CUSTOMER_A_14", 0);
    constraintsCustomer.put("CUSTOMER_B_1", 24_000);
    constraintsCustomer.put("CUSTOMER_B_2", 12_000);
    constraintsCustomer.put("CUSTOMER_B_3", 300);
    constraintsCustomer.put("CUSTOMER_C_1", 24_000);
    constraintsCustomer.put("CUSTOMER_D_1", 20_000);
    constraintsCustomer.put("CUSTOMER_E_1", 12_000);
    constraintsCustomer.put("CUSTOMER_F_1", 12_000);
    constraintsCustomer.put("CUSTOMER_G_1", 72_000);
    constraintsCustomer.put("CUSTOMER_H_1", 28_000);
    constraintsCustomer.put("CUSTOMER_I_1", 24_000);
    constraintsCustomer.put("CUSTOMER_J_1", 16_000);
    constraintsCustomer.put("CUSTOMER_K_1", 24_000);
    constraintsCustomer.put("CUSTOMER_L_1", 56_000);
    final double demandTotal = constraintsCustomer.values().stream().mapToDouble(e -> e.doubleValue()).sum();
    BasicLogger.debug("DEMAND_TOTAL " + demandTotal);
    /*
         * User constraint. In this case, user want to allocate 236_000 Qty on Customer_A_*
         */
    final double userConstraintQty = 236_000;
    final List<String> userConstraint = new ArrayList<>();
    userConstraint.add("CUSTOMER_A_1|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_2|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_3|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_4|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_5|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_6|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_7|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_8|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_9|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_10|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_11|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_12|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_13|PRODUCT_2");
    userConstraint.add("CUSTOMER_A_14|PRODUCT_2");
    // List of Variable Names
    final List<String> variablesName = new ArrayList<>();
    variablesName.add("CUSTOMER_A_1|PRODUCT_2");
    variablesName.add("CUSTOMER_A_2|PRODUCT_2");
    variablesName.add("CUSTOMER_A_3|PRODUCT_2");
    variablesName.add("CUSTOMER_A_4|PRODUCT_2");
    variablesName.add("CUSTOMER_A_5|PRODUCT_2");
    variablesName.add("CUSTOMER_A_6|PRODUCT_2");
    variablesName.add("CUSTOMER_A_7|PRODUCT_2");
    variablesName.add("CUSTOMER_A_8|PRODUCT_2");
    variablesName.add("CUSTOMER_A_9|PRODUCT_2");
    variablesName.add("CUSTOMER_A_10|PRODUCT_2");
    variablesName.add("CUSTOMER_A_11|PRODUCT_2");
    variablesName.add("CUSTOMER_A_12|PRODUCT_2");
    variablesName.add("CUSTOMER_A_13|PRODUCT_2");
    variablesName.add("CUSTOMER_A_14|PRODUCT_2");
    variablesName.add("CUSTOMER_B_1|PRODUCT_2");
    variablesName.add("CUSTOMER_B_1|PRODUCT_3");
    variablesName.add("CUSTOMER_B_2|PRODUCT_2");
    variablesName.add("CUSTOMER_B_2|PRODUCT_3");
    variablesName.add("CUSTOMER_B_3|PRODUCT_2");
    variablesName.add("CUSTOMER_B_3|PRODUCT_3");
    variablesName.add("CUSTOMER_C_1|PRODUCT_2");
    variablesName.add("CUSTOMER_C_1|PRODUCT_3");
    variablesName.add("CUSTOMER_D_1|PRODUCT_4");
    variablesName.add("CUSTOMER_D_1|PRODUCT_5");
    variablesName.add("CUSTOMER_D_1|PRODUCT_2");
    variablesName.add("CUSTOMER_D_1|PRODUCT_3");
    variablesName.add("CUSTOMER_E_1|PRODUCT_1");
    variablesName.add("CUSTOMER_F_1|PRODUCT_4");
    variablesName.add("CUSTOMER_F_1|PRODUCT_5");
    variablesName.add("CUSTOMER_F_1|PRODUCT_2");
    variablesName.add("CUSTOMER_F_1|PRODUCT_3");
    variablesName.add("CUSTOMER_G_1|PRODUCT_4");
    variablesName.add("CUSTOMER_G_1|PRODUCT_5");
    variablesName.add("CUSTOMER_G_1|PRODUCT_2");
    variablesName.add("CUSTOMER_G_1|PRODUCT_3");
    variablesName.add("CUSTOMER_H_1|PRODUCT_4");
    variablesName.add("CUSTOMER_H_1|PRODUCT_5");
    variablesName.add("CUSTOMER_H_1|PRODUCT_2");
    variablesName.add("CUSTOMER_H_1|PRODUCT_3");
    variablesName.add("CUSTOMER_I_1|PRODUCT_4");
    variablesName.add("CUSTOMER_I_1|PRODUCT_5");
    variablesName.add("CUSTOMER_I_1|PRODUCT_2");
    variablesName.add("CUSTOMER_I_1|PRODUCT_3");
    variablesName.add("CUSTOMER_J_1|PRODUCT_4");
    variablesName.add("CUSTOMER_J_1|PRODUCT_5");
    variablesName.add("CUSTOMER_J_1|PRODUCT_2");
    variablesName.add("CUSTOMER_J_1|PRODUCT_3");
    variablesName.add("CUSTOMER_K_1|PRODUCT_4");
    variablesName.add("CUSTOMER_K_1|PRODUCT_5");
    variablesName.add("CUSTOMER_K_1|PRODUCT_2");
    variablesName.add("CUSTOMER_K_1|PRODUCT_3");
    variablesName.add("CUSTOMER_L_1|PRODUCT_1");
    /*
         *
         */
    final ExpressionsBasedModel model = new ExpressionsBasedModel();
    final List<Variable> variables = new ArrayList<>();
    /*
         * Create All Variables:
         */
    BasicLogger.debug("---- Variable creation ------");
    variablesName.forEach(name -> {
        final Variable var = Variable.make(name).lower(0.0).weight(1.0);
        model.addVariable(var);
        variables.add(var);
        BasicLogger.debug(var);
    });
    BasicLogger.debug("---- Constraints customers ------");
    // Apply Customers constraints.
    // CUSTOMER_A of Demand constraint because managed by user constraints.
    constraintsCustomer.entrySet().stream().filter(e -> !e.getKey().startsWith("CUSTOMER_A")).forEach(entry -> {
        final List<Variable> linked = variables.stream().filter(v -> v.getName().startsWith(entry.getKey())).collect(Collectors.toList());
        final Expression constraint = model.addExpression("CONSTRAINTS_" + entry.getKey());
        constraint.upper(entry.getValue().doubleValue());
        constraint.setLinearFactorsSimple(linked);
        BasicLogger.debug(constraint);
    });
    BasicLogger.debug("---- User Constraints Customers ------");
    // Apply Product Type constraints.
    final List<Variable> userLinked = variables.stream().filter(v -> userConstraint.contains(v.getName())).collect(Collectors.toList());
    final Expression constraintUser = model.addExpression("CONSTRAINTS_USER_CUSTOMER_A");
    constraintUser.level(userConstraintQty);
    constraintUser.setLinearFactorsSimple(userLinked);
    BasicLogger.debug(constraintUser);
    BasicLogger.debug("---- Constraints Product ------");
    // Apply Product Type constraints.
    constraintsProduct.entrySet().forEach(entry -> {
        final List<Variable> linked = variables.stream().filter(v -> v.getName().endsWith(entry.getKey())).collect(Collectors.toList());
        final Expression constraint = model.addExpression("CONSTRAINTS_" + entry.getKey());
        constraint.upper(entry.getValue().doubleValue());
        constraint.setLinearFactorsSimple(linked);
        BasicLogger.debug(constraint);
    });
    /*
         * Objective expression. - Maximize the Sum of all variables - Minimize the Sum of square error vs
         * proportionality.
         */
    BasicLogger.debug("---- Objective  ------");
    final Expression objective = model.addExpression("OBJECTIVE").weight(-1.0);
    // - Maximize the Sum of all variables
    // objective.setLinearFactorsSimple(variables);
    BasicLogger.debug("---- Error formula ------");
    /*
         * Example: x1, x2, x3 linked variables for Customer X Error = ( (x1+x2+x3) / Target - 1 )^2 * ratio
         */
    constraintsCustomer.entrySet().forEach(entry -> {
        final List<Variable> linked = variables.stream().filter(v -> v.getName().startsWith(entry.getKey())).collect(Collectors.toList());
        if (!linked.isEmpty() && (entry.getValue().doubleValue() > 0)) {
            final double demand = entry.getValue();
            final double ratio = demand / demandTotal;
            final double target = stockTotal * ratio;
            linked.forEach(v1 -> {
                linked.forEach(v2 -> {
                    objective.set(v1, v2, ratio / (target * target));
                });
                objective.set(v1, (-2.0 * ratio) / target);
            });
        }
    });
    // - Maximise
    // model.options.validate = true;
    final Result result = model.maximise();
    BasicLogger.debug(result);
    // GOOD  OPTIMAL 560300.4702803734
    // WRONG OPTIMAL 560300.4015031556
    BasicLogger.debug("");
    BasicLogger.debug("");
    variables.forEach(v -> BasicLogger.debug(v.getName() + " = " + v.getValue().doubleValue()));
/*
         * WRONG ALLOCATION CUSTOMER_A_1|PRODUCT_2 = 236000.0 CUSTOMER_A_2|PRODUCT_2 = 0.0
         * CUSTOMER_A_3|PRODUCT_2 = 0.0 CUSTOMER_A_4|PRODUCT_2 = 0.0 CUSTOMER_A_5|PRODUCT_2 = 0.0
         * CUSTOMER_A_6|PRODUCT_2 = 0.0 CUSTOMER_A_7|PRODUCT_2 = 0.0 CUSTOMER_A_8|PRODUCT_2 = 0.0
         * CUSTOMER_A_9|PRODUCT_2 = 0.0 CUSTOMER_A_10|PRODUCT_2 = 0.0 CUSTOMER_A_11|PRODUCT_2 = 0.0
         * CUSTOMER_A_12|PRODUCT_2 = 0.0 CUSTOMER_A_13|PRODUCT_2 = 0.0 CUSTOMER_A_14|PRODUCT_2 = 0.0
         * CUSTOMER_B_1|PRODUCT_2 = 24000.0 CUSTOMER_B_1|PRODUCT_3 = 0.0 CUSTOMER_B_2|PRODUCT_2 = 12000.0
         * CUSTOMER_B_2|PRODUCT_3 = 0.0 CUSTOMER_B_3|PRODUCT_2 = 0.0 CUSTOMER_B_3|PRODUCT_3 = 300.0
         * CUSTOMER_C_1|PRODUCT_2 = 24000.0 CUSTOMER_C_1|PRODUCT_3 = 0.0 CUSTOMER_D_1|PRODUCT_4 = 20000.0
         * CUSTOMER_D_1|PRODUCT_5 = 0.0 CUSTOMER_D_1|PRODUCT_2 = 0.0 CUSTOMER_D_1|PRODUCT_3 = 0.0
         * CUSTOMER_E_1|PRODUCT_1 = 12000.0 CUSTOMER_F_1|PRODUCT_4 = 12000.0 CUSTOMER_F_1|PRODUCT_5 = 0.0
         * CUSTOMER_F_1|PRODUCT_2 = 0.0 CUSTOMER_F_1|PRODUCT_3 = 0.0 CUSTOMER_G_1|PRODUCT_4 = 72000.0
         * CUSTOMER_G_1|PRODUCT_5 = 0.0 CUSTOMER_G_1|PRODUCT_2 = 0.0 CUSTOMER_G_1|PRODUCT_3 = 0.0
         * CUSTOMER_H_1|PRODUCT_4 = 28000.0 CUSTOMER_H_1|PRODUCT_5 = 0.0 CUSTOMER_H_1|PRODUCT_2 = 0.0
         * CUSTOMER_H_1|PRODUCT_3 = 0.0 CUSTOMER_I_1|PRODUCT_4 = 24000.0 CUSTOMER_I_1|PRODUCT_5 = 0.0
         * CUSTOMER_I_1|PRODUCT_2 = 0.0 CUSTOMER_I_1|PRODUCT_3 = 0.0 CUSTOMER_J_1|PRODUCT_4 = 16000.0
         * CUSTOMER_J_1|PRODUCT_5 = 0.0 CUSTOMER_J_1|PRODUCT_2 = 0.0 CUSTOMER_J_1|PRODUCT_3 = 0.0
         * CUSTOMER_K_1|PRODUCT_4 = 24000.0 CUSTOMER_K_1|PRODUCT_5 = 0.0 CUSTOMER_K_1|PRODUCT_2 = 0.0
         * CUSTOMER_K_1|PRODUCT_3 = 0.0 CUSTOMER_L_1|PRODUCT_1 = 56000.0
         */
/*
         * GOOD ALLOCATION CUSTOMER_A_1|PRODUCT_2 = 80150.9434796 CUSTOMER_A_2|PRODUCT_2 = 48981.1320493
         * CUSTOMER_A_3|PRODUCT_2 = 13358.4905589 CUSTOMER_A_4|PRODUCT_2 = 40075.4716767
         * CUSTOMER_A_5|PRODUCT_2 = 0.0 CUSTOMER_A_6|PRODUCT_2 = 40075.4716767 CUSTOMER_A_7|PRODUCT_2 =
         * 13358.4905589 CUSTOMER_A_8|PRODUCT_2 = 0.0 CUSTOMER_A_9|PRODUCT_2 = 0.0 CUSTOMER_A_10|PRODUCT_2 =
         * 0.0 CUSTOMER_A_11|PRODUCT_2 = 0.0 CUSTOMER_A_12|PRODUCT_2 = 0.0 CUSTOMER_A_13|PRODUCT_2 = 0.0
         * CUSTOMER_A_14|PRODUCT_2 = 0.0 CUSTOMER_B_1|PRODUCT_2 = 24000.0 CUSTOMER_B_1|PRODUCT_3 = 0.0
         * CUSTOMER_B_2|PRODUCT_2 = 12000.0 CUSTOMER_B_2|PRODUCT_3 = 0.0 CUSTOMER_B_3|PRODUCT_2 = 0.0
         * CUSTOMER_B_3|PRODUCT_3 = 300.0 CUSTOMER_C_1|PRODUCT_2 = 24000.0 CUSTOMER_C_1|PRODUCT_3 = 0.0
         * CUSTOMER_D_1|PRODUCT_4 = 20000.0 CUSTOMER_D_1|PRODUCT_5 = 0.0 CUSTOMER_D_1|PRODUCT_2 = 0.0
         * CUSTOMER_D_1|PRODUCT_3 = 0.0 CUSTOMER_E_1|PRODUCT_1 = 12000.0 CUSTOMER_F_1|PRODUCT_4 = 12000.0
         * CUSTOMER_F_1|PRODUCT_5 = 0.0 CUSTOMER_F_1|PRODUCT_2 = 0.0 CUSTOMER_F_1|PRODUCT_3 = 0.0
         * CUSTOMER_G_1|PRODUCT_4 = 72000.0 CUSTOMER_G_1|PRODUCT_5 = 0.0 CUSTOMER_G_1|PRODUCT_2 = 0.0
         * CUSTOMER_G_1|PRODUCT_3 = 0.0 CUSTOMER_H_1|PRODUCT_4 = 28000.0 CUSTOMER_H_1|PRODUCT_5 = 0.0
         * CUSTOMER_H_1|PRODUCT_2 = 0.0 CUSTOMER_H_1|PRODUCT_3 = 0.0 CUSTOMER_I_1|PRODUCT_4 = 24000.0
         * CUSTOMER_I_1|PRODUCT_5 = 0.0 CUSTOMER_I_1|PRODUCT_2 = 0.0 CUSTOMER_I_1|PRODUCT_3 = 0.0
         * CUSTOMER_J_1|PRODUCT_4 = 16000.0 CUSTOMER_J_1|PRODUCT_5 = 0.0 CUSTOMER_J_1|PRODUCT_2 = 0.0
         * CUSTOMER_J_1|PRODUCT_3 = 0.0 CUSTOMER_K_1|PRODUCT_4 = 24000.0 CUSTOMER_K_1|PRODUCT_5 = 0.0
         * CUSTOMER_K_1|PRODUCT_2 = 0.0 CUSTOMER_K_1|PRODUCT_3 = 0.0 CUSTOMER_L_1|PRODUCT_1 = 56000.0
         */
}

Example 25 with Result

use of org.ojalgo.optimisation.Optimisation.Result in project ojAlgo by optimatika.

the class LinearDesignTestCases method testDuality.

/**
 * http://web.mit.edu/15.053/www/AMP-Chapter-04.pdf
 * https://web.fe.up.pt/~mac/ensino/docs/OT20122013/Chapter%204%20-%20Duality%20in%20Linear%20Programming.pdf
 */
@Test
public void testDuality() {
    final Factory<Double, PrimitiveDenseStore> factory = PrimitiveDenseStore.FACTORY;
    final PrimitiveDenseStore expPrimSol = factory.rows(new double[] { 36.0, 0.0, 6.0 });
    final PrimitiveDenseStore expDualSol = factory.rows(new double[] { 11.0, 0.5 });
    final double expOptVal = 294.0;
    final LinearSolver.Builder primal = LinearSolver.getBuilder();
    // Negated since actual problem is max and algorithm expects min
    final PrimitiveDenseStore pC = factory.makeZero(5, 1);
    pC.set(0, -6.0);
    pC.set(1, -14.0);
    pC.set(2, -13.0);
    pC.set(3, 0);
    pC.set(4, 0);
    primal.objective(pC);
    final PrimitiveDenseStore pAE = factory.makeZero(2, 5);
    pAE.set(0, 0, 0.5);
    pAE.set(0, 1, 2.0);
    pAE.set(0, 2, 1.0);
    pAE.set(0, 3, 1.0);
    pAE.set(0, 4, 0.0);
    pAE.set(1, 0, 1.0);
    pAE.set(1, 1, 2.0);
    pAE.set(1, 2, 4.0);
    pAE.set(1, 3, 0.0);
    pAE.set(1, 4, 1.0);
    final PrimitiveDenseStore pBE = factory.makeZero(2, 1);
    pBE.set(0, 24.0);
    pBE.set(1, 60.0);
    primal.equalities(pAE, pBE);
    final LinearSolver primalSolver = primal.build();
    // primalSolver.options.debug(LinearSolver.class);
    final Result pRes = primalSolver.solve();
    final Access1D<?> pMultipliers = factory.columns(pRes.getMultipliers().get());
    TestUtils.assertStateNotLessThanOptimal(pRes);
    // Negated since actual problem is max and algorithm expects min
    TestUtils.assertEquals(expOptVal, -pRes.getValue());
    for (int i = 0; i < expPrimSol.count(); i++) {
        TestUtils.assertEquals(expPrimSol.doubleValue(i), pRes.doubleValue(i));
    }
    for (int i = 0; i < expDualSol.count(); i++) {
        // Negated since actual problem is max and algorithm expects min
        TestUtils.assertEquals(expDualSol.doubleValue(i), -pMultipliers.doubleValue(i));
    }
    final LinearSolver.Builder dual = LinearSolver.getBuilder();
    final PrimitiveDenseStore dC = factory.makeZero(5, 1);
    dC.set(0, 24.0);
    dC.set(1, 60.0);
    dC.set(2, 0.0);
    dC.set(3, 0.0);
    dC.set(4, 0.0);
    dual.objective(dC);
    final PrimitiveDenseStore dAE = factory.makeZero(3, 5);
    dAE.set(0, 0, 0.5);
    dAE.set(0, 1, 1.0);
    dAE.set(0, 2, -1.0);
    dAE.set(0, 3, 0.0);
    dAE.set(0, 4, 0.0);
    dAE.set(1, 0, 2.0);
    dAE.set(1, 1, 2.0);
    dAE.set(1, 2, 0.0);
    dAE.set(1, 3, -1.0);
    dAE.set(1, 4, 0.0);
    dAE.set(2, 0, 1.0);
    dAE.set(2, 1, 4.0);
    dAE.set(2, 2, 0.0);
    dAE.set(2, 3, 0.0);
    dAE.set(2, 4, -1.0);
    final PrimitiveDenseStore dBE = factory.makeZero(3, 1);
    dBE.set(0, 6.0);
    dBE.set(1, 14.0);
    dBE.set(2, 13.0);
    dual.equalities(dAE, dBE);
    final LinearSolver dualSolver = dual.build();
    // dualSolver.options.debug(LinearSolver.class);
    final Result dRes = dualSolver.solve();
    final Access1D<?> dMultipliers = factory.columns(dRes.getMultipliers().get());
    TestUtils.assertStateNotLessThanOptimal(dRes);
    TestUtils.assertEquals(expOptVal, dRes.getValue());
    for (int i = 0; i < expDualSol.count(); i++) {
        TestUtils.assertEquals(expDualSol.doubleValue(i), dRes.doubleValue(i));
    }
    for (int i = 0; i < expPrimSol.count(); i++) {
        TestUtils.assertEquals(expPrimSol.doubleValue(i), dMultipliers.doubleValue(i));
    }
}