Nery RS

UNIVERSIDADE DE SO PAULO
FACULDADE DE FILOSOFIA, CINCIAS E LETRAS DE RIBEIRO PRETO

MATEMTICA APLICADA A NEGCIOS
Mtodos Hbridos para Resoluo de Problemas de

Programao No-Linear
RIBEIRO PRETO, NOVEMBRO DE 2007
RAPHAEL SANTUCCI NERY
Mtodos Hbridos para Resoluo de Problemas de

Programao No-Linear
Monografia de concluso do curso de

Matemtica Aplicada a Negcios da Faculdade
de Filosofia, Cincias e Letras de Ribeiro
Preto, com colaborao da Faculdade de
Economia, Administrao e Contabilidade de
Ribeiro Preto da Universidade de So Paulo.
Orientadora: Prof. Dr. Vanessa Rolnik Artioli
RIBEIRO PRETO, NOVEMBRO DE 2007
ii
1 ndice
2 Resumo ................................................................................................................................ 1
3 Cronograma ......................................................................................................................... 2
4 Introduo............................................................................................................................ 3
5 Mtodos Irrestritos............................................................................................................... 8
5.1 Mtodos Unidimensionais Irrestritos............................................................................ 8
5.1.1 Mtodo de Fibonacci Fibonacci Search Method ............................................ 8
5.1.2 Mtodo da Razo urea Search By Golden Section....................................... 9
5.1.3 Busca por ajuste de curva .................................................................................... 10
Mtodo de Newton Newtons Method ............................................................... 10
Mtodo da Falsa Posio Method of False Position .......................................... 11
Ajuste Cbico Cubic Fit .................................................................................... 12
Ajuste Quadrtico Quadratic Fit ....................................................................... 12
5.2 Critrios de Parada de uma Busca Unidimensional.................................................... 13
5.2.1 Teste da Porcentagem.......................................................................................... 14
5.2.2 Critrio de Armijo ............................................................................................... 14
5.2.3 Teste de Goldstein ............................................................................................... 15
5.2.4 Teste de Wolfe..................................................................................................... 15
5.3 Mtodos n-dimensionais Irrestritos ............................................................................ 15
5.3.1 Mtodo da Inclinao Mxima The Steepest Descent Method ..................... 16
5.3.2 Mtodo de Newton n-dimensional Newtons Method................................... 20
5.3.3 Mtodos de Direes Conjugadas ....................................................................... 22
Mtodo dos Gradientes Conjugados Conjugate Gradient Method.................... 24
Mtodo Geral dos Gradientes Conjugados............................................................... 25
Mtodo Fletcher-Reeves........................................................................................... 26
Mtodo Polak-Ribiere .............................................................................................. 27
5.3.4 Mtodos Quasi-Newton....................................................................................... 28
Mtodo de Newton Modificado................................................................................ 28
Mtodo Clssico de Newton Modificado ................................................................. 29
Mtodo Davidon-Fletcher-Powell ............................................................................ 30
6 Mtodos Restritos.............................................................................................................. 31
6.1 Restries de Igualdade .............................................................................................. 31
6.1.1 Condies de 1 ordem ........................................................................................ 31
6.1.2 Condies de 2 ordem ........................................................................................ 32
6.2 Restries de Desigualdade ........................................................................................ 33
6.2.1 Condies de 1 ordem ........................................................................................ 33
6.2.2 Condies de 2 ordem ........................................................................................ 34
7 Implementaes ................................................................................................................. 36
7.1 Busca Unidimensional................................................................................................ 37
7.2 Busca n-dimensional .................................................................................................. 38
7.2.1 Caso Quadrtico .................................................................................................. 38
7.2.2 Caso no-Quadrtico ........................................................................................... 39
8 Simulated Annealing.......................................................................................................... 41
8.1 O mtodo computacional Simulated Annealing......................................................... 42
8.2 Implementao do Simulated Annealing.................................................................... 44

8.2.1 Exemplo unidimensional ..................................................................................... 45
8.2.2 Exemplo bidimensional ....................................................................................... 48
9 Mtodos Hbridos .............................................................................................................. 51
9.1 Simulated Annealing com Inclinao Mxima .......................................................... 54
9.2 Simulated Annealing com Gradientes Conjugados .................................................... 54
9.3 Comparaes e resultados .......................................................................................... 55
10 Aplicao: problema de tomografia por impedncia eltrica.......................................... 57
10.1 Resultados com o Simulated Annealing................................................................... 60
10.2 Resultados do hbrido Simulated Annealing com Gradientes Conjugados.............. 61
11 Concluso ........................................................................................................................ 62
12 Referncias Bibliogrficas............................................................................................... 63
Anexo A Mtodo de Newton Unidimensional .................................................................. 64
Anexo B Mtodo da Inclinao Mxima caso quadrtico................................................. 65
Anexo C Gradiente Conjugado caso no-quadrtico ........................................................ 68
Anexo D Fletcher-Reeves caso no-quadrtico................................................................. 72
Anexo E Mtodo Simulated Annealing unidimensional.................................................... 76
Anexo F Mtodo Simulated Annealing n dimensional...................................................... 79
Anexo G Hbrido Simulated Annealing com Inclinao Mxima Estratgia 1.............. 82
Anexo H - Hbrido Simulated Annealing com Inclinao Mxima Estratgia 2............... 89
Anexo I - Hbrido Simulated Annealing com Gradientes Conjugados Estratgia 1.......... 96
Anexo J - Hbrido Simulated Annealing com Gradientes Conjugados Estratgia 2 ....... 104
ii
2 Resumo
Este trabalho um estudo dos mtodos iterativos para resoluo de problemas de
otimizao no qual a funo objetivo extremamente no linear e repleta de extremos
locais, pontos de sela, regies praticamente planas entre outras caractersticas topolgicas.
Dessa forma, para se alcanar o mnimo global deve-se utilizar uma tcnica de
otimizao apropriada, com destaques para o Simulated Annealing (SA) que possui ao
menos duas caractersticas positivas: a princpio, escapam de pontos de mnimo local e no
dependem da aproximao inicial da soluo. Apesar de ser uma tcnica robusta, o SA
requer alto tempo computacional empregado e apresenta dificuldade de realizar uma busca
refinada em regies promissoras.
Com objetivo de contornar tais obstculos, recentemente surgiram os algoritmos
hbridos que misturam um algoritmo de busca global com um de busca local, e so
algoritmos deste tipo que sero desenvolvidos neste trabalho.
Palavras-chave: Otimizao. Busca Global. Simulated Annealing. Meta-heurstica.

Mtodos Hbridos.
3 Cronograma
Jan
Fev
Mar
Abr
Mai
Jun
Jul
Ago
X
X
X
X
Set
Out
Nov
comparao dos resultados
Escrita e Reviso do TCC
Descrio das etapas de estudo

Pesquisa bibliogrfica
Estudos
preliminares
dos
aspectos
tericos de otimizao
Estudo e implementao de mtodos

Iterativos irrestritos
Estudo e implementao de mtodos
Iterativos restritos
Estudo e implementao do Simulated
Annealing
Estudo e implementao dos mtodos
hbridos
Testes com um problema prtico e
4 Introduo
As tcnicas de otimizao aparecem com freqncia em diversas reas. Na Economia,
por exemplo, h um objetivo claro de maximizar os lucros de uma empresa, minimizar o
custo de produzir um dado nvel de produo. Na Medicina deseja-se obter o menor erro
funcional para o problema inverso de tomografia por impedncia eltrica, dentre outros.
Os problemas reais modelados como problemas de otimizao geram funes e
restries que variam consideravelmente. Os problemas podem ser lineares ou no
lineares, irrestritos ou restritos, unidimensionais ou multidimensionais e a busca pode ser
pelo timo global ou pelo timo local. Resolver analiticamente um problema de
otimizao, muitas vezes, no uma tarefa trivial, sendo preciso recorrer s tcnicas
iterativas e computacionais. Existem diversas tcnicas iterativas de otimizao para os
mais diversos tipos de problema, porm no existe uma tcnica de propsito geral.
O objetivo deste projeto promover um estudo dos mtodos de otimizao no linear
em seu aspecto terico, prtico e comparativo. O desenvolvimento se deu nas seguintes
etapas:
Estudo das propriedades bsicas de solues e algoritmos, envolvendo os

conceitos de funes cncavas e convexas, condies de primeira e segunda
ordens, minimizao e maximizao de funes convexas, convergncia global
dos algoritmos de descida.
Estudo dos os mtodos iterativos para busca do timo local, implementao dos
mtodos mais relevantes, validao de cada um deles atravs de exemplos da
literatura e comparao do desempenho entre os mtodos implementados como
tempo computacional, eficincia e preciso do resultado.
Estudos e implementao do Simulated Annealing para obteno do timo

global
Implementao de mtodos hbridos
Testes extensivos dos mtodos implementados.
No segundo item, alguns dos mtodos a serem estudados para otimizao irrestrita so:
mtodo da inclinao mxima, mtodo de Newton, mtodo de Fibonacci para funes
unidimensionais, mtodo dos gradientes conjugados, mtodos Quasi-Newton, mtodo de
Powell (que usa somente valores da funo objetiva), mtodo Fletcer-Powell.
Para
otimizao restrita sero estudados os mtodos dos multiplicadores de Lagrange e

condies Kuhn-Tuker.
A formulao geral para um problema de otimizao
otimizar f(x1,x2,...,xn)
s.a. gi(x1,x2,...,xn) =ai
hj(x1,x2,...,xn) bj
i=0,,m1
j=0,,m2
por otimizar entenda-se maximizar ou minimizar. A funo f(x1,x2,...,xn)

conhecida por funo objetivo e funo de n variveis , s.a. abreviao para sujeito
a, gi representam m1 restries de igualdade e hj, m2 restries de desigualdade. Se m1 +
m2 = 0 tem-se o caso de programao irrestrita. Os valores de x1, x2,..., xn que satisfazem
todas as m1 + m2 restries e que maximizam ou minimizam a funo f a soluo do
problema de otimizao.
A soluo procurada para o problema, ou ponto timo, classificada como global
(absoluto, relativo ao domnio todo) ou local (relativo a uma determinada regio). A figura
a seguir destaca alguns pontos importantes. O ponto P5 um mnimo global, que o ponto
em que a funo atinge seu menor valor absoluto entre todos os pontos do domnio; P4 e P6
so mnimos locais, ou seja, pontos de menor valor para a funo em uma vizinhana finita
e no nos extremos dessa vizinhana; P2 ponto de mximo e P3; de inflexo. J os pontos
P1 e P7 so chamados de pontos de borda nos quais a derivada primeira no se anula,
portanto no so pontos crticos da funo objetivo. Porm, dependendo do problema em
questo, por exemplo, nos problemas restritos, necessrio buscar o ponto timo na borda.
P7
P2
P3
P1
P4
P6
P5
Figura 1 - Ilustrao de pontos extremos: P1 e P7: de borda, P2: mximo local,

P3: inflexo, P4 e P6: mnimos locais e P5: mnimo global.
Por definio, uma funo dita ser convexa num espao real se, para x1, x2
pertencentes ao domnio e todo , 0 1, a desigualdade
f(x1 + (1 - )x2) f(x1) + (1 - )f(x2)
for satisfeita (LUENBERGER, 1984). Isso significa que, uma funo convexa se a regio
acima da curva convexa, ou seja, dados quaisquer dois pontos acima da curva existe um
segmento de reta que liga esses dois pontos e no corta a curva, conforme figura abaixo.
(a)
(b)
Figura 2 - Exemplo de funo (a) convexa, (b) no-convexa.
Os mtodos iterativos para otimizao no-linear, em geral, partem de um ponto inicial

x0 e calcula por uma determinada regra uma seqncia { xi } que deve convergir, no
sentido de alcanar uma soluo to prxima quanto se queira e que o computador permita
da soluo tima x*. Os mtodos existentes diferem entre si pela regra com que os novos
pontos so calculados. Normalmente, o ponto xk+1 (soluo da iterao k+1) obtido
deslocando xk (soluo da iterao k) uma distncia k na direo dk, ou seja,
xk+1 = xk + k.dk
O novo ponto xk+1 melhor que o anterior xk se a funo objetivo f satisfizer f(xk+1) <
f(xk) para o problema de minimizao ou satisfizer f(xk+1) > f(xk) para o problema de
maximizao. As iteraes cessam quando algum critrio de parada pr-estabelecido for
satisfeito como, por exemplo, | f | < ( pequeno) (BARD, 1974).
Como exemplo, o mtodo da inclinao mxima um dos mais antigos e mais
conhecidos mtodos para minimizao de uma funo de vrias variveis. O mtodo da
inclinao mxima baseado na inclinao do gradiente e, portanto, a direo escolhida
para o clculo do novo ponto no processo iterativo :
dk = - f(xk)
para maximizao
dk = f(xk) para maximizao

A escolha tima para a distncia de deslocamento do ponto, k, aquela que minimiza
a funo objetivo ao longo da direo dk. A escolha do k timo justifica o estudo dos
mtodos de busca em linha como Fibonacci e Golden Search.
Na prtica, mtodos baseados na inclinao do gradiente e com critrios de parada do
tipo |f|< garantem a obteno de um mnimo local no vale onde o ponto inicial para o
processo iterativo foi colocado (Bard, 1974). Encontrar um extremo global de uma funo
no-convexa em geral, uma tarefa difcil. Quando o problema no convexo
provavelmente existem muitos mnimos locais diferentes do global procurado. Os
algoritmos baseados no gradiente local de funo, por exemplo, tendem a convergir para o
mnimo mais prximo e no necessariamente para o mnimo global. preciso dispor de
algoritmos que fujam dos mnimos locais e convirjam para o global. Normalmente, usa-se
uma varivel aleatria para permitir que a seqncia de busca examine o domnio como um
todo e no apenas em uma regio. A incluso dessa varivel aleatria faz com que o
problema se torne probabilstico, ou seja, garante a convergncia a menos de uma certa
probabilidade (REEVES, 1993).
Neste contexto, destaca-se o mtodo Simulated Annealing (SA) ou recozimento

simulado que possui ao menos duas caractersticas positivas: a princpio, escapam de
pontos de mnimo local e no dependem da aproximao inicial da soluo.
As idias que formam a base do Simulated Annealing tm analogia com a
termodinmica, especialmente na maneira com que os lquidos congelam e cristalizam e os
materiais se resfriam e enrijecem. Essas idias foram publicadas pela primeira vez por
Metropolis et al. em 1953, o qual apresentou um algoritmo para simulao do processo
fsico chamado annealing (ou resfriamento lento). Este algoritmo simula o resfriamento de
um material que inicialmente submetido a altas temperaturas e, em seguida, resfriado
lenta e gradualmente, permitindo um tempo amplo para a redistribuio dos tomos
enquanto eles perdem a mobilidade. Trinta anos depois, Kirkpatrick et al. (1983)
mostraram que o algoritmo de Metropolis poderia ser aplicado a problemas de otimizao.
Apesar de ser uma tcnica extremamente robusta, o SA apresenta, ao menos, duas
dificuldades quando aplicados funes altamente no lineares: alto tempo computacional
empregado e dificuldade de realizar uma busca refinada em regies promissoras. Com
objetivo de contornar tais dificuldades, recentemente surgiram os algoritmos hbridos que
misturam um algoritmo de busca global com um de busca local. possvel, por exemplo,
associar o Simulated Annealing com o mtodo da inclinao mxima ou o Simulated
Annealing com gradientes conjugados.
5 Mtodos Irrestritos
O objetivo desenvolver o estudo de diversas tcnicas iterativas utilizadas para a
resoluo de problemas de minimizao irrestritos de busca local. O conhecimento
aprofundado dessas tcnicas essencial para a preparao, estudo e desenvolvimento de
ferramentas mais eficientes quanto velocidade de convergncia e facilidade de
implementao. A seguir sero apresentados os mtodos estudados, suas caractersticas,
vantagens e desvantagens.
5.1 Mtodos Unidimensionais Irrestritos
5.1.1 Mtodo de Fibonacci Fibonacci Search Method
Este mtodo determina o valor mnimo de uma funo f unimodal (apenas um

mnimo relativo), sobre um intervalo fechado [c1 , c 2 ] , que conhecido como regio ou
intervalo de incerteza.
A idia encontrar, pelo menos aproximadamente, o mnimo de f em um certo
nmero de pontos a partir de uma regio de incerteza.
Aps determinar N pontos x1 , x 2 ,..., x n com c1 x 1 , x 2 ,..., x N c 2 a regio de
incerteza ser reduzida ao intervalo [c k 1 , c k +1 ] centrado em x k , sendo o ponto de mnimo

entre os N pontos.
Pode-se ento resumir o procedimento para reduo da largura do intervalo de
incerteza da seguinte maneira:
Os dois primeiros pontos so medidos simetricamente uma distncia de
FN 1
d1 a partir das extremidades do intervalo inicial, de acordo com qual desses

FN
F
o menor valor, um intervalo d 2 = N 1 d 1 determinado.
FN
O terceiro ponto medido simetricamente no novo intervalo de incerteza
com respeito aos pontos j no intervalo. O resultado o novo intervalo de incerteza

