UNIVERSIDADE FEDERAL DO RIO DE JANEIRO

COPPE/UFRJ

PROGRAMA DE ENGENHARIA ELÉTRICA

CPE737 - TÉCNICAS DE OTIMIZAÇÃO EM SISTEMAS DE ENGENHARIA

TRABALHO 2

Alunos:

Leander de Oliveira Rêgo

Leonardo Augusto Abreu de Souza
Luı́s Kin Miyatake
Samuel Souza Júnior
Vladimir Rodrigues de Lima

Professor:

Afonso Celso Del Nero Gomes

RIO DE JANEIRO

2017
Sumário

1 Introdução 1

2 Métodos Numéricos 3
2.1 Método do Gradiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1.1 Implementação . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.2 Convergência . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Método do Gradiente Conjugado . . . . . . . . . . . . . . . . . . . . . 6
2.2.1 Convergência . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Método de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3.1 Implementação . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.2 Convergência . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4 Método de Newton Modificado . . . . . . . . . . . . . . . . . . . . . . . 11
2.4.1 Implementação . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4.2 Convergência . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.5 Método de Quase Newton . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5.1 Implementação . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.5.2 Convergência . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3 Simulações e Resultados 16
3.1 Caso 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2 Caso 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3 Caso 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.4 Caso 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.5 Caso 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4 Considerações Finais 30

Anexos 31

i
Capı́tulo 1

Introdução

Otimização consiste em encontrar uma solução ou um conjunto de soluções ótimas para

uma determinada função ou conjunto de funções. Basicamente, otimização trata-se de
um problema de maximização ou minimização de uma função qualquer, ou seja, de um
problema de busca de pontos especiais - maximizadores ou minimizadores.
As técnicas de otimização são amplamente aplicadas em problemas de engenharia.
Contudo, à medida que o número de funções ou, até mesmo, o número de variáveis
aumentam, a dificuldade em se determinar o conjunto de soluções ótimas também au-
menta. Neste contexto, surge a necessidade de desenvolver técnicas matemáticas e com-
putacionais que refinem o processo de otimização, os conhecidos métodos numéricos de
otimização.
Dentro do contexto de otimização, duas importantes vertentes são amplamente es-
tudadas: a Otimização Escalar e Otimização Vetorial. Neste trabalho, especificamente,
será abordada a problemática da Otimização Vetorial, que tem como principal objetivo
determinar os pontos especiais - minimizadores ou maximizadores - de funções vetoriais.
Além disso, serão apresentados cinco métodos numéricos de solução para o pro-
blema. São eles: o Método do Gradiente, o Método do Gradiente Conjugado, o Método
de Newton, o Método de Newton Modificado e, por fim, o Método de Quase Newton.

1
Em cada um dos métodos numéricos apresentados, serão discutidos algumas de suas
principais particularidades e serão apresentados os algoritmos implementados em MA-
TLAB®, bem como algumas simulações de exemplos que buscam validar os códigos
desenvolvidos.

2
Capı́tulo 2

Métodos Numéricos

Neste capı́tulo será apresentada uma breve abordagem teórica, destacando o princı́pio
de funcionamento e as principais particularidades de cada um dos métodos numéricos
em questão.
Os métodos apresentados se aplicam a funções suaves e trabalham com sequência
de pontos convergentes, ou seja, dado um ponto xk (vetor em <n ) devemos escolher
uma direção dk (vetor em <n ) e avançar certa distância αk nela. A diferença entre os
métodos está na maneira de se determinar a direção de avanço e a quantidade de avanço
em cada iteração.

2.1 Método do Gradiente

O método do Gradiente (MG) ou de Descida Máxima (MDM), desenvolvido para

funções suaves, é um método de primeira ordem (basta o cálculo das primeiras deriva-
das) que trabalha com sequência de pontos convergentes na qual a direção de avanço
em cada iteração deve causar o máximo decréscimo possı́vel na função f .
A Figura 2.1 apresenta o comportamento vetorial do algoritmo. Dado um ponto xk
qualquer, define-se uma direção dk e avançamos uma distância αk nela. Uma vez que
desejamos avançar de forma a causar o máximo decréscimo de f , o sentido do vetor dk

3
deve ser oposto ao do gradiente em cada ponto, ou seja, a direção de descida máxima
(ddm) fica: dk = −∇f (xk ).

Figura 2.1: Representação vetorial do avanço a cada iteração no método do Gradiente.

xk+1 = xk + αk dk (2.1)

Dados um xk e um dk , o ponto xk+1 depende apenas do avanço αk , que por sua

vez, é determinado por uma busca linear através da minimização da função f (α) =
f (xk + αk dk ). Trata-se, então, de um problema de otimização escalar o qual pode ser
resolvido de maneira visual, analı́tica ou numérica. Analiticamente, podemos dizer que
df
|
dα αk
= 0 e chega-se a [dk+1 ]T dk = 0, ou seja, duas direções de descida quaisquer são
perpendiculares. O método avança em zig-zag com ângulos retos. Isso pode explicar o
fato deste método ter convergência lenta.
Com relação ao critério de parada, temos basicamente três possibilidades além,
obviamente, de um limite máximo de iterações: (1) como o gradiente se anula na solução
x∗ , e como as funções são suaves, quando ∇f (xk ) estiver suficientemente próximo de
zero é hora de parar, ou seja, k∇f (xk )k < g ; (2) se xk+1 está suficientemente próximo
de xk , paramos, ou seja, kxk+1 − xk k < x ; (3) se f (xk+1 ) está suficientemente próximo
de f (xk ), paramos, ou seja, |f (xk+1 ) − f (xk )| < a .

4
 Outra questão importante se refere ao condicionamento da Hessiana da função f .
Hessianas bem condicionadas nos pontos de interesse (região “bem comportada”) pro-
movem uma convergência rápida do método; caso contrário há lentidão. Por exemplo,
se as curvas de nı́vel forem circulares, converge com apenas uma iteração, uma vez que
a primeira direção d aponta direto para o mı́nimo.

2.1.1 Implementação

Algoritmo do Gradiente
k←0
enquanto (não satisfaz critério de parada)
g k ← gradiente (f (.), xk )
dk ← −g k
αk ← argminα f (xk + αdk )
xk+1 = xk + αdk
k ←k+1
fim-enquanto

2.1.2 Convergência

O Método do Gradiente pode ter convergência lenta em alguns casos e, mesmo em casos
simples, como o de funções quadráticas, não se pode garantir convergência exata em
um número finito de passos e para qualquer ponto inicial. O Método do Gradiente
Conjugado, que será explicado a seguir, foi criado para melhorar esses aspectos.

5
2.2 Método do Gradiente Conjugado

O Método do Gradiente Conjugado (MGC), também de primeira ordem, visa melhorar

a convergência do MDM suavizando a mudança de direção a cada iteração da seguinte
forma:

dk+1 = −g(xk+1 ) + βk dk (2.2)

onde, o elemento −g(xk+1 ) é a ddm e o elemento βk dk um desvio na direção anterior. O

escalar βk representa uma medição da inércia de convergência. É como se estivéssemos
“cortando caminho” em relação ao caminho seguido pelo MDM, melhorando, dessa
forma, a velocidade de convergência. A determinação de βk é feita impondo que dk , e
T
dk+1 sejam direções conjugadas, ou seja: dk Adk+1 = 0. Onde A é a Hessiana da função
no ponto. Assim, por manipulação algébrica, chega-se à expressão de βk em suas duas
versões:

De fato, a expressão mais simples de Fletcher-Reeves é obtida da expressão de

Polak-Rebière considerando que o termo (g k+1 )T g k é nulo.
A Figura 2.2 apresenta o comportamento vetorial do algoritmo a partir de um ponto
xk qualquer e sua evolução até o ponto xk+2 . A primeira direção de avanço é obtida
da mesma forma que no MDM: d0 = −g 0 . Os avanços αk são obtidos por busca linear,
minimizando f (α) = f (xk + αk dk ), como no caso do MDM.

6
 Figura 2.2: Representação vetorial do avanço a cada iteração no método do Gradiente
Conjugado.

xk+1 = xk + αk dk
(2.3)
k+1 k+1 k
d = −g + βk d

Apesar do MGC ter sido desenvolvido para funções quadráticas, o mesmo pode ser
aplicado a uma função objetivo qualquer, uma vez que as expressões de βk independem
dos parâmetros A e b da função quadrática f (x) = q(x) = 21 xT Ax + bT x, onde a busca
linear de αk deve ser resolvida por um método numérico qualquer ou pela derivação de
f (α).

2.2.1 Convergência

O Método do Gradiente Conjugado, foi criado para melhorar alguns aspectos relaci-
onados ao Método do Gradiente, que pode ter convergência lenta ou até mesmo, em
alguns casos, pode não ser garantida uma convergência exata em um número finito de
passos e para qualquer ponto inicial. A principal mudança em relação ao Método do
Gradiente advém da suavização da mudança de direção dk a cada iteração. Com isso,
o Método do Gradiente Conjugado apresenta uma maior velocidade de convergência.

7
2.3 Método de Newton

Diferente dos Métodos do Gradiente e do Gradiente Conjugado, o Método de Newton é

considerado um método de 2a ordem. Ou seja, além do gradiente, é necessário realizar
o cálculo da hessiana para obter as direções.
Os métodos de Newton sustentam-se na praticidade de minimização de uma função
quadrática. A cada iteração é obtida uma aproximação quadrática q(x) para a função
objetivo f (x). É realizada a minimização de q(x) para obtenção do ponto a ser utilizado
na próxima iteração.
Essa aproximação, na verdade, corresponde à suposição de que a função f (x) seja
de classe pelo menos C 2 , visto que toda função dessa classe pode ser aproximada por
uma série de Taylor:

q(x) ≈f (xk ) + (x − xk )T ∇f (xk ) + (1/2)(x − xk )T ∇2 f (xk )(x − xk )

(2.4)
k k T k k T k k
q(x) ≈f (x ) + (x − x ) g + (1/2)(x − x ) G (x − x )

Onde o vetor ∇f (xk ) é o gradiente da função avaliado no ponto xk , representado

por g k , e ∇2 f (xk ) é a matriz Hessiana da função em xk , representada por Gk . Supondo
Gk > 0, pode-se considerar a expressão acima como uma quadrática em (x − xk ), com
mı́nimo em:

x − xk = −[Gk ]−1 g k (2.5)

Fazendo xk+1 = x, obtemos a lei de iteração:

xk+1 = xk + dk (2.6)

8
 Ou seja, o valor da próxima iteração depende da iteração atual mais uma determi-
nada direção, que é obtida por meio do cálculo da hessiana e do gradiente avaliados no
ponto xk .

dk = − [Gk ]−1 g k
(2.7)
k 2 k −1 k
d = − [∇ f (x )] ∇f (x )

A cada iteração o algoritmo caminha na direção de busca dk , que depende tanto do

gradiente quanto da Hessiana. Optou-se, durante a implementação, pelo tamanho de
passo fixo e unitário, procedimento que leva alguns autores a classificar o método de
Newton como “puro”. Se a função objetivo for exatamente quadrática, basta conhecer
o gradiente e a Hessiana em um ponto qualquer para se determinar, em uma única
iteração, o ponto de mı́nimo x∗ , por meio da lei de iteração. Para uma função objetivo
aproximadamente quadrática num certo domı́nio, a lei de iteração é utilizada para
obtenção sucessiva de estimativas do ponto mı́nimo que, quando convergem, convergem
em menos iterações que os métodos do gradiente e gradiente conjugado. Porém, para
casos diferentes dos citados, podem haver problemas de convergência.

2.3.1 Implementação

A partir da lei de iteração definida no Método de Newton, pode-se constituir um algo-

ritmo de minimização de funções, que pode ser expresso, em sua forma mais simples,
como a aplicação sequencial da lei de iteração, conforme o exposto a seguir:

9
 Algoritmo de Newton
k←0
enquanto (não satisfaz critério de parada)
g k ← gradiente (f (.), xk )
Gk ← Hessiana (f (.), xk )
xk+1 = xk − [Gk ]−1 g k
k ←k+1
fim - enquanto
O algoritmo foi implementado no Matlab, por metodologia simbólica, e encontra-se
disponı́vel para escolha do usuário na caixa de seleção disponı́vel na interface gráfica
do software Otimizador de Funções Multidimensionais. O critério de parada utilizado
foi | xk+1 − xk |< , onde  é uma tolerância definida pelo usuário.

2.3.2 Convergência

No caso em que a função objetivo apresenta formato precisamente quadrático, o algo-

ritmo de Newton não apenas converge para a solução exata do problema, como também
o faz de maneira não-iterativa, em um único passo. Porém, essa não é uma situação ge-
ral: as funções a serem otimizadas, mesmo duplamente diferenciáveis (premissa básica
do método), nem sempre possuem a Hessiana inversı́vel e definida positiva para deter-
minado ponto. Ou seja, em determinados tipos de função objetivo a direção fornecida
pelo método de Newton pode não ser uma direção de descida causando a divergência do
método. A falha na convergência é comum e o método é bastante sensı́vel com relação
ao vetor inicializador.

10
2.4 Método de Newton Modificado

Na intenção de garantir que o algoritmo produza a diminuição monotônica do valor da

função objetivo, mesmo para funções não-lineares que tenham comportamento diferente
do caso quadrático, incorpora-se a execução de uma minimização unidimensional em
cada iteração (busca linear). Com tal modificação, objetiva-se resolver os problemas de
convergência que o Método de Newton apresenta.
Objetivamente, o passo deixa de ser fixo e unitário como na metodologia anterior.
Por meio da introdução do fator αk (antes unitário), obtido por meio de uma busca
linear, o método de Newton Modificado objetiva reduzir o avanço em determinada
direção dk para tentar evitar a divergência.

xk+1 = xk + αk dk (2.8)

Outra modificação importante proposta pelo método é a ”correção”do sinal da Hes-

siana por meio de um truque matricial, onde é somado um fator suficientemente grande
para tornar F k positiva definida no ponto. A equação 2.9 ilustra a alteração, onde γ é
o fator citado e In é a matriz identidade de ordem n. Os autovalores de F k não devem
está próximos de zero.

F k = Gk + γIn

dk = −[F k ]−1 g k (2.9)

dk = −[∇2 f (xk ) + γIn ]−1 ∇f (xk )

11
2.4.1 Implementação

Algoritmo de Newton Modificado

k←0
enquanto (não satisfaz critério de parada)
g k ← gradiente (f (.), xk )
Gk ← Hessiana (f (.), xk )
dk ← −[F k ]−1 g k
αk ← argminα f (xk + αdk )
xk+1 = xk + αdk
k ←k+1
fim-enquanto
O algoritmo foi implementado no Matlab, por metodologia simbólica, e encontra-se
disponı́vel para escolha do usuário na caixa de seleção disponı́vel na interface gráfica do
software Otimizador de Funções Multidimensionais. Assim como no método de Newton
(“puro”), o critério de parada utilizado foi |xk+1 − xk | < , onde  é uma tolerância
definida pelo usuário.

