Algumas ferramentas para resolução de problemas de

Otimização Linear
Guilherme H. Polo Gonçalves

Departamento de Informática
Universidade Estadual de Maringá (UEM) – Maringá, PR – Brasil
ggpolo@gmail.com

1. Introdução
Problemas de otimização reais podem requerer uma quantidade muito grande de variá-
veis e restrições, sendo impraticáveis para resolução manual. O trabalho apresentado em
[Castro and Frangioni 2000] descreve uma instância de um problema contendo mais de
2,45 milhões de variáveis e cerca de 267 mil restrições. Assim, utilizar ferramentas para
resolução de problemas de programação linear se torna imprescindível.
Nesse trabalho apresentamos, nessa ordem, as ferramentas COIN-OR LP (CLP)
[COIN-OR 2010], ConVeX OPTimization (CVXOPT) [CVXOPT 2009], GNU Linear
Programming Kit (GLPK) [GNU 2008], Matlab [MathWorks 2010] e seu toolbox de
otimização, e também a MOSEK [MOSEK ApS 2008]. Vale observar que todas essas
ferramentas são capazes de resolver muitos outros tipos de problemas que fogem do
nosso escopo, e, portanto, elas serão apenas brevemente exploradas. Em seguida um
mesmo problema é solucionado com o CVXOPT, GLPK e Matlab, permitindo uma
rápida análise entre os mesmos. Um segundo problema, dessa vez teórico, é apresentado
e resolvido mas apenas uma parte dele é modelado e solucionado com essas mesmas
ferramentas.

2. Ferramentas
2.1. CLP
O projeto Computational Infrastructure for Operations Research (COIN-OR) foi criado
pela IBM em 2000. Dentro do COIN-OR existe uma coleção de projetos, todos desenvol-
vidos seguindo a filosofia de código livre, em várias categorias. O CLP faz parte dessa
coleção, servindo como um solucionador para problemas de programação linear. Escrito
em C++, já foi testado com modelos contendo até 1,5 milhões de restrições, e tem sido
utilizado pela Yahoo.
Através de um utilitário chamado clp pode-se resolver problemas escritos no for-
mato MPS (Mathematical Programming System). Essa é a forma mais simples de utilizar
o CLP, mas também a mais limitada. Essa ferramenta foi projetada na forma de biblioteca
e boa parte de suas funcionalidades só podem ser acessadas por meio desta. Para exempli-
ficar, poderíamos escrever um pequeno programa que lê um arquivo no formato MPS ou
GMPL (GNU Mathematical Programming Language) e resolve o problema utilizando o
método dual simplex com a API (Application Programming Interface) existente. O trecho
seguinte implementa tal funcionalidade, porém nem mesmo exibe a solução obtida:
 Código 1. Uso básico da API da CPL para ler e resolver um problema no formato MPS ou GMPL
1 #include <string.h>
2 #include "ClpSimplex.hpp"
3
4 int main (int argc, const char *argv[])
5 {
6 ClpSimplex modelo;
7 int erro = 1, status = 1;
8
9 if (argc == 3) {
10 if (!(strcmp(argv[1], "-mps"))) {
11 erro = modelo.readMps(argv[2]);
12 } else if (!(strcmp(argv[1], "-gmpl"))) {
13 erro = modelo.readGMPL(argv[2]);
14 }
15 if (!erro) {
16 modelo.dual();
17 status = 0;
18 }
19 }
20 return status;
21 }

2.2. CVXOPT
CVXOPT é um pacote para a linguagem Python que foi escrito em 2004 e é distribuído
sob a licença GPL. É utilizado pelo projeto Sage [Sage 2010], que é uma alternativa livre
ao Maple, Mathematica ou Matlab. O CVXOPT permite o uso das ferramentas GLPK
ou MOSEK, mas também tem o próprio solver escrito em Python. Entre os aplicativos
desenvolvidos com ele, encontra-se um plugin para o OpenOffice.org Calc.
Solucionar um problema de otimização com essa ferramenta consiste em mo-
delar o mesmo utilizando a linguagem Python. Para essa tarefa existe o módulo
cvxopt.modeling, um exemplo mais a frente demonstra como realizar essa ativi-
dade. Estruturas para manipulação de matrizes e vetores são fornecidas, permitindo
o uso de uma notação próxima da forma matricial. Problemas de maximização de-
vem ser convertidos para minimização, já que a função existente para criar um modelo
(cvxopt.modeling.op) espera ter a função objetivo sempre como de minimização.