F
d 3 = N 2
FN
d1
Assim, em geral, cada ponto sucessivo colocado no intervalo de incerteza atual

simetricamente com o ponto j existente no intervalo.
Abaixo apresentado o algoritmo deste mtodo:

x0 = c1
x N 1 = c 2
d 1 = c 2 c1
F
d k = N k +1 d1
FN
onde
Fk : elementos da seqncia de Fibonacci (1,1,2,3,5,8,13,...).
d k : intervalo de incerteza em k passos.
5.1.2 Mtodo da Razo urea Search By Golden Section

Este mtodo obtido quando N na busca de Fibonacci. Em qualquer ponto do
1
processo o intervalo de incerteza tem comprimento d k =
1
1
k 1
d1 , onde 1 1,618 e
0,618 .
5.1.3 Busca por ajuste de curva
Tanto o Mtodo de Fibonacci quanto o Mtodo da Razo urea no exploram as

caractersticas e as informaes da funo em questo. Para contornar esse fato surgiram
mtodos que ajustam uma curva suave aos pontos analisados, e com informaes dos
pontos aplicados na funo e/ou nas derivadas possvel obter tcnicas melhores para
minimizar a funo.
Mtodo de Newton Newtons Method

Neste caso o objetivo minimizar uma funo de apenas uma varivel f ( x ) , para
isso deve-se considerar a seguinte suposio: no ponto x k podemos obter f ( x k ) , f ( x k ) e
f ( x k ) .
A partir da possvel construir uma funo quadrtica q ( x ) tal que seja igual a
f ( x ) expandida em srie de Taylor em torno de x k e truncada aps a primeira derivada:
q( x ) = f ( x k ) + f (x k )(x x k ) +
1
2
f ( k )( x x k )
2
(1)
onde o termo da direita corresponde ao erro local de truncamento.

Calcula-se uma estimativa x k +1 do ponto de mnimo da funo f ( x ) encontrando o
ponto em que a derivada de q ( x ) se anula:
0 = q ( x k +1 ) = f ( x k ) + f ( x k )( x k +1 x k )
x k +1 = x k
f ( x k )
f ( x k )
(2)
(3)
10
Nota-se imediatamente que o novo ponto x k +1 no depende de f ( x k ) .
O Mtodo de Newton tem ordem de convergncia de pelo menos 2.
Mtodo da Falsa Posio Method of False Position

Foi visto anteriormente que o Mtodo de Newton utiliza apenas a informao de um
nico ponto para fazer um ajuste quadrtico. A idia agora utilizar mais pontos e
conseqentemente menos informaes. Ento, utilizando f ( x k ) , f ( x k ) e f ( x k 1 ) tem-se
o seguinte ajuste quadrtico:
2
f ( x k 1 ) f ( x k ) ( x x k )
q( x ) = f ( x k ) + f (x k )( x x k ) +
x k 1 x k
2
onde
(4)
f (x k 1 ) f ( x k )
( f ( x k )) , ou seja, diferenas regressivas para a derivada primeira.

x k 1 x k
Assim como no Mtodo de Newton, encontra-se uma aproximao para o ponto de

mnimo x k +1 ; encontrando o ponto onde a derivada de q ( x ) se anule:
0 = q ( x k +1 ) = f ( x k ) +
f ( x k 1 ) f ( x k )
( x k +1 x k )
x k 1 x k
(5)
isolando xk +1 :
x k 1 x k
x k +1 = x k f ( x k )
f ( x k 1 ) f ( x k )
(6)
11
Embora no Mtodo da Falsa Posio no se tem necessidade de utilizar-se do valor

de f ( x k ) , nem da segunda derivada, sua convergncia da ordem da razo urea, 1,618,
inferior ordem de convergncia do Mtodo de Newton.
Ajuste Cbico Cubic Fit

Agora utilizando x k 1 e x k junto com os valores f ( x k 1 ) , f ( x k 1 ) , f (x k ) e f ( x k ) ,
encontra-se um ajuste cbico e assim obtm-se uma estimativa para o prximo ponto xk +1
encontrando o ponto de mnimo deste ajuste, simplificando os clculos teremos que:
f ( x k ) + u 2 u1
x k +1 = x k ( x k x k 1 )
f ( x k ) f ( x k 1 ) + 2u 2
(7)
onde
u1 = f ( x k 1 ) + f ( x k ) 3
f ( x k 1 ) f ( x k )
x k 1 x k
2
u2 = u1 f ( xk 1 ) f ( xk )
(8)
12
(9)
Apesar do Mtodo nos levar a crer que a ordem de convergncia seja 3 devido sua
caracterstica cbica, temos na verdade uma ordem de convergncia 2.
Ajuste Quadrtico Quadratic Fit

Seguindo o mesmo raciocnio dos ajustes anteriores, agora sero utilizados 3 pontos
e no haver necessidade de se utilizar nenhuma das derivadas da funo f ( x ) .
12
Dados x1 , x 2 e x3 e os valores correspondentes f ( x1 ) = f1 , f (x 2 ) = f 2 e f ( x3 ) = f 3

podemos fazer um ajuste quadrtico passando por estes pontos tal que:
q( x ) = i =1 f i
3
(x x )
(x x )
j
j i
j i
(10)
e a partir da podemos determinar o prximo ponto x 4 onde a derivada de q ( x ) se anula:
x4 =
1 b23 f 1 + b31 f 2 + b12 f 3
2 a 23 f 1 + a31 f 2 + a12 f 3
(11)
onde
aij = xi x j , bij = xi x j
2
(12)
e ainda mais, este mtodo tem ordem de convergncia de aproximadamente 1,3.
5.2 Critrios de Parada de uma Busca Unidimensional

O objetivo nesta parte do estudo ser conhecer os critrios mais utilizados para
determinar a melhor situao para finalizar uma busca unidimensional, tambm chamada de
busca em linha.
A utilizao desses critrios motivada pelo fato de ser praticamente impossvel
obter o ponto de mnimo exato, devido ao custo computacional e aos erros de
arredondamento intrnsecos da mquina. Assim deve-se procurar uma maneira de terminar
a busca de uma maneira que seja suficientemente precisa e que no prejudique os
algoritmos de busca.
13
5.2.1 Teste da Porcentagem
Este teste consiste em estabelecer uma proporo pr-fixada do valor verdadeiro. O

valor de escolhido de maneira que c onde o valor real do parmetro
e uma constante c tal que 0 < c < 1 .

O principal problema desta abordagem que no se tem conhecimento prvio do
real valor tornando-se assim muito complicada a determinao de uma porcentagem c
razovel.
5.2.2 Critrio de Armijo

Este critrio de parada um dos mais populares e durante os estudos foi bastante
utilizado. Ele consiste em ajustar o parmetro para que no seja to grande e nem to
pequeno. A seguinte funo definida:
( ) = f ( x k + d k )
(13)
O critrio ter por base a seguinte funo: (0) + (0) para um valor fixo tal
que 0< <1.
O parmetro considerado como no to grande se
( ) (0) + (0 )
(14)
Para saber se o parmetro selecionado no to pequeno, um valor > 1

escolhido, e ser no to pequeno se
( ) > (0) + (0)
(15)
14
5.2.3 Teste de Goldstein
Muito parecido com o critrio de Armijo, este teste consiste em determinar o

parmetro de maneira que ele no seja to grande sob a mesma perspectiva do critrio
anterior, Equao 14, s que para um 0< < 1 2 .
No teste de Goldstein o valor considerado como sendo no to pequeno se:
( ) > (0 ) + (1 ) (0)
(16)
5.2.4 Teste de Wolfe

Este teste difere dos anteriores em relao ao uso da derivada da funo objetivo
desde que esta possa ser facilmente calculada. Assim, para um 0< < 1 2 o parmetro
deve obedecer a Equao 14 e ainda mais:
( ) > (1 ) (0)
(17)
A vantagem deste teste que a Equao 17 no afetada por mudanas no parmetro .
5.3 Mtodos n-dimensionais Irrestritos

A maioria dos algoritmos de programao no-linear para funes de vrias
variveis inclui uma busca pelo ponto de mnimo ao longo de uma linha. Portanto,
plausvel que o procedimento escolhido seja fechado, ou seja, que o procedimento tenha
convergncia garantida e que a busca tenha um momento eficiente de ser finalizada.
Para iniciar um algoritmo de busca com respeito a uma funo f h a necessidade
de duas informaes primordiais: o ponto inicial x , n dimensional, e a direo d ,
tambm n dimensional, na qual ser realizada a busca.
15
Definio 1: O mapa/algoritmo S : E 2 n E n definido por:
S ( x, d ) = {y | y = x + d }
f ( y ) = min f ( x + d )
0
O procedimento tem incio em x0 , caminha-se um passo na direo d 0 e assim

obtm-se x1 . Esse procedimento repetido diversas vezes gerando uma seqncia {x k } que
esperamos que seja convirja para o ponto de mnimo. Os mtodos diferem um dos outros
pela direo e pelo passo escolhidos a cada iterao.
5.3.1 Mtodo da Inclinao Mxima The Steepest Descent Method
O Mtodo da Inclinao Mxima um dos mais antigos e estudados para minimizar

funes de vrias variveis. Este mtodo de grande importncia para este trabalho, pois
geralmente usado como base na tentativa de encontrar tcnicas mais sofisticadas. Assim,
o Mtodo da Inclinao Mxima utilizado como parmetro de comparao quando se
estudam diversas tcnicas de otimizao.
Seja f uma funo com a primeira derivada parcial contnua E n . O gradiente da
funo, f ( x ) , definido como um vetor linha com dimenso n . O vetor transposto, ou
seja, o vetor coluna n -dimensional ser definido por g ( x ) = f ( x ) , o mtodo da inclinao
t
mxima definido pelo seguinte algoritmo iterativo:

x k +1 = x k k g k
(18)
onde k o escalar no-negativo que minimiza f ( x k k g k ) .
16
Portanto, partindo do ponto xk , a busca ser realizada na direo negativa do

gradiente, g k , afim de encontrar o ponto de mnimo, x k +1 , nessa linha.
O caso quadrtico ser o primeiro a ser analisado:
Considere:
f (x ) =
1 t
x Qx x t b
2
(19)
onde Q uma matriz n n simtrica positiva definida. Como Q positiva definida, todos
os autovalores de Q so positivos e ainda mais, da teoria de Anlise, como Q positiva
definida temos que f estritamente convexa.
Podemos ento encontrar o nico ponto de mnimo de f igualando o gradiente da
funo zero, ou seja, f ( x ) = 0 , satisfazendo Qx * = b .
O mtodo da Inclinao Mxima pode ser expresso ento da seguinte maneira:

x k +1 = x k k g k
(20)
g k = Qx k b
(21)
onde k o escalar no-negativo que minimiza f (x k k g k ) .

Mas avanando um pouco mais pode-se determinar a forma explcita de k , sabe-se
que:
f ( x k g k ) =
1
(xk g k )t Q(xk g k ) (xk g k )t b = h( )
2
(22)
encontrando a derivada em relao e buscando o mnimo :
17
(23)
b ) + g kt Qg k = 0
(24)
dh 1
= 2 g kt Q( x k g k ) + g kt b = 0
d 2
( g )(Qx
t
k
g kt g k
g kt Qg k
(25)
Agora j possvel deixar o Mtodo da Inclinao Mxima em sua forma explcita:
gt g
x k +1 = x k t k k
g k Qg k
gk
(26)
onde g k = Qx k b .
Sobre a convergncia deste procedimento deve-se usar o Teorema 1 para se obter
uma idia de seu comportamento. Introduzindo ento a funo:
E (x ) =
t
1
(
x x * ) Q(x x * )
2
(27)
1 *t *
x Qx + f ( x )
2
(28)
ou seja,
E (x ) =
assim como ambas diferem apenas por uma constante procura-se minimizar E ( x ) ao invs
de f .
Teorema 1: Para qualquer x 0 E n o Mtodo da Inclinao Mxima converge para o

nico ponto de mnimo x * de uma funo quadrtica f .
Para E ( x ) =
t
1
(
x x * ) Q(x x * ) , em todo passo k temos que:
2
18
Aa
E ( x k +1 )
E (xk )
A+a
onde a e A so respectivamente o menor e o maior autovalor de Q.
Segue imediatamente que E ( x k ) 0 , como Q positiva definida, que x k x * .
Este teorema mostra que a taxa de convergncia do Mtodo da Inclinao Mxima

se torna mais lenta conforme as curvas de nvel de f ficam mais excntricas. Se a = A , o
que quer dizer que as curvas de nvel so circulares a convergncia ocorre em um nico
passo. Observa-se tambm que se um dos autovalores est a uma grande distncia dos
demais j ser suficiente para que haja uma convergncia lenta e assim prejudicar a
efetividade do mtodo.
Conclu-se que a taxa de convergncia depende da razo r =
A
(tambm conhecido
a
como nmero de condio da matriz). A razo de convergncia pode ser observada a

seguir:
A
2
(A a)
1
r 1
Aa
a
a
=
A
r + 1
1(
A+a
A + a)
+ 1
a
(29)
isto mostra que conforme r cresce a convergncia fica mais lenta.
O prximo passo avanar para o caso no-quadrtico. Em geral utiliza-se a matriz

Hessiana da funo objetivo para desempenhar o papel da matriz Q do caso quadrtico. O
Teorema 2 ilustra teoricamente essa passagem entre os casos e a questo da convergncia.
Teorema 2: Seja f definida em E n , com derivadas segundas parciais contnuas e com
mnimo relativo em x * . Suponhamos ainda que a matriz Hessiana de f , F (x ) , tenha o
19
menor autovalor a > 0 e o maior autovalor A > 0 . Se {x k } a seqncia gerada a partir

do Mtodo da Inclinao Mxima que converge para x * , ento a seqncia dos valores da
( )
funo objetivo { f ( x k )} converge para f x * linearmente com taxa de convergncia no

2
Aa
melhor que
.
A+ a
5.3.2 Mtodo de Newton n-dimensional Newtons Method
Mais uma vez, deseja-se minimizar uma funo f , que pode ser aproximada
localmente por uma funo quadrtica, funo esta que pode ser minimizada de maneira
exata. Assim, pode-se aproximar f pela srie de Taylor truncada aps a primeira derivada
na vizinhana de x k :
f ( x ) f ( x k ) + f ( x k )( x x k )
(30)
conseqentemente sua derivada dada por:

f ( x ) = f ( x k ) + F ( x k )( x x k )
(31)
O que leva a forma pura do Mtodo de Newton:

x k +1 = x k [F ( x k )] f (x k )
1
(32)
Este mtodo bem definido perto da soluo x * devido ao fato de f ter segundas
( )
derivadas parciais contnuas e de que matriz Hessiana F x * positiva definida num ponto
20
de mnimo local. Quando iniciado prximo suficiente da soluo, o Mtodo de Newton tem
ordem de convergncia 2 como mostra o Teorema 3:
Teorema 3: Seja f C 3 em E n , e assumimos que no ponto de mnimo local x * a matriz
( )
Hessiana F x * seja positiva definida. Ento, se iniciado suficientemente perto de x * , os

pontos gerados pelo Mtodo de Newton convergem para x * com ordem de convergncia
de pelo menos 2.
O grande atrativo do Mtodo de Newton justamente suas caractersticas de

convergncia, no entanto necessrio fazer algumas adaptaes ao mtodo para que possa
ser utilizado a partir de pontos mais distantes da soluo.
A primeira modificao a ser feita introduzir um parmetro de busca tal que
k seja selecionado de modo a minimizar f :

x k +1 = x k k [F ( x k )] f ( x k )
1
(33)
Nota-se que perto da soluo, chega-se ao Mtodo de Newton em sua forma pura
com k 1 . Esta modificao no to boa, pois corre-se o risco de que a funo objetivo
se afaste do mnimo para k = 1 devido aos termos no-quadrticos de f .
A segunda modificao deve ser analisada, para isso parte-se da expresso geral dos
algoritmos:
x k +1 = x k M k g k
(34)
onde M k uma matriz n n , um parmetro de busca positivo e g k = f ( x k ) .

t
M k = I Inclinao Mxima
possvel perceber claramente que se
M k = [F ( x k )]1 Newton
21
No caso em que M k = I (Mtodo da Inclinao Mxima) tem convergncia

garantida mas, no entanto, converge apenas linearmente; j quando M k = [F ( x k )]
(Mtodo de Newton) tem convergncia mais rpida perto da soluo mas para um ponto em
geral distante da soluo o mtodo pode no gerar uma direo de descida uma vez que
[F (xk )]1 pode no ser positiva definida ou at mesmo no existir.

Como
f ( x k +1 ) = f ( x k ) + f ( x k )(x k +1 x k ) + x k +1 x k
),
substituindo
pela
frmula proposta na segunda modificao e fazendo f ( x k ) = g kt obtm-se:
( )
f ( x k +1 ) = f ( x k ) g kt M k g k + 2
(35)
Quando 0 , o segundo termo da direita domina o terceiro. Com pequeno,

