OTIMIZAÇÃO LINEAR - dt.fee.unicamp.brtiago/courses/otimizacao_linear/Relatorio... · departamento...
40
DEPARTAMENTO DE TELEMÁTICA FACULDADE DE ENGENHARIA ELÉTRICA E DE COMPUTAÇÃO UNIVERSIDADE ESTADUAL DE CAMPINAS OTIMIZAÇÃO LINEAR “Algoritmos de Pontos Interiores” Autor: Tiago Agostinho de Almeida
Transcript of OTIMIZAÇÃO LINEAR - dt.fee.unicamp.brtiago/courses/otimizacao_linear/Relatorio... · departamento...
DEPARTAMENTO DE TELEMÁTICA FACULDADE DE ENGENHARIA ELÉTRICA E DE COMPUTAÇÃO
UNIVERSIDADE ESTADUAL DE CAMPINAS
OTIMIZAÇÃO LINEAR
“Algoritmos de Pontos Interiores”
Autor: Tiago Agostinho de Almeida
Índice 1 - Fundamentações Teóricas...............................................................................................................1
1.1 - Método Primal Afim-Escala ................................................................................................................. 2 1.2 - Método Dual Afim-Escala .................................................................................................................... 3 1.3 - Método Primal-Dual Afim-Escala ........................................................................................................ 4 1.4 - Método Primal-Dual Clássico............................................................................................................... 6 1.5 - Método Preditor-Corretor ..................................................................................................................... 7 1.6 - Método de Barreira Logarítmica........................................................................................................... 8
2 - Apresentação dos Resultados .......................................................................................................10
2.1 - Exercício 1 .......................................................................................................................................... 10 2.2 - Exercício 2 .......................................................................................................................................... 10
2.2.1 - Resultados obtidos para o Exercício 2 ......................................................................................................... 11 2.3 - Exercício 3 .......................................................................................................................................... 13
2.3.1 - Resultados obtidos para o exercício 3.......................................................................................................... 14 2.3.1.1- Método Primal Afim-Escala.................................................................................................................. 14 2.3.1.2- Método Dual Afim-Escala .................................................................................................................... 15 2.3.1.3- Método Primal-Dual Afim-Escala ........................................................................................................ 16 2.3.1.4- Método Primal-Dual Clássico ............................................................................................................... 16 2.3.1.5- Método Preditor-Corretor...................................................................................................................... 17 2.3.1.6- Método de Barreira Logarítmica ........................................................................................................... 17
2.4 - Exercício 4 .......................................................................................................................................... 18 2.4.1 - Resultados obtidos para o exercício 4.......................................................................................................... 18
Apêndice I - Algoritmos e Fluxogramas............................................................................................20
Método Primal Afim-Escala........................................................................................................................ 20 Método Dual Afim-Escala .......................................................................................................................... 21 Método Primal-Dual Afim-Escala .............................................................................................................. 22 Método Primal-Dual Clássico ..................................................................................................................... 23 Método Preditor-Corretor............................................................................................................................ 24 Método de Barreira Logarítmica ................................................................................................................. 25
Apêndice II - Códigos para os algoritmos do Apêndice I (Matlab) ..................................................26
Método Primal Afim-Escala........................................................................................................................ 26 Método Dual Afim-Escala .......................................................................................................................... 27 Método Primal-Dual Afim-Escala .............................................................................................................. 29 Método Primal-Dual Clássico ..................................................................................................................... 30 Método Preditor-Corretor............................................................................................................................ 32 Método de Barreira Logarítmica ................................................................................................................. 34
Apêndice III - Código para o algoritmo Primal-Dual Clássico com variáveis canalizadas...............36
III.1 Algoritmo auxiliar para cálculo do valor da função objetivo ............................................................. 38
1 - Fundamentações Teóricas
Nesta seção procura-se fornecer uma breve introdução teórica necessária ao entendimento
dos algoritmos de pontos interiores utilizados neste trabalho. As principais definições e as notações
utilizadas estão mostradas a seguir:
a) Notação
• A = {aij} - Matriz;
• a, b, c - Vetores colunas de elementos constantes;
• x, y, z - Vetores colunas de variáveis;
• X, Y, Z - Matriz diagonal com elementos de x, y, z.
b) Programação Linear - Formas Padrões
' ': . : . '
0 0,
min c x max b yPrimal s a Ax b Dual s a A y z c
x z y livre
⎧ ⎧⎪ ⎪= ⇔ +⎨ ⎨⎪ ⎪≥ ≥⎩ ⎩
=
0
c) Condições de Otimalidade
• Primal Factibilidade: ; 0, 0b Ax x− = ≥
• Dual Factibilidade: ; ' 0, zc A y z− − = ≥
• Condição de Complementaridade: 0i ix z =
d) Definições
• 1) Ponto Interior: x0 tal que x0 > 0 é ponto interior do primal;
• 2) Ponto Factível: x0 tal que Ax0 = b, x0 ≥ 0 é um ponto factível do primal;
• 3) Ponto Interior Factível (satisfaz 1 e 2): x0 tal que Ax0 = b, x0 > 0 é um ponto interior
factível do primal.
• 4) GAP: Diferença entre o valor do primal e do dual. Ex.: GAP = c'x - b'y.
1
As notações e as definições apresentadas acima são utilizadas para a implementação dos
métodos que estão em discussão neste trabalho. A saber: Método Primal Afim-Escala, Método Dual
Afim-Escala, Método Primal-Dual Afim-Escala, Método Primal-Dual Clássico, Método Preditor-
Corretor e o Método de Barreira Logarítmica. No Apêndice I estão mostrados os algoritmos para
cada um dos métodos discutidos a seguir.
1.1 - Método Primal Afim-Escala
A partir da propriedade da complementaridade e das formas padrões, mostrados acima,
deduz-se que:
( ) ( )
( )
( )( )
22
'2
2 2
12 2
12 2
11 ( - ' )22- '
1 1( - ' ) ' '2 2
1 ' ' ' ' ' ' ' ' ' '2
', 0 : ' 0
'
' '
y,zy,z
y
min Xzmin X c A y
s.a z c A y
Z X c A y X c A y X c A y
c X Xc c X XA y y AX Xc y AX XA y
X X Z AX c AX A y
y AX A AX c
z c A AX A AX c
−
−
⎧⎪ ⇒⎨⎪ =⎩
= = − − =⎡ ⎤ ⎡ ⎤⎣ ⎦ ⎣ ⎦
− − +
= ∆ = − + =
⎧=⎪⎪∴⎨
⎪ = −⎪⎩
Teorema (Dikin): Dados x tal que Ax = b, x > 0, z = c - A'y, y = (AX2A')-1 AX2c, então a direção
d = -X2z é uma direção de descida factível. Assim, d = -X2z minimiza 2Xz e, portanto:
1
0
,onde
, 0 1, { }ki
k k k k
kk ki
iki
x x d
xmin dδ
α
kα τ τδ
+
<
= +
⎛ ⎞= − < < =⎜ ⎟⎜ ⎟
⎝ ⎠δ
2
1.2 - Método Dual Afim-Escala
Considere o problema abaixo:
21 2
.
min Zx
s a Ax b
⎧⎪⎨⎪ =⎩
Lagrangeano:
21 1( , ) '( ) ( ' ) '( )2 2
L x w Zx w b Ax x ZZx w b Ax= + − = + −
Condições de Otimalidade:
20 '
0 0
L Z x A wxL b Axw
∂⎧ = ⇒ − =⎪⎪∂⎨∂⎪ = ⇒ − =⎪∂⎩
0,
ou seja,
( )( )
2 2
12 2
' ; '
' '
x Z A w AZ A w b
x Z A AZ A b
− −
−− −
= =
∴ =
Hessiana:
2' 0
' 0Z AH AA
⎡ ⎤−= = −⎢ ⎥−⎢ ⎥⎣ ⎦
A <
Direção dz = -Z2x
( ) ( )1 12 2 2 2' ' ' '
e' '
dz Z Z A AZ A b A AZ A b
z c A y dz A dy
− −− − −⎡ ⎤= − = −⎢ ⎥
⎣ ⎦
= − ⇒ = −
Assim,
3
2 1( ')dy AZ A b− −=
Teorema: Dados (y,z) tais que , z ≥ 0, Ax = b, 'z c A y= − ( ) 12 2' 'x Z A AZ A b−− −= , a direção
dada por:
( ) ( ) 12 2, ' , dy dz AZ A b Z x−− −⎛ ⎞
= −⎜ ⎟⎝ ⎠
é dual factível de subida.
1.3 - Método Primal-Dual Afim-Escala
Condições de Otimalidade:
( , , ) ' 0p
d
a
F Ax bF x y z F A y z c
F XZe
⎡ ⎤ −⎡ ⎤⎢ ⎥ ⎢ ⎥= = + − =⎢ ⎥ ⎢ ⎥⎢ ⎥ ⎢ ⎥⎣ ⎦⎣ ⎦
A aproximação linear fornece:
( ) 0 0 0 1 0 0 0 0 0 0, , ( , , ) ( , , ) ( , , )x y z x y z J x y z F x y z−≅ − ,
pois
( ) 0 0 0 0 0 0 0 0 0
0
0 0 0 0
0 0
, , ( , , ) ( , , ) ( , , ) ( , , ) 0
( , , ) 'p
d
a
F x y z F x y z J x y z x y z x y z
b Ax r
F x y z c A y r rrX Z e
⎡ ⎤≅ + −⎣ ⎦⎡ ⎤− ⎡ ⎤⎢ ⎥ ⎢ ⎥⎢ ⎥⇒ − = − = =⎢ ⎥⎢ ⎥ ⎢ ⎥⎢ ⎥− ⎣ ⎦⎣ ⎦
=
e
0 0 0
0 0
0 0( , , ) 0 '
0
tptdta
F AJ x y z F A I
F Z X
⎡ ⎤∇ ⎡ ⎤⎢ ⎥ ⎢ ⎥⎢ ⎥= ∇ = ⎢ ⎥⎢ ⎥ ⎢ ⎥⎢ ⎥∇ ⎢ ⎥⎣ ⎦⎢ ⎥⎣ ⎦
Assim,
4
1
0 0 0 0 0 0
0 0
0 0( , , ) ( , , ) 0 ' ( , , )
0
p
d
a
rAx y z x y z A I r x y z d
rZ X
−⎡ ⎤ ⎡ ⎤⎢ ⎥ ⎢ ⎥
= + = +⎢ ⎥ ⎢ ⎥⎢ ⎥ ⎢ ⎥⎢ ⎥ ⎣ ⎦⎣ ⎦
,
onde
1
0 0
0 00 '
0
p
d
a
rdx Ad dy A I r
dz rZ X
−⎡ ⎤ ⎡ ⎤⎡ ⎤⎢ ⎥ ⎢ ⎥⎢ ⎥= = ⎢ ⎥ ⎢ ⎥⎢ ⎥⎢ ⎥ ⎢ ⎥⎢ ⎥⎣ ⎦ ⎢ ⎥ ⎣ ⎦⎣ ⎦
Pode-se resolver o sistema
0 0
0 00 '
0
p
d
a
rA dxA I dy r
dz rZ X
⎡ ⎤ ⎡ ⎤⎡ ⎤⎢ ⎥ ⎢ ⎥⎢ ⎥ =⎢ ⎥ ⎢ ⎥⎢ ⎥⎢ ⎥ ⎢ ⎥⎢ ⎥⎣ ⎦⎢ ⎥ ⎣ ⎦⎣ ⎦
considerando
0 0
'p
d
a
Adx r
A dy dz r
Z dx X dz r
⎧ =⎪⎪ + =⎨⎪
+ =⎪⎩
0 0 0 0
0 0 0
'
( ' )
'
d
d a
a d
dz r A dy
Z dx X dz Z dx X r A dy r
Z dx X A dy r X r
= −
+ = + − =
− = −
,
ou seja,
( ) ( )1 10 0 0' a dX Z dx A dy X r r− −
− + = − + ,
que fornece
( ) 100
'
p
d a
rA dxD A dy r X r
−
⎡ ⎤⎡ ⎤ ⎡ ⎤ ⎢ ⎥=⎢ ⎥ ⎢ ⎥ ⎢ ⎥−⎣ ⎦ ⎣ ⎦ −⎢ ⎥⎣ ⎦
,
onde
D = X-1Z.
5
1.4 - Método Primal-Dual Clássico
O método Primal-Dual Afim-Escala permite que x e z se aproximem rapidamente das
fronteiras, isto o torna ineficiente. O método Primal Clássico acrescenta uma perturbação na
condição de complementaridade: i i ix z µ= .
Novas condições de otimalidade:
0' '
0
b Axc A y z
e XZeµ
− =⎧⎪ − − =⎨⎪ − =⎩
0 ,
onde µ é tal que ( )lim 0kk
µ→+∞
= .
Estimação de µk:
( )'Trk k kX Zγ⎡ ⎤
= ⎢⎣ ⎦
⎥ , onde:Tr[X] = traço de X.
Na maioria das implementações, adota-se:
, (0,1)k
k k knγµ σ σ⎛ ⎞
= ∈⎜ ⎟⎜ ⎟⎝ ⎠
Assim, a cada iteração, tem-se o sistema J(xk, yk, zk )dk = rk, ou seja,
( )'0 0
0 ' '
0
kk kpk k k k
dk k k k k k ka
rdx b AxAA I dy r c A y z
Z X dz r e X Z eµ
⎡ ⎤⎡ ⎤⎡ ⎤ −⎡ ⎤ ⎢ ⎥⎢ ⎥⎢ ⎥⎢ ⎥ ⎢ ⎥⎢ ⎥⎢ ⎥ = = − −⎢ ⎥ ⎢ ⎥⎢ ⎥⎢ ⎥⎢ ⎥ ⎢ ⎥⎢ ⎥⎢ ⎥⎢ ⎥⎣ ⎦ ⎢ ⎥−⎣ ⎦ ⎢ ⎥⎣ ⎦ ⎣ ⎦
Portanto, tem-se duas diferenças em relação ao método Primal-Dual Afim-Escala:
• a) Troca de rak por rc
k;
• b) Cálculo de µk
6
1.5 - Método Preditor-Corretor
Baseado em três componentes:
• Direção afim-escala (direção de Newton, preditor); ~d
• Direção de centragem, definido pelo σ do primal-dual clássico;
• Direção de correção , que tenta compensar a aproximação linear de Newton. ^d
Idéia: Calcular a direção afim-escala e estudar o progresso ao longo desta direção, atuando na
perturbação µ (centragem) e na correção não-linear.
No ponto (x, y, z):
~
~ ~
~ ~
(1) '
p
d
a
Ad x r
A d y d z r
Zd x Xd z r XZe
⎧=⎪
⎪⎪ = =⎨⎪⎪ + = = −⎪⎩
Obtém-se, então, o ponto ~ ~ ~, ,x y z⎛ ⎞
⎜⎝ ⎠
⎟ , onde:
~ ~
~ ~
~ ~
x x d x
y y d y
z z d z
⎡ ⎤ ⎡ ⎤+⎢ ⎥ ⎢ ⎥
⎢ ⎥ ⎢ ⎥⎢ ⎥ ⎢ ⎥= +⎢ ⎥ ⎢ ⎥⎢ ⎥ ⎢ ⎥+⎢ ⎥ ⎢ ⎥⎣ ⎦ ⎣ ⎦
A seguir, determinar a direção : ^ ^ ^, ,d x d y d z⎛ ⎞
⎜ ⎟⎝ ⎠
^
^ ^
^ ^ ~ ~
0
(2) ' 0
( ) c
Ad x
A d y d z
Zd x Xd z e D x D y e rµ
⎧=⎪
⎪⎪ + =⎨⎪⎪ + = − =⎪⎩
,
onde . Finalmente, a direção final ~ ~ ~
( ) e (D x diag d x D z diag d z= =~) ( ), ,dx dy dz é determinada
somando (1) e (2):
7
~ ^
~ ^ ~ ^
~ ^ ~ ^
'
p
d
a c s
A d x d x r
A d y d y d z d z r
Z d x d x X d z d z r r r
⎧ ⎛ ⎞+ =⎪ ⎜ ⎟
⎝ ⎠⎪⎪ ⎛ ⎞ ⎛ ⎞⎪ + + + =⎨ ⎜ ⎟ ⎜ ⎟
⎝ ⎠ ⎝ ⎠⎪⎪ ⎛ ⎞ ⎛ ⎞⎪ + + + = + =⎜ ⎟ ⎜ ⎟⎪ ⎝ ⎠ ⎝ ⎠⎩
,
onde
~ ~( )
a
c
r XZe
r e D x D yµ
= −⎧⎪⎨⎪ = −⎩ e
b
1.6 - Método de Barreira Logarítmica
Seja o problema:
'( 1) : .
0
max c xP s a Ax
x
⎧⎪ =⎨⎪ ≥⎩
Substituindo a restrição x ≥ 0 na forma:
' ' ( )( 1) :
. min c x f x
Ps a Ax b
µ+⎧⎨ =⎩
% ,
onde
1
2
ln( )ln( )
( ) ln( )
ln( )n
xx
f x x
x
⎡ ⎤⎢ ⎥⎢= =⎢⎢ ⎥⎢ ⎥⎣ ⎦
M⎥⎥
e µ pode ser assumido um escalar ( )µ ∈R .
(P1) pode ser colocado como sendo:
( ) ' ln( )( 2) :
. max f x c x x
Ps a Ax b
µ= +⎧⎨ =⎩
e o problema de busca de melhor direção factível (em torno do ponto xk) pode ser colocado como:
8
1 ( , ) '( ) ( ) ' ( )2( 3) :
. 0
k k k k k k
k
max f x dx f x dx dx J x dxP
s a Adx
⎧ ∆ ≅ ∆ +⎪⎨⎪ =⎩
k
Note que:
( )2
1( )
( ) { }
1 se
0 se . .
kk
kij
kij
f x cx
J x a
i ja x
c c
µ
µ
∆ = +
=
⎧− =⎪⎪= ⎨⎪⎪⎩
Aplicando o método primal afim-escala ao (P3), obtém-se (do lagrangeano associado):
1 ( )k k kdx X P c µµ
= +% ,
onde é a matriz de projeção com
.
( ), ek k k kX diag x c cX P= = k k
k
1( ) '[ ( ) ']k k k kP I A A A A−= −
k kA AX=
Próximo ponto interior:
1k k kx x dα+ = + x , com ( )k k kdx X P c µ= + ,
onde
,kmax
1minα τλµ
⎧ ⎫= ⎨ ⎬
⎩ ⎭ e 0kx ki
i
ki
maxx
xminδλδ<
⎧ ⎫⎪ ⎪= −⎨ ⎬⎪ ⎪⎩ ⎭
Obs: O valor de µ influencia fortemente no fator de convergência.
9
2 - Apresentação dos Resultados
Nessa seção estão apresentados os resultados obtidos para os problemas contidos na
primeira lista de exercícios. As implementações utilizadas para a obtenção dos resultados podem ser
encontradas nos Apêndices II e III.
2.1 - Exercício 1
Neste exercício são feitas as implementações dos algoritmos de programação linear
utilizando as seguintes técnicas de pontos interiores:
• Primal Afim-Escala (PAE);
• Dual Afim-Escala (DAE);
• Priaml-Dual Afim-Escala (PDAE);
• Primal-Dual Clássico (PDC);
• Preditor-Corretor (PC);
• Barreira Logarítmica (BL).
Os códigos para os métodos acima, implementados em MatLab, estão mostrados no Apêndice II.
2.2 - Exercício 2
Para cada um dos algoritmos implementados no item anterior, foi resolvido o problema de
programação linear mostrado abaixo:
'.
min c xPrimal
s a Ax b⎧⎨ =⎩
,
'. '
max b yDual
s a A y z c⎧⎨ + =⎩
,
onde
[ ]
[ ][ ][ ][ ]
1 2 3 4 5 6 7
1 2 3
1 2 3 4 5 6 7
' 0 0 0 3 4 20 1 2 61 0 0 1 4 8 1 9'0 1 0 1 2 12 1 2 3
0 0 1 0 0 1 0 '' 0 0 1 '
c
x x x x x x x xA
y y y yb z z z z z z z z
= − −− −⎡ ⎤⎢ ⎥ == − −⎢ ⎥⎢ ⎥ =⎣ ⎦
= =
10
11
2.2.1 - Resultados obtidos para o Exercício 2
Nas Tabs. de 1 até 6 estão mostrados os resultados obtidos através da implementação dos
métodos do exercício 1. Em cada tabela estão mostrados os resultados para um método específico,
com os parâmetros τ e ε sob observação.
Tabela 1 - Método Primal Afim-Escala com σ0=1 e x0=[1 1 1 1 1 1 1]’.
τ ε x' F.O. Iterações Tempo[ms]
0.995 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 12 25 0.5 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 31 50 0.1 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.249999 194 280
0.995 10-6 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.249995 10 20 0.995 10-3 [0.7493 0.0000 0.0008 1.0001 0.0001 0.9992 0.0000] -1.247616 6 15 0.995 10-1 [0.7324 0.0054 0.0032 1.3983 0.0191 0.9968 0.0075] -1.120016 3 5
Tabela 2 - Método Dual Afim-Escala.
τ ε x' F.O. Iterações Tempo[ms]
0.995 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 9 15 0.5 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 25 30 0.1 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250001 141 160
0.995 10-6 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 8 15 0.995 10-3 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250103 4 10 0.995 10-1 [0.7499 0.0000 0.0000 0.9995 0.0000 1.0000 0.0000] -1.250024 2 5
Tabela 3 - Método Primal-Dual Afim-Escala.
τ ε x' F.O. Iterações Tempo[ms]
0.9 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 22 75 0.5 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 49 155 0.1 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 272 835 0.9 10-6 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 21 65 0.9 10-3 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.249997 18 60 0.9 10-1 [0.7498 0.0000 0.0002 0.9998 0.0000 0.9998 0.0000] -1.249710 16 55
12
Tabela 4 - Método Primal-Dual Clássico com σ=0.2.
τ ε x' F.O. Iterações Tempo[ms]
0.995 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 11 50 0.5 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 35 130 0.1 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 226 800
0.995 10-6 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 10 45 0.995 10-3 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.249951 9 40 0.995 10-1 [0.7405 0.0087 0.0094 1.0025 0.0016 0.9906 0.0013] -1.208194 7 30
Tabela 5 - Método Preditor-Corretor.
τ ε x' F.O. Iterações Tempo[ms]
0.995 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 11 70 0.5 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 33 185 0.1 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 315 1770
0.995 10-6 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 10 60 0.995 10-3 [0.7500 0.0000 0.0000 1.0002 0.0000 1.0000 0.0000] -1.249934 9 55 0.995 10-1 [0.7528 0.0011 0.0012 1.0474 0.0022 0.9988 0.0001] -1.240968 8 50
Tabela 6 - Método da Barreira Logarítmica σ0=1 e x0=[1 1 1 1 1 1 1]’.
τ ε x' F.O. Iterações Tempo[ms]
0.995 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.249999 14 20 0.5 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250000 40 50 0.1 10-7 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.250002 236 260
0.995 10-6 [0.7500 0.0000 0.0000 1.0000 0.0000 1.0000 0.0000] -1.249999 14 20 0.995 10-3 [0.7500 0.0000 0.0000 1.0002 0.0000 1.0000 0.0000] -1.251104 9 15 0.995 10-1 [0.7505 0.0033 0.0013 0.9931 0.0001 0.9987 0.0000] -1.431130 6 10
2.2.2 - Comentários a respeito dos resultados
Pode-se notar, pelos resultados apresentados, que os algoritmos primal afim-escala e dual
afim-escala apresentam desempenho semelhante. Já nos algoritmos primal-dual afim-escala e
primal-dual clássico requerem um tempo maior de execução, com ligeira vantagem para o último
método. No entanto, cabe considerar que os métodos primal afim-escala e dual afim-escala
requerem procedimentos auxiliares para a obtenção de um ponto inicial factível, ao passo que os
métodos primal-dual afim-escala e clássico dispensam os referidos procedimentos. O método
preditor-corretor apresenta um desempenho comparável aos métodos primal-dual afim-escala e
clássico; já o método de barreira logarítmica apresenta um desempenho sensivelmente melhor para
a instância analisada.
2.3 - Exercício 3
Ainda utilizando os algoritmos implementados no exercício 1, foi resolvido o problema de
programação linear mostrado abaixo:
1 2
1 2
1
2
10 203
. 1 41 4
min x xx x
s a xx
+
+ ≥⎧⎪ ≤ ≤⎨⎪ ≤ ≤⎩
(3.1)
Colocando o problema 3.1 no formato padrão, tem-se:
1 2 3
1 4
1 5
2 6
2 7
0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
1 2 3 4 5 6 710 20 0 0 0 0 0
.
x x x
x x
x x
x x
x x
min x x x x x x x
s a
+ − + + + + =
+ + − + + + =
+ + + + + + =
+ + + + − + =
+ + + + + + =
+ + + + + +
⎧⎪⎪⎪⎨⎪⎪⎪⎩
3
1
4
1
4
, (3.2)
A representação matricial para este problema é dada por:
'
. min c xs a Ax b=
, 0 1,...,7ix i≥ = (3.3)
onde
[ ]
1 1 1 0 0 0 0 31 0 0 1 0 0 0 1
; 1 0 0 0 1 0 0 40 1 0 0 0 1 0 10 1 0 0 0 0 1 4
' 10 20 0 0 0 0 0
A b
c
−⎡ ⎤⎢ ⎥−⎢ ⎥⎢ ⎥= =⎢ ⎥⎢ ⎥⎢ ⎥⎣ ⎦
=
⎡ ⎤⎢ ⎥⎢ ⎥⎢ ⎥⎢ ⎥⎢ ⎥⎢ ⎥⎣ ⎦
13
A representação matricial para o Dual do problema 3.3 pode ser escrita como
'
. 'max b ys a A y z c+ =
, 0 1,...,50 1,...,7
i
i
y iz i≥ =⎧
⎨ ≥ =⎩(3.4)
onde z é o vetor das variáveis de folga do dual.
2.3.1 - Resultados obtidos para o exercício 3
A seguir estão mostrados os resultados para o exercício 3, obtidos através da utilização dos
seis métodos implementados no exercício 1. Para cada método é mostrada a sua respectiva
representação gráfica, baseado no problema primal. A região de soluções factíveis (S) para o
problema primal (3.1) é mostrada na Fig 3.1.
0 1 20
1
2
3
4
5
x 2
Figura 2.3.1 - Região formada pel
2.3.1.1- Método Primal Afim-Escala
Considerando τ=0.995, σ=1, ε=10-6 e x0=[4
no exercício 1, obteve-se:
S
3 4 5
x1 as restrições do problema 3.1.
4 1 1 1 1 1]', através do algoritmo implementado
14
k x1k x2
k
0 4,000000 4,0000001 2,261609 2,1701152 1,966234 1,0592503 1,989975 1,0165014 2,003880 1,0001275 1,999980 1,0001216 1,999958 1,0000617 2,000013 1,0000018 2,000000 1,000000
0 1 2 30
1
2
3
4K=0
K=1
x 2
K=2
Ponto Ótimo (2,1)
4
x1 Pode-se observar que todos os pontos obtidos pelo método primal afim-escala são interiores
à região de soluções factíveis mostrada na Fig 3.1. A partir da 3a iteração (k=2) ocorrem pequenas
variações nos valores de x1 e x2. Daí surge a dificuldade de se visualizar graficamente os pontos
posteriores a essas iterações.
2.3.1.2- Método Dual Afim-Escala
Considerando τ=0.995, ε=10-6 e y0=[1 1 1 1 1]', através do algoritmo implementado no
exercício 1, obteve-se:
k x1k x2
k
15
0 0,601634 0,1082051 2,268572 0,3670752 2,042880 0,9539823 1,998318 1,0008154 2,000106 0,9999475 1,999997 1,0000026 2,000000 1,0000007 2,000000 1,0000008 2,000000 1,000000
0,5 1,0 1,5 2,00,0
0,5
1,0
2,5
x 2
x1
Ponto Ótimo (2,1)
K=2
K=1
K=0
Pode-se observar que no método dual afim-escala as sucessivas iterações resultam em pontos que não pertencem à região de factibilidade do primal. Porém, o ponto ótimo do problema dual é o mesmo que o do problema primal. Além disso, do ponto de vista do problema dual, todos os pontos encontrados são pontos interiores. Assim como ocorreu no método no método anterior, a partir da 3a iteração (k=2), a visualização gráfica fica prejudicada, devido às pequenas variações nos valores de x1 e x2.
2.3.1.3- Método Primal-Dual Afim-Escala Considerando τ=0.995 e ε=10-6, através do algoritmo implementado no exercício 1, obteve-se:
16
k x1k x2
k
0 1,600000 1,6000001 1,615555 1,5108762 2,029434 1,0025543 2,014616 1,0000134 2,000180 1,0000005 2,000001 1,0000006 2,000000 1,000000
1,6 1,7 1,8 1,9 2,
1,0
1,1
1,2
1,3
1,4
1,5
1,6
0 2,1
x 2
x1
K=0
K=1
Ponto Ótimo (2,1) K=2
K=3
A partir da 4a iteração (k=3) ocorrem pequenas variações nos valores de x1 e x2. Daí surge a
dificuldade de se visualizar graficamente os pontos posteriores a essas iterações (k=4 e 6).
2.3.1.4- Método Primal-Dual Clássico
Considerando τ=0.995, σ=0.1 e ε=10-6, através do algoritmo implementado no exercício 1,
obteve-se:
k x1k x2
k
0 1,600000 1,6000001 1,700991 1,5907752 1,924635 1,0970533 2,009144 1,0004854 1,999956 1,0061515 1,999992 1,0025716 1,999994 1,0004637 2,000000 1,0000158 2,000000 1,0000009 2,000000 1,000000
1,6 1,7 1,8 1,9 2,0
1,0
1,1
1,2
1,3
1,4
1,5
1,6
x 2
x
K=0 K=1
K=2
Ponto Ótimo (2,1)
K=3
A partir da 4a iteração (k=3) ocorrem pequenas variações nos valores de x1 e x2. Daí surge a
dificuldade de se visualizar graficamente os pontos posteriores a essas iterações (k=4,...,9).
2.3.1.5- Método Preditor-Corretor
Considerando τ=0.995 e ε=10-6, através do algoritmo implementado no exercício 1, obteve-
se:
17
k x1k x2
k
0 1,600000 1,6000001 1,638851 1,4370362 2,028587 1,0021853 2,000137 1,0000174 2,000000 1,0000015 2,000000 1,000000
1,6 1,7 1,8 1,9 2,0
1,0
1,1
1,2
1,3
1,4
1,5
1,6
2,1
x 2
x1
K=0
K=1
Ponto Ótimo (2,1)
K=2
A partir da 3a iteração (k=2) ocorrem pequenas variações nos valores de x1 e x2. Daí surge a
dificuldade de se visualizar graficamente os pontos posteriores a essas iterações (k=3, 4 e 5).
2.3.1.6- Método de Barreira Logarítmica
Considerando τ=0.995 e ε=10-6, através do algoritmo implementado no exercício 1, obteve-
se:
k x1
k x2k
0 1,000000 1,0000001 2,032026 2,0304572 2,014469 1,8733593 1,912687 1,0917044 2,003741 1,0004415 2,002770 1,0004476 1,999631 1,0003857 2,000013 1,0000028 2,000010 1,0000029 1,999998 1,000002
10 2,000000 1,000000
1,0 1,2 1,4 1,6 1,8 2,0
1,0
1,2
1,4
1,6
1,8
2,0
2,2
2,2
x 2
x1
K=1
Ponto Ótimo(2,1) K=2 K=0
A partir da 3a iteração (k=2) ocorrem pequenas variações nos valores de x1 e x2. Daí surge a
dificuldade de se visualizar graficamente os pontos posteriores a essas iterações (k=3,...,10).
2.4 - Exercício 4
Problema proposto:
1 2
1 2
1
2
5 31
. 0 20 2
max x xx x
s a xx
+
+ ≥⎧⎪ ≤ ≤⎨⎪ ≤ ≤⎩
(4.1)
Colocando o problema acima em sua forma padrão, temos:
1 2 3
1 2 3
1
2
3
5 3 01
0 2.
0 20 3
max x x xx x x
xs a
xx
+ +
+ − =⎧⎪ ≤ ≤⎪⎨ ≤ ≤⎪⎪ ≤ ≤⎩
, (4.2)
O problema proposto foi resolvido através do algoritmo primal-dual clássico para variáveis
canalizadas, mostrado no apêndice III.
2.4.1 - Resultados obtidos para o exercício 4
A seguir estão mostrados os resultados para o exercício 3, obtidos através da utilização do
método primal-dual clássico para variáveis canalizadas. Na figura a seguir são representados os
pontos obtidos pelo algoritmo, partindo do ponto inicial (x0) até o ponto ótimo (x*). Estes resultados
foram obtidos com τ=0.995, σ=0.2, ε=10-7. Foram simuladas, no entanto, outras estâncias. A tabela
7 mostra, o comportamento do algoritmo para diferentes valores de τ e ε.
18
Figura 2.4.1 – Pontos visitados: τ=0.995, σ=0.2, ε=10-7
Note que o ponto inicial (x0) está fora da região factível. Na primeira iteração chega-se a um
ponto interior factível (x1). A partir daí, o procedimento converge com passos maiores nas primeiras
iterações; passos esses que diminuem à medida que o ponto ótimo (x*) se aproxima.
Tabela 7 - Método primal-dual para variáveis canalizadas. O ponto inicial é mostrado na figura acima
τ ε x' F.O. Iterações Tempo
[ms]
0.995 10-7 [2 2] 16 10 20
0.5 10-7 [2 2] 16 30 50
0.1 10-7 [2 2] 16 186 270
0.995 10-6 [2 2] 16 9 20
0.995 10-3 [2 2] 16 8 20
0.995 10-1 [2 2] 16 6 20
19
Apêndice I
Algoritmos e Fluxogramas
Método Primal Afim-Escala
Início
•x' = [x' σ]•p = b – Ax•k = 0
•A = [A p]•σ =1•c' = [c' M]•M=100
•x' = [x' σ]•p = b – Ax•k = 0
•A = [A p]•σ =1•c' = [c' M]•M=100
2 1 2( ( ) ') ( )
'
k k k
k k
y A X A A X c
z c A y
−=
= −
( )( ) ( )
2 1 ' '
1 ' 1
rx Xz rg Xz c x b y
rp b Ax b rd z c A y c
= = + +
= − + = − − +
(rx ou rp ou rg ou rd) > ε
FIMx = xk sem σ
2 1 2
2
0
1
( ( ) ') ( )
'
( )
1
ki
k k k
k k
k k k
kk i
ki
k k k k
y A X A A X c
z c A y
d X z
xmin
x x dk k
δα τδ
α
−
<
+
=
= −
= −
⎧ ⎫⎪ ⎪= −⎨ ⎬⎪ ⎪⎩ ⎭
= += +
Não
Sim
•A, b e c•τ ∈ (0,1)•ε•x0 ∀
20
Método Dual Afim-Escala
Início
•A, b e c•τ ∈ (0,1)•ε•y∀
•y' = [y' σ]•z = c – A'y + e σ
•r = ε+1•l, k = 0
•A' = [A' e]•σ=-2min(z)•b' = [b' -M]•M=100
•y' = [y' σ]•z = c – A'y + e σ
•r = ε+1•l, k = 0
•A' = [A' e]•σ=-2min(z)•b' = [b' -M]•M=100
0
2 1
1
1
( ( ) ')
'
1
kzi
l l
l l
ll i
li
l l l l
l l l l
dy A Z A b
dz A dy
zmin
z
y y dy
z z dzl l
δα τ
δ
α
α
<
− −
+
+
=
= −
⎧ ⎫⎪ ⎪= −⎨ ⎬⎪ ⎪⎩ ⎭
= +
= += +
σ > 0
Sim
y0 = yl sem σz0 = zl
Não
*
*
0
2 1
1
1
( ( ) ')
'
1
kzi
k k
k k
kk i
ki
k k k k
k k k k
dy A Z A b
dz A dy
zmin
z
y y dy
z z dzk k
δα τ
δ
α
α
<
− −
+
+
=
= −
⎧ ⎫⎪ ⎪= −⎨ ⎬⎪ ⎪⎩ ⎭
= +
= += +
r > ε
Sim
Não
( )1 1' ' 1, 'k k kr b y b y max b y− −= −
FIM
21
Método Primal-Dual Afim-Escala
Início
•E3 = 1+||c||1•E1 = min(max(x), E2, ||b||1/E2||A||1)
•NF = 100•x = A'(AA')-1b•k = 0•E2 = 100
•E3 = 1+||c||1•E1 = min(max(x), E2, ||b||1/E2||A||1)
•NF = 100•x = A'(AA')-1b•k = 0•E2 = 100
01
0( , )
00
x max x Eyz
==
> ∀
30
3
3 3
se 0sese 0
i i
i i i
i
z E zz z z E
E E z
+ ≥⎧⎪= − ≤ −⎨⎪ − ≤ ≤⎩
NF > ε FIM
{ }{ }
111 1 1
1 1
1
0
0
'
( )
( ) ' ( ) ( )
( ) ' ( )
( )
1,
ki
ki
kpk k kdk k ka
k k k
k k k k k k kp d a
k k k k k kd a
k k k k ka
k k kp i ixk k kd i izkp p
r b Axr c A y zr X Z eD X Z
dy A D A r A D r A Z r
dx D A dy r X r
dz X r Z dx
min x x
min z z
min
δ
δ
ρ δ
ρ δ
α τρ
−
−− − −
− −
−
<
<
= −= − −= −=⎡ ⎤ ⎡ ⎤= + −⎣ ⎦ ⎣ ⎦
⎡ ⎤= − +⎣ ⎦⎡ ⎤= −⎣ ⎦
= −
= −
= { }{ }
1
1
1
1,
1
k
k kd dk k k k
pk k k k
dk k k k
d
min
x x dxy y dyz z dzk k
α τρ
ααα
+
+
+
=
= += += +
= +
Não
Sim
•A, b e c•τ ∈ (0,1)•ε
*
*
[ ]1
'
' ' ' '
Fp Ax bFd A y z cFa XZeF Fp Fd FaNF F
= −= + −===
22
Método Primal-Dual Clássico
Início
•E3 = 1+||c||1•E1 = min(max(x), E2, ||b||1/E2||A||1)
•NF = 100•x = A'(AA')-1b•k = 0•E2 = 100
•E3 = 1+||c||1•E1 = min(max(x), E2, ||b||1/E2||A||1)
•NF = 100•x = A'(AA')-1b•k = 0•E2 = 100
01
0( , )
00
x max x Eyz
==
> ∀
30
3
3 3
se 0sese 0
i i
i i i
i
z E zz z z E
E E z
+ ≥⎧⎪= − ≤ −⎨⎪ − ≤ ≤⎩
NF > ε FIM
{ }{ }
111 1 1
1 1
1
0
0
'
( )
( ) ' ( ) ( )
( ) ' ( )
( )
1,
ki
ki
kpk k kdk k k kc
k k k
k k k k k k kp d c
k k k k k kd c
k k k k kc
k k kp i ixk k kd i izkp
r b Axr c A y zr e X Z eD X Z
dy A D A r A D r A Z r
dx D A dy r X r
dz X r Z dx
min x x
min z z
min
δ
δ
µ
ρ δ
ρ δ
α
−
−− − −
− −
−
<
<
= −= − −= −=⎡ ⎤ ⎡ ⎤= + −⎣ ⎦ ⎣ ⎦
⎡ ⎤= − +⎣ ⎦⎡ ⎤= −⎣ ⎦
= −
= −
= { }{ }
1
1
1
1,
1
kp
k kd dk k k k
pk k k k
dk k k k
d
min
x x dxy y dyz z dzk k
τρ
α τρ
ααα
+
+
+
=
= += += +
= +
Não
Sim
•A, b e c•τ ∈ (0,1)•ε•σ ∈ (0,1)
*
*
[ ]1
'
' ' ' '
Fp Ax bFd A y z cFa XZeF Fp Fd FaNF F
= −= + −===
2
se 1
( ) se 1
k k k
kk
kk
k
Tr X Z
n
n
γ
γσ γµ
γσ γ
⎡ ⎤= ⎣ ⎦⎧
>⎪⎪= ⎨⎪ <⎪⎩
23
Método Preditor-Corretor
24
Início
"E3 = 1+||c||1"E1 = min(max(x), E2, ||b||1/E2||A||1)
"NF = 100"x = A'(AA')-1b"k = 0"E2 = 100
"E3 = 1+||c||1"E1 = min(max(x), E2, ||b||1/E2||A||1)
"NF = 100"x = A'(AA')-1b"k = 0"E2 = 100
01
0( , )
00
x max x Eyz
==
> ∀
30
3
3 3
se 0sese 0
i i
i i i
i
z E zz z z E
E E z
+ ≥⎧⎪= − ≤ −⎨⎪ − ≤ ≤⎩
"A, b e c"τ ∈ (0,1)"ε"σ ∈ (0,1)
*
NF > ε FIM
[ ]
~
~
1
~ 11 1 1
~ ~1 1
~ ~1
~ ~
0
~
'
( )
( ) ' ( ) ( )
( ) ' ( )
( )
k
i
kpk k k
dk k k
ak k k
kkk k k k k
p d ak k
kk k kd a
k kk k k
a
k kk iip
xk
dz
r b Ax
r c A y zr X Z eD X Z
d y A D A r A D r A Z r
d x D A d y r X r
d z X r Z d x
min x x
min
δ
δ
ρ δ
ρ
−
−− − −
− −
−
<
= −
= − −
= −
=
= + −
= − +
= −
= −
=
⎡ ⎤⎣ ⎦⎡ ⎤⎢ ⎥⎢ ⎥⎣ ⎦⎡ ⎤⎢ ⎥⎢ ⎥⎣ ⎦⎧ ⎫⎪ ⎪⎨ ⎬⎪ ⎪⎩ ⎭
( )
~
0
~ ~ ~ ~
~ ~ ~ ~ ~ ~
3~
~ ~
1, 1,
( ) '( ); ( )
se 1
se 1
( )
( )( )
;
k
i
k
k ii
k k k k
p dp d
k k k k k kk k k kp d
kk k
k
k k
k k
k kk k k
s a
k
z z
min min
x d x z x d z Tr X Z
n
r r e D x D z e
dy A
k n
δ
α τ ρ α τ ρ
γ α γ
γ γ γσ
γ γ
µ σ
µ
γ
<
−
= =
= + + =
>=
≤
=
= + −
=
⎧ ⎫⎪ ⎪⎨ ⎬⎪ ⎪⎩ ⎭
⎧ ⎫ ⎧ ⎫⎪ ⎪ ⎪ ⎪⎨ ⎬ ⎨ ⎬⎪ ⎪ ⎪ ⎪⎩ ⎭ ⎩ ⎭
⎧⎛ ⎞⎪⎜ ⎟⎪⎜ ⎟⎨⎝ ⎠⎪⎪⎩
[ ]
[ ]{ } { }
{ } { }
11 1 1
1 1
1
0 0
1
1
1
( ) ' ( ) ( )
( ) ' ( )
( )
1, 1,
; ;
k ki i
kk k k k kp d skk k k k k
d sk k k k k
skk k k k k
p i i d i ix zk kk k
p p d dk k k k
pkk k kd
k k
D A r A D r A Z r
dx D A dy r X r
dz X r Z dx
min x x min z z
min min
x x dx
y y dy
z z
δ δρ δ ρ δ
α τρ α τρ
α
α
α
−− − −
− −
−
< <
+
+
+
+ −
= − +
= −
= − = −
= =
= +
= +
= +
⎡ ⎤⎣ ⎦⎡ ⎤⎣ ⎦
1
k kd dz
k k= +
Não
Sim
*
[ ]1
'
' ' ' '
Fp Ax bFd A y z cFa XZeF Fp Fd FaNF F
= −= + −===
Método de Barreira Logarítmica
Início
•A, b e c•τ ∈ (0,1)•ε•x0 > 0 qualquer
•µ = 200•β=0.001•f0 = c0'x0•∆=10000•x' = [x' σ]•p = b – Ax
•k = 0
•A = [A p]•σ =1•c0= [c' M]'•M=10000
•µ = 200•β=0.001•f0 = c0'x0•∆=10000•x' = [x' σ]•p = b – Ax
•k = 0
•A = [A p]•σ =1•c0= [c' M]'•M=10000
0
1
0
10 ' 1
1
1
( ) ' ( ) '
( )
1 ,
se >1
se 11
ki
kk
k k k k k
k k k k k
kk imax x k
i
k kmaxk
k k k kk
k k
kk
k
c XcA AX
P I A A A A
dx X P cx
minx
min
x x dxf c x
f f
k k
δ
µ
λδ
α τλµα
µ βµ
µ
−
<
+
+
+
+
==
⎡ ⎤= − ⎣ ⎦= − +
⎧ ⎫⎪ ⎪= −⎨ ⎬⎪ ⎪⎩ ⎭
⎧ ⎫⎪ ⎪= ⎨ ⎬⎪ ⎪⎩ ⎭
= +=
∆ = −
⎧ ∆⎪= ⎨∆ ≤⎪⎩
= +
∆ ou σ > εNão
Sim
FIMx = xk sem σ
25
26
Apêndice II
Códigos para Algoritmos do Apêndice I feitos em MatLab
Método Primal Afim-Escala % Algoritmo de pontos interiores: Primal Afim-Escala. % [x,y,z]=pae(tau,epsilon) function [x,y,z]=pae(tau,epsi) tp=cputime; % Carrega as variáveis do problema (Salvas em var.mat). load variaveis A b c x % Problema equivalente com x inicial qualquer. M=100; sigma=1; p=b-A*x; c=[c; M]; A=[A p]; x=[x; sigma]; % Inicializacao de variaveis. k=0; % Calculo das variaveis segundo a direcao de descida. y = (A*(diag(x.^2))*A')\(A*(diag(x.^2))*c); z = c - A'*y; % Cálculo dos residuos. rx = norm(diag(x)*z)^2; rg = norm(diag(x)*z)/(1+norm(c'*x+b'*y)); rp = norm(b - A*x)/(1+norm(b)); rd = norm(z - c - A'*y)/(1+norm(c)); % Loop para encontrar o ponto otimo. while (rx>= epsi) | (rg>= epsi) | (rp>= epsi) | (rd>= epsi) | (x(length(x))> epsi) if k+1 >= 1000 %Para evitar de entrar em loop eterno caso ocorra erro break end % Calculo da direcao. d = -(x.^2).*z; % Calculo do tamanho do passo. indx = find(d < 0); % Índices dos elementos negativos de d. alfa = tau*min(-x(indx)./d(indx)); % Tamanho do Passo % Encontrando um novo ponto. x = x + alfa*d; y = (A*(diag(x.^2))*A')\(A*(diag(x.^2))*c); z = c - A'*y; % Calculo dos residuos. rx = norm(x.*z)^2;
27
rg = norm(x.*z)/(1+norm(c'*x+b'*y)); rp = norm(b - A*x)/(1+norm(b)); rd = norm(c - z - A'*y)/(1+norm(c)); k = k + 1; end tp=cputime-tp; % Impressão dos resultados fprintf(1,' \n'); for i=1:(length(x)-1) fprintf(1,'x(%d) = %f \n',i,x(i)); end fprintf(1,' \n'); for i=1:(length(y)) fprintf(1,'y(%d) = %f \n',i,y(i)); end fprintf(1,' \n'); for i=1:(length(z)-1) fprintf(1,'z(%d) = %f \n',i,z(i)); end fprintf(1,' \n'); fprintf(1,'sigma = %f \n',x(length(x))); fprintf(1,' \n'); fprintf(1,'Mínimo da função objetivo Primal (c`*x): %f \n',c'*x); fprintf(1,' \n'); fprintf(1,'Tempo de processamento (ms): %f \n',tp/1e-3); fprintf(1,'Iterações Realizadas: %d \n',k); fprintf(1,' \n'); x=x(1:length(x)-1,:); z=z(1:length(z)-1,:);
Método Dual Afim-Escala
% Algoritmo de pontos interiores: Dual Afim-Escala. % dae(tau,epsilon) function [x,y,z]=dae(tau,epsi); tp=cputime; % Carrega as variáveis do problema (Salvas em var.mat). load variaveis A b c y % Encontra z0 e y0 pontos interiores iniciais M=100; t=c-A'*y; indxs=find(t<0); z=c-A'*y; if ~ isempty(indxs) sigma=-2*min(t(indxs)); zs=c-A'*y+ones(length(c),1)*sigma; ys=[y; sigma]; As=[A; -ones(1,length(c))]; bs=[b; -M]; ks=0; while ys(length(ys))> 0 if ks+1 >= 1000 %Para evitar de entrar em loop eterno caso ocorra erro break end % Calculo das direções de subida
28
dys=((As*(diag(zs.^-2))*As')^-1)*bs; dzs=-(As'*dys); % Calculo do tamanho do passo. indxs = find(dzs < 0); % Índices dos elementos negativos de dz. alfas = (tau/10)*min(-zs(indxs)./dzs(indxs)); % Tamanho do Passo % Encontrando um novo ponto. ys = ys+alfas*dys; zs = zs+alfas*dzs; ks = ks + 1; end z=zs; for i=1:length(ys)-1 y(i)=ys(i); end end clear As bs zs ys dys dzs indxs alfas ks M t i sigma k=0; r=epsi+1; % Calculo das variaveis segundo a direcao de subida. dy=((A*(diag(z.^-2))*A')^-1)*b; dz=-(A'*dy); % Loop para encontrar o ponto otimo. while r>= epsi if k+1 >= 1000 %Para evitar de entrar em loop eterno caso ocorra erro break end % Calculo das direções de subida dy=((A*(diag(z.^-2))*A')^-1)*b; dz=-A'*dy; % Calculo do tamanho do passo. indx = find(dz < 0); % Índices dos elementos negativos de dz. alfa = tau*min(-z(indx)./dz(indx)); % Tamanho do Passo % Encontrando um novo ponto. yant=y; y = y+alfa*dy; z = z+alfa*dz; % Cálculo do residuo. r=norm(b'*yant-b'*y)/max(1,norm(b'*yant)); k = k + 1; end tp=cputime-tp; x=diag(z.^-2)*A'*((A*(diag(z.^-2))*A')^-1)*b; % Impressão dos resultados Finais fprintf(1,' \n'); for i=1:(length(x)) fprintf(1,'x(%d) = %f \n',i,x(i)); end fprintf(1,' \n'); for i=1:(length(y)) fprintf(1,'y(%d) = %f \n',i,y(i)); end fprintf(1,' \n'); for i=1:(length(z))
29
fprintf(1,'z(%d) = %f \n',i,z(i)); end fprintf(1,' \n'); fprintf(1,'Mínimo da função objetivo Primal (c`*x): %f \n',c'*x); fprintf(1,' \n'); fprintf(1,'Tempo de processamento (ms): %f \n',tp/1e-3); fprintf(1,'Iterações Realizadas: %d \n',k); fprintf(1,' \n');
Método Primal-Dual Afim-Escala % Metodo de Pontos interiores Primal-Dual Afim-Escala % function [x,y,z]=pdae(tau,epsilon) function [x,y,z]=pdae(tau,epsi) tp=cputime; %clear all; load variaveis A b c %carrega os dados do arquivo % ************** INICIALIZAÇAO ************** % [m n] = size(A); x = A' * inv(A*A') * b; E2 = 100; E1 = min([max(x), E2, norm(b,1)/(E2*norm(A,1))]); E3 = 1 + norm(c,1); % Determinaçao dos pontos iniciais: x = max(x, E1); % valor inicial de x y = zeros(m, 1); %valor inicial de y z = c; % valor provisorio de z % **** Atribuiçao de valores para z inicial **** % % para z >= 0 sub = find(z >= 0); z(sub,1) = z(sub, 1) + E3; % para de z<=0 aux = min(z, 0); sub = find(aux <= -E3); % z <= -E3 aux(sub,1) = -z(sub,1); sub = find(aux > -E3); % z >= -E3 aux(sub,1) = E3; z=max(aux, z); % valor inicial de z clear aux; clear sub; % ************** FIM: INICIALIZAÇAO ************** % % * Definiçao de parametros * % NF = 1; % criterio de parada k = 0; % contador de iteraçoes e= ones(n,1); while NF > epsi rp = b - A*x; rd = c - A'*y - z; ra = - diag(x)*diag(z)*e; D = diag(x.^-1)*diag(z); aux = inv(A*diag(diag(D).^-1)*A'); dy = aux*rp + aux*A*diag(diag(D).^-1)*(rd -diag(x.^-1)*ra); clear aux;
30
dx = diag(diag(D).^-1)*(A'*dy - rd + diag(x.^-1)*ra); dz = rd - A'*dy; xdx = -x./dx; zdz = -z./dz; xdx(xdx<0) = []; zdz(zdz<0) = []; rhop = min(xdx); rhod = min(zdz); alphap = min([tau*rhop, 1]); alphad = min([tau*rhod, 1]); x = x + alphap*dx; y = y + alphad*dy; z = z + alphad*dz; % Condiçao de otimalidade primal-dual: Fp = A*x - b; Fd = A'*y + z -c; Fa = diag(x)*diag(z)*e; F = [Fp; Fd; Fa]; NF = norm(F, 1); k = k+1; end tp=cputime-tp; % Impressão dos resultados fprintf(1,' \n'); for i=1:(length(x)) fprintf(1,'x(%d) = %f \n',i,x(i)); end fprintf(1,' \n'); for i=1:(length(y)) fprintf(1,'y(%d) = %f \n',i,y(i)); end fprintf(1,' \n'); for i=1:(length(z)) fprintf(1,'z(%d) = %f \n',i,z(i)); end fprintf(1,' \n'); fprintf(1,'Mínimo da função objetivo Primal (c`*x): %f \n',c'*x); fprintf(1,' \n'); fprintf(1,'Tempo de processamento (ms): %f \n',tp/1e-3); fprintf(1,'Iterações Realizadas: %d \n',k); fprintf(1,' \n');
Método Primal-Dual Clássico
% Método de pontos interiores Primal-Dual Clássico % function [x,y,z]=pdclass(tau,sigma,epsilon) function [x,y,z]=pdclass(tau,sigma,epsi) tp=cputime; %clear all; load variaveis A b c; %carrega os dados do arquivo % ************** INICIALIZAÇAO ************** % [m n] = size(A);
31
x = A' * inv(A*A') * b; E2 = 100; E1 = min ([max(x), E2, norm(b,1)/(E2*norm(A,1))]); E3 = 1 + norm(c,1); % Determinaçao dos pontos iniciais: x = max(x, E1); % valor inicial de x y = zeros(m, 1); %valor inicial de y z = c; % valor provisorio de z % **** Atribuiçao de valores para z inicial **** % % para z >= 0 sub = find(z >= 0); z(sub,1) = z(sub, 1) + E3; % para z<=0 aux = min(z, 0); sub = find(aux <= -E3); % z <= -E3 aux(sub,1) = -z (sub,1); sub = find(aux > -E3); % z >= -E3 aux(sub,1) = E3; z=max(aux, z); % valor inicial de z clear aux; clear sub; % ************** FIM: INICIALIZAÇAO ************** % % * Definiçao de parametros * % NF = 1; % criterio de parada k = 0; % contador de iteraçoes e= ones(n,1); while NF > epsi, if k==1000 % Evita loop Eterno fprintf(1,' \n'); fprintf(1,'Número máximo de iterações: %d \n',k); fprintf(1,' \n'); break end gama = trace(diag(x)*diag(z)); if gama < 1 mi = gama^2/n; else mi = sigma * gama/n; end rp = b - A*x; rd = c - A'*y - z; rc = mi*e - diag(x)*diag(z)*e; D = diag(x.^-1)*diag(z); aux = inv(A*diag(diag(D).^-1)*A'); dy = aux*(rp + A*diag(diag(D).^-1)*rd - A*diag(z.^-1)*rc); dx = diag(diag(D).^-1)*(A'*dy - rd + diag(x.^-1)*rc); dz = diag(x.^-1)*(rc - diag(z)*dx); xdx = -x./dx; zdz = -z./dz; xdx(xdx<0) = []; zdz(zdz<0) = []; rhop = min(xdx); rhod = min(zdz); alphap = min([tau*rhop, 1]); alphad = min([tau*rhod, 1]); x = x + alphap*dx; y = y + alphad*dy; z = z + alphad*dz;
32
% Condiçao de otimalidade primal-dual: Fp = A*x - b; Fd = A'*y + z -c; Fa = diag(x)*diag(z)*e; F = [Fp; Fd; Fa]; NF = norm(F, 1); k = k+1; end tp=cputime-tp; % Impressão dos resultados fprintf(1,' \n'); for i=1:(length(x)) fprintf(1,'x(%d) = %f \n',i,x(i)); end fprintf(1,' \n'); for i=1:(length(y)) fprintf(1,'y(%d) = %f \n',i,y(i)); end fprintf(1,' \n'); for i=1:(length(z)) fprintf(1,'z(%d) = %f \n',i,z(i)); end fprintf(1,' \n'); fprintf(1,'Mínimo da função objetivo Primal (c`*x): %f \n',c'*x); fprintf(1,' \n'); fprintf(1,'Tempo de processamento (ms): %f \n',tp/1e-3); fprintf(1,'Iterações Realizadas: %d \n',k); fprintf(1,' \n');
Método Preditor-Corretor % Metodo de pontos interiores Preditor-Corretor % function [x,y,z]=pc(tau,epsilon) function [x,y,z]=pc(tau,epsi) tp=cputime; load variaveis A b c %carrega os dados do arquivo % ************** INICIALIZAÇAO ************** % [m n] = size(A); x = A' * inv(A*A') * b; E2 = 100; E1 = min ([max(x), E2, norm(b,1)/(E2*norm(A,1))]); E3 = 1 + norm(c,1); % Determinaçao dos pontos iniciais: x = max(x, E1); % valor inicial de x y = zeros(m, 1); %valor inicial de y z = c; % valor provisorio de z % **** Atribuiçao de valores para z inicial **** % % para z >= 0 sub = find(z >= 0); z(sub,1) = z(sub, 1) + E3; % para de z<=0 aux = min(z, 0); sub = find(aux <= -E3); % z <= -E3 aux(sub,1) = -z (sub,1); sub = find(aux > -E3); % z >= -E3 aux(sub,1) = E3;
33
z=max(aux, z); % valor inicial de z clear aux; clear sub; % ************** FIM: INICIALIZAÇAO ************** % % * Definiçao de parametros * % NF = 1; % criterio de parada k = 0; % contador de iteraçoes e= ones(n,1); while NF > epsi, rp = b - A*x; rd = c - A'*y - z; ra = - diag(x)*diag(z)*e; D = diag(x.^-1)*diag(z); aux = inv(A*diag(diag(D).^-1)*A'); dy = aux*rp + aux*A*diag(diag(D).^-1)*(rd - diag(x.^-1)*ra); dx = diag(diag(D).^-1)*(A'*dy - rd + diag(x.^-1)*ra); dz = rd - A'*dy; xdx = -x./dx; zdz = -z./dz; xdx(xdx<0) = []; zdz(zdz<0) = []; rhop = min(xdx); rhod = min(zdz); alphap = min([tau*rhop, 1]); alphad = min([tau*rhod, 1]); gama1 = ( x + alphap*dx )' * ( z + alphad*dz ); gama = trace(diag(x)*diag(z)); if gama <= 1 sigma = gama / sqrt(n); else sigma = ( gama1 / gama ) ^ 3; end mi = sigma * (gama / n); rs = ra + mi*e - diag(dx) * ( diag(dz) ) * e; dy = aux*rp + aux*A*diag(diag(D).^-1)*(rd - diag(x.^-1)*rs); dx = diag(diag(D).^-1)*(A'*dy - rd + diag(x.^-1)*rs); dz = diag(x.^-1) * (rs - diag(z)*dx); xdx = -x./dx; zdz = -z./dz; xdx(xdx<0) = []; zdz(zdz<0) = []; rhop = min(xdx); rhod = min(zdz); alphap = min([tau*rhop, 1]); alphad = min([tau*rhod, 1]); x = x + alphap*dx; y = y + alphad*dy; z = z + alphad*dz; % Condiçao de otimalidade % Fp = A*x - b; Fd = A'*y + z -c; Fa = diag(x)*diag(z)*e; F = [Fp; Fd; Fa]; NF = norm(F, 1); k = k+1; end tp=cputime-tp; % Impressão dos resultados
34
fprintf(1,' \n'); for i=1:(length(x)) fprintf(1,'x(%d) = %f \n',i,x(i)); end fprintf(1,' \n'); for i=1:(length(y)) fprintf(1,'y(%d) = %f \n',i,y(i)); end fprintf(1,' \n'); for i=1:(length(z)) fprintf(1,'z(%d) = %f \n',i,z(i)); end fprintf(1,' \n'); fprintf(1,'Mínimo da função objetivo Primal (c`*x): %f \n',c'*x); fprintf(1,' \n'); fprintf(1,'Tempo de processamento (ms): %f \n',tp/1e-3); fprintf(1,'Iterações Realizadas: %d \n',k); fprintf(1,' \n');
Método de Barreira Logarítmica
% Método de pontos interiores de Barreira Logarítmica % function x=bl(tau, epsi) function x=bl(tau, epsi); tp=cputime; load variaveis A b c % ** Procedimento do Big M ** % [m,n] = size(A); x = ones(n,1); M=1e4; sigma =1; p=b-A*x; c = [c; M]; A=[A p]; x=[x; sigma]; % ** Procedimento do Big M ** % c0 = c; A0 = A; f0 = c0'*x; mi = 200; k=0; beta = 0.001; delta = 1; [m,n] = size(A0); while (delta > epsi) | (x(length(x)) > epsi) %sigma=x(length(x)) if k==1000 fprintf(1,'Número máximo de iterações: %d \n',k); break end passo = 1/mi; X=diag(x); c = X*c0; A = A0 * X; P = eye(n) - A' * inv( A * A' ) * A;
35
dx = -X* P * ( c - mi ); xdx = -x./dx; xdx(xdx<0) = []; % excluindo dx positivos lambda = min(xdx); alpha = min(passo, tau*lambda); x = x + alpha * dx; f = c0'*x; delta = abs(f - f0); if delta > 1 mi = mi*beta; end f0 = f; k = k+1; end tp=cputime-tp; x=x(1:length(x)-1,:); % Remove sigma de x c=c(1:length(c)-1,:); % Remove M de c % Impressão dos resultados fprintf(1,' \n'); for i=1:(length(x)) fprintf(1,'x(%d) = %f \n',i,x(i)); end fprintf(1,' \n'); fprintf(1,'Mínimo da função objetivo Primal (c`*x): %f \n',c'*x); fprintf(1,' \n'); fprintf(1,'Tempo de processamento (ms): %f \n',tp/1e-3); fprintf(1,'Iterações Realizadas: %d \n',k); fprintf(1,' \n');
36
Apêndice III
Exercício 4: Código em Matlab para o algoritmo primal dual
clássico com variáveis canalizadas
% Metodo primal-dual classico com variaveis canalizadas % leitura de dados de um arquivo .mat % function [x,fx,k,tempo]=can_pdc(tau,sigma,tol) function [x,fx,k,tempo]=can_pdc(tau,sigma,tol) % k – total de iterações t0=clock; load exercicio4.mat; %carrega os dados do arquivo b= b - A*l; % ************** INICIALIZAÇAO ************** % [m n] = size(A); nv=length(u); np = n + nv; % numero de variaveis primais nao negativas % * Calculo da norma 1 de |b + u| * % for k=1:length(b) aux = b(k) + u; num(k) = norm(aux,1); end % * Calculo da norma 1 de |b + u| * % num = norm(num,1); %num = norm((b+u) , 1) clear k; clear aux; % ******* ESTABELECIMENTO DE X0 E V0 ******* % x= A' * inv(A*A') * b; v=u; E2 = 100; E1 = min([max(x), max(v),E2, num/(E2*norm(A,1))]); % tirei max(v) clear num; % Determinaçao dos pontos iniciais: x = max(x, E1); % valor inicial de x v = max(v, E1); % valor inicial de v y = zeros(m, 1); %valor inicial de y % valores iniciais de v e w z = c+1; w=z; % valores provisorios de z e w z(c>0) = 2 * c(c>0); w(c>0) = c(c>0); z(c<0) = -c(c<0); w(c<0) = -2 * c(c<0); % ************** FIM: INICIALIZAÇAO ************** % % * Definiçao de parametros * %
37
NF = 1; % criterio de parada k = 0; % contador de iteraçoes e= ones(n,1); fx=linear(c,x); while NF > tol, X = diag(x); Z = diag(z); V = diag(v); W = diag(w); Xinv = diag(x.^-1); Vinv = diag(v.^-1); gama = trace(X*Z) + trace(V*W); if gama < 1 mi = gama^2/np; else mi = sigma * gama/np; end rp = b - A*x; rd = c - A'*y - z + w; ru = u - x - v; rc = mi*e - X*Z*e; rb = mi*e - V*W*e; D = Xinv*diag(z) + Vinv*W; % ***** Inversa da Matriz D ***** % dinv = diag(D).^-1; Dinv = diag(dinv); clear dinv; % ***** Inversa da Matriz D ***** % aux = inv(A*Dinv*A'); dy = aux*rp + aux*A*Dinv*(rd - Xinv*rc + Vinv*(rb - W*ru)); dx = Dinv*(A'*dy - rd + Xinv*rc - Vinv*(rb - W*ru)); dv = ru - dx; dw = Vinv * (rb - W*dv); dz = rd - A'*dy + dw; xdx = -x./dx; vdv = -v./dv; zdz = -z./dz; wdw = -w./dw; xdx(xdx<0) = []; vdv(vdv<0) = []; zdz(zdz<0) = []; wdw(wdw<0) = []; rhox = min(xdx); rhov = min(vdv); rhoz = min(zdz); rhow = min(wdw); rhop = min(rhox, rhov); rhod = min(rhoz, rhow);
38
alphap = min([tau*rhop, 1]); alphad = min([tau*rhod, 1]); x = x + alphap*dx; v = v + alphap*dv; y = y + alphad*dy; z = z + alphad*dz; w = w + alphad*dw; % Condiçao de otimalidade primal-dual: Fp = A*x - b; Fd = A'*y + z - w - c; Fu = u - x - v; Fa = X*Z*e; Fb = V*W*e; F = [Fp; Fd; Fu; Fa; Fb]; NF = norm(F, 1); k = k+1; x1 = [x1 x(1,1)]; x2 = [x2 x(2,1)]; end fx=linear(c,x); tempo = etime(clock,t0); III.1 Algoritmo auxiliar para cálculo do valor da função objetivo
% calculo da funçao valor de um PL - f= c'x % function f=linear(c,x) function f=linear(c,x) f= c' * x;
![UESC Comunicação Social [ Telemática ] Prof. Dr. Rogério Vargas .](https://static.fdocumentos.tips/doc/165x107/552fc14b497959413d8e2578/uesc-comunicacao-social-telematica-prof-dr-rogerio-vargas-httprogerioin.jpg)