2.4.2 Convergência

Mesmo com as modificações, a obtenção da hessiana e de seus autovalores pode ser

um pouco problemática. Entretanto, o algoritmo de Newton Modificado visa superar
os problemas de convergência para o mı́nimo do método de Newton ao fazer o uso da
busca linear e correção da Hessiana para que seja positiva definida. Porém, mesmo com
as melhorias, não se pode garantir convergência exata em um número finito de passos
e para qualquer ponto inicial.

12
2.5 Método de Quase Newton

A proposta básica do método de Quase Newton é, justamente, eliminar a necessidade

de obtenção exata da derivada segunda da função objetivo. Utiliza-se, então, uma re-
gra que permita a construção gradativa de uma matriz H k , a qual corresponde a uma
estimativa da inversa da Hessiana da função objetivo. Ou seja, o objetivo é obter uma
matriz H k que mantenha caracterı́sticas da hessiana a cada iteração. Essencialmente,
busca-se garantir que a matriz H k permaneça sempre definida positiva e, preferencial-
mente, bem condicionada.
Na implementação do algoritmo do método Quase Newton, foram utilizados dois
métodos para a produção de estimativas recursivas para H k com as propriedades reque-
ridas: o Método DFP (Davidon-Fletcher-Powell) e o Método BFGS (Broyden-Fletcher-
Goldfarb-Shanno), assim batizados em homenagem aos seus formuladores. O usuário
pode optar por qualquer um deles na própria interface do programa.
A lei de iteração permanece a mesma do Método de Newton Modificado. Porém,
agora a direção dk é definida a partir da estimativa de H k , conforme equação 2.10.

dk = −H k g k (2.10)

Em cada iteração a estimativa de H k é delimitada pela condição de Quase-Newton,

apresentada pelas equações 2.11 e 2.12.

H k+1 γ k = δ k (2.11)

γ k = g k+1 − g k
(2.12)
k k+1 k
δ =x −x

13
 A geração das matrizes é dada pela formulação dos métodos DFP e BFGS, apre-
sentados nas equações 2.13 e 2.14.

Hgγ T H Hδδ T
H k+1 = H − + T (2.13)
γ T Hg δ γ

δγ T H + Hγδ T γ T Hg δδ T
H k+1 = H − + (1 + ) (2.14)
δT γ δT γ δT γ

2.5.1 Implementação

Algoritmo de Quase Newton

k←0
Hk ← I
g k ← gradiente(f (.), xk )
enquanto (não satisfaz critério de parada)
dk ← −H k g k
αk ← argminα f (xk + αdk )
xk+1 = xk + αdk
g k ← gradiente(f (.), xk+1 )
δ k = xk+1 − xk
γ k = g k+1 − g k
H k+1 ← cálculo método DFP ou BFGS (a partir de H k )
k ←k+1
fim-enquanto
O algoritmo foi implementado no Matlab, por metodologia simbólica, e encontra-se
disponı́vel para escolha do usuário na caixa de seleção disponı́vel na interface gráfica
do software Otimizador de Funções Multidimensionais. Assim como nos métodos de
Newton (“puro”) e Newton modificado, o critério de parada utilizado foi |xk+1 −xk | < ,
onde  é uma tolerância definida pelo usuário.

14
2.5.2 Convergência

Assim como nos métodos anteriormente apresentados, a escolha do ponto inicial in-
fluencia consideravelmente o mı́nimo encontrado, especialmente em funções altamente
não-lineares. Por mais que o método de Quase Newton utilize uma estimativa do in-
verso da Hessiana, para os casos em que os algoritmos foram testados e comparados,
o desempenho do método foi similar ao do Newton Modificado no que diz respeito ao
número de iterações. Isso é especialmente interessante pois no Método de Quase New-
ton não é necessário computar informação de 2a ordem. Os resultados dos exemplos de
simulação serão apresentados na seção subsequente.

15
Capı́tulo 3

Simulações e Resultados

Nesta seção será realizada a implementação de alguns exemplos de minimização, elen-

cados de forma a destacar algumas particularidades dos métodos e dos algoritmos, além
de elucidar alguns dos desafios encontrados. Os casos tratam desde funções suaves e uni-
modais (ao menos na região de interesse do problema), onde espera-se fácil convergência
dos métodos, além de funções mais complicadas.

3.1 Caso 1

No Caso 1, buscou-se mostrar a influência da escolha do passo de enquadramento.

Se o passo utilizado no enquadramento for grande, a busca linear pode fazer com o
resultado dos métodos de otimização alternasse entre mı́nimos locais próximos. As
Figuras 3.1 e 3.2 ilustram esta situação, as quais apresentam os resultados para o método
do gradiente utilizando passo de enquadramento de α de 0.1 e 1, respectivamente, para
a função objetivo f (x1 , x2 ) = sen(0.5x21 − 0.25x22 + 3)cos(2x1 + 1 − exp(x2 )). O passo
de enquadramento maior (passo = 1) fez com que o algoritmo ficasse oscilando entre
diferentes mı́nimos sem atingir o critério de parada pela tolerância. Ou seja, neste caso,
o algoritmo não convergiu. Já no caso do passo de enquadramento de 0.1, o algoritmo
convergiu com apenas 5 iterações para o mı́nimo local mais próximo do ponto inicial.

16
 Figura 3.1: Resultados para MDM,
f (x1 , x2 ) = sen(0.5x21 − 0.25x22 + 3)cos(2x1 + 1 − exp(x2 )), passo de enquadramento 0,1 e
tolerância de 0,001.

Figura 3.2: Resultados para MDM,

f (x1 , x2 ) = sen(0.5x21 − 0.25x22 + 3)cos(2x1 + 1 − exp(x2 )), passo de enquadramento 1 e
tolerância de 0,001.

17
 Tabela 3.1: Comparação entre os métodos MDM e MGC para a função
f (x1 , x2 ) = sen(0.5x21 − 0.25x22 + 3)cos(2x1 + 1 − exp(x2 )) e diferentes pontos de partida.

Ponto inicial Parâmetro MGC (Polak-Rebière) MGC (Fletcher) MDM

f (x) -1 -1 -0,99999
[3, -4]
Iterações 4 5 26
f (x) -1 -0,99999 -1
[-3, -3]
Iterações 5 7 8
f (x) -1 -0.998427 -0,99995
[10, -10]
Iterações 5 4 6
f (x) -1 -0.999994 -0.99996
[-1, -20]
Iterações 4 6 24

Este exemplo também ilustra bem as vantagens do Método do Gradiente Conjugado

em relação ao Método do Gradiente, tanto em termos de robustez quanto em termos de
velocidade de convergência. O MGC por Polak-Rebière se demonstrou um pouco mais
eficiente que por Fletcher-Reeves. A Tabela 3.1 ilustra tais diferenças para uma função
objetivo f (x1 , x2 ) = sen(0.5x21 − 0.25x22 + 3)cos(2x1 + 1 − exp(x2 )), tolerância de 0,001
e diferentes pontos de partida.
Como pode ser visto na Figura 3.3, esta função apresenta diversos pontos de máximo
e mı́nimo locais. Fica evidente que as diferenças entre os métodos se tornam mais ou
menos evidentes a depender do ponto partida. Se a região em torno do ponto inicial é
bem comportada, ou seja, se as primeiras direções de avanço apontam para o mı́nimo,
as diferenças ficam menos expressivas (ver Tabela 3.1).