para acontecer um decrscimo no valor de f impo-se que g kt M k g k > 0 e para isso a
soluo mais simples exigir que M k seja positiva definida.
5.3.3 Mtodos de Direes Conjugadas
Estes mtodos surgiram para melhorar a convergncia do Mtodo da Inclinao

Mxima e resolver o problema de encontrar, armazenar e trabalhar com a matriz Hessiana
inversa no Mtodo de Newton.
Assim como nos mtodos anteriores, a anlise tem incio pelos problemas
quadrticos:
minimizar f ( x ) =
1 t
x Qx b t x
2
Para comear o estudo dos mtodos necessrio definir o conceito de direes

conjugadas e analisar o Teorema 4 para compreender melhor os procedimentos realizados.
22
Definio 2: Dada uma matriz simtrica Q, os vetores d1 e d 2 so ditos Q-Ortogonais ou
conjugados em relao Q, se d1t Qd 2 = 0 .

Teorema 4: Seja {d i }i =1 um conjunto de vetores Q-ortogonais no-nulos. Para qualquer
n 1
x0 E n a seqncia gerada de acordo com o modelo abaixo:

x k +1 = x k + k d k , k 0
(36)
g kt d k
k = t
d k Qd k
(37)
g k = Qx k b
(38)
com
e ainda
converge para a soluo nica, x * , de Qx = b aps n passos, ou seja, x n = x * .
g kt d k
O termo k = t
a grande diferena desta classe de mtodos. Este termo foi
d k Qd k
encontrado a partir do seguinte raciocnio: os vetores no-nulos d 0 , d1 ,..., d n 1 formam uma
base e a partir da a soluo x * pode ser escrita como uma combinao linear dos elementos
dessa base, ou seja, x * = 0 d 0 + ... + n 1 d n 1 , para algum conjunto de i , i = 0 ,..., n 1 .
Agora, fazendo o produto com Q e tomando o produto escalar com respeito d i , tem-se:
i =
d it Qx *
d it b
,
=
d it Qd i d it Qd i
i = 0,..., n 1 .
(39)
23
Mtodo dos Gradientes Conjugados Conjugate Gradient Method

O Mtodo dos Gradientes Conjugados um mtodo de direes conjugadas no qual,
ao longo do procedimento, os vetores direo so obtidos utilizando informaes do
gradiente da funo objetivo. A direo conjugada em que o mtodo far a busca obtida
em cada passo k pela soma do vetor gradiente negativo com uma combinao linear da
direo anterior. Abaixo apresentado o algoritmo do Mtodo dos Gradientes Conjugados:
Comeando a busca em um x0 E n define-se d 0 = g 0 = b Qx0 e
k =
g kt d k
d kt Qd k
(40)
x k +1 = x k + k d k
(41)
g k +1 = Qx k +1 b
(42)
g kt +1Qd k
k = t
d k Qd k
(43)
d k +1 = g k +1 + k d k
(44)
O primeiro passo do algoritmo idntico ao Mtodo da Inclinao Mxima, a partir

da cada passo calculado como uma combinao linear do gradiente com o vetor direo
precedente. Este algoritmo mostra a facilidade com que se encontra o vetor direo, e
apesar de ser um pouco mais complicado que o Mtodo de Inclinao Mxima, o Mtodo
do Gradiente Conjugado converge em um nmero finito de passos.
24
Trs grandes vantagens devem ser destacadas neste mtodo. Primeiro, o gradiente
sempre no-nulo e linearmente independente de todos os vetores direo obtidos
anteriormente; segundo, o mtodo de fcil implementao; e por ltimo, como o mtodo
baseado na direo do gradiente ele tem um bom progresso uniforme at a soluo em cada
passo, o que muito importante para estudar a generalizao para os problemas noquadrticos.
Mtodo Geral dos Gradientes Conjugados
Agora, o Mtodo dos Gradientes Conjugados ser extendido para problemas noquadrticos, para isso so realizadas as seguintes aproximaes em x k : g k substitudo
por f ( x k ) e a matriz Q por F ( x k ) .
t
O Mtodo dos Gradientes Conjugados, quando utilizado em problemas noquadrticos, geralmente no ir terminar em n passos como no caso quadrtico. A sada
para essa questo buscar novas direes de acordo com o algoritmo abaixo e somente
terminar a busca aps um critrio de parada ser atingido, esse procedimento conhecido
como restart. Assim, o Mtodo Geral dos Gradientes Conjugados definido da seguinte
maneira:
Passo 1.
Iniciando em x 0 calcule g 0 = f ( x 0 ) e defina d 0 = g 0 .
Passo 2.
Para k = 0,1,..., n 1 :
a) Defina x k +1 = x k + k d k , onde k =
g kt d k
.
d kt F ( x k )d k
b) Calcule g k +1 = f ( x k +1 ) .
t
c) A menos que k = n 1 , defina d k +1 = g k +1 + k d k onde k =
g kt +1 F ( x k )d k
d kt F ( x k )d k
25
e repita (a).
Passo 3. Faa x 0 x n e volte ao passo 1.
Neste mtodo a busca em linha est embutida no prprio mtodo, pois a cada passo,
x k +1 obtido deslocando x k de um passo k na direo d k . Essa uma vantagem j que

no preciso usar um algoritmo de busca em linha como nos mtodos anteriores. Como
desvantagem destaca-se a necessidade de calcular F (xk ) em cada ponto o que gera um
esforo computacional maior e, alm disso, os clculos de F ( xk ) fazem com que o mtodo
no seja globalmente convergente.
Mtodo Fletcher-Reeves
Ao invs de substituir Q por F ( xk ) existe a opo de usar um dos mtodos de
busca em linha descritos na Seo 5.1. Diferentemente dos mtodos de direes conjugadas
anteriores, k ser ento determinado de modo que minimize a funo objetivo enquanto
k ser determinado por uma nova frmula. O Mtodo Fletcher-Reeves pode realizar estas
mudanas:
Passo 1.
Iniciando em x0 calcule g 0 = f ( x0 ) e defina d 0 = g 0 .
Passo 2.
Para k = 0,1,..., n 1 :
a) Defina x k +1 = x k + k d k , onde k minimiza f ( x k + d k ) .

b) Calcule g k +1 = f ( x k +1 ) .
t
26
c) A menos que k = n 1 , defina d k +1 = g k +1 + k d k onde k =
g kt +1 g k +1
g kt g k
e repita (a).
Passo 3. Faa x 0 x n e volte ao passo 1.
Nota-se claramente que as nicas alteraes se encontram nos itens (a) e (c) como
explicado anteriormente.
Mtodo Polak-Ribiere
Este mtodo muito parecido com o de Fletcher-Reeves, diferindo somente em

relao maneira com que se encontra o parmetro k . O algoritmo o mesmo do mtodo
anterior, exceto em relao nova maneira de calcular k :
k =
(g k +1 g k )t g k +1
g kt g k
(44)
27
5.3.4 Mtodos Quasi-Newton
Os mtodos discutidos nesta parte do estudo so motivados pela dificuldade de

avaliao e de uso da matriz Hessiana no Mtodo de Newton que necessita da Hessiana
inversa. Assim, os Mtodos Quasi-Newton iro encontrar aproximaes sucessivas para
esta matriz inversa e contornar os problemas de implementao do Mtodo de Newton.
Mtodo de Newton Modificado

Mais uma vez o objetivo minimizar f ( x ) e para isso o seguinte processo iterativo
deve ser analisado:
x k +1 = x k k S k f ( x k )
(45)
onde S k uma matriz simtrica n n e como j visto anteriormente k escolhido de

modo a minimizar f ( x k +1 ) .
A matriz S k se relaciona com os mtodos j estudados da seguinte maneira:
S k = H 1 Mtodo de Newton.
S k = I Mtodo da Inclinao Mxima.
S k H 1 Mtodo Quasi-Newton.
Para garantir que a Equao 43 seja um mtodo de descida necessrio que S k seja
positiva definida para valores pequenos de k .
Analisando mais uma vez o caso quadrtico:
f (x ) =
1 t
x Qx b t x
2
(46)
28
e o processo iterativo fica da forma:

x k +1 = x k k S k f ( x k ) ,
t
(47)
g k = Qx k b
k =
(48)
g kt S k g k
g kt S k QS k g k
(49)
S k prxima de Q -1 desde que tanto o menor autovalor quanto o maior autovalor

estejam prximos de 1.
Para funes objetivo no-quadrticas, o anlogo matriz Q a matriz Hessiana
F (xk ) e, portanto, S k deve ser prxima de F ( x k ) .

1
Mtodo Clssico de Newton Modificado

Este mtodo no calcula F ( x k ) , ele usa a Hessiana calculada em x0 ao longo do
1
processo. Assim, o mnimo obtido de acordo com o seguinte processo:

x k +1 = x k k [F ( x0 )] f ( x k )
1
(50)
A eficincia deste mtodo est relacionada com a variao nos valores da matriz
Hessiana calculada no ponto x k +1 e no ponto x0 . Quanto menor essa variao melhor o
mtodo.
29
Mtodo Davidon-Fletcher-Powell
Este mtodo foi originalmente desenvolvido por Davidon para encontrar uma
aproximao para a inversa da matriz Hessiana e depois melhorado por Fletcher e Powell.
Alm de construir a aproximao da inversa da matriz Hessiana esse mtodo gera as
direes do gradiente conjugado. O algoritmo do mtodo ser visto a seguir:
Iniciando em qualquer ponto x0 , com qualquer matriz positiva definida H 0 e com

k = 0:
Passo 1.
Faa d k = H k g k .
Passo 2.
Minimizar f ( x k + d k ) com respeito 0 para obter x k +1 , p k = k d k e
g k +1 = f ( x k +1 ) .
t
Passo 3.
Faa q k = g k +1 g k e
H k +1 = H k +
p k p kt H k q k q kt H k
t
p kt q k
qk H k qk
(51)
Faa k = k + 1 e volte ao Passo 1.
30
6 Mtodos Restritos
O enfoque agora estudar os problemas do tipo:
Minimizar
f (x )
Sujeito a
hi (x ) = 0 , g j ( x ) 0
(52)
x En
onde
f ( x ) a funo objetivo, hi ( x ) , i = 1,...,m , so as restries de igualdade, g j ( x ) ,

j = 1,..., p , so as restries de desigualdade e o domnio de x .
Vamos assumir que as funes f , hi e g j so contnuas e possuem derivadas

parciais de segunda ordem contnuas. Para simplificar, a notao de vetor de funes
h = (h1 , h2 ,..., hm ) e g = ( g 1 , g 2 ,..., g p ) ser utiliza ao longo do trabalho.
6.1 Restries de Igualdade

6.1.1 Condies de 1 ordem
Definio 3: O ponto x * que satisfaz o conjunto de restries h(x * ) = 0 dito ponto
( )
regular das restries se os vetores gradientes hi x * forem linearmente independentes.
Teorema 5: Seja x * um ponto extremo local de
f sujeito s restries h( x ) = 0 .
Assumimos ainda que x * seja um ponto regular desse conjunto de restries. Ento existe
um E m tal que:
( )
( )
f x * + t h x * = 0
(53)
31
A partir do Teorema 5, o Lagrangiano associado ao problema com restries de

igualdade:
l ( x , ) = f ( x ) + t h ( x )
(54)
Buscando minimizar o Lagrangiano, derivando em relao a x e a e igualando a

zero encontram-se as condies necessrias de 1 ordem, as quais podem ser expressas da
seguinte forma:
x l ( x, ) = 0
(55)
l ( x, ) = 0
(56)
As condies necessrias de 1 ordem juntamente com as restries h( x ) = 0

formam um total de m + n equaes, onde m refere-se ao nmero de restries e n ao
nmero de variveis do vetor x .
Para encontrar as condies necessrias de segunda ordem - Teorema 6 preciso assumir

que f , h C 2 .
Teorema 6: Seja x * um ponto de mnimo
local de f sujeito s restries h( x ) = 0 .
Assumimos ainda que x * seja um ponto regular desse conjunto de restries. Ento existe
um E m tal que:
( )
( )
f x * + t h x * = 0
(57)
Denotando-se por M o plano tangente M = {y : h(x * )y = 0}, ento a matriz

32
L(x * ) = F (x * ) + t H (x * )
(58)
positiva semi-definida em M , ou seja, y t L(x * )y 0 para todo y M .
A matriz L a matriz das segundas derivadas parciais, com respeito a x , do
Lagrangiano l . As condies suficientes de segunda ordem so encontradas no Teorema 7.

Teorema 7: Suponhamos que existe um ponto x * que satisfaa h(x * ) = 0 e tambm um
E m tal que
( )
( )
f x * + t h x * = 0
( )
( )
(59)
( )
e suponhamos ainda que a matriz L x * = F x * + t H x *
( )
seja positiva definida em
( )
M = y : h x * y = 0 , ou seja, para y M , y 0 implica que y t L x * y > 0 . Ento x *
ponto de mnimo local de f sujeito a h( x ) = 0 .
6.2 Restries de Desigualdade

Agora o problema est sujeito tanto s restries de igualdade quanto s restries
de desigualdade.
Teorema 8 - Condies de Kuhn-Tucker: Seja x * um ponto de mnimo relativo para o
problema (52) e suponhamos que x * seja um ponto regular das restries. Ento existe um
vetor E m e um vetor E p com 0 tais que
33
( )
( )
( )
f x * + t h x * + t g x * = 0
(60)
t g (x * ) = 0
(61)
O Teorema 9 mostra as condies necessrias de segunda ordem para problemas

com restries de desigualdades:
Teorema 9: Suponhamos que f , g , h C 2 e que x * seja um ponto regular das restries.
Se x * for soluo do problema de minimizao restrito, ento existe um vetor E m e um

vetor E p com 0 tais que (59) e (60) sejam vlidas e que
L(x * ) = F (x * ) + t H (x * ) + t G (x * )
seja positiva definida no plano tangente das restries ativas em x * .
(62)
As condies suficientes de segunda ordem so vistas no Teorema 10:
Teorema 10: Seja f , g , h C 2 . As condies suficientes para que x * seja um ponto de
mnimo relativo do problema de minimizao restrito so que exista E m e E p tais

que
(63)
t g (x * ) = 0
(64)
34
( )
( )
( )
f x * + t h x * + t g x * = 0
(65)
L(x * ) = F (x * ) + t H (x * ) + t G (x * )
(66)
e a matriz Hessiana
seja positiva definida no subespao

M = {y : h(x * )y = 0, g j (x * )y = 0} , para todo j J ,
onde
( )
J = j : g j x * = 0, j .
35
7 Implementaes
Alm do estudo terico tambm foi abordada a implementao dos mtodos
estudados para se perceber na prtica as caractersticas de cada mtodo, as vantagens, as
desvantagens, a facilidade ou dificuldade de implementao. A linguagem de programao
utilizada foi o C/C++ e os seguintes programas foram implementados com sucesso:
para busca unidimensional:
Fibonacci
Golden Section
Newton
Falsa Posio
Ajuste Cbico
Ajuste Quadrtico
critrio de parada (usado frequentemente como um mtodo de busca unidimensional):
Critrio de Armijo
para busca n-dimensional:
Mtodo da Inclinao Mxima
Gradientes Conjugados para casos Quadrticos
Gradientes Conjugados para casos no-Quadrticos
Polak-Ribiere
Fletcher-Reeves
36
A seguir, alguns dos mtodos implementados sero exemplificados e comparados.

Os exemplos sero em geral funes simples, mas os programas so eficientes para funes
mais complexas. Neste caso basta alterar, nos cdigos fonte, a funo e as informaes
relacionadas para os programas executarem.
Nos anexos de A at D encontram-se os seguintes cdigos fontes para consulta:
Mtodo de Newton para busca unidimensional, Mtodo da Inclinao Mxima, Mtodo dos
Gradientes Conjugados e Mtodo de Fletcher-Reeves.
7.1 Busca Unidimensional

Abaixo observa-se o comportamento dos mtodos quando queremos minimizar a
funo f ( x ) = x 2 6 x + 9 , cujo grfico pode ser visto na Figura 3.
70
60
50
40
30
20
10
0
-6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12
Figura 3 Grfico da funo f ( x ) = x 2 6x + 9
Percebe-se tanto pelo grfico quanto analiticamente que a funo tem seu valor
mnimo na abscissa x * = 3 . Na Tabela 1 observa-se como cada um dos mtodos se
comportou quando executados:
37
Tabela 1 Resultados obtidos com os mtodos de busca unidimensional
Mtodo
Soluo Encontrada
Nmero de Iteraes
Fibonacci
2.999726
20
Razo urea
2.999801
20
Newton
Falsa Posio
Ajuste Cbico
No convergiu
7.2 Busca n-dimensional