2.3. GLPK
O GLPK foi escrito em C no ano de 2000 e faz parte do projeto GNU. Diversas linguagens,
como R, Python ou Matlab, possuem bindings para o GLPK de forma a possibilitar
seu uso através dessas. Também é possível utilizá-lo diretamente através do programa
glpsol em linha de comando, que é o foco desse trabalho.
Ao fazer uso do glpsol, a modelagem por meio do formato MathProg (também
chamada de GMPL), MPS, MPS livre ou ainda CPLEX LP pode ser empregada para des-
crição de um problema qualquer. A documentação oficial do GLPK possui a referência
completa para a MathProg, assim como os outros formatos já mencionados também pos-
suem material extenso e não são detalhados aqui. Mais adiante é apresentado um exemplo
modelado em GMPL, que não impõe a restrição descrita para o CVXOPT.
2.4. Matlab
Matlab (de MATrix LABoratory) foi inicialmente desenvolvimento por Cleve Moler no
final dos anos 70, mais tarde foi reescrito e a MathWorks surgiu. A linguagem fornece
maneiras convenientes de se trabalhar com vetores e matrizes, permitindo um melhor
relacionamento entre um modelo na forma matricial e a aplicação do método simplex.
Atualmente apresenta uma interface gráfica que, por meio de um interpretador, facilita a
verificação e testes de pequenos trechos de código. Nesse trabalho estamos interessados
em seu toolbox de otimização, que dispõe de uma função linprog e o aplicativo gráfico
optimtool para resolver os problemas descritos aqui.
O Matlab apresenta duas semelhanças com o projeto CVXOPT. A modelagem e a
resolução de um problema acontece por meio do uso da linguagem Matlab. A segunda
semelhança é a necessidade de tratar a função objetivo como de minimização. Porém, a
função linprog define ainda mais limites na modelagem. Apenas restrições de menor-
igual e de igualdade são aceitas, e essas ainda devem ser separadas. O problema exemplo
que é resolvido mais adiante explicita essas restrições. O aplicativo optimtool simpli-
fica (um pouco) a descrição do modelo, mas não é necessário seu uso.

2.5. MOSEK
O MOSEK, assim como o GLPK, pode ser utilizado em diversas linguagens (além de C
e C++) através de bindings existentes para C#, Python e outras, além de disponibilizar
um outro toolbox de otimização para o Matlab. Uma ferramenta em linha de comando
também acompanha o pacote. Não é livre, e é pago assim como o Matlab.
Essa ferramenta apresenta um diferencial em relação ao formato de problema
aceito, o OPF (Optimization Problem Format) (mas também aceita os formatos MPS e
LP). O OPF é uma alternativa aos formatos antigos MPS e LP, orientados a coluna e de
difícil leitura, e não tanto um concorrente ao MathProg. Tem-se também como diferencial
um programa que analisa o modelo descrito e relata dados como: número de restrições e
variáveis livres/fixas/limitadas superiormente/limitadas inferiormente, valores absolutos/
mínimos/máximos de coeficientes da função objetivo, além de outras informações.

3. Problemas exemplo
A seguir apresentamos dois problemas utilizados na discussão de algumas ferramentas. O
primeiro é direcionado a resolução de um pequeno modelo existente e o segundo valida
algumas questões teóricas a respeito da programação linear e o método simplex. Como as
ferramentas estudadas não dispõem de um “modo didático”, não é tão interessante utilizá-
las para validar os itens da questão 2 e, assim, só fazemos tal trabalho com o segundo item.

1. Resolva o problema a seguir.

minimizar f (x1 , x2 , x3 ) = 3x1 + 2x2 + 7x3

sujeito a
−x1 + x2 = 10
2x1 − x2 + x3 ≥ 10
e
x1 , x2 , x3 ≥ 0
 2. Classifique e justifique cada afirmação a seguir como verdadeira ou falsa:

(a) Em uma determinada iteração do método simplex, se houver um empate

para qual variável deverá ser a variável básica que sai, então a solução BV
seguinte deve ter pelo menos uma variável básica igual a zero.
(b) Se não houver nenhuma variável básica que sai na mesma iteração, então
o problema não tem nenhuma solução viável.
(c) Se pelo menos uma das variáveis básicas tiver um coeficiente igual a zero
na linha 0 da tabela final, então o problema tem soluções ótimas múltiplas.
(d) Se o problema tiver soluções ótimas múltiplas, então o problema tem que
ter uma região de soluções viáveis limitada.

4. Resolução dos problemas

4.1. Problema 1
Código 2. CVXOPT
1 from cvxopt.modeling import variable, op
2
3 x1, x2, x3 = variable(), variable(), variable()
4