Figura 3.3: Função objetivo do tipo

f (x1 , x2 ) = sen(0.5x21 − 0.25x22 + 3)cos(2x1 + 1 − exp(x2 )).

18
 A Figura 3.4 apresenta o detalhe da convergência dos métodos MDM e MGC (Polak-
Rebière) para o ponto de partida [3,-4] da Tabela 3.1. Enquanto o MDM avança de
forma lenta numa trajetória em zig-zag, o MGC “corta caminho” e encontra o mı́nimo
de forma bem mais rápida.

Figura 3.4: Detalhe da trajetória de convergência para o MDM e MGC (Polak-Rebière).

3.2 Caso 2

No Caso 1, a escolha de um passo de enquadramento elevado fez com que o resultado

dos métodos de otimização alternasse entre mı́nimos locais próximos. Desta forma,
chegou-se a conclusão da necessidade de escolha de um passo de enquadramento pe-
queno, de forma a atingir um resultado satisfatório. Entretanto, a escolha do passo de
enquadramento não segue uma regra geral. Para cada função a ser estudada e para cada
condição inicial, uma escolha de passo de enquadramento deve ser realizada, podendo
ser necessário adotar passos de pequena ou elevada magnitude. No Caso 2, buscou-se
analisar uma função cujo comportamento fosse contrário ao mostrado no Caso 1.

19
 q
f (x1 , x2 ) = − 20 exp(−0.2 0.5x21 + 0.5x22 )
(3.1)
− exp(0.5(cos(2πx1 ) + cos(2πx2 )) + exp(1) + 20

A função a ser minimizada é dada pela expressão analı́tica mostrada na Equação 3.1
e é conhecida como Função de Ackley. Como, a princı́pio, o comportamento da função
não é conhecido, optou-se por realizar a análise partindo de um ponto inicial qualquer
[2 ; 5]. Além disso, foi utilizado um passo de enquadramento unitário.
Novamente, a função f (x1 , x2 ) foi submetida ao procedimento de minimização pelos
métodos de otimização vetorial propostos, com uma tolerância de 10−3 . Conforme
esperado, não houve problema de convergência dos métodos para a tolerância definida,
com exceção do Método de Newton, no qual o resultado convergiu para um ponto de
mı́nimo local. A Tabela 3.2 apresenta os resultados obtidos.
A Figura 3.5 (a) mostra as curvas de nı́vel da função analisada, bem como o resultado
da minimização através dos métodos de otimização. Já a Figura 3.5 (b) mostra o gráfico
3D da Função de Ackley e, em destaque, os minimizadores do processo iterativo.

(a) Curvas de Nı́vel (b) Plot 3D

Figura 3.5: Caso 2 - Função de Ackley

20
 A escolha do passo de enquadramento unitário (elevado) possibilitou uma melhor
otimização por parte dos métodos analisados, uma vez que foi possı́vel atingir o mı́nimo
global. Para a função estudada, a escolha de um passo de enquadramento pequeno
implicaria em uma busca reduzida e, com isso, o resultado facilmente tenderia para um
mı́nimo local.

Tabela 3.2: Resultados da Otimização para a Função de Ackley - Caso 2

Método de Otimização Minimizadores Mı́nimo Estimado Iterações

Gradiente [0 ; 0] 0 2

Gradiente Conjugado (PR) [0 ; 0] 0 2

Gradiente Conjugado (FR) [0 ; 0] 0 2

Newton [1.9908 ; 4.9768] 10.645 2

Newton Modificado [0 ; 0] 0 2

Quase Newton (DFP) [0 ; 0] 0 2

Quase Newton (BFGS) [0 ; 0] 0 2

21
3.3 Caso 3

No Caso 3, buscou-se avaliar a influência da escolha do ponto inicial no resultado

dos métodos de otimização. As análises mostram que a escolha do ponto inicial pode
influenciar diretamente no resultado do processo de otimização e, associada a escolha
do passo de enquadramento, determinar a busca minimizadores locais ou globais.

x41 + x42 − 16x21 − 16x22 + 5x1 + 5x2

f (x1 , x2 ) = (3.2)
2

A função a ser minimizada é dada pela expressão analı́tica mostrada na Equação

3.2 e é conhecida como Função de Styblinski–Tang. Como, a princı́pio, a ideia é avaliar
a influência da escolha do ponto inicial, optou-se por realizar a análise partindo de
quatro pontos iniciais quaisquer [±5 ; ±5]. Além disso, foi utilizado um passo de
enquadramento de 0,1.
Novamente, a função f (x1 , x2 ) foi submetida ao procedimento de minimização pelos
métodos de otimização vetorial propostos, com uma tolerância de 10−3 .

Figura 3.6: Influência da Escolha do Ponto Inicial - Caso 3

22
 A Figura 3.6 mostra que para os quatros pontos iniciais analisados obteve-se quatro
minimizadores diferentes: um global e os demais locais.
Partindo do ponto inicial [0 ; 0], os métodos de otimização atingem o mı́nimo global
f (x1 , x2 ) = −78.3323, conforme mostra a Figura 3.7.

Figura 3.7: Influência da Escolha do Ponto Inicial - Caso 3

Assim como no Caso 2, mostrado em 3.2, no Método de Newton o resultado do

processo de minimização convergiu para um ponto de mı́nimo local. A Tabela 3.3
apresenta os resultados obtidos em todos os métodos de otimização.

23
 Tabela 3.3: Resultados da Otimização para a Função de Styblinski–Tang - Caso 3

Método de Otimização Minimizadores Mı́nimo Estimado Iterações

Gradiente [-2.9035 ; -2.9035] -78.3323 2

Gradiente Conjugado (PR) [-2.9035 ; -2.9035] -78.3323 2

Gradiente Conjugado (FR) [-2.9035 ; -2.9035] -78.3323 2

Newton [0.15673 ; 0.15673] 0.391225 2

Newton Modificado [-2.9035 ; -2.9035] -78.3323 2

Quase Newton (DFP) [-2.9035 ; -2.9035] -78.3323 2

Quase Newton (BFGS) [-2.9035 ; -2.9035] -78.3323 2

24
3.4 Caso 4

No Caso 4, os métodos de minimização implementados serão avaliados em uma função

não convexa.

f (x1 , x2 ) = (x1 − 1)2 + 100(x2 − x21 )2 (3.3)

A função descrita pela equação 3.3 é conhecida como função de Rosenbrock para
o caso de duas variáveis. Esta função é caracterizada por possuir um mı́nimo global
dentro de um vale parabólico e flat, conforme ilustrado na Figura 3.8. A convergência
para o vale é simples para todos os métodos, porém, devido a região plana, a busca
pelo mı́nimo global torna-se trabalhosa.

Figura 3.8: Função de Rosenbrock para o caso no <2

25
 Tabela 3.4: Resultados obtidos na minimização da função de Rosenbrock no <2

Mı́nimo
Método de Otimização Minimizadores Iterações
Estimado
Gradiente [0.649 , 0.423] 0.123 120
Gradiente Conjugado [1.0 , 1.0] 0 15
Newton [1.0 , 1.0] 0 5
Newton Modificado [1.0 , 1.0] 0 20
Quase Newton [1.0 , 1.0] 0 15

O valor mı́nimo da função é igual a 0 e encontra-se no ponto (x1 ,x2 )=(1,1). Os

métodos implementados foram utilizados para a minimização com os seguintes critérios:

ˆ Ponto de partida (5,-5);

ˆ Tolerância de 0.0001;

ˆ Passo de enquadramento da busca linear de 0.1;

ˆ Número máximo de iterações igual a 120.

Com os critérios assumidos acima, a Tabela 3.4 ilustra os resultados obtidos.

Observa-se que, se excetuando o método do Gradiente, todos os outros métodos
convergiram para o mı́nimo global da função. O método do Gradiente foi limitado
pelo número máximo de iterações, isto deve-se ao fato que na região flat, o método
apresenta grande dificuldade de progressão, porém, ainda indicando um certo grau de
convergência para o mı́nimo global, conforme pode ser observado pela Figura 3.9.

26
 Figura 3.9: Dificuldade do Método do Gradiente - Caso 4

Apesar de não serem projetados para funções não convexas, os métodos conseguiram
estimar o mı́nimo global com precisão.

27
3.5 Caso 5

No caso 5, os métodos implementados foram testados em uma função no <4 . A função

escolhida novamente foi a de Rosenbrock, contudo agora no seu caso de quatro variáveis,
conforme pode ser observado pela 3.4.

f (x1 , x2 , x3 , x4 ) =(x1 − 1)2 + 100(x2 − x21 )2 + (x2 − 1)2 +

(3.4)
100(x3 − x22 )2 2
+ (x3 − 1) + 100(x4 − x23 )2

Infelizmente, devido à dimensão do problema não é possı́vel sua visualização gráfica.

O valor mı́nimo da função continua sendo igual a 0, em semelhança ao caso no <2 , e
seus minimizadores encontram-se no ponto (x1 ,x2 ,x3 ,x4 )=(1,1,1,1).
Os métodos implementados foram utilizados para a minimização com os seguintes
critérios:

ˆ Ponto de partida (5,-5, 5,-5);

ˆ Tolerância de 0.001;

ˆ Passo de enquadramento da busca linear de 0.1;

ˆ Número máximo de iterações igual a 120.

Com os critérios assumidos acima, a 3.5 ilustra os resultados obtidos.

Novamente, o método do Gradiente foi limitado pelo número máximo de iterações,
possivelmente pelo mesmo motivo do caso no <2 , a lentidão na convergência para o
mı́nimo global. O método de Newton, ao contrário do caso no <2 , não conseguiu
convergir para o mı́nimo da função, fato ocasionado pelo mal condicionamento do ponto
inicial.

28
Tabela 3.5: Resultados obtidos na minimização da função de Rosenbrock no <4 .

Método de Mı́nimo
Minimizadores Iterações
Otimização Estimado

[0.815 , 0.664 ,
Gradiente 0.461 120
0.441 , 0.191]

Gradiente [0.99871 , 0.99743 ,

0 23
Conjugado 0.99488 , 0.98968]

[9.2 , 84.2 ,
Newton 5.03e+7 10
7090.4 , 50.2e+6]

Newton [1, 1,
0 23
Modificado 1, 1]

[1, 1,
Quase Newton 0 24
1, 1]

29
Capı́tulo 4

Considerações Finais

ˆ Os métodos de segunda ordem tendem a funcionar melhor que os de primeira

ordem;

ˆ A escolha do passo de enquadramento determina se a busca é local ou mais afas-

tada das vizinhanças da condição inicial;

ˆ A escolha do ponto inicial influencia o mı́nimo encontrado, especialmente em

funções altamente não-lineares;

ˆ O Método do Gradiente Conjugado - Polak-Rebière tende a funcionar melhor que

Fletcher-Reeves;

ˆ O Método do Gradiente Conjugado tende a acelerar a busca quando comparado

ao Método do Gradiente – Exemplo: Rosenbrock.

ˆ O Método de Quase Newton DFP e BFGS possuem desempenho semelhante,

poucas diferenças foram observadas em termos dos resultado obtidos;

ˆ O Método de Newton funciona muito bem quando a hessiana ao redor do ponto

inicial é positiva definida e a função é suave. Caso contrário, o Método de Newton

Modificado é mais robusto.

30
 Anexos

Script para Otimização de Funções Multidimensionais

1 % Metodo do G r a d i e n t e
2 x0 = x i n i t ; max step = 1 0 ; i t e r = 1 ;
3 i f dim == 2
4 e z c o n t o u r ( f , [ xmin xmax ymin ymax ] , 1 0 0 )
5 hold a l l
6 end
7 [ v alu e0 , g0 ] = numerico ( x0 ) ;
8 xx = x0 ;
9 gg = g0 ;
10 pp = [ ] ;
11 f f = value0 ;
12 d0 = −g0 / ( norm ( g0 , 2 ) +1e −12) ;
13 i f dim == 2
14 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−r o ’ )
15 a x i s ( [ xmin xmax ymin ymax ] )
16 % t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( v a l u e ) , ’ | ’ , ’ P. I .
= ’ num2str ( p r o d u t o i n t e r n o ) ] )
17 end
18 w h i l e i t e r <= i t e r m a x
19 valor = [ ] ;
20 count = 1 ;
21 f o r p a s s o = 0 : i n c r : max step
22 v a l o r = [ v a l o r o b j f u n b u s c a l i n e a r ( x0 , −g0 , p a s s o ) ] ;
23 i f count > 2
24 i f v a l o r ( end ) > v a l o r ( end −1)
25 break
26 end
27 end
28 count = count + 1 ;
29 end
30 f u n f u n = @( a l p h a ) o b j f u n b u s c a l i n e a r ( x0 , −g0 , a l p h a ) ;
31 p a s s o = fminbnd ( funfun , 0 , passo , o p t i m s e t ( ’ TolX ’ , 1 e −4) ) ;
32 d = −g0 /norm ( g0 , 2 ) ;