7.2.1 Caso Quadrtico
O Mtodo da Inclinao Mxima e o Mtodo dos Gradientes Conjugados foram
aplicados para minimizar a funo f (x, y ) = x 2 + 3 y 2 2 x + 2 y ; cujo grfico pode ser visto
na Figura 4:
Figura 4 Grfico da funo f ( x , y ) = x 2 + 3 y 2 2 x + 2 y
usando os pontos iniciais ( x0 , y 0 ) = (5,5) como partida da busca obtm-se a Tabela 2:
38
Tabela 2 Resultados obtidos com os mtodos de busca para vrias variveis no caso quadrtico
Mtodo
Soluo Encontrada x * , y *
Nmero de Iteraes
Inclinao Mxima
(1,0.331923)
16
Gradientes Conjugados
(1,0.333334)
Polak-Ribiere
(1,0.333318)
18
Flecther-Reeves
(1,0.333318)
18
Dentro do Mtodo da Inclinao Mxima foi utilizado o Critrio de Armijo para a

busca em linha uma vez que esse critrio extensamente utilizado com sucesso na
programao no-linear. Percebe-se que os mtodos chegaram praticamente mesma
soluo, entretanto o Mtodo dos Gradientes Conjugados teve desempenho muito superior
quanto ao nmero de iteraes e, conseqentemente, quanto ao tempo de execuo.
7.2.2 Caso no-Quadrtico
Foram implementados mais uma vez o mtodo da Inclinao Mxima, o Mtodo

dos Gradientes Conjugados, agora no-quadrticos e tambm os mtodos de FletcherReeves e Polak-Ribiere.
Deseja-se
encontrar
ponto
de
mnimo
da
funo:
f ( x, y ) = x 2 5 xy + y 4 25 x 8 y , analiticamente sabe-se que a soluo que minimiza a

funo dada por (20,3) :
39
Figura 5 Grfico da funo f ( x , y ) = x 2 5 xy + y 4 25 x 8 y
usando os pontos iniciais ( x 0 , y 0 ) = (0,0) obtm-se a Tabela 3:
Tabela 3 Resultados obtidos com os mtodos de busca de vrias variveis no caso no-quadrtico
Mtodo
Soluo Encontrada (x * , y * )
Nmero de Iteraes
Inclinao Mxima
(19.996469,2.999756)
210
Gradientes Conjugados
(20.000001,3.000061)
12
Fletcher-Reeves
(19.979500,2.998498)
162
Polak-Ribiere
(19.979500,2.998498)
162
40
8 Simulated Annealing
O Simulated Annealing um mtodo baseado na teoria termodinmica, o qual
simula o processo de recozimento de um slido at que este alcance seu estado mnimo de
energia. Este mtodo ser utilizado como uma ferramenta para a otimizao global e
posteriormente trabalhado conjuntamente com mtodos estudados anteriormente para a
construo de programas hbridos de busca.
Annealing pode ser traduzido neste caso como recozimento, nome dado pela
termodinmica ao processo de aquecimento de um slido at o seu ponto de fuso, seguido
de um resfriamento gradual e vagaroso, at que se alcance novamente o seu enrijecimento.
Nesse processo, a etapa de resfriamento essencial para se manter um equilbrio
trmico do slido, se feito de maneira correta esse resfriamento gradual e vagaroso far
com que os tomos encontrem tempo suficiente para se organizarem em uma estrutura
uniforme com energia mnima. Se o slido resfriado bruscamente, seus tomos formaro
uma estrutura irregular e fraca, com alta energia em conseqncia do esforo interno gasto.
Sob o aspecto computacional e matemtico, esse recozimento pode ser considerado
como um processo estocstico de determinao da estrutura dos tomos de um slido que
apresente energia mnima em seu estado final. Em altas temperaturas, os tomos se movem
livremente e, com grande probabilidade, movem-se para posies que incrementaro a
energia total do sistema. Quando se baixa a temperatura, os tomos gradualmente se
movem em direo uma estrutura regular e, somente com pequena probabilidade,
incrementaro suas energias.
De acordo com Metropolis et al. (1953) nos estudos iniciais desta rea, quando os
tomos se encontram em equilbrio, em uma temperatura T , a probabilidade de que a
energia do sistema seja E , proporcional e
kt
, onde k conhecida como constante de
Bolzmann.
Desta forma, a probabilidade de que a energia de um sistema seja ( E + E ) pode ser
expressa por:
prob (E + E ) = prob(E ) prob(E ) = prob(E )e E kT
( 67 )
41
Ou seja, a probabilidade de que a energia de um sistema passe de E para (E + E )

dada por e E kT . Na expresso e E kT , como k uma constante, nota-se que conforme T
diminui, a probabilidade da energia do sistema se alterar cada vez menor. Nota-se
tambm que nessas condies, quanto menor o valor de E , maior a probabilidade da
mudana ocorrer.
8.1 O mtodo computacional Simulated Annealing

O Simulated Annealing um mtodo de busca que evita solues locais e utilizado
para a obteno de boas solues para problemas complexos de otimizao de resoluo
complicada. Esse mtodo vem sendo atualmente utilizado em diversas reas, tais como
projeto de circuitos integrados por computador, processamento de imagem, tomografias,
redes neurais, dentre outros.
Em trabalhos distintos de Kirkpatrick et al. (1983), e CERNY (1985), este mtodo
proposto como um modelo de simulao de recozimento de slidos, como estudado em
Metropolis et al. (1953), para ser utilizado em problemas de otimizao, onde a funo
objetivo, a ser minimizada, corresponde energia dos estados do slido.
interessante formalizar o problema de usar a teoria termodinmica de recozimento
como um mtodo de otimizao. Para isso um espao S
definido como sendo um
conjunto finito que contm todas as combinaes possveis que representam as solues
viveis para o problema. Seja f uma funo de valores reais definida sobre S , f : S R .
O problema caracterizado em encontrar uma soluo (ou estado) x S , tal que f ( x ) seja
mnimo.
Uma das formas mais simples de tentar resolver o problema, utilizando uma busca
local em S, seria utilizar algum dos mtodos de descida j estudados dentre os quais
destacaram-se o Mtodo de Descida Mxima e o Mtodo dos Gradientes Conjugados.
Porm, como o interesse maior na obteno do timo global, um processo de
busca por uma soluo pode ser iniciado a partir de uma soluo inicial x 0 tomada de
forma aleatria. Uma outra soluo x1 ento gerada, na vizinhana desta atravs de algum
42
mtodo sistemtico. Caso tenhamos uma soluo melhor, para o caso de minimizao,
f (x1 ) < f ( x0 ) , a mesma passa a ser considerada a soluo atual e o processo se repete.
Caso contrrio, a nova soluo rejeitada e uma outra ser buscada. Esse processo se
repete at que no se obtenha uma soluo satisfatria na vizinhana da soluo atual aps
um nmero determinado de iteraes. O algoritmo retorna o valor da ltima soluo
encontrada, considerada uma soluo de mnimo local.
A deficincia do mtodo acima, apesar de ser simples e rpido, que o mnimo
local encontrado pode estar longe de ser um mnimo global, o que seria uma soluo
inaceitvel para o problema. Uma estratgia simples para melhorar a soluo obtida atravs
desse tipo de algoritmo, seria escolher a menor soluo, de um conjunto de solues obtidas
de execues sucessivas, realizadas a partir de diferentes solues iniciais.
O Simulated Annealing, em contraposio, tenta evitar a convergncia para um
mnimo local, aceitando, s vezes, uma nova soluo gerada, mesmo que essa incremente o
valor de f . O aceitar ou o rejeitar de uma nova soluo, que causar um incremento de
em f , sob uma temperatura T , determinado por um critrio probabilstico, atravs de

uma funo g conhecida por funo de aceitao. Normalmente, essa funo expressa
por:
g ( , T ) = e T
( 68 )
Caso = f ( x1 ) f (x0 ) for menor que zero, a soluo x1 ser aceita como a nova
soluo. Caso contrrio, a nova soluo somente ser aceita se:
g ( , T ) > random(0,1)
( 69 )
A semelhana com o mtodo original de simulao de recozimento na

termodinmica, grande, pois o parmetro , corresponde variao da energia de um
estado para outro E e o parmetro de controle T , corresponde temperatura. Uma vez
que, agora T uma varivel intuitiva, a constante k , que aparecia na expresso original
multiplicando T , considerada igual a 1.
43
Assim as seguintes concluses aps a anlise da funo g ( , T ) so:
a probabilidade de aceitao de uma nova soluo inversamente proporcional ao

incremento .
quando T alto, a maioria dos movimentos (de um estado para outro ou de uma
soluo para outra) aceita, entretanto, a medida que T se aproxima de zero, a
grande maioria das solues so rejeitadas.
Para evitar uma convergncia precoce para um mnimo local, o algoritmo inicia com
um valor de T relativamente alto. Esse parmetro gradativamente reduzido e, para cada
um dos seus valores, so realizadas vrias tentativas de se alcanar uma melhor soluo nas
vizinhanas da soluo atual (processo dito como restart nos programas anteriores).
8.2 Implementao do Simulated Annealing

Para problemas caracterizados pela existncia de diversos timos locais as chances
de se conseguir atingir o timo global com o uso dos mtodos de otimizao estudados nas
sees anteriores so remotas, uma vez que um processo de descida dependente da
soluo inicial utilizada.
O incio da implementao do Simulated Annealing pode ser a partir do seguinte
algoritmo para maximizar uma funo objetivo f :
Passo 1.
n0
Passo 2.
definir temperatura inicial T

gerar uma soluo inicial aleatria v0
calcular f (v0 )
Passo 3.
selecione uma nova soluo v1 na vizinhana de v0

se f (v0 ) < f (v1 )
44
ento v0 v1
seno se random(0 , 1) < e ( f (v1 ) f (v0 )) T
ento v0 v1
volte ao Passo 3 k vezes
Passo 4.
T T
n n +1
volte ao Passo 3 at atingir o critrio de parada
importante considerar a idia de que sendo o Simulated Annealing um mtodo de

caractersticas estocsticas, a sua soluo tima no a mais recente encontrada no
processo de busca e sim a melhor soluo encontrada durante toda a busca. Assim, uma
varivel que armazena a melhor soluo encontrada durante todo o processo acrescida e
essa ser a resposta apresentada pelo programa. Alm disso, o programa no chegar na
mesma soluo em todas as tentativas, mas chegar respostas muito prximas. A esse
respeito, executa-se repetidamente o programa para certificar-se de sua confiabilidade.
A seguir o mtodo implementado utilizado em dois exemplos, um unidimensional
e outro bidimensional, ambos com funes complexas repletas de pontos timos locais.
Mais do que obter uma boa aproximao para a soluo, percebe-se a influncia de cada um
dos parmetros envolvidos no mtodo assim como obter um conjunto timo de parmetros.
8.2.1 Exemplo unidimensional
A primeira aplicao do Simulated Annealing como mtodo de otimizao ser com

um exemplo unidimensional. A seguir a funo f ( x ) ser utilizada,
f ( x ) = x sin (10 x ) + 1
( 70 )
45
cujo comportamento pode ser observado na Figura 6. O problema consiste em

encontrar o ponto x dentro do intervalo [ 1 , 2] que maximize a funo, ou seja, encontrar
tal
x0
que
f ( x0 ) f ( x ), para todo x [- 1 , 2] .
Este
exemplo
foi
retirado
de
MICHALEWICZ (1996).
Figura 6 - Grfico da funo
O mtodo Simulated Annealing foi implementado baseado no algoritmo

apresentado na Seo 8.2 e seu cdigo fonte encontra-se no Anexo E.
O prximo passo aps a implementao do mtodo foi encontrar a melhor
combinao dos parmetros envolvidos para encontrar uma soluo melhor e um custo
computacional menor.
Abaixo todos os parmetros e variveis importantes para compreenso dos
resultados e que esto envolvidos na implementao do Simulated Annealing so
apresentados. Na Tabela 4, est o resumo dos experimentos. Para obter os resultados da
Tabela 4, o programa foi executado dez vezes para cada variao no valor de um dos
parmetros e a melhor das solues encontradas foi utilizada como critrio para
determinao dos demais parmetros.
v0 : soluo inicial
t: temperatura final (muito prximo de zero)
46
alfa: taxa de decaimento da temperatura
viz: raio da vizinhana para gerao de um n aleatrio
T: temperatura inicial
Restart: n de restarts dentro do programa antes do decaimento da temperatura
MAX: n mximo de iteraes
Max f ( x ) : valor mximo encontrado
Temp final: temperatura final
Iteraes: n de iteraes ao final do programa
Avaliaes: n de vezes de avaliao da funo f ( x )
Tabela 4 - Resumo e resultados para o problema unidimensional
parmetros
v0
t
alfa
viz
T
restart
MAX
resultados
max f(x)
temp final
iteraes
avaliaes
1
valor
0
0.0001
0.95
1.0
100
10
10000
valor
2,850184
0,000097
270
965
Combinaes de parmetros e Resultados

2
3
4
5
valor
valor
valor
valor
0
0
0
0
0.0001
0.0001
0.0001
0.01
0.95
0.95
0.95
0,9
1.0
1.0
1.0
0,5
100
100
100
50
10
10
10
10
10000
10000
10000
10000
valor
valor
valor
valor
2,850185
2,850183
2,850184
2,850184
0,009778
0,000091
0,000097
0,000099
180
132
270
256
978
480
970
769
Observa-se na Tabela 4 que, para o problema descrito anteriormente, todos os

experimentos alcanaram uma boa aproximao para a funo objetivo, sendo que o maior
valor encontrado foi de 2,850185 para a situao 2. A diferena relevante entre eles foi o
nmero de avaliaes da funo objetivo, que variou de 480 na situao 3 at 978 na
situao 2. Como a avaliao da funo objetivo pode ser um processo caro
computacionalmente, conforme ser visto na Seo 10, conclui-se que a melhor
combinao dos parmetros estudados aquela apresentada na situao 3.
47
8.2.2 Exemplo bidimensional
Nesta seo o Simulated Annealing ser aplicado para um problema de otimizao

com funo objetivo bidimensional, porm deve-se ressaltar que o programa implementado
pode ser utilizado perfeitamente em problemas com diversas variveis com necessidade
apenas de mudana da funo objetivo e da varivel dimenso no cdigo fonte do
programa.
O objetivo ser ento maximizar a funo apresentada na Equao 71, retirada de
MICHALEWICZ (1996).
f ( x1 , x 2 ) = 21.5 + x1 sin (4 x1 ) + x 2 sin (20 x 2 )
(71)
em que 3.0 x1 12.1 e 4.1 x 2 5.8 .

O grfico da funo pode ser observado na Figura 7, a funo caracterizada pela
presena de inmeros timos locais e por isso este exemplo ilustra to bem a importncia
do mtodo Simulated Annealing.
Figura 7 - Grfico da funo
48
Assim como no exemplo anterior, foram realizados diversos testes para

encontrarmos a melhor combinao dos parmetros para que se chegasse em uma soluo
tima e com custo computacional menor. A descrio dos parmetros a mesma do
problema anterior com a incluso do parmetro v1 que representa o valor inicial da segunda
varivel e v0 passa a ser o valor inicial para a primeira varivel. O cdigo fonte deste
mtodo encontra-se no Anexo F.
Neste exemplo o programa tambm foi executado dez vezes para cada mudana no
valor de um dos parmetros e a melhor soluo encontrada foi encontrada como critrio de
escolha dos demais valores dos parmentros. O resumo dos experimentos para o problema
de otimizao descrito acima apresentado a seguir na Tabela 5.
Tabela 5 - Resumo e resultados para o problema bi-dimensional
varivel
v0
v1
t
alfa
viz
T
restart
MAX
resultados
maior f(x)
temp final
iteraes
avaliaes
Combinaes de parmetros e Resultados

1
2
3
4
valor
valor
valor
valor
0
0
0
0
5
5
5
5
0.0001
0.0001
0.0001
0.0001
0,99
0,99
0.95
0,99
1.0
1.0
0,5
1,2
100
10000
10000
10000
10
10
10
10
10000
10000
10000
10000
valor
valor
valor
valor
38,660828 38,832943
38,8349
38,845600
0,000096
0,000096
0,0001
0,0001
315
1604
1833
1833
3151
16041
18331
18331
A Tabela 5 mostra que a variao dos parmetros para o problema bidimensional

exerce maior influncia sobre a soluo do que no problema unidimensional. A nosso ver,
essa sensibilidade causada pela complexidade da funo objetivo. Pequenas variaes,
como por exemplo, a mudana no parmetro alfa (situaes 1 e 2) levam uma melhora
considervel da soluo.
49
Outra observao vista na Tabela 2 diz respeit mudana no parmetro vizinhana.

Este exerce um papel importante, pois sua variao no afeta o custo computacional e alm
disso, melhora de maneira significativa a preciso da solua. Esse fato pode ser observado
na situao 4 com o ponto
f ( x1 , x2 ) = 38,8456 enquanto
que
(11.624089 , 5.725650)
a
melhor
soluo
que leva ao mximo de