5 r1 = (- x1 + x2 == 10)
6 r2 = (2*x1 - x2 + x3 >= 10)
7 nao_neg = [(x1 >= 0), (x2 >= 0), (x3 >= 0)]
8 restricoes = [r1, r2] + nao_neg
9 modelo = op(3*x1 + 2*x2 + 7*x3, restricoes)
10 modelo.solve()
11
12 print "%f %f %f" % (x1.value[0], x2.value[0], x3.value[0])
13 print "%f" % modelo.objective.value()[0]

Código 3. GLPK, exemplo1.gmpl (glpsol -m exemplo1.gmpl -o solucao)

1 var x1 >= 0;
2 var x2 >= 0;
3 var x3 >= 0;
4
5 minimize z: 3*x1 + 2*x2 + 7*x3;
6
7 s.t. r1 : - x1 + x2 = 10;
8 s.t. r2 : 2*x1 - x2 + x3 >= 10;
9
10 end;

Código 4. Matlab
1 Aineq = [0 0 0; -2 1 -1];
2 Aeq = [-1 1 0; 0 0 0];
3 bineq = [0 -10];
4 beq = [10 0];
5 nao_neg = zeros(3, 1);
6 [x z] = linprog([3 2 7], Aineq, bineq, Aeq, beq, nao_neg)
 Uma forma de programação simbólica é observada no código em Python ao
utilizar o pacote da CVXOPT. As restrições r1 e r2 são declaradas de forma quase
idêntica à aquelas no modelo em MathProg, diferindo apenas no operador de igualdade
(= e ==). Cada objeto de tipo variable nesse exemplo é um vetor com uma coluna,
e, por isso, na apresentação dos resultados acessamos o índice 0 para obter o valor ali
contido.
O modelo em MathProg para o GLPK ficou bastante próximo daqueles vistos em
textos relacionados a programação linear. A abreviação s.t. vem de subject to (sujeito
a). O arquivo “solucao” contém a descrição da resposta, e não é tão direto quanto as
outras duas ferramentas:
1 Problem: exemplo1
2 Rows: 3
3 Columns: 3
4 Non-zeros: 8
5 Status: OPTIMAL
6 Objective: z = 120 (MINimum)
7

8 No. Row name St Activity Lower bound Upper bound Marginal

9 --- ----------- ---- -------- ----------- ----------- --------
10 1 z B 120
11 2 r1 NS 10 10 = 7
12 3 r2 NL 10 10 5
13

14 No. Column name St Activity Lower bound Upper bound Marginal

15 --- ----------- ---- -------- ----------- ----------- --------
16 1 x1 B 20 0
17 2 x2 B 30 0
18 3 x3 NL 0 0 2

O conteúdo acima foi editado, retirando partes finais e ajustando as colunas para caber
numa folha de papel. Na linha 1 temos o nome do arquivo que contém o modelo agora
resolvido, a linha 5 indica que foi encontrada uma solução ótima e seguida dela temos
o valor ótimo para z acompanhado do tipo de problema (minimização nesse caso). As
linhas 16, 17 e 18 na coluna activity apresentam os valores finais para as variáveis de
decisão.
Matlab apresenta o código mais breve, mas se distancia um pouco do modelo
original ao impor a necessidade de separar inequações (Aineq e bineq) de menor-igual
das restrições de igualdade (Aeq e beq). A função zeros na linha 5, da forma que é
utilizada, retorna uma matriz 3 × 1 e representa as restrições de não negatividade para as
variáveis de decisão. O código em questão precisa ser escrito no interpretador do Matlab
para que, após a linha 7, o resultado seja exibido.
O resultado obtido, como esperado, é o mesmo para todos: x1 = 20, x2 = 30,
x3 = 0 com z = 120.
4.2. Problema 2
(a) Verdadeiro. Isso é uma característica da existência de solução degenerada.
(b) Falso. Se um variável já foi escolhida para entrar mas não é possível determinar uma
para sair então ocorre que temos um problema ilimitado. Isso ocorre se as variáveis
 básicas atuais possuírem coeficientes negativos ou nulos nas restrições, fazendo com
o que teste da razão mínima não consiga determinar uma limite para a variável básica
que entraria.
(c) Falso. Uma variável não-básica precisa ter coeficiente igual a zero na linha 0 final
para se ter soluções ótimas múltiplas.
(d) Falso. Pode ocorrer de termos um conjunto ilimitado de soluções ótimas em uma
região ilimitada.
Como mencionado antes, analisamos o item “b”. Supondo um modelo como:
maximizar f (x1 , x2 ) = x1 + x2
sujeito a x1 + 4x2 ≥ 2
4x1 + x2 ≥ 4
e
x1 , x2 ≥ 0
Podemos verificar que sua representação geométrica na figura 1 demonstra que há a pos-
sibilidade de não existir solução ótima, porém há infinitas soluções viáveis.