31
33 x = x0 − g0 * p a s s o / ( norm ( g0 , 2 ) +1e −12) ;
34 xx = [ xx x ]
35 [ v alue , g , ˜ ] = numerico ( x ) ;
36 p r o d u t o i n t e r n o = gg ( : , end ) ’ * g ;
37 i f dim == 2
38 hold a l l
39 % p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’− ro ’ )
40 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−r o ’ )
41 a x i s ( [ xmin xmax ymin ymax ] )
42 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( v a l u e ) , ’ | ’,’ P. I
. = ’ num2str ( p r o d u t o i n t e r n o ) ] )
43 pause ( 0 . 0 1 )
44 end
45 gg = [ gg g ] ;
46 pp = [ pp p a s s o ] ;
47 f f = [ f f value ]
48 iter = iter + 1;
49 i f norm ( x−x0 , 2 ) < t o l
50 break
51 end
52 x0 = x ;
53 g0 = g ;
54 end
55 i f i t e r >= i t e r m a x
56 e r r o r d l g ( ’ Numero maximo de i t e r a c o e s do p r o c e s s o
numerico e x c e d i d o ’ )
57 end
58 saida = ’ ’ ;
59 f o r i = 1 : dim
60 s a i =[ s p r i n t f ( ’ x%d = ’ , i ) , num2str ( xx ( i , end ) ) ] ;
61 saida = char ( saida , s a i ) ;
62 end
63 set ( handles . result , ’ String ’ , saida ) ;
64 s e t ( h a n d l e s . Vfunc , ’ S t r i n g ’ , f f ( end ) ) ;
65 s e t ( h a n d l e s . N i t e r , ’ S t r i n g ’ , i t e r −1) ;
66