obtida
anteriormente
nos
experimentos foi f ( x1 , x2 ) = 38,8349 na situao 3.
50
9 Mtodos Hbridos
O desenvolvimento de mtodos hbridos mostra-se necessrio quando nos
deparamos com um problema que envolva uma funo extremamente complicada, ou seja,
repleta de vales, picos e regies planas. Nestes casos os mtodos estudados no incio do
trabalho mostram-se inadequados, pois encontraro uma soluo que ser apenas local no
gerando assim o timo desejado pelo usurio.
A primeira abordagem a escolha de um mtodo que escape desses timos locais e
para isso o mtodo do Simulated Annealing foi estudado, o qual por um lado se mostrou
bastante eficiente, mas por outro demandou um alto custo computacional.
neste ponto que o desenvolvimento de mtodos hbridos se mostra relevante, uma
vez que pode ser possvel aproveitar a caracterstica positiva de fugir de timos locais do
Simulated Annealing e delegando a tarefa de realizar buscas finas em regies promissoras

aos mtodos de busca local. Essa diviso de tarefas exigiria menor esforo computacional
do Simulated Annealing diminuindo o custo computacional total do mtodo.
O mtodo dos Gradientes Conjugados foi escolhido para compor os mtodos
hbridos devido aos bons resultados obtidos nas etapas anteriores de estudo, e para se ter
uma base de comparao utilizou-se tambm o mtodo da Inclinao Mxima.
O uso dos mtodos de busca local, por meio das estratgias abaixo, proporciona a
possibilidade de deixar a parte da busca do Simulated Annealing no to robusta (com
parmetros no to exigentes), diminuindo assim o custo computacional e ganhando em
eficincia do mtodo hbrido.
Conforme mencionado, a idia bsica realizar uma busca mais refinada em regies
que tenham potencial para serem timos globais e no apenas locais. Para isso foram
desenvolvidas e implementadas duas estratgias diferentes de combinao entre o
Simulated Annealing e os mtodos de busca local. Cada uma delas ser explicada e
exemplificada a seguir.
51
Estratgia 1
Consiste em realizar uma busca fina (local) aps o trmino do restart do Simulated
Annealing, ou seja, antes do decaimento da temperatura realiza-se uma busca local para
chegar num ponto de melhor qualidade. A visualizao deste procedimento encontra-se
abaixo. O passo 4 representa a modificao introduzida.
Passo 1.
n0
Passo 2.

calcular f (v0 )
Passo 3.

se f (v0 ) < f (v1 )
ento v0 v1
ento v0 v1
Passo 4.
Passo 5.
Utilizar a busca local com soluo inicial v0
T T
n n +1
52
Estratgia 2
Consiste em utilizar o mtodo do Simulated Annealing em sua forma pura (da

mesma maneira que na Seo 8) e usar a soluo tima encontrada como soluo inicial
para a busca local conforme algoritmo abaixo sendo o passo 5 o mtodo de busca local
includo.
Passo 1.
n0
Passo 2.

calcular f (v0 )
Passo 3.

se f (v0 ) < f (v1 )
ento v0 v1
ento v0 v1
Passo 4.
T T
n n +1
Passo 5.
Utilizar a busca local com soluo inicial v0
53
9.1 Simulated Annealing com Inclinao Mxima

O primeiro mtodo hbrido apresentado consiste em utilizar o mtodo Simulated
Annealing em conjunto com o mtodo de busca local da Inclinao Mxima. Esse mtodo
hbrido aplicado para as estratgias 1 e 2 apresentadas na Seo 9 e os respectivos cdigos
fonte encontram-se nos Anexos G e H.
Para correto funcionamento da unio dos mtodos e para ganhos de eficincia foram
necessrias algumas adaptaes em ambos mtodos. O Simulated Annealing pde ter
alguns de seus parmetros relaxados uma vez que teremos buscas finas ao longo do
processo, este relaxamento diminui o nmero de iteraes e principalmente o nmero de
avaliaes da funo em questo. J no mtodo da Inclinao Mxima, foi necessrio uma
mudana dos parmetros do Critrio de Armijo e do valor inicial da varivel , essa readequao foi necessria devido alta sensibilidade do problema utilizado como exemplo
assim, tem um valor muito prximo de zero assim como as constantes de verificao do
Critrio de Armijo.
9.2 Simulated Annealing com Gradientes Conjugados

Neste segundo hbrido houve apenas a necessidade de adaptaes no mtodo do
Simulated Annealing para se obter ganhos de eficincia computacional por meio do

relaxamento de alguns dos parmetros uma vez que o mtodo dos Gradientes Conjugados
tem uma forma explcita para o clculo da varivel . Haver tambm como no mtodo
anterior buscas finas ao longo (estratgia 1) ou ao trmino (estratgia 2) do processo que
possibilitaro uma busca menos robusta por parte do Simulated Annealing. Os Anexos I e J
contm os cdigos fontes do hbrido Simulated Annealing com Gradientes Conjugados para
as estratgias 1 e 2, respectivamente.
Tanto no mtodo hbrido com Inclinao Mxima quanto no hbrido com Gradientes
Conjugados optou-se, aps diversos testes, por reduzir a preciso da temperatura final no
Simulated Annealing, criando assim uma busca menos robusta, com menos iteraes e
54
menor esforo computacional que sero recompensados pelas buscas locais utilizadas nos
mtodos hbridos.
9.3 Comparaes e resultados

Os mtodos hbridos desenvolvidos foram aplicados no problema bidimensional
tratado na Seo 8 (Equao 71). A Tabela 6 mostra na segunda coluna o desempenho do
Simulated Annealing puro e nas colunas seguintes, o desempenho de cada um dos mtodos
hbridos implementados.
Tabela 6 - Comparaes e Resultados
varivel
v0
v1
t
alfa
viz
T
restart
MAX
resultados
maior f(x)
temp final
iteraes
avaliaes
Comparaes e Resultados
S.A.
S.A. com IM (1) S.A. com IM (2) S.A. com GC (1) S.A. com GC (2)
valor
valor
valor
valor
valor
0
0
0
0
0
5
5
5
5
5
0.0001
0.01
0.01
0.01
0.01
0,99
0,99
0,99
0,99
0,99
1,2
1,2
1,2
1,2
1,2
10000
10000
10000
10000
10000
10
10
10
10
10
10000
10000
10000
10000
10000
valor
valor
valor
valor
valor
38,850399
38,845600
38,850307
38,849518
38,850494
0,0001
0,00942
0,00942
0,00942
0,00942
1833
917
1000
917
1000
18331
9171
10001
9171
10001
Observa-se que tanto os mtodos hbridos com Inclinao Mxima quanto os

hbridos com Gradientes Conjugados tiveram desempenho muito superior ao Simulated
Annealing puro uma vez que os hbridos chegaram a solues melhores dos que as j
encontradas pelo Simulated Annealing com uma reduo significativa do nmero de
iteraes e principalmente do nmero de avaliaes da funo.
A temperatura final foi reduzida em sua preciso em duas casas decimais e mesmo
assim os mtodos hbridos tiveram um bom desempenho conforme esperado.
O mtodo de maior destaque foi o hbrido de Simulated Annealing com Gradientes
Conjugados seguindo a estratgia 1com quantidade muito inferior de iteraes e avaliaes
55
do que o Simulated Annealing, este hbrido chegou ao timo f ( x1 , x2 ) = 38,850494 . O

segundo melhor mtodo foi novamente um hbrido de Simulated Annealing com Gradientes
Conjugados
que
com
utilizao
da
estratgia
com
um
mximo
f ( x1 , x2 ) = 38,850399 .
Os mtodos hbridos com Inclinao Mxima tiveram um desempenho pouco
inferior aos hbridos com Gradientes Conjugados, entretanto tiveram desempenho muito
superior ao Simulated Annealing.
56
10 Aplicao: problema de tomografia por impedncia

eltrica
Com objetivo de testar os programas computacionais desenvolvidos neste projeto
em um problema prtico, o problema de tomografia por impedncia eltrica foi escolhido.
A tomografia por sensoriamento eltrico representa uma tcnica de grande potencial para a
otimizao de processos normalmente associados s industrias do petrleo e qumica.
Esse tema vem sendo pesquisado h alguns anos no Ncleo de Engenharia Trmica
e Fluidos (NETeF) da EESC USP, onde a orientadora desta monografia participa
ativamente. Este trabalho representa uma contribuio aos esforos do grupo e tem como
objetivo contribuir com uma nova linha de pesquisa que trata da implementao de
mtodos hbridos de otimizao, mesclando um algoritmo de otimizao global com um
mtodo de otimizao local (geralmente baseado na inclinao do gradiente). Esta
contribuio importante tanto para a parte tcnica quanto para a parte cientfica uma vez
que o emprego de tcnicas tomogrficas em processos industriais envolvendo fluidos
multifsicos ainda carece de mtodos robustos e computacionalmente eficientes.
O problema de tomografia por impedncia eltrica pode ser descrito pelo seguinte
problema de otimizao (ROLNIK E SELEGHIM, 2006):
Min e ( 0 , 1 ,..., n ) ,
s.a.
min i ( x, y ) max
=
=
(72)
i = 1..n ,
(73)
C(x, y, z)(x, y, z)dxdydz ,
(74)
xyzC(x, y, z)(x, y, z)dxdydz ,
(75)
onde n o nmero de variveis no espao de busca, min e max so os limites para

asincgnitas, C(x,y,z) denota o modelo de calibrao, a frao de vazio e o
coeficiente de simetria do escoamento.
57
As n primeiras restries (73) representam os limites de fronteira do espao de

busca, a restrio (74), representando a frao de vazio que compe o escoamento, e a
restrio (75), considerando o coeficiente de simetria do escoamento, podem ser medidas
tanto experimentalmente quanto numericamente. Estas informaes do escoamento
conhecidas a priori devem colaborar no aumento da preciso da soluo e diminuio do
tempo de convergncia do algoritmo gentico.
A funo objetivo e( ) representa o funcional de erro construdo a partir do
confronto entre medidas experimentais e numricas. O ponto de mnimo global do
funcional de erro (Equao 72) est relacionado com a imagem do domnio sensoriado,
porm, encontr-lo no uma tarefa trivial, pois a superfcie do funcional de erro
extremamente no linear e repleta de extremos locais, pontos de sela, regies praticamente
planas entre outras caractersticas topolgicas.
Em comunicao com a aluna de doutorado Grazieli L. C. Carosio (CAROSIO et
al., 2003 e processo Fapesp no 03/12537-7), foi fornecido seu programa computacional que
realiza o clculo do erro (Eq. 72). Os dados utilizados em sua implementao so:
Domnio bidimensional: quadrado de lados unitrios com 16 eletrodos

dispostos uniformemente no contorno, conforme Figura 8.
Figura 8 - Domnio de Sensoriamento
Condies de contorno: tipo Dirichlet em todo o contorno tendo perfil

triangular que simula uma tenso de 10V em um eletrodo, localizado no
canto direito da aresta superior do quadrado, variando gradativamente at
um valor mnimo (0V) no eletrodo diametralmente oposto a ele, conforme
Figura 9.
58
Figura 9 - Condies de contorno que simulam o perfil de excitao triangular.
Discretizao da equao diferencial parcial: mtodo dos elementos finitos,

tendo como a Equao 72 como resultante dessa discretizao.
A i j-1 + B i 1 j + C ij + D i +1 j + E ij+1 = 0
(76)
com
1
A = .( L1 + L 2 )
2
(76.a)
1
B = .( L1 + L 4 )
2
(76.b)
1
C = 1.( L1 + L 6 ) + .( L 2 + L 3 + L 4 + L 5 )
2
(76.c)
1
D = .( L3 + L 6 )
2
(10.d)
1
E = .( L 5 + L 6 )
2
(76.e)
Para a discretizao do domnio foi utilizada uma malha de 10 x 10 pontos,

gerando um total de 64 pontos nodais, igualmente espaados por = 0,11
nas duas direes, e 162 elementos triangulares.
Para visualizao dos resultados, as 162 incgnitas foram alinhadas em um vetor

= (1,2,...,162) e correspondem ao eixo horizontal no grfico a seguir. J o eixo vertical
denota nos elementos discretos. A soluo correta para o problema-teste pode ser
observada no grfico seguinte:
59
Contraste
80
1
1
15
22
29
36
43
50
57
64
71
78
85
92
99 106 113 120 127 134 141 148 155 162
Elementos discretos
Figura 10 - Soluo correta para o problema-teste
10.1 Resultados com o Simulated Annealing

O Simulated Annealing foi includo diretamente no problema de minimazao do
erro. Os parmetros relacionados temperatura e ao restart foram alterados para que o
Simulated Annealing realizasse um nmero maior de iteraes e conseqentemente de

avaliaoes da funo objetivo.
Apesar de ter rodado com sucesso, o Simulated Annealing no chegou a uma
soluo satisfatria. A Figura 11 mostra a soluo encontrada e se comparada Figura 10
percebe-se que a soluo est longe da soluo correta para o problema teste.
100
90
80
C o n tra s te
70
60
50
40
30
20
10
0
1
6 11 16 21 26 31 36 41 46 51 56 61 66 71 76 81 86 91 96 101 106 111 116 121 126 131 136 141 146 151 156 161
Elementos discretos
Figura 11 - Soluo encontrada pelo Simulated Annealing
60
Nas primeiras iteraes o mtodo caminhou de maneira satisfatria para a soluo,

mas pequenas variaes nos pontos encontrados levaram a soluo para pontos piores.
10.2 Resultados do hbrido Simulated Annealing com Gradientes

Conjugados
Para aplicar o mtodo hbrido Simulated Annealing com Gradientes Conjugados no
problema de tomografia eltrica foi necessrio, em primeiro lugar, alterar o mtodo de
clculo das derivadas. Ao invs de usar as formas explcitas das derivadas, ser usada a
aproximao numrica de diferenas finitas centradas para o clculo da derivada primeira
conforme a equao abaixo:
df
f (x + ) f (x )
=
dx
2
(77)
Da mesma maneira que o Simulated Annealing, os resultados no foram

satisfatrios. O mesmo comportamento foi observado, o que j era esperado devido
complexidade do problema.
61
11 Concluso
As hipteses e metas determinadas no incio do projeto foram constatadas e
cumpridas uma vez que os mtodos hbridos foram desenvolvidos e com isso atingir o
objetivo de se obter um processo de otimizao consistente e eficiente.
Dentre os mtodos implementados, o mtodo hbrido que une o Simulated
Annealing ao Gradientes Conjugados foi o que apresentou o melhor desempenho para

resoluo de problemas de otimizao global.
Alm disso, tambm iniciou-se os estudos para aplicao dos mtodos hbridos
desenvolvidos no problema de tomografia por impedncia eltrica. Esse estudo, apesar de
no ter tido resultados satisfattios para a aplicao, mostrou ser vivel e promissor.
Diversas idias ainda podem ser desenvolvidas nesta rea dentre as quais algumas
propostas se destacam:
Calcular a probabilidade de cada um dos mtodos alcanar uma boa

aproximao para a soluo tima.
Adaptar todos os mtodos para o clculo da derivada atravs de diferenas

finitas com objetivo de ampliar a viabilidade de uso dos mesmos em outros
projetos.
Continuar a tentativa de melhoria da soluo para o problema de impedncia

eltrica.
Estudar outras tcnicas meta-heursticas e de algoritmos genticos.
A realizao do projeto de concluso de curso foi de grande satisfao e orgulho,

todos os estudos foram de grande relevncia para a formao do aluno e alm de gerarem
um enriquecimento cientfico e uma ampla experincia acadmica tambm proporcionaram
amadurecimento pessoal e profissional.
62
12 Referncias Bibliogrficas
CERNY. Thermodynamical approach to the traveling salesman problem: An efficient
simulation algorithm. Journal of Optimization Theory and Applications. vol 45, No. 1,
pp. 41-51.
DAVIDON, W.C. Variance Algorithm for Minimization Computer J. 10, 1968, pages
406-410.
FLETCHER, R., POWELL, M.J.D., A Rapidly Convergent
Descent Method for
Minimization. Computer J. 6, 1963, pages 163-168.

JACOBY, S.L.S., KOWALIK, J.S., PIZZO, J.T. Iterative Methods for nonlinear
optimization problems, Prentice-Hall, 1972.
KAMIEM, I.M., SCHWARTZ, N.L. Dinamic Optimization, North Holland 1981.
KIRKPATRICK, S. (1983). Optimization by Simulated Annealing, Science, vol. 220, pp.
671-680.
LUENBERGER, D. G. Introduction to Linear and Nonlinear Programming, AddisonWesley, 1984.
METROPOLIS, N. (1953). Equation of State Calculations by Fast Computing Machines,
Journal of Chemical Physics, vol. 21, pp. 1087-1092.

MICHALEWICZ, Z. (1996). Genetic Algorithms + Data Structures = Evolution
Programs. New York: Springer-Verlag Berlin Heidelberg.
ROLNIK, V. P.; SELEGHIM Jr, P. (2006). A Specialized Genetic Algorithm for the
Electrical Impedance Tomography of Two-Phase Flows. Journal of the Brazilian
Society of Mechanical Sciences and Engineering, Vol. XXVIII, n. 4, pp. 378 390.
63
Anexo A Mtodo de Newton Unidimensional

