https://www.maths.ed.ac.uk/hall/Xpress/FICO_Docs/optimizer/HTML...

[Previous chapter] [Next chapter]

Goal Programming

Overview
Note that the Goal Programming functionality of the Optimizer will be dropped
in a future release. This functionality will be replaced by an example program,
available with this release (see goal_example.c in the examples/optimizer/c
folder of the installation), that provides the same functionality as the original
library function XPRSgoal(GOAL) but is implemented using the Optimizer library
interface.
Goal programming is an extension of linear programming in which targets are specified
for a set of constraints. In goal programming there are two basic models: the pre–
emptive (lexicographic) model and the Archimedean model. In the pre–emptive model,
goals are ordered according to priorities. The goals at a certain priority level are
considered to be infinitely more important than the goals at the next level. With the
Archimedean model, weights or penalties for not achieving targets must be specified and
one attempts to minimize the weighted sum of goal under–achievement.
In the Optimizer, goals can be constructed either from constraints or from objective
functions (N rows). If constraints are used to construct the goals, then the goals are to
minimize the violation of the constraints. The goals are met when the constraints are
satisfied. In the pre–emptive case we try to meet as many goals as possible, taking them
in priority order. In the Archimedean case, we minimize a weighted sum of penalties for
not meeting each of the goals. If the goals are constructed from N rows, then, in the
pre–emptive case, a target for each N row is calculated from the optimal value for the N
row. this may be done by specifying either a percentage or absolute deviation that may
be allowed from the optimal value for the N rows. In the Archimedean case, the problem
becomes a multi–objective linear programming problem in which a weighted sum of the
objective functions is to be minimized.
In this section four examples will be provided of the four different types of goal
programming available. Goal programming itself is performed using theXPRSgoal(GOAL)
command, whose syntax is described in full in the reference section of this manual.

Pre-emptive Goal Programming Using Constraints

For this case, goals are ranked from most important to least important. Initially we try to
satisfy the most important goal. Then amongst all the solutions that satisfy the first goal,
we try to come as close as possible to satisfying the second goal. We continue in this
fashion until the only way we can come closer to satisfying a goal is to increase the
deviation from a higher priority goal.
An example of this is as follows:

goal 1 (G1): 7x + 3y 40
goal 2 (G2): 10x + 5y = 60
goal 3 (G3): 5x + 4y 35
LIMIT: 100x + 60y 600

Initially we try to meet the first goal (G1), which can be done with x=5.0 and y=1.6, but
this solution does not satisfy goal 2 (G2) or goal 3 (G3). If we try to meet goal 2 while
still meeting goal 1, the solution x=6.0 and y=0.0 will satisfy. However, this does not
satisfy goal 3, so we repeat the process. On this occasion no solution exists which
satisfies all three.

Archimedean Goal Programming Using Constraints

1 of 3 22-03-2019, 08:11
 https://www.maths.ed.ac.uk/hall/Xpress/FICO_Docs/optimizer/HTML...

We must now minimize a weighted sum of violations of the constraints. Suppose that we
have the following problem, this time with penalties attached:

Penalties
goal 1 (G1): 7x + 3y 40 8
goal 2 (G2): 10x + 5y = 60 3
goal 3 (G3): 5x + 4y 35 1
LIMIT: 100x + 60y 600

Then the solution will be the solution of the following problem:

minimize: 8d1 + 3d2 + 3d3 + 1d4

subject to: 7x + 3y + d1 40
10x + 5y + d2 – d3 = 60
5x + 4y + d4 35
100x + 60y 600
d1 0, d2 0, d3 0, d4 0

In this case a penalty of 8 units is incurred for each unit that 7x + 3y is less than 40 and
so on. the final solution will minimize the weighted sum of the penalties. Penalties are
also referred to as weights. This solution will be x=6, y=0, d1=d2=d3=0 and d4=5, which
means that the first and second most important constraints can be met, while for the
third constraint the right hand side must be reduced by 5 units in order to be met.
Note that if the problem is infeasible after all the goal constraints have been relaxed,
then no solution will be found.

Pre-emptive Goal Programming Using Objective Functions

Suppose that we now have a set of objective functions of which we know which are the
most important. As in the pre–emptive case with constraints, goals are ranked from most
to least important. Initially we find the optimal value of the first goal. Once we have
found this value we turn this objective function into a constraint such that its value does
not differ from its optimal value by more than a certain amount. This can be a fixed
amount (or absolute deviation) or a percentage of (or relative deviation from) the
optimal value found before. Now we optimize the next goal (the second most important
objective function) and so on.
For example, suppose we have the following problem:

Sense D/P Deviation

goal 1 (OBJ1): 5x + 2y – 20 max P 10
goal 2 (OBJ2): –3x + 15y – 48 min D 4
goal 3 (OBJ3): 1.5x + 21y – 3.8 max P 20
LIMIT: 42x + 13y 100

For each N row the sense of the optimization (max or min) and the percentage (P) or
absolute (D) deviation must be specified. For OBJ1 and OBJ3 a percentage deviation of
10% and 20% respectively have been specified, whilst for OBJ2 an absolute deviation of
4 units has been specified.
We start by maximizing the first objective function, finding that the optimal value is
–4.615385. As a 10% deviation has been specified, we change this objective function into
the following constraint:

5x + 2y – 20 –4.615385 – 0.14.615385

Now that we know that for any solution the value for the former objective function must
be within 10% of the best possible value, we minimize the next most important objective

2 of 3 22-03-2019, 08:11
 https://www.maths.ed.ac.uk/hall/Xpress/FICO_Docs/optimizer/HTML...

function (OBJ2) and find the optimal value to be 51.133603. Goal 2 (OBJ2) may then be
changed into a constraint such that:

–3x + 15y – 48 51.133603 + 4

and in this way we ensure that for any solution, the value of this objective function will
not be greater than the best possible minimum value plus 4 units.
Finally we have to maximize OBJ3. An optimal value of 141.943995 will be obtained.
Since a 20% allowable deviation has been specified, this objective function may be
changed into the following constraint:

1.5x + 21y – 3.8 141.943995 – 0.2141.943995

The solution of this problem is x=0.238062 and y=6.923186.

Archimedean Goal Programming Using Objective Functions

In this, the final case, we optimize a weighted sum of objective functions. In other words
we solve a multi–objective problem. For consider the following:

Weights Sense
goal 1 (OBJ1): 5x + 2y – 20 100 max
goal 2 (OBJ2): –3x + 15y – 48 1 min
goal 3 (OBJ3): 1.5x + 21y – 3.8 0.01 max
LIMIT: 42x + 13y 100

In this case we have three different objective functions that will be combined into a single
objective function by weighting them by the values given in the weights column. The
solution of this model is one that minimizes:

1(–3x + 15y – 48) – 100(5x + 2y – 20) – 0.01(1.5x + 21y – 3.8)

The resulting values that each of the objective functions will have are as follows:

OBJ1: 5x + 2y – 20 = –4.615389
OBJ2: –3x + 15y – 48 = 67.384613
OBJ3: 1.5x + 21y – 3.8 = 157.738464

The solution is x=0.0 and y=7.692308.

[Next] [Index]

If you have any comments or suggestions about these pages, please send mail to
support@fico.com.

© Copyright 1983-2013 Fair Isaac Corporation. All rights reserved.

3 of 3 22-03-2019, 08:11