67 % Metodo do G r a d i e n t e Conjugado (PR)

68 x0 = x i n i t ; max step = 1 0 ; i t e r = 1 ;
69 i f dim == 2
70 e z c o n t o u r ( f , [ xmin xmax ymin ymax ] , 1 0 0 )
71 hold a l l
72 end
73 xx = x0 ;
74 [ v alu e0 , g0 , ˜ ] = numerico ( x0 ) ;
75 i f dim == 2
76 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−bo ’ )
77 a x i s ( [ xmin xmax ymin ymax ] )
78 end

32
 79 f f = value0 ;
80 d0 = −g0 ;
81 valor = [ ] ;
82 count = 1 ;
83 f o r p a s s o = 0 : i n c r : max step
84 v a l o r = [ v a l o r o b j f u n b u s c a l i n e a r ( x0 , d0 , p a s s o ) ] ;
85 i f count > 2
86 i f v a l o r ( end ) > v a l o r ( end −1)
87 break
88 end
89 end
90 count = count + 1 ;
91 end
92 f u n f u n = @( a l p h a ) o b j f u n b u s c a l i n e a r ( x0 , d0 , a l p h a ) ;
93 p a s s o = fminbnd ( funfun , 0 , passo , o p t i m s e t ( ’ TolX ’ , 1 e −4) ) ;
94 % i n t e r v a l o = d i v i s a o a u r e a ( x0 , d0 , 0 , max step , 1 e −3) ;
95 % p a s s o = mean ( i n t e r v a l o ) ;
96 x = x0 + d0 * p a s s o /norm ( d0 , 2 ) ;
97 xx = [ xx x ] ;
98 x0 = x ;
99 w h i l e i t e r <= i t e r m a x
100 [ v alue , g , ˜ ] = numerico ( x ) ;
101 i f dim == 2
102 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−bo ’ )
103 a x i s ( [ xmin xmax ymin ymax ] )
104 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( v a l u e ) ] )
105 pause ( 0 . 1 )
106 end
107 f f = [ f f value ] ;
108 % b = g ’ * g / ( g0 ’ * g0 ) ;
109 b = g ’ * ( g−g0 ) / ( g0 ’ * g0 ) ;
110 g0 = g ;
111 d = −g +b * d0 ;
112 d0 = d ;
113 valor = [ ] ;
114 count = 1 ;
115 f o r p a s s o = 0 : i n c r : max step
116 valor = [ valor o b j f u n b u s c a l i n e a r (x , d , passo ) ] ;
117 i f count > 2
118 i f v a l o r ( end ) > v a l o r ( end −1)
119 break
120 end
121 end
122 count = count + 1 ;
123 end
124 % MDA
125 % i n t e r v a l o = d i v i s a o a u r e a ( x , d , 0 , passo , 0 . 0 0 0 0 1 ) ;
126 % p a s s o = mean ( i n t e r v a l o ) ;

33
127

128 % Usando fminbnd ( economiza muito tempo )

129 f u n f u n = @( a l p h a ) o b j f u n b u s c a l i n e a r ( x , d , a l p h a ) ;
130 p a s s o = fminbnd ( funfun , 0 , passo , o p t i m s e t ( ’ TolX ’ , 1 e −4) ) ;
131 x = x0 + p a s s o * d/norm ( d , 2 ) ;
132 xx = [ xx x ]
133 iter = iter + 1;
134 i f norm ( x−x0 , 2 ) < t o l
135 break
136 end
137 x0 = x ;
138 end
139 [ v alue , g , ˜ ] = numerico ( x ) ;
140 f f = [ f f value ]
141 i f dim == 2
142 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−bo ’ )
143 a x i s ( [ xmin xmax ymin ymax ] )
144 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( v a l u e ) ] )
145 pause ( 0 . 1 )
146 end
147 i f i t e r >= i t e r m a x
148 e r r o r d l g ( ’ Numero maximo de i t e r a c o e s do p r o c e s s o
numerico e x c e d i d o ’ )
149 end
150 saida = ’ ’ ;
151 f o r i = 1 : dim
152 s a i =[ s p r i n t f ( ’ x%d = ’ , i ) , num2str ( xx ( i , end ) ) ] ;
153 saida = char ( saida , s a i ) ;
154 end
155 set ( handles . result , ’ String ’ , saida ) ;
156 s e t ( h a n d l e s . Vfunc , ’ S t r i n g ’ , f f ( end ) ) ;
157 s e t ( handles . Niter , ’ String ’ , i t e r ) ;
158

159 % Metodo do G r a d i e n t e Conjugado (FR)

160 x0 = x i n i t ; max step = 1 0 ; i t e r = 1 ;
161 i f dim == 2
162 e z c o n t o u r ( f , [ xmin xmax ymin ymax ] , 1 0 0 )
163 hold a l l
164 end
165 xx = x0 ;
166 [ v alu e0 , g0 , ˜ ] = numerico ( x0 ) ;
167 i f dim == 2
168 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−yo ’ )
169 a x i s ( [ xmin xmax ymin ymax ] )
170 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( v a l u e 0 ) ] )
171 end
172 f f = value0 ;
173 d0 = −g0 ;

34
174 valor = [ ] ;
175 count = 1 ;
176 f o r p a s s o = 0 : i n c r : max step
177 v a l o r = [ v a l o r o b j f u n b u s c a l i n e a r ( x0 , d0 , p a s s o ) ] ;
178 i f count > 2
179 i f v a l o r ( end ) > v a l o r ( end −1)
180 break
181 end
182 end
183 count = count + 1 ;
184 end
185 f u n f u n = @( a l p h a ) o b j f u n b u s c a l i n e a r ( x0 , d0 , a l p h a ) ;
186 p a s s o = fminbnd ( funfun , 0 , passo , o p t i m s e t ( ’ TolX ’ , 1 e −4) ) ;
187 % i n t e r v a l o = d i v i s a o a u r e a ( x0 , d0 , 0 , max step , 1 e −3) ;
188 % p a s s o = mean ( i n t e r v a l o ) ;
189 x = x0 + d0 * p a s s o /norm ( d0 , 2 ) ;
190 xx = [ xx x ] ;
191 x0 = x ;
192 w h i l e i t e r <= i t e r m a x
193 [ v alue , g , ˜ ] = numerico ( x ) ;
194 i f dim == 2
195 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−yo ’ )
196 a x i s ( [ xmin xmax ymin ymax ] )
197 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( v a l u e ) ] )
198 pause ( 0 . 1 )
199 end
200 f f = [ f f value ] ;
201 b = g ’ * g / ( g0 ’ * g0 ) ;
202 %b = g ’ * ( g−g0 ) / ( g0 ’ * g0 ) ;
203 g0 = g ;
204 d = −g +b * d0 ;
205 d0 = d ;
206 valor = [ ] ;
207 count = 1 ;
208 f o r p a s s o = 0 : i n c r : max step
209 valor = [ valor o b j f u n b u s c a l i n e a r (x , d , passo ) ] ;
210 i f count > 2
211 i f v a l o r ( end ) > v a l o r ( end −1)
212 break
213 end
214 end
215 count = count + 1 ;
216 end
217 % MDA
218 % i n t e r v a l o = d i v i s a o a u r e a ( x , d , 0 , passo , 0 . 0 0 0 0 1 ) ;
219 % p a s s o = mean ( i n t e r v a l o ) ;
220