#include <stdio.h>
#include <math.h>
float f(float x)
{float z;
z = pow(x,2)-6*x +9; /* altere aqui a funcao a ser analisada*/
return z;}
float f1(float x)
{float w;
w = 2*x - 6; /* primeira derivada*/
return w;}
float f2(float x)
{float u;
u = 2; /* segunda derivada */
return u;}
main(){
float e=1,x,d1,d2,m,y;
int i=0;
printf("Entre com o valor inicial:\nx[k]=");
scanf("%f",&x);
while(e>0.001){
i=i+1;
d1=f1(x);
d2=f2(x);
y = x - (d1/d2);
printf("\nx[k+1]=%f",y);
e= y-x;
printf("\ne=%f",e);
if(e<0){
e=-1*e;}
x=y;}
m=f(x);
printf("\n\nPto de minimo:%f \nValor minimo:%f\n\n", x,m);
printf("\n\niteracoes:%d\n\n", i);
system("PAUSE");}
64
Anexo B Mtodo da Inclinao Mxima caso quadrtico

#include <stdio.h>
#include <math.h>
float funcao(float u, float w)
{float z;
z = pow(u,2)+ 3*pow(w,2) - 2*u + 2*w; /* altere aqui a funcao a ser analisada*/
return z;}
float derivadax0(float u, float w)
{float z;
z = 2*u - 2; /* altere aqui a derivada a ser analisada*/
return z;}
{float z;
z = 6*w + 2; /* altere aqui a derivada a ser analisada*/
return z;}
float phi(float u, float w, float p, float g2, float g3)
{float z;
z = pow(u-p*g2,2) + 3*pow(w - p*g3,2) - 2*(u-p*g2) + 2*(w - p*g3);
return z;}
main(){
float x,y;
float g0, g1, g,fmin;
int n=0,nmax=30;
float e=0.01;
float d0=1, d=1;
float alpha=0.1;
float phi0, philinha0, phia, large, penultimo;
int teste;
printf("::::::::::: Metodo de Descida ::::::::::::::::::\n\n\n");
printf("Entre com o valor inicial da primeira variavel:\nx=");
scanf("%f",&x);
printf("Entre com o valor inicial da segunda variavel:\ny=");
scanf("%f",&y);
g0=derivadax0(x,y);
g1=derivadax1(x,y);
while((d0>e || d>e) && n<nmax ){
65
printf("\nDerivada em x %f\n",g0);
printf("Derivada em y %f\n",g1);
// :::::::::::: inicio do teste armijo :::::::::::::::::::

phi0=phi(x,y,0,g0,g1);
philinha0=g0*g0+g1*g1;
phia= phi(x,y,alpha,g0,g1);
large= phi0 + 0.2*philinha0*alpha - phia;
if (large>=0)
teste=0;
else
teste=1;
if (teste==0){
while(large>=0){ // INICIO WHILE
penultimo=alpha;
alpha=alpha*2;
large= phi0 + 0.2*philinha0*alpha - phia;} // FIM WHILE
alpha=penultimo;
} // FIM SE
if(teste==1){
while(large<0){
alpha=alpha/2;
large= phi0 + 0.2*philinha0*alpha - phia;}
}//:::::::::::::::: fim do ARMIJO :::::::::::::::::::::::::
x= x - alpha*g0;
y= y - alpha*g1;
g0=derivadax0(x,y);
d0=g0;
g1=derivadax1(x,y);
d=g1;
if(d0<0)
66
d0=d0*(-1);
if(d<0)
d=d*(-1);
n=n+1;
printf("\n\n\ninteracao numero: %d",n);
printf("\nalpha:%f",alpha);
printf("\nx=%f\ny=%f\n",x,y);
fmin=funcao(x,y);
printf("Valor de F=%f",fmin); } // fim do while
printf("\n\n::::::::::::::::::::::::RESULTADO::::::::::::::::::::::::::");
if(n==300){
printf("\n\nx,y MINIMO :\nx=%f\ny=%f\n",x,y);
printf("Interacoes necessarias=%d(maximo possivel)\n\n", n);}
if (n<300){
printf("\n\nx,y MINIMO :\nx=%f\ny=%f\n",x,y);
printf("Interacoes necessarias=%d\n\n ", n);}
system("PAUSE");}
67
Anexo C Gradiente Conjugado caso no-quadrtico

#include <stdio.h>
#include <math.h>
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

{float z;
z = pow(u,2)-5*u*w + pow(w,4) - 25*u - 8*w; /* altere aqui a funcao a ser analisada*/
return z;}
{float z;
z = 2*u - 5*w - 25; /* altere aqui a derivada a ser analisada*/
return z;}
{float z;
z = -5*u + 4*pow(w,3) - 8; /* altere aqui a derivada a ser analisada*/
return z;}
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
main(){
float x[2][1],xaux[2][1], xdif[2][1];
float Q[2][2];
float g[2][1], derivada[1][2], d[2][1];
float gt[1][2], dt[1][2];
float num_alpha, den_alpha, alpha, num_beta, den_beta, beta, e=0.01;
float denaux_alpha[1][2], numaux_beta[1][2];
int n=0,nmax=2,i,j,k, teste=0, restart=0;
// MATRIZ Q // ELEMENTOS INDEPENDENTES DE Q

Q[0][0]=2;
Q[0][1]=-5;
Q[1][0]=-5;
printf("::::::::::: Metodo GRADIENTE CONJUGADO NAO QUADRATICO ::::::::::::::::::\n");

printf("::::::::::: x^2 - 5xy + y^4 - 25x - 8y
::::::::::::::::::\n\n\n");
for(i=0;i<=1;i++){ // Vetor inicial x
for(j=0;j<1;j++){
68
printf("\nEntre com X[%d%d]:",i,j);

scanf("%f",&x[i][j]);}
}
while(teste==0){
printf("\nRESTART:%d",restart);
derivada[0][0]= derivadax0(x[0][0], x[1][0]);
for(i=0;i<1;i++){ // Transposto da Derivada
for(j=0;j<=1;j++){
g[j][i]=derivada[i][j];}}
d[0][0]= -1*g[0][0];
d[1][0]= -1*g[1][0];
n=0;
while(n<nmax ){
printf("\ninteracao:%d",n);
Q[1][1]= 12*x[1][0]*x[1][0]; // AQUI TEM TODOS OS ELEMNETOS FUNCAO DE X
// :::::::::::::::::::::::: Calcula ALPHA ::::::::::::::::::::
for(i=0;i<=1;i++){ // Transposto da G
for(j=0;j<1;j++){
gt[j][i]=g[i][j];}} // Calculou o transposto do G
for(i=0;i<1;i++){ // Numerador do alpha

for(j=0;j<1;j++){
num_alpha = 0;
for(k=0;k<=1;k++){
num_alpha=gt[i][k]*d[k][j] +num_alpha;}}} // Calculou o num ALPHA
for(i=0;i<=1;i++){ // Transposto da D
for(j=0;j<1;j++){
dt[j][i]=d[i][j];}} // Calculou o transposto do D
// Calculo de dt*Q
for(i=0;i<1;i++){
for(j=0;j<=1;j++){
denaux_alpha[i][j] = 0;
for(k=0;k<=1;k++){
denaux_alpha[i][j]=dt[i][k]*Q[k][j] + denaux_alpha[i][j];}}}
// Calculo de [dt*Q]*d
for(i=0;i<1;i++){
for(j=0;j<1;j++){
den_alpha = 0;
for(k=0;k<=1;k++){
69
den_alpha = denaux_alpha[i][k]*d[k][j] + den_alpha;}}}

// Calculo alpha
alpha = (-1)*(num_alpha/den_alpha);
//:::::::::::::: FIM ALPHA ::::::::::::::
// ::::::::::::::::::: CALCULO DO X ::::::::::::::::::::::::::::::::::::::
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
xaux[i][j] = x[i][j] ;}}
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
x[i][j] = x[i][j] + alpha*d[i][j];}}
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
xdif[i][j] = x[i][j] - xaux[i][j] ;
if(xdif[i][j]<0)
xdif[i][j]=xdif[i][j]*-1;
}}
// ::::::::::::::::::: FIM DO CALCULO DE X ::::::::::::::::::::::::::::::

//:::::::::::::::Calc do Gk+1 ::::::::::::::::::::::::::::::::::::
for(j=0;j<=1;j++){
//::::::::::::::::FIM De Gk+1 ::::::::::::::::::::::::::::::::::::::::::::
// :::::::::::::: Calculo BETA ::::::::::::::::::::::::::::::
for(j=0;j<1;j++){
// Calculo de gt*Q
for(i=0;i<1;i++){
for(j=0;j<=1;j++){
numaux_beta[i][j] = 0;
for(k=0;k<=1;k++){
numaux_beta[i][j]=gt[i][k]*Q[k][j] + numaux_beta[i][j];}}}
// Calculo de [gt*Q]*d
70
for(i=0;i<1;i++){
for(j=0;j<1;j++){
num_beta = 0;
for(k=0;k<=1;k++){
num_beta = numaux_beta[i][k]*d[k][j] + num_beta;}}}
den_beta = den_alpha;
beta = num_beta/den_beta;
//:::::::::::::: FIM BETA ::::::::::::::::::::::::::::::
//:::::::::::::: CALCULA NOVO D ::::::::::::::::::::::::::::::
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
d[i][j]= -1*g[i][j]+ beta*d[i][j];}}
// ::::::::::::::::::: FIM D ::::::::::::::::::::::::::::::::::::::::::
n=n+1;}
printf("\nx=%f\ny=%f\n\n",x[0][0],x[1][0]);
if(xdif[0][0]<e && xdif[1][0]<e)
teste=1;
restart=restart+1;}
printf("\n\nValores minimos\nx=%f\ny=%f\n\n",x[0][0],x[1][0]);
system("PAUSE");
}
71
Anexo D Fletcher-Reeves caso no-quadrtico

#include <stdio.h>
#include <math.h>
{float z;
z = pow(u,2)-5*u*w + pow(w,4) - 25*u - 8*w; /* altere aqui a funcao a ser analisada*/
return z;}
{float z;
z = 2*u - 5*w - 25; /* altere aqui a derivada a ser analisada*/
return z;}
{float z;
z = -5*u + 4*pow(w,3) - 8; /* altere aqui a derivada a ser analisada*/
return z;}
float phi(float u, float w, float p, float g2, float g3)
{float z;
z = pow(u-p*g2,2)- (5*(u-p*g2)*(w - p*g3)) + pow(w - p*g3,4) - 25*(u-p*g2) - 8*(w - p*g3);
return z;}
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
main(){
float x[2][1],xaux[2][1], xdif[2][1];
float gt[1][2], dt[1][2];
float alpha=0.2, num_beta, den_beta, beta, e=0.001;
float gaux[2][1],gauxt[1][2];
int n=0,nmax=2,i,j,k, teste_restart=0, restart=0, restart_max=300;
float phi0, philinha0, phia, large, penultimo;
int teste;
printf(":::::::::::
printf(":::::::::::
printf(":::::::::::
LINE SEARCH METHODS

::::::::::::::::::\n");
FLETCHER - REEVES
::::::::::::::::::\n");
x^2 - 5xy + y^4 - 25x - 8y ::::::::::::::::::\n\n\n");
for(i=0;i<=1;i++){ // Vetor inicial x

for(j=0;j<1;j++){
printf("\nEntre com X[%d%d]:",i,j);
72
}
while(teste_restart==0 && restart<restart_max){
printf("\nRESTART:%d",restart);
for(j=0;j<=1;j++){
d[0][0]= -1*g[0][0];
d[1][0]= -1*g[1][0];
n=0;
while(n<nmax ){
// :::::::::::::::::::::::: Calcula ALPHA ::::::::::::::::::::

phi0=phi(x[0][0],x[1][0],0,g[0][0],g[1][0]);
philinha0=g[0][0]*g[0][0]+g[1][0]*g[1][0];
phia= phi(x[0][0],x[1][0],alpha,g[0][0],g[1][0]);
if (large>=0)
teste=0;
else
teste=1;
if (teste==0){
penultimo=alpha;
alpha=alpha*2;
phi0=phi(x[0][0],x[1][0],0,g[0][0],g[1][0]);
philinha0=g[0][0]*g[0][0]+g[1][0]*g[1][0];
alpha=penultimo;
} // FIM SE
if(teste==1){
while(large<0){
73
alpha=alpha/2;
phi0=phi(x[0][0],x[1][0],0,g[0][0],g[1][0]);
philinha0=g[0][0]*g[0][0]+g[1][0]*g[1][0];
}
//:::::::::::::: FIM ALPHA ::::::::::::::
// ::::::::::::::::::: CALCULO DO X ::::::::::::::::::::::::::::::::::::::
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
xaux[i][j] = x[i][j] ;}}
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
x[i][j] = x[i][j] + alpha*d[i][j];}}
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
if(xdif[i][j]<0)
}}

//:::::::::::::::Calc do Gk+1 ::::::::::::::::::::::::::::::::::::
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
gaux[i][j] = g[i][j];}}
for(i=0;i<1;i++){ // Transposto da Derivada auxiliar
for(j=0;j<=1;j++){
gauxt[j][i]=gaux[i][j];}}
for(j=0;j<=1;j++){
//::::::::::::::::FIM De Gk+1 ::::::::::::::::::::::::::::::::::::::::::::
// :::::::::::::: Calculo BETA ::::::::::::::::::::::::::::::
for(j=0;j<1;j++){
74
// Calculo de gt*g
for(i=0;i<1;i++){
for(j=0;j<1;j++){
num_beta = 0;
for(k=0;k<=1;k++){
num_beta = gt[i][k]*g[k][j] + num_beta;}}}
// calc denominador Beta
for(i=0;i<1;i++){
for(j=0;j<1;j++){
den_beta = 0;
for(k=0;k<=1;k++){
den_beta = gauxt[i][k]*gaux[k][j] + den_beta;}}}
//:::::::::::::: FIM BETA ::::::::::::::::::::::::::::::
//:::::::::::::: CALCULA NOVO D ::::::::::::::::::::::::::::::
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
d[i][j]= -1*g[i][j]+ beta*d[i][j];}}
// ::::::::::::::::::: FIM D ::::::::::::::::::::::::::::::::::::::::::
n=n+1;}
printf("\nx=%f\ny=%f\n\n",x[0][0],x[1][0]);
if(xdif[0][0]<e && xdif[1][0]<e)
teste_restart=1;
restart=restart+1;}
printf("\n\nValores minimos\nx=%f\ny=%f\n\n",x[0][0],x[1][0]);
system("PAUSE");
}
75
Anexo E Mtodo Simulated Annealing unidimensional

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
float f(float x)
{float z;
z = x*sin(10*3.1415*x) + 1; /* altere aqui a funcao a ser analisada*/
return z;}
float expon(float x, float w, float u) // x valor final, w valor inicial, u temp
{float z;
z=exp((x-w)/u);
return z;}
// inicializacao dos geradores randomicos
void iniciaRand(){
int stime;
long ltime;
/* Obtm a hora de calendrio atual para usar como semente. */
ltime = time(NULL);
stime = (unsigned) ltime/2;
/* Configurando a semente de rand. */
srand(stime);
}//fim da inciaRand
/******************************************************************************/
//Gera nmeros randmicos no intervalo 0 a n-1
long randInt(long n){
return (long) (((float)n)*rand()/(RAND_MAX+1.0));
}
double randFloat(double min, double max){
return ((double) randInt((max-min)*1000 + 1) / 1000.0) + min;
}
FILE *saida;
main(){
int i=0, MAX=10000, j=0, restart=10;
float v0, v1, y0, y1, y, p, e, n0, n1; // n sao auxiliares para viz
float a=-1, b=2; /* altere aqui o intervalo a ser analisada a funcao*/
float T=50, temp; /* altere aqui a temperatua inicial */
float viz=1.0; /* raio da vizinhanca */
float alfa=0.9; // taxa de reducao da temperatura
76
float t=0.0001; //precisao da temperatura

int aval=0; // contador de avaliacao
//_____________________ SA ____________________________________________________
saida=fopen("resultados.dat","w");
iniciaRand();
//v0=randFloat(a,b);
v0=0;
//printf("\nxrand=%f",v0);
y0=f(v0);
fprintf(saida,"\n%f",y0);
aval=aval+1;
while(i<MAX && T>t){

j=0;
while(j<restart){
j=j+1;
//printf("\n\niteracao %d",i);
n0=v0-viz;
n1=v0+viz;
//printf("\nv0=%f",v0);
v1=-10;
while(v1<a||v1>b){
v1=randFloat(n0,n1);}
//printf("\nv1=%f",v1);
y1=f(v1);
aval=aval+1;
//printf("\nf(v1)=%f",y1);
if(y0<y1){
v0=v1;
y0=y1;
}
else{
p=randFloat(0,1);
//printf("\np=%f",p);
e=expon(y1,y0,T);
//printf("\ne=%f",e);
if(p<e){
v0=v1;
y0=y1;
} // fim if
} // fim do else
}//fim do j
T=alfa*T;
77
//printf("\nT=%f",T);
i=i+1;}
printf("\n\n:::::::::::::::::::::::\n\nx=%f",v0);
printf("\nf(x)=%f",y0);
printf("\n\nT=%f",T);
printf("\nem %d iteracoes\n",i);
printf("\n\nnum aval=%d\n\n",aval);
fclose(saida);
system("PAUSE");}
78
Anexo F Mtodo Simulated Annealing n dimensional

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
float f(float x[],int N)