II

Ilimitado
x2

x2

x1

Figura 1. Região ilimitada sem solução ótima

Modelando o problema em CVXOPT, GLPK e Matlab verificamos que o último

desses apresenta mais informações que possam nos interessar aqui e portanto seu código
é exibido. Dessa vez é feito uso de algumas opções, forçando o uso do algoritmo simplex
e a exibição de resultados parciais durante a tentativa de resolução do problema. Lem-
brando que a função linprog trabalha apenas com função objetivo de minimização,
convertemos a mesma.
Código 5. Problema ilimitado no Matlab
1 Aineq = [-1 -4; -4 -1];
2 bineq = [-2 -4];
3 nao_neg = zeros(2, 1);
4

5 opc = optimset(’Simplex’, ’on’, ’LargeScale’, ’off’,

’Display’, ’iter’);
6 [x z] = linprog([-1 -1], Aineq, bineq, [], [], nao_neg, [], [], opc)

Como saída obtemos:

 Phase 1: Compute initial basic feasible point.
Iter Infeasibility
0 6
1 1
2 -0

Phase 2: Minimize using simplex.

Iter Objective Dual Infeasibility
f’*x A’*y+z-w-f
0 -1.2 0.282843
1 -2 1
Exiting: The problem is unbounded; the constraints are not
restrictive enough.

x =

1.0e+16 *

1.0000
0

z =

-1.0000e+16

Dentre as informações exibidas, vemos que um valor para z foi obtido. As variá-
veis de decisão receberam valores também, x1 obteve um valor bastante alto (1 × 1016 )
enquanto que x2 ficou com 0. A função objetivo, passando para maximização, obteve o
respectivo valor de x1 . Se não utilizarmos nenhuma daquelas opções, as variáveis rece-
bem valores mais altos ainda: x1 ≈ 1.1895 × 1082 e x2 ≈ 1.1331 × 1082 . Resolvendo esse
mesmo problema com o GLPK (fazendo conversão para minimização como no Matlab,
ou não), verificamos que o resultado obtido foi x1 = 2 e x2 = 0, indicando que os dois
utilizaram algoritmos diferentes em todos os casos. Ao tentar resolver utilizando o CV-
XOPT, obtivemos uma resposta que não satisfez as restrições. Por essa razão, o código
feito com esse pacote também é exibido agora:
Código 6. Modelagem e resolução do problema 2.b utilizando CVXOPT 1.1.1
1 from cvxopt.modeling import variable, op
2

3 x1, x2 = variable(), variable()

4
5 r1 = (x1 + 4*x2 >= 2)
6 r2 = (4*x1 + x2 >= 4)
7 nao_neg = [(x1 >= 0), (x2 >= 0)]
8 restricoes = [r1, r2] + nao_neg
9 modelo = op(-x1 -x2, restricoes)
10 modelo.solve()
11

12 print "%f %f" % (x1.value[0], x2.value[0])

13 print "%f" % modelo.objective.value()[0]
O resultado obtido com o código acima é: x1 = 0.619906 e x2 = 0.380094, fazendo com
que 4x1 + x2  4.

5. Conclusão
Apenas uma noção da utilização de cada uma das 5 ferramentas foi passada. Entre elas,
fizemos uso da CVXOPT, GLPK e Matlab para resolução de dois problemas. O primeiro
desses teve problemas para definir uma solução viável em um modelo com região factível
ilimitada. O GLPK e seu formato MathProg fornecem uma representação bastante seme-
lhante a forma em que os problemas são naturalmente escritos. Matlab e o MOSEK são
as duas ferramentas pagas mencionadas, onde a primeira facilita a utilização de matrizes
e vetores.

Referências
Castro, J. and Frangioni, A. (2000). A parallel implementation of an interior-point al-
gorithm for multicommodity network flows. In VECPAR ’00: Selected Papers and
Invited Talks from the 4th International Conference on Vector and Parallel Processing,
pages 301–315, London, UK. Springer-Verlag.
COIN-OR (2010). Coin-or linear programming solver. https://projects.
coin-or.org/Clp.
CVXOPT (2009). Python software for convex optimization. http://abel.ee.
ucla.edu/cvxopt/.
GNU (2008). Gnu linear programming kit. http://www.gnu.org/software/
glpk/.
MathWorks (2010). Matlab. http://www.mathworks.com/products/
matlab/.
MOSEK ApS (2008). The mosek optimization software. http://www.mosek.com/.
Sage (2010). Sage: Open source mathematics software. http://www.sagemath.
org/.