221 % Usando fminbnd ( economiza muito tempo )

35
222 f u n f u n = @( a l p h a ) o b j f u n b u s c a l i n e a r ( x , d , a l p h a ) ;
223 p a s s o = fminbnd ( funfun , 0 , passo , o p t i m s e t ( ’ TolX ’ , 1 e −4) ) ;
224 x = x0 + p a s s o * d/norm ( d , 2 ) ;
225 xx = [ xx x ]
226 iter = iter + 1;
227 i f norm ( x−x0 , 2 ) < t o l
228 break
229 end
230 x0 = x ;
231 end
232 [ v alue , g , ˜ ] = numerico ( x ) ;
233 f f = [ f f value ]
234 i f dim == 2
235 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−yo ’ )
236 a x i s ( [ xmin xmax ymin ymax ] )
237 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( v a l u e ) ] )
238 pause ( 0 . 1 )
239 end
240 i f i t e r >= i t e r m a x
241 e r r o r d l g ( ’ Numero maximo de i t e r a c o e s do p r o c e s s o
numerico e x c e d i d o ’ )
242 end
243 saida = ’ ’ ;
244 f o r i = 1 : dim
245 s a i =[ s p r i n t f ( ’ x%d = ’ , i ) , num2str ( xx ( i , end ) ) ] ;
246 saida = char ( saida , s a i ) ;
247 end
248 set ( handles . result , ’ String ’ , saida ) ;
249 s e t ( h a n d l e s . Vfunc , ’ S t r i n g ’ , f f ( end ) ) ;
250 s e t ( handles . Niter , ’ String ’ , i t e r ) ;
251

252 % Metodo de Newton

253 x0 = x i n i t ; i t e r = 1 ;
254 xx = x0 ;
255 i f dim == 2
256 e z c o n t o u r ( f , [ xmin xmax ymin ymax ] , 1 0 0 )
257 hold a l l
258 end
259 ff = [];
260 count = 1 ;
261 w h i l e i t e r <= i t e r m a x
262 [ f v a l , g r a d v a l , h e s s i a n v a l ] = numerico ( x0 ) ;
263 ff = [ ff fval ] ;
264 d0 = −pinv ( h e s s i a n v a l ) * g r a d v a l ;
265 i f dim == 2
266 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−co ’ )
267 a x i s ( [ xmin xmax ymin ymax ] )
268 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( f v a l ) ] )

36
269 pause ( 0 . 5 )
270 end
271 x = x0 + d0 ;
272 xx = [ xx x ]
273 iter = iter + 1;
274 i f norm ( x−x0 , 2 ) < t o l
275 break
276 end
277 x0 = x ;
278 count = count + 1 ;
279 end
280 [ f v a l , g r a d v a l , h e s s i a n v a l ] = numerico ( x ) ;
281 ff = [ ff fval ]
282 i f dim == 2
283 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−co ’ )
284 a x i s ( [ xmin xmax ymin ymax ] )
285 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( f v a l ) ] )
286 pause ( 0 . 5 )
287 end
288 i f i t e r >= i t e r m a x
289 e r r o r d l g ( ’ Numero maximo de i t e r a c o e s do p r o c e s s o
numerico e x c e d i d o ’ )
290 end
291 saida = ’ ’ ;
292 f o r i = 1 : dim
293 s a i =[ s p r i n t f ( ’ x%d = ’ , i ) , num2str ( xx ( i , end ) ) ] ;
294 saida = char ( saida , s a i ) ;
295 end
296 set ( handles . result , ’ String ’ , saida ) ;
297 s e t ( h a n d l e s . Vfunc , ’ S t r i n g ’ , f f ( end ) ) ;
298 s e t ( h a n d l e s . N i t e r , ’ S t r i n g ’ , i t e r −1) ;
299

300 % Metodo de Newton M o d i f i c a d o

301 x0 = x i n i t ; max step = 1 0 ; i t e r = 1 ;
302 xx = x0 ;
303 i f dim == 2
304 e z c o n t o u r ( f , [ xmin xmax ymin ymax ] , 1 0 0 )
305 hold a l l
306 end
307 ff = [];
308 w h i l e i t e r <= i t e r m a x
309 [ f v a l , g r a d v a l , h e s s i a n v a l ] = numerico ( x0 ) ;
310 ff = [ ff fval ] ;
311 i f dim == 2
312 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−go ’ )
313 a x i s ( [ xmin xmax ymin ymax ] )
314 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( f v a l ) ] )
315 pause ( 0 . 1 )

37
316 end
317 gama = 0 . 1 ;
318 w h i l e 1 == 1
319 i f min ( e i g ( h e s s i a n v a l ) ) < 0
320 h e s s i a n v a l = h e s s i a n v a l + gama * eye ( dim ) ;
321 gama = gama + 0 . 1 ;
322 else
323 break
324 end
325 end
326 d0 = −pinv ( h e s s i a n v a l ) * g r a d v a l ;
327 valor = [ ] ;
328 count = 1 ;
329 f o r p a s s o = 0 : i n c r : max step
330 v a l o r = [ v a l o r o b j f u n b u s c a l i n e a r ( x0 , d0 , p a s s o ) ] ;
331 i f count > 2
332 i f v a l o r ( end ) > v a l o r ( end −1)
333 break
334 end
335 end
336 count = count + 1 ;
337 end
338 % i n t e r v a l o = d i v i s a o a u r e a ( x0 , d0 , 0 , passo , 0 . 0 0 0 0 1 ) ;
339 % p a s s o = mean ( i n t e r v a l o ) ;
340 f u n f u n = @( a l p h a ) o b j f u n b u s c a l i n e a r ( x0 , d0 , a l p h a ) ;
341 p a s s o = fminbnd ( funfun , 0 , passo , o p t i m s e t ( ’ TolX ’ , 1 e −4) ) ;
342 x = x0 + p a s s o * d0/norm ( d0 , 2 ) ;
343 xx = [ xx x ]
344 iter = iter + 1;
345 i f norm ( x−x0 , 2 ) < t o l
346 break
347 end
348 x0 = x ;
349 end
350 [ f v a l , g r a d v a l , h e s s i a n v a l ] = numerico ( x ) ;
351 ff = [ ff fval ]
352 i f dim == 2
353 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−go ’ )
354 a x i s ( [ xmin xmax ymin ymax ] )
355 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( f v a l ) ] )
356 pause ( 0 . 1 )
357 end
358 i f i t e r >= i t e r m a x
359 e r r o r d l g ( ’ Numero maximo de i t e r a c o e s do p r o c e s s o
numerico e x c e d i d o ’ )
360 end
361 saida = ’ ’ ;
362 f o r i = 1 : dim

38
363 s a i =[ s p r i n t f ( ’ x%d = ’ , i ) , num2str ( xx ( i , end ) ) ] ;
364 saida = char ( saida , s a i ) ;
365 end
366 set ( handles . result , ’ String ’ , saida ) ;
367 s e t ( h a n d l e s . Vfunc , ’ S t r i n g ’ , f f ( end ) ) ;
368 s e t ( h a n d l e s . N i t e r , ’ S t r i n g ’ , i t e r −1) ;
369

370 % Metodo de Quase Newton (DFP)