{float z;
z = 21.5 + x[0]*sin(4*3.1415*x[0]) + x[1]*sin(20*3.1415*x[1]); /* altere aqui a funcao a ser
analisada*/
return z;}
{float z;
z=exp((x-w)/u);
return z;}
void iniciaRand(){
int stime;
long ltime;
ltime = time(NULL);
srand(stime);
}//fim da inciaRand
/******************************************************************************/
}
}
FILE *saida;
main(){
int N =2;
int i=0, MAX=10000, j=0, restart=10, k=0;
float v0[N], v1[N], v[N], y0, y1, y, p, e, n0[N], n1[N]; // n sao auxiliares para viz
float a[N], b[N];
79

int aval=0, it=0;
//_____________________ SA ____________________________________________________
saida=fopen("SAmaisVAR.dat","w");
iniciaRand();
v0[0]=0; // ENTRADA DAS VARIAVEIS INICIAIS
v0[1]=5;
//v0[2]=0;
//...
FIM DA ENTRADA DAS VARIAVEIS INICIAIS
y0=f(v0,N); // VERIFICAR A FUNCAO OBJTIVO - NUMERO DE VAR

y=y0;
aval=aval+1;
a[0]=-3; // Entrada dos intervalos
b[0]=12.1;
a[1]=4.1;
b[1]=5.8;
//...

j=0;
while(j<restart){
j=j+1;
for(k=0;k<N;k++){
n0[k]=v0[k]-viz;
n1[k]=v0[k]+viz;}
for(k=0;k<N;k++){ // Iiniciacao das V1
v1[k]=-10;}
for(k=0;k<N;k++){
while(v1[k]<a[k]||v1[k]>b[k]){
v1[k]=randFloat(n0[k],n1[k]);}
}
80
y1=f(v1,N);
aval=aval+1;
if(y0<y1){
for(k=0;k<N;k++){
v0[k]=v1[k];}
y0=y1;
if(y0>y){
it=aval;
y=y0;
for(k=0;k<N;k++){
v[k]=v0[k];}
}
}
else{
p=randFloat(0,1);
e=expon(y1,y0,T);
if(p<e){
for(k=0;k<N;k++){
v0[k]=v1[k];}
y0=y1;
} // fim if
} // fim do else
}//fim do j
T=alfa*T;
i=i+1;}
for(k=0;k<N;k++){
printf("\nx[%d]=%f",k,v0[k]);}
printf("\nf(x)=%f",y0);
printf("\n\nT=%f",T);
printf("\nem %d iteracoes",i);
printf("\nem %d avaliacoes\n\n\n",aval);
printf(":::: BEST EVER ::::::::::\n\n");
for(k=0;k<N;k++){
printf("\nv[%d]=%f",k,v[k]);}
printf("\nf(x*)=%f",y);
printf("\nna %d avaliacao\n\n\n",it);
fclose(saida);
system("PAUSE");}
81
Anexo G Hbrido Simulated Annealing com Inclinao

Mxima Estratgia 1
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define pi 3.14159
//variaveis globais
float v0[2];
float derivada[2];
FILE *saida;
float derivada[2];
float f(float x[], int N)

