How to encourage a balanced solution in ojAlgo ExpressionBasedModel

Question

I have the following model:

        ExpressionsBasedModel model = new ExpressionsBasedModel();

        Variable va = model.addVariable("va")
                .lower(0);

        Variable vb = model.addVariable("vb")
                .lower(0);

        Variable vc = model.addVariable("vc")
                .lower(0);

        Variable vd = model.addVariable("vd")
                .lower(0);

        Variable ve = model.addVariable("ve")
                .lower(0);

        Expression ef = model.addExpression("ef")
                .lower(0);

        Expression eg = model.addExpression("eg")
                .lower(0);

        Expression eh = model.addExpression("eh")
                .lower(-240);

        Expression ei = model.addExpression("ei")
                .lower(0);

        Expression ej = model.addExpression("ej")
                .lower(0);

        Expression ek = model.addExpression("ek")
                .lower(0);

        Expression el = model.addExpression("el")
                .lower(-2000);

        ef.set(va, -50);
        el.set(va, -100);
        eg.set(va, 100);

        eh.set(vb, -30);
        ef.set(vb, 40);
        ej.set(vb, 20);

        ek.set(vc, -30);
        eg.set(vc, -30);
        ei.set(vc, 60);

        ei.set(vd, -30);
        eg.set(vd, -30);
        ek.set(vd, 60);

        ej.set(ve, -40);
        el.set(ve, -40);
        ek.set(ve, 20);

        ei.weight(1);
        ek.weight(1);

        /*
         * These next 2 lines required to get balanced solution.
         * Without them ei = 720 and ek = 0.
         */
//        ek.lower(360);
//        ei.lower(360);

        model.maximise();

        BasicLogger.debug(model);

Although ei and ek are equally weighted, the solution I get is:

############################################
0 <= va: 6.4 <= 6.4
0 <= vb: 8 <= 8
0 <= vc: 15.111111 (300)
0 <= vd: 6.222222 (300)
0 <= ve: 4 (200) <= 4
0 <= ef: 0.0
0 <= eg: 0.0
-240 <= eh: -240.0
0 <= ei: 720.0
0 <= ej: 0.0
0 <= ek: -0.0
-2000 <= el: -800.0
############################################

ei == 720, ek == 0.

I would prefer a solution in which ei and ek are as balanced as possible, (ei == 360, ek == 360). Is there some way of encoding that requirement for "as balanced as possible" as a weighted expression?

In this specific example I have commented out the lower value constraint that actually result in the behavior I want. In real life, the model is dynamic and I may have 5 equally weighted expressions. I won't know the correct values in order to set the lower constraints.

Maybe try https://math.stackexchange.com for optimisation modelling questions. Both ei and ek are restricted to positive values, then can't you just penalise the difference between those 2 expressions? — apete, Feb 10 '22 at 07:35
Cannot penalize difference because penalizing, say, `ei - ek` then maximizes `ek`. If you do both they cancel out. — elcheapogary, Feb 11 '22 at 14:30
You can have different weights on different expressions (different orders of magnitude) but doesn't matter now – you found a solution. — apete, Feb 11 '22 at 15:51

score 1 · Accepted Answer · answered Feb 11 '22 at 14:38

For future readers, I was able to do this by first converting the values represented by ei and ek into new variables, with the existing expressions ei and ek constraining the value of the new variables to the value these expressions previously had. Then I added a new variable, weighted it heavily, and constrained it to be less than each of the new variables.

        Expression ei = model.addExpression("ei")
                .lower(0);

        Expression ek = model.addExpression("ek")
                .lower(0);

became:

        Expression ei = model.addExpression("ei")
                .level(0);
        Variable vei = model.addVariable("vei")
                .lower(0);
        ei.set(vei, -1);

        Expression ek = model.addExpression("ek")
                .level(0);
        Variable vek = model.addVariable("vek")
                .lower(0);
        ek.set(vek, -1);

Weighting became:

        vei.weight(1);
        vek.weight(1);

And added balance variable and constraints:

        Variable balance = model.addVariable("balance")
                .weight(100);

        model.addExpression("balance constraint for vei")
                .set(vei, 1)
                .set(balance, -1)
                .lower(0);

        model.addExpression("balance constraint for vek")
                .set(vek, 1)
                .set(balance, -1)
                .lower(0);

This results in a solution that is as balanced as possible:

############################################
0 <= va: 6.4 <= 6.4
0 <= vb: 8 <= 8
0 <= vc: 11.111111
0 <= vd: 10.222222
0 <= ve: 4 <= 4
0 <= vei: 360 (1)
0 <= vek: 360 (1)
balance: 360 (100)
0 <= ef: 0.0
0 <= eg: 0.0
-240 <= eh: -240.0
0 <= ei: 0.0 <= 0
0 <= ej: 0.0
0 <= ek: -0.0 <= 0
-2000 <= el: -800.0
0 <= balance constraint for vei: 0.0
0 <= balance constraint for vek: 0.0
############################################

How to encourage a balanced solution in ojAlgo ExpressionBasedModel

1 Answers1