371 x0 = x i n i t ; max step = 1 0 ; i t e r = 1 ;
372 xx = x0 ;
373 i f dim == 2
374 e z c o n t o u r ( f , [ xmin xmax ymin ymax ] , 1 0 0 )
375 hold a l l
376 end
377 ff = [];
378 H0 = eye ( dim ) ;
379 [ val , g0 , ˜ ] = numerico ( x0 ) ;
380 w h i l e i t e r <= i t e r m a x
381 d0 = −H0 * g0 ;
382 f f = [ f f val ] ;
383 i f dim == 2
384 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−mo ’ )
385 a x i s ( [ xmin xmax ymin ymax ] )
386 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( v a l ) ] )
387 pause ( 0 . 1 )
388 end
389 valor = [ ] ;
390 count = 1 ;
391 f o r p a s s o = 0 : i n c r : max step
392 v a l o r = [ v a l o r o b j f u n b u s c a l i n e a r ( x0 , d0 , p a s s o ) ] ;
393 i f count > 2
394 i f v a l o r ( end ) > v a l o r ( end −1)
395 break
396 end
397 end
398 count = count + 1 ;
399 end
400 % i n t e r v a l o = d i v i s a o a u r e a ( x0 , d0 , 0 , passo , 0 . 0 1 ) ;
401 % p a s s o = mean ( i n t e r v a l o ) ;
402 f u n f u n = @( a l p h a ) o b j f u n b u s c a l i n e a r ( x0 , d0 , a l p h a ) ;
403 p a s s o = fminbnd ( funfun , 0 , passo , o p t i m s e t ( ’ TolX ’ , 1 e −4) ) ;
404 x = x0 + p a s s o * d0/norm ( d0 , 2 ) ;
405 xx = [ xx x ]
406 iter = iter + 1;
407 i f norm ( x−x0 , 2 ) < t o l
408 break
409 end
410 d e l t a = x − x0 ;

39
411 [ val , g , ˜ ] = numerico ( x ) ;
412 gama = g − g0 ;
413 H = H0 − H0 * gama * gama ’ * H0 / ( gama ’ * H0 * gama ) + d e l t a *
d e l t a ’ / ( d e l t a ’ * gama ) ; %DFP
414 % H = ( [ 1 0 0 ; 0 1 0 ; 0 0 1 ] − ( x − x0 ) * gama ’ / ( gama
’ * ( x − x0 ) ) ) * H0 * ( [ 1 0 0 ; 0 1 0 ; 0 0 1]−gama * ( x − x0 )
’ / ( gama ’ * ( x − x0 ) ) ) + ( x − x0 ) * ( x − x0 ) ’ / ( gama ’ * ( x − x0 )
) ; %BFGS c e r t o
415 H0 = H;
416 g0 = g ;
417 x0 = x ;
418 end
419 [ f v a l , g r a d v a l , ˜ ] = numerico ( x ) ;
420 ff = [ ff fval ]
421 i f dim == 2
422 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−mo ’ )
423 a x i s ( [ xmin xmax ymin ymax ] )
424 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( f v a l ) ] )
425 pause ( 0 . 1 )
426 end
427 i f i t e r >= i t e r m a x
428 e r r o r d l g ( ’ Numero maximo de i t e r a c o e s do p r o c e s s o
numerico e x c e d i d o ’ )
429 end
430 saida = ’ ’ ;
431 f o r i = 1 : dim
432 s a i =[ s p r i n t f ( ’ x%d = ’ , i ) , num2str ( xx ( i , end ) ) ] ;
433 saida = char ( saida , s a i ) ;
434 end
435 set ( handles . result , ’ String ’ , saida ) ;
436 s e t ( h a n d l e s . Vfunc , ’ S t r i n g ’ , f f ( end ) ) ;
437 s e t ( h a n d l e s . N i t e r , ’ S t r i n g ’ , i t e r −1) ;
438

439 % Metodo de Quase Newton (BFGS)

440 x0 = x i n i t ; max step = 1 0 ; i t e r = 1 ;
441 xx = x0 ;
442 i f dim == 2
443 e z c o n t o u r ( f , [ xmin xmax ymin ymax ] , 1 0 0 )
444 hold a l l
445 end
446 ff = [];
447 H0 = eye ( dim ) ;
448 [ val , g0 , ˜ ] = numerico ( x0 ) ;
449 w h i l e i t e r <= i t e r m a x
450 d0 = −H0 * g0 ;
451 f f = [ f f val ] ;
452 i f dim == 2
453 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−ko ’ )

40
454 a x i s ( [ xmin xmax ymin ymax ] )
455 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( v a l ) ] )
456 pause ( 0 . 1 )
457 end
458 valor = [ ] ;
459 count = 1 ;
460 f o r p a s s o = 0 : i n c r : max step
461 v a l o r = [ v a l o r o b j f u n b u s c a l i n e a r ( x0 , d0 , p a s s o ) ] ;
462 i f count > 2
463 i f v a l o r ( end ) > v a l o r ( end −1)
464 break
465 end
466 end
467 count = count + 1 ;
468 end
469 % i n t e r v a l o = d i v i s a o a u r e a ( x0 , d0 , 0 , passo , 0 . 0 1 ) ;
470 % p a s s o = mean ( i n t e r v a l o ) ;
471 f u n f u n = @( a l p h a ) o b j f u n b u s c a l i n e a r ( x0 , d0 , a l p h a ) ;
472 p a s s o = fminbnd ( funfun , 0 , passo , o p t i m s e t ( ’ TolX ’ , 1 e −4) ) ;
473 x = x0 + p a s s o * d0/norm ( d0 , 2 ) ;
474 xx = [ xx x ]
475 iter = iter + 1;
476 i f norm ( x−x0 , 2 ) < t o l
477 break
478 end
479 d e l t a = x − x0 ;
480 [ val , g , ˜ ] = numerico ( x ) ;
481 gama = g − g0 ;
482 %H = H0 − H0 * gama * gama ’ * H0 / ( gama ’ * H0 * gama ) + d e l t a *
d e l t a ’ / ( d e l t a ’ * gama ) ; %DFP
483 H = ( eye ( dim ) − ( x − x0 ) * gama ’ / ( gama ’ * ( x − x0 ) ) ) * H0 * (
eye ( dim )−gama * ( x − x0 ) ’ / ( gama ’ * ( x − x0 ) ) ) + ( x − x0 )
* ( x − x0 ) ’ / ( gama ’ * ( x − x0 ) ) ; %BFGS c e r t o
484 H0 = H;
485 g0 = g ;
486 x0 = x ;
487 end
488 [ f v a l , g r a d v a l , ˜ ] = numerico ( x ) ;
489 ff = [ ff fval ]
490 i f dim == 2
491 p l o t ( xx ( 1 , : ) , xx ( 2 , : ) , ’−ko ’ )
492 a x i s ( [ xmin xmax ymin ymax ] )
493 t i t l e ( [ ’ Valor : ’ , ’= ’ num2str ( f v a l ) ] )
494 pause ( 0 . 1 )
495 end
496 i f i t e r >= i t e r m a x
497 e r r o r d l g ( ’ Numero maximo de i t e r a c o e s do p r o c e s s o
numerico e x c e d i d o ’ )

41
498 end
499 saida = ’ ’ ;
500 f o r i = 1 : dim
501 s a i =[ s p r i n t f ( ’ x%d = ’ , i ) , num2str ( xx ( i , end ) ) ] ;
502 saida = char ( saida , s a i ) ;
503 end
504 set ( handles . result , ’ String ’ , saida ) ;
505 s e t ( h a n d l e s . Vfunc , ’ S t r i n g ’ , f f ( end ) ) ;
506 s e t ( h a n d l e s . N i t e r , ’ S t r i n g ’ , i t e r −1) ;

42