{float z;
z = -(21.5 + x[0]*sin(4*pi*x[0]) + x[1]*sin(20*pi*x[1])); /* altere aqui a funcao a ser analisada*/
return z;}
void derivef(float x[], int N){

derivada[0] = -(sin(4*pi*x[0])+4*pi*x[0]*cos(4*pi*x[0])); /* altere aqui a derivada a ser analisada*/
}
{float z;
z=exp(-(x-w)/u);
return z;}
void iniciaRand(){
int stime;
long ltime;
ltime = time(NULL);
srand(stime);
}//fim da inciaRand
/******************************************************************************/
}
82

}
/******************************************************************************/
//Gradientes conjugados
void im(void){
int N=2,i;
float x[N], v[N];
float fmin;
float g[N], d[N], gaux[N];
int n=0,nmax=3;
float e=0.01;
float alpha=0.000001;
float phi0, philinha0=0, phia, large, penultimo;

float a[N], b[N];
int teste, parada=0;
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
//printf("::::::::::: Metodo de Descida ::::::::::::::::::\n\n\n");

b[0]=12.1;
a[1]=4.1;
b[1]=5.8;
//...
for(i=0;i<N;i++){
d[i]=100;}
for(i=0;i<N;i++){
x[i]=v0[i];
}
for(i=0;i<N;i++){
//printf("\nx[%d]:%f",i,x[i]);
}
derivef(x,N);
83
for(i=0;i<N;i++){
g[i]=derivada[i];
gaux[i]=g[i];
if(gaux[i]<0)
gaux[i]=gaux[i]*-1;
if(gaux[i]<e)
parada=parada+1;
}
while(parada!=N && n<nmax ){

parada=0;
phi0=f(x,N);
//printf("\nphi0=%f\n",phi0);
philinha0=0;
for(i=0;i<N;i++){
philinha0 = g[i]*g[i]+ philinha0;}
//printf("\nphilinha=%f\n",philinha0);
for(i=0;i<N;i++){
v[i]=x[i]-alpha*g[i];}
phia=f(v,N);
//printf("\nphia=%f\n",phia);
if (large>=0)
teste=0;
else
teste=1;
if (teste==0){
penultimo=alpha;
alpha=alpha*2;
//printf("\nerro");
for(i=0;i<N;i++){
phia=f(v,N);
alpha=penultimo;
} // FIM SE
84
if(teste==1){
while(large<0){
alpha=alpha/2;
for(i=0;i<N;i++){
phia=f(v,N);
}
// :::::: fim do ARMIJO :::::::::::::::::::::::::
for(i=0;i<N;i++){
x[i] = x[i] - alpha*g[i];
v0[i]=x[i];
}
parada=0;
derivef(x,N);
for(i=0;i<N;i++){
g[i]=derivada[i];
d[i]=g[i];
if(d[i]<e && d[i]>-e)
parada=parada+1;
}
n=n+1;
//printf("\n\n\niteracao numero: %d",n);
//printf("\nalpha:%f",alpha);
for(i=0;i<N;i++){
//printf("\nx[%d]=%f",i,x[i]);
}
for(i=0;i<N;i++){
//printf("\ng[%d]:%f",i,g[i]);
}
fmin=f(x,N);
//printf("\nValor de F=%f",fmin);
} // fim do while
//printf("\n\n::::::::::::::::::::::::RESULTADO::::::::::::::::::::::::::");
if(n==nmax){
//printf("\n\nIteracoes necessarias=%d(maximo possivel)\n\n", n);
}
if (n<nmax){
//printf("\n\nIteracoes necessarias=%d\n\n ", n);
}
85
} // fim da inclinacao maxima

/******************************************************************************/
//Programa Principal
main(){
int N =2;
float v1[N], v[N], y0, y1, y, p, e, n0[N], n1[N]; // n sao auxiliares para viz
float a[N], b[N];
int aval=0, it=0;
//_____________________ SA ____________________________________________________
printf("Inicio SA\n\n");
//system("pause");
iniciaRand();
v0[1]=5;
//v0[2]=0;
//...

y=y0;
// fprintf(saida,"\n%f",y0);
aval=aval+1;
b[0]=12.1;
a[1]=4.1;
b[1]=5.8;
//...

// printf("========SIMULATED ANNEALING========\n\n");
// printf("iteracao %d\n",i);
// printf("solucao inicial para o simulated annealing\n");
for(j=0;j<N;j++){
86
//
printf("%f ",v0[j]);
}
// printf("\n");
//system("pause");
j=0;
while(j<restart){
// printf("j = %d\n",j);
j=j+1;
for(k=0;k<N;k++){
n0[k]=v0[k]-viz;
n1[k]=v0[k]+viz;}
v1[k]=-10;}
for(k=0;k<N;k++){
}
//
printf("avaliacao da f\n");
y1=f(v1,N);
// printf("f = %f\n",y1);
aval=aval+1;
// printf("numero de avaliacoes\n");
if(y0>y1){
for(k=0;k<N;k++){
v0[k]=v1[k];
}
y0=y1;
//
//
}
else{
p=randFloat(0,1);
e=expon(y1,y0,T);
if(p<e){
for(k=0;k<N;k++){
v0[k]=v1[k];}
y0=y1;
} // fim if
} // fim do else
}//fim do j
printf("Solucao final para o Simulated Annealing\n");
for(j=0;j<N;j++){
printf("\nantes do gc\nv[%d]=%f f=%f",j,v0[j],y0);
87
}
//
printf("\n");
//system("pause");
// chamar Gradientes Conjugados
/*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
im();
/*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
//printf("\nsaiu do GC\n");
y0=f(v0,N);
for(j=0;j<N;j++){
printf("\ndepois do gc\nv0[%d]=%f f=%f",j,v0[j],y0);
}
for(k=0;k<N;k++){
if(v0[k]<a[k]){
//
printf("o gc encontrou um ponto fora do dominio\n\n\n\n");
v0[k]=a[k];
}
if(v0[k]>b[k]){
//
v0[k]=b[k];
}
}
y0=f(v0,N);
if(y0<y){
it=aval;
y=y0;
for(k=0;k<N;k++){
v[k]=v0[k];}
}
T=alfa*T;
i=i+1;}
printf("\n\n:::::: BEST EVER HIBRIDO::::::::::\n\n");

for(k=0;k<N;k++){
printf("\nf(x*)=%f",-y);
printf("\nna %d avaliacao",it);
printf("\nT=%f",T);
fclose(saida);
system("PAUSE");}
88
Anexo H - Hbrido Simulated Annealing com Inclinao

Mxima Estratgia 2
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define pi 3.14159
//variaveis globais
float v0[2];
float derivada[2];
FILE *saida;
float derivada[2];
float f(float x[], int N)

{float z;
z = -(21.5 + x[0]*sin(4*pi*x[0]) + x[1]*sin(20*pi*x[1])); /* altere aqui a funcao a ser analisada*/
return z;}
void derivef(float x[], int N){

}
{float z;
z=exp(-(x-w)/u);
return z;}
void iniciaRand(){
int stime;
long ltime;
ltime = time(NULL);
srand(stime);
}//fim da inciaRand
/******************************************************************************/
}
89
/******************************************************************************/
void im(void){
int N=2,i;
float x[N], v[N];
float fmin;
float g[N], d[N], gaux[N];
int n=0,nmax=3;
float e=0.01;
float alpha=0.000001;
float phi0, philinha0=0, phia, large, penultimo;

float a[N], b[N];
int teste, parada=0;
//printf("::::::::::: Metodo de Descida ::::::::::::::::::\n\n\n");

b[0]=12.1;
a[1]=4.1;
b[1]=5.8;
//...
for(i=0;i<N;i++){
d[i]=100;}
for(i=0;i<N;i++){
x[i]=v0[i];
}
for(i=0;i<N;i++){
//printf("\nx[%d]:%f",i,x[i]);
}
derivef(x,N);
for(i=0;i<N;i++){
g[i]=derivada[i];
gaux[i]=g[i];
90
if(gaux[i]<0)
gaux[i]=gaux[i]*-1;
if(gaux[i]<e)
parada=parada+1;
}
while(parada!=N && n<nmax ){

parada=0;
phi0=f(x,N);
//printf("\nphi0=%f\n",phi0);
philinha0=0;
for(i=0;i<N;i++){
philinha0 = g[i]*g[i]+ philinha0;}
//printf("\nphilinha=%f\n",philinha0);
for(i=0;i<N;i++){
phia=f(v,N);
//printf("\nphia=%f\n",phia);
if (large>=0)
teste=0;
else
teste=1;
if (teste==0){
penultimo=alpha;
alpha=alpha*2;
//printf("\nerro");
for(i=0;i<N;i++){
phia=f(v,N);
alpha=penultimo;
} // FIM SE
if(teste==1){
while(large<0){
91
alpha=alpha/2;
for(i=0;i<N;i++){
phia=f(v,N);
}
// :::::: fim do ARMIJO :::::::::::::::::::::::::

for(i=0;i<N;i++){
x[i] = x[i] - alpha*g[i];
v0[i]=x[i];
}
parada=0;
derivef(x,N);
for(i=0;i<N;i++){
g[i]=derivada[i];
d[i]=g[i];
if(d[i]<e && d[i]>-e)
parada=parada+1;
}
n=n+1;
//printf("\n\n\niteracao numero: %d",n);
//printf("\nalpha:%f",alpha);
for(i=0;i<N;i++){
//printf("\nx[%d]=%f",i,x[i]);
}
for(i=0;i<N;i++){
//printf("\ng[%d]:%f",i,g[i]);
}
fmin=f(x,N);
//printf("\nValor de F=%f",fmin);
} // fim do while
//printf("\n\n::::::::::::::::::::::::RESULTADO::::::::::::::::::::::::::");
if(n==nmax){
//printf("\n\nIteracoes necessarias=%d(maximo possivel)\n\n", n);
}
if (n<nmax){
//printf("\n\nIteracoes necessarias=%d\n\n ", n);
}
92
} // fim da inclinacao maxima

/******************************************************************************/
main(){
int N =2;
float a[N], b[N];
int aval=0, it=0;
//_____________________ SA ____________________________________________________
//system("pause");
iniciaRand();
v0[1]=5;
//v0[2]=0;
//...

y=y0;
aval=aval+1;
b[0]=12.1;
a[1]=4.1;
b[1]=5.8;
//...

93

for(j=0;j<N;j++){
//
}
// printf("\n");
//system("pause");
j=0;
while(j<restart){
j=j+1;
for(k=0;k<N;k++){
n0[k]=v0[k]-viz;
n1[k]=v0[k]+viz;}
v1[k]=-10;}
for(k=0;k<N;k++){
}
//
y1=f(v1,N);
aval=aval+1;
if(y0>y1){
for(k=0;k<N;k++){
v0[k]=v1[k];
}
y0=y1;
if(y0<y){
it=aval;
y=y0;
for(k=0;k<N;k++){
v[k]=v0[k];}
}
//
}
else{
p=randFloat(0,1);
e=expon(y1,y0,T);
if(p<e){
for(k=0;k<N;k++){
v0[k]=v1[k];}
y0=y1;
94
} // fim if
} // fim do else
}//fim do j
T=alfa*T;
i=i+1;}
printf("\n::::::::: BEST EVER no SA::::::::::\n\n");

for(k=0;k<N;k++){
printf("\nT=%f",T);
printf("\ntotal aval=%d",aval);
for(j=0;j<N;j++){
v0[j]=v[j];}
// chamar Inclinacao Maxima
im();
for(k=0;k<N;k++){
if(v0[k]<a[k]){
v0[k]=a[k];
}
if(v0[k]>b[k]){
v0[k]=b[k];
}
}
printf("\n\n:::: BEST EVER no HIBRIDO::::::::::\n\n");
for(k=0;k<N;k++){
printf("\nv[%d]=%f",k,v0[k]);}
y=f(v0,N);
printf("\nf(x*)=%f\n\n",-y);
fclose(saida);
system("PAUSE");}
95
Anexo I - Hbrido Simulated Annealing com Gradientes

Conjugados Estratgia 1
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define pi 3.14159
//variaveis globais
float v0[2];
FILE *saida;
{float z;
z = -(21.5 + x[0]*sin(4*3.1415*x[0]) + x[1]*sin(20*3.1415*x[1])); /* altere aqui a funcao a ser
analisada*/
return z;}
{float z;
z = -(sin(4*pi*u)+4*pi*u*cos(4*pi*u)); /* altere aqui a derivada a ser analisada*/
return z;}
{float z;
z = -(sin(20*pi*w)+20*pi*w*cos(20*pi*w)); /* altere aqui a derivada a ser analisada*/
return z;}
{float z;
z=exp(-(x-w)/u);
return z;}
void iniciaRand(){
int stime;
long ltime;
ltime = time(NULL);
srand(stime);
}//fim da inciaRand
/******************************************************************************/
}
96
/******************************************************************************/
void gc(void){
float x[2][1],xaux[2][1], xdif[2][1],vet[2];
float Q[2][2];
float gt[1][2], dt[1][2],ffinal;
double num_alpha, den_alpha, alpha, num_beta, den_beta, beta, e=0.01;
double denaux_alpha[1][2], numaux_beta[1][2];
int n=0,nmax=2,i,j,k, teste=0, restart=0,iter=1,itermax=3;
//printf("\nentrou no GC\n");
//printf("::::::::::: x^2 - 5xy + y^4 - 25x - 8y
::::::::::::::::::\n\n\n");
//for(i=0;i<=1;i++){ // Vetor inicial x

// printf("solucao inicial para o gradientes conjugados\n");
for(j=0;j<=1;j++){
x[j][0]=v0[j];
// printf("%f " ,x[j][0]);
//printf("\nEntre com X[%d%d]:",i,j);
//
}
// printf("\n");
// system("pause");

if(derivada[0][0]<0)
derivada[0][0]=derivada[0][0]*(-1);
if(derivada[0][1]<0)
derivada[0][1]=derivada[0][1]*(-1);
if(derivada[0][0]<e && derivada[0][1]<e){
teste=1;
printf("\nsaiu por causa da derivada\n");
}
while(teste==0){
// printf("\n NUMERO DE ITERAES:%d",iter);
// printf("\nRESTART:%d",restart);
97


for(j=0;j<=1;j++){
d[0][0]= -1*g[0][0];
d[1][0]= -1*g[1][0];
n=0;
while(n<nmax ){
// printf("\ninteracao:%d",n);
Q[0][0]=-(cos(4*pi*x[0][0])*4*pi+4*pi*cos(4*pi*x[0][0])+x[0][0]*pow(4*pi,2)*(-sin(4*pi*x[0][0])));
Q[0][1]=0;
Q[1][0]=0;
// :::::::::::::::::::::::: Calcula ALPHA ::::::::::::::::::::
for(j=0;j<1;j++){

for(j=0;j<1;j++){
num_alpha = 0;
for(k=0;k<=1;k++){
for(j=0;j<1;j++){
// Calculo de dt*Q
for(i=0;i<1;i++){
for(j=0;j<=1;j++){
for(k=0;k<=1;k++){
for(i=0;i<1;i++){
for(j=0;j<1;j++){
den_alpha = 0;
for(k=0;k<=1;k++){
98
// Calculo alpha
alpha = -1*(num_alpha/den_alpha);
// printf("\n\nalpha=%f",alpha);
//:::::::::::::: FIM ALPHA ::::::::::::::
// ::::::::::::::::::: CALCULO DO X ::::::::::::::::::::::::::::::::::::::
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
xaux[i][j] = x[i][j] ;}}
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
x[i][j] = x[i][j] + alpha*d[i][j];}}
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
if(xdif[i][j]<0)
}}

//:::::::::::::::Calc do Gk+1 ::::::::::::::::::::::::::::::::::::
for(j=0;j<=1;j++){
//::::::::::::::::FIM De Gk+1 ::::::::::::::::::::::::::::::::::::::::::::
// :::::::::::::: Calculo BETA ::::::::::::::::::::::::::::::
for(j=0;j<1;j++){
// Calculo de gt*Q
for(i=0;i<1;i++){
for(j=0;j<=1;j++){
for(k=0;k<=1;k++){
99
for(i=0;i<1;i++){
for(j=0;j<1;j++){
num_beta = 0;
for(k=0;k<=1;k++){
//:::::::::::::: FIM BETA ::::::::::::::::::::::::::::::
//:::::::::::::: CALCULA NOVO D ::::::::::::::::::::::::::::::
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
d[i][j]= -1*g[i][j]+ beta*d[i][j];}}
// ::::::::::::::::::: FIM D ::::::::::::::::::::::::::::::::::::::::::
n=n+1;}
// printf("\nx=%f\ny=%f\n\n",x[0][0],x[1][0]);
if((xdif[0][0]<e && xdif[1][0]<e)||(iter>itermax))
teste=1;
restart=restart+1;
iter=iter+1;
}
//printf("\n\nPonto maximo encontrado\nx=%f\ny=%f\n\n",x[0][0],x[1][0]);

vet[0]=x[0][0];
vet[1]=x[1][0];
ffinal=-1*f(vet,2);
//printf("\n\nValor da f no ponto maximo = %f\n\n",ffinal);
// system("pause");
//atualiza variavel v0
for(i=0;i<=1;i++){
v0[i]=x[i][0];
}
} // fim gradientes conjugados

/******************************************************************************/
100
main(){
int N =2;
float a[N], b[N];
int aval=0, it=0;
//_____________________ SA ____________________________________________________
//system("pause");
iniciaRand();
v0[1]=5;
//v0[2]=0;
//...

y=y0;
aval=aval+1;
b[0]=12.1;
a[1]=4.1;
b[1]=5.8;
//...

for(j=0;j<N;j++){
//
}
// printf("\n");
101
//system("pause");
j=0;
while(j<restart){
j=j+1;
for(k=0;k<N;k++){
n0[k]=v0[k]-viz;
n1[k]=v0[k]+viz;}
v1[k]=-10;}
for(k=0;k<N;k++){
}
//
y1=f(v1,N);
aval=aval+1;
if(y0>y1){
for(k=0;k<N;k++){
v0[k]=v1[k];
}
y0=y1;
//
}
else{
p=randFloat(0,1);
e=expon(y1,y0,T);
if(p<e){
for(k=0;k<N;k++){
v0[k]=v1[k];}
y0=y1;
} // fim if
} // fim do else
}//fim do j
printf("Solucao final para o Simulated Annealing\n");
for(j=0;j<N;j++){
printf("\nantes do gc\nv[%d]=%f",j,v0[j]);
}
// printf("\n");
//system("pause");
//
102
gc();
//printf("\nsaiu do GC\n");
for(j=0;j<N;j++){
printf("\ndepois do gc\nv0[%d]=%f",j,v0[j]);
}
for(k=0;k<N;k++){
if(v0[k]<a[k]){
//
v0[k]=a[k];
}
if(v0[k]>b[k]){
//
v0[k]=b[k];
}
}
y0=f(v0,N);
if(y0<y){
it=aval;
y=y0;
for(k=0;k<N;k++){
v[k]=v0[k];}
}
T=alfa*T;
i=i+1;}
printf("\n\n:::::: BEST EVER HIBRIDO::::::::::\n\n");

for(k=0;k<N;k++){
printf("\nT=%f",T);
fclose(saida);
system("PAUSE");}
103
Anexo J - Hbrido Simulated Annealing com Gradientes

Conjugados Estratgia 2
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define pi 3.14159
//variaveis globais
float v0[2];
FILE *saida;
{float z;
z = -(21.5 + x[0]*sin(4*3.1415*x[0]) + x[1]*sin(20*3.1415*x[1])); /* altere aqui a funcao a ser
analisada*/
return z;}
{float z;
z = -(sin(4*pi*u)+4*pi*u*cos(4*pi*u)); /* altere aqui a derivada a ser analisada*/
return z;}
{float z;
z = -(sin(20*pi*w)+20*pi*w*cos(20*pi*w)); /* altere aqui a derivada a ser analisada*/
return z;}
{float z;
z=exp(-(x-w)/u);
return z;}
void iniciaRand(){
int stime;
long ltime;
ltime = time(NULL);
srand(stime);
}//fim da inciaRand
/******************************************************************************/
}
104
/******************************************************************************/
void gc(void){
float x[2][1],xaux[2][1], xdif[2][1],vet[2];
float Q[2][2];
float gt[1][2], dt[1][2],ffinal;
double num_alpha, den_alpha, alpha, num_beta, den_beta, beta, e=0.001;
double denaux_alpha[1][2], numaux_beta[1][2];
int n=0,nmax=2,i,j,k, teste=0, restart=0,iter=1,itermax=100;
printf("\n::::::::::: Metodo GRADIENTE CONJUGADO NAO QUADRATICO ::::::::::::::::::\n");

//printf("::::::::::: x^2 - 5xy + y^4 - 25x - 8y
::::::::::::::::::\n\n\n");
//for(i=0;i<=1;i++){ // Vetor inicial x
// printf("solucao inicial para o gradientes conjugados\n");
for(j=0;j<=1;j++){
x[j][0]=v0[j];
// printf("%f " ,x[j][0]);
//printf("\nEntre com X[%d%d]:",i,j);
//
}
// printf("\n");
// system("pause");
while(teste==0){
// printf("\n NUMERO DE ITERAES:%d",iter);
// printf("\nRESTART:%d",restart);
for(j=0;j<=1;j++){
d[0][0]= -1*g[0][0];
d[1][0]= -1*g[1][0];
n=0;
while(n<nmax ){
//
105

Q[0][1]=0;
Q[1][0]=0;
// :::::::::::::::::::::::: Calcula ALPHA ::::::::::::::::::::
for(j=0;j<1;j++){

for(j=0;j<1;j++){
num_alpha = 0;
for(k=0;k<=1;k++){
for(j=0;j<1;j++){
// Calculo de dt*Q
for(i=0;i<1;i++){
for(j=0;j<=1;j++){
for(k=0;k<=1;k++){
for(i=0;i<1;i++){
for(j=0;j<1;j++){
den_alpha = 0;
for(k=0;k<=1;k++){
// Calculo alpha
alpha = (-1)*(num_alpha/den_alpha);
// printf("\n\nalpha=%f",alpha);
//:::::::::::::: FIM ALPHA ::::::::::::::
// ::::::::::::::::::: CALCULO DO X ::::::::::::::::::::::::::::::::::::::
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
xaux[i][j] = x[i][j] ;}}
for(i=0;i<=1;i++){
for(j=0;j<1;j++){
106
x[i][j] = x[i][j] + alpha*d[i][j];}}

for(i=0;i<=1;i++){
for(j=0;j<1;j++){
if(xdif[i][j]<0)
}}

//:::::::::::::::Calc do Gk+1 ::::::::::::::::::::::::::::::::::::
for(j=0;j<=1;j++){
//::::::::::::::::FIM De Gk+1 ::::::::::::::::::::::::::::::::::::::::::::
// :::::::::::::: Calculo BETA ::::::::::::::::::::::::::::::
for(j=0;j<1;j++){
// Calculo de gt*Q
for(i=0;i<1;i++){
for(j=0;j<=1;j++){
for(k=0;k<=1;k++){
for(i=0;i<1;i++){
for(j=0;j<1;j++){
num_beta = 0;
for(k=0;k<=1;k++){
//:::::::::::::: FIM BETA ::::::::::::::::::::::::::::::
//:::::::::::::: CALCULA NOVO D ::::::::::::::::::::::::::::::
for(i=0;i<=1;i++){
107
for(j=0;j<1;j++){
d[i][j]= -1*g[i][j]+ beta*d[i][j];}}
// ::::::::::::::::::: FIM D ::::::::::::::::::::::::::::::::::::::::::
n=n+1;}
// printf("\nx=%f\ny=%f\n\n",x[0][0],x[1][0]);
if((xdif[0][0]<e && xdif[1][0]<e)||(iter>itermax))
teste=1;
restart=restart+1;
iter=iter+1;}
//printf("\n\nPonto maximo encontrado\nx=%f\ny=%f\n\n",x[0][0],x[1][0]);

vet[0]=x[0][0];
vet[1]=x[1][0];
ffinal=-1*f(vet,2);
//printf("\n\nValor da f no ponto maximo = %f\n\n",ffinal);
// system("pause");
//atualiza variavel v0
for(i=0;i<=1;i++){
v0[i]=x[i][0];
}
} // fim gradientes conjugados
/******************************************************************************/
main(){
int N =2;
float a[N], b[N];
int aval=0, it=0;
//_____________________ SA ____________________________________________________
108
printf("Inicio SA\n");
//system("pause");
iniciaRand();
v0[1]=5;
//v0[2]=0;
//...

y=y0;
aval=aval+1;
b[0]=12.1;
a[1]=4.1;
b[1]=5.8;
//...

//printf("========SIMULATED ANNEALING========\n\n");
//printf("iteracao %d\n",i);
//printf("solucao inicial para o simulated annealing\n");
/* for(j=0;j<N;j++){
printf("%f ",v0[j]); */
//}
//printf("\n");
//system("pause");
j=0;
while(j<restart){
j=j+1;
for(k=0;k<N;k++){
n0[k]=v0[k]-viz;
n1[k]=v0[k]+viz;}
v1[k]=-10;}
for(k=0;k<N;k++){
}
// printf("avaliacao da f\n");
y1=f(v1,N);
//printf("f = %f\n",y1);
109
aval=aval+1;
if(y0>y1){
for(k=0;k<N;k++){
v0[k]=v1[k];
}
y0=y1;
if(y0<y){
it=aval;
y=y0;
for(k=0;k<N;k++){
v[k]=v0[k];}
}
}
else{
p=randFloat(0,1);
e=expon(y1,y0,T);
if(p<e){
for(k=0;k<N;k++){
v0[k]=v1[k];}
y0=y1;
} // fim if
} // fim do else
}//fim do j
T=alfa*T;
i=i+1;}
printf("\n::::::::: BEST EVER no SA::::::::::\n\n");

for(k=0;k<N;k++){
printf("\nT=%f",T);
printf("\ntotal aval=%d",aval);
for(j=0;j<N;j++){
v0[j]=v[j];}
110
gc();
for(k=0;k<N;k++){
if(v0[k]<a[k]){
v0[k]=a[k];
}
if(v0[k]>b[k]){
v0[k]=b[k];
}
}
printf("\n\n:::: BEST EVER no HIBRIDO::::::::::\n\n");
for(k=0;k<N;k++){
printf("\nv[%d]=%f",k,v0[k]);}
y=f(v0,N);
printf("\nf(x*)=%f\n\n",-y);
fclose(saida);
system("PAUSE");}
111

Nery RS

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Nery RS

Enviado por

Direitos autorais:

Formatos disponíveis

UNIVERSIDADE DE SO PAULO

FACULDADE DE FILOSOFIA, CINCIAS E LETRAS DE RIBEIRO PRETO

Mtodos Hbridos para Resoluo de Problemas de

RIBEIRO PRETO, NOVEMBRO DE 2007

RAPHAEL SANTUCCI NERY

Mtodos Hbridos para Resoluo de Problemas de

Monografia de concluso do curso de

RIBEIRO PRETO, NOVEMBRO DE 2007

8.2 Implementao do Simulated Annealing.................................................................... 44

Palavras-chave: Otimizao. Busca Global. Simulated Annealing. Meta-heurstica.

comparao dos resultados

Escrita e Reviso do TCC

Descrio das etapas de estudo

Estudo e implementao de mtodos

Testes com um problema prtico e

Estudo das propriedades bsicas de solues e algoritmos, envolvendo os

Estudos e implementao do Simulated Annealing para obteno do timo

Implementao de mtodos hbridos

Testes extensivos dos mtodos implementados.

otimizao restrita sero estudados os mtodos dos multiplicadores de Lagrange e

A formulao geral para um problema de otimizao

por otimizar entenda-se maximizar ou minimizar. A funo f(x1,x2,...,xn)

Figura 1 - Ilustrao de pontos extremos: P1 e P7: de borda, P2: mximo local,

Figura 2 - Exemplo de funo (a) convexa, (b) no-convexa.

Os mtodos iterativos para otimizao no-linear, em geral, partem de um ponto inicial

dk = f(xk) para maximizao

Neste contexto, destaca-se o mtodo Simulated Annealing (SA) ou recozimento

Annealing com gradientes conjugados.

5.1 Mtodos Unidimensionais Irrestritos

5.1.1 Mtodo de Fibonacci Fibonacci Search Method

Este mtodo determina o valor mnimo de uma funo f unimodal (apenas um

incerteza ser reduzida ao intervalo [c k 1 , c k +1 ] centrado em x k , sendo o ponto de mnimo

Os dois primeiros pontos so medidos simetricamente uma distncia de

d1 a partir das extremidades do intervalo inicial, de acordo com qual desses

O terceiro ponto medido simetricamente no novo intervalo de incerteza

com respeito aos pontos j no intervalo. O resultado o novo intervalo de incerteza

Assim, em geral, cada ponto sucessivo colocado no intervalo de incerteza atual

Abaixo apresentado o algoritmo deste mtodo:

5.1.2 Mtodo da Razo urea Search By Golden Section

5.1.3 Busca por ajuste de curva

Tanto o Mtodo de Fibonacci quanto o Mtodo da Razo urea no exploram as

Mtodo de Newton Newtons Method

onde o termo da direita corresponde ao erro local de truncamento.

Nota-se imediatamente que o novo ponto x k +1 no depende de f ( x k ) .

O Mtodo de Newton tem ordem de convergncia de pelo menos 2.

Mtodo da Falsa Posio Method of False Position

( f ( x k )) , ou seja, diferenas regressivas para a derivada primeira.

Assim como no Mtodo de Newton, encontra-se uma aproximao para o ponto de

Embora no Mtodo da Falsa Posio no se tem necessidade de utilizar-se do valor

Ajuste Cbico Cubic Fit

Ajuste Quadrtico Quadratic Fit

Dados x1 , x 2 e x3 e os valores correspondentes f ( x1 ) = f1 , f (x 2 ) = f 2 e f ( x3 ) = f 3

e a partir da podemos determinar o prximo ponto x 4 onde a derivada de q ( x ) se anula:

1 b23 f 1 + b31 f 2 + b12 f 3

e ainda mais, este mtodo tem ordem de convergncia de aproximadamente 1,3.

5.2 Critrios de Parada de uma Busca Unidimensional

5.2.1 Teste da Porcentagem

Este teste consiste em estabelecer uma proporo pr-fixada do valor verdadeiro. O

e uma constante c tal que 0 < c < 1 .

5.2.2 Critrio de Armijo

Para saber se o parmetro selecionado no to pequeno, um valor > 1

( ) > (0) + (0)

5.2.3 Teste de Goldstein