Aplicação de Algoritmos Genéticos

UNIVERSIDADE FEDERAL DE MINAS GERAIS
Curso de Ps Graduao em Engenharia Metalrgica e de Minas
Dissertao de Mestrado
Aplicao de algoritmos genticos na determinao

de cava final e sequenciamento de lavra
em minas a cu aberto
Autor: Octvio Rosa de Almeida Guimares

Orientadora: Professora Maria de Ftima Gripp
Fevereiro/2007
UNIVERSIDADE FEDERAL DE MINAS GERAIS

Curso de Ps Graduao em Engenharia Metalrgica e de Minas
Octvio Rosa de Almeida Guimares
APLICAO DE ALGORITMOS GENTICOS

NA DETERMINAO DE CAVA FINAL E
SEQENCIAMENTO DE LAVRA EM MINAS A CU ABERTO
Dissertao de Mestrado apresentada ao Curso de PsGraduao em Engenharia Metalrgica e de Minas da

Universidade Federal de Minas Gerais
rea de concentrao: Tecnologia Mineral

Orientadora: Professora Maria de Ftima Gripp
Belo Horizonte
Escola de Engenharia da UFMG
Fevereiro/2007
Folha de aprovao
A meus pais,
pela educao e oportunidade.
A minha esposa Lu,
pelo apoio e pacincia.
A meus filhos Ana Cristina e Vinicius,
pelas alegrias e inspiraes.
AGRADECIMENTOS:
O autor agradece a todos aqueles que, direta ou indiretamente, colaboraram na
preparao deste trabalho e, em particular:
Professora Maria de Ftima Gripp pela competncia, clareza e objetividade
na orientao deste estudo.
Aos professores da UFMG Ricardo Takahashi e Joo Vasconcelos pelos
esclarecimentos durante as aulas de otimizao multiobjetivo e pelas opinies na
elaborao dos algoritmos implementados.
Aos professores do Departamento de Engenharia de Minas da UFMG Antonio
Carlos Girodo, George Eduardo Sales Valado e ao amigo Beck Nader pela indicao
junto ao Centro de Ps Graduao em Engenharia Metalrgica e de Minas - CPGEM.
Aos demais professores e colaboradores do Departamento de Engenharia de
Minas e Metalrgica da UFMG, bem como aos colaboradores do CPGEM,
pela
ateno, apoio e contribuio a minha formao profissional.

Companhia Vale do Rio Doce e Gemcom do Brasil, nas pessoas dos
Gelogos Marcelo Rossi e Hildegundes Silva, e dos Engenheiros Fabiano Arajo,
Maurlio Botelho, Paulo Sachs e Marcos Rittner, pela oportunidade e apoio.
Aos colegas de profisso Charles Henrique Sales Valado, Josimar Souza
Pires, Joaquim Pedro de Toledo e Antonio Carlos Girodo pela motivao e inspirao.
Ao Matemtico Computacional Alexandre Marinho pelas sugestes de
programao e auxlio na codificao dos programas.
amiga Solange Nobre pelo interesse, disponibilidade, ateno e ajuda na
reviso final.
SUMRIO
Lista de figuras ..............................................................................................................
xi
Lista de tabelas .............................................................................................................
xiv
Resumo .........................................................................................................................
xv
Abstract .........................................................................................................................
xvi
1 Introduo e objetivos ................................................................................................
2 Reviso Bibliogrfica ..................................................................................................
2.1 Descrio sumria de mtodos de otimizao de cava final .........................
2.1.1 O algoritmo de Lerchs-Grossmann .........................................................
2.1.2 Mtodo dos cones flutuantes ...................................................................
2.1.3 Parametrizao tcnica de reservas .......................................................
2.2 Aplicao de algoritmos genticos no planejamento de mina .......................
2.3 Otimizao Multiobjetivo ................................................................................
2.4 Elementos de um algoritmo gentico ............................................................
10
2.4.1 Codificao ..............................................................................................
11
2.4.2 Populao inicial ......................................................................................
12
2.4.3 Avaliao e aptido .................................................................................
12
2.4.4 Seleo ....................................................................................................
15
2.4.5 Recombinao .........................................................................................
20
2.4.6 Mutao ...................................................................................................
22
2.4.7 Penalidades e restries..........................................................................
24
2.4.8 Definio dos parmetros ........................................................................
25
2.4.9 Critrios de Parada ..................................................................................
26
2.5 Otimizao multiobjetivo utilizando algoritmos genticos ...........................
27
2.5.1 Descrio do Algoritmo NSGA .................................................................
28
3 Metodologia ................................................................................................................
34
3.1 Processo de Modelagem ..................................................................................
34
3.2 Definio dos problemas ..................................................................................
35
3.3 Construo dos modelos de blocos tericos ....................................................
35
3.4 Codificao das rotinas computacionais para os problemas propostos ...........
36
3.5 Validao dos algoritmos ..................................................................................
37
4 Descrio dos algoritmos e programas de computador codificados .........................
38
4.1 Cdigos implementados ....................................................................................
38
4.2 Descrio do algoritmo gentico simples (AGS) com elitismo em VBA ...........
39
4.2.1 Caractersticas Gerais ................................................................................
39
4.2.2 Interface de parmetros ..............................................................................
40
4.2.2.1 Modelo de Blocos .................................................................................
41
4.2.2.2 Parmetros de controle de loop ...........................................................
41
4.2.3 Resultados ..................................................................................................
42
4.2.3.1 Modelo Lido ..........................................................................................
42
4.2.3.2 Visualizao sees verticais ................................................................ 42
4.2.3.3 Planilhas auxiliares ...............................................................................
43
4.2.3.4 Planilha de Resultados .........................................................................
43
4.2.3.5 Sees verticais cava final ...................................................................
43
4.3 Descrio programa NSGA VBA ..................................................................
44
4.3.1 Caractersticas Gerais ................................................................................
44
4.3.2 Descrio das funes de teste utilizadas ..................................................
44
4.3.3 Parmetros de entrada ...............................................................................
46
4.3.4 Resultados ..................................................................................................
47
4.4 Descrio do programa EvolPit Delphi ..........................................................
47
4.4.1 Caractersticas gerais .................................................................................
47
4.4.2 Parmetros de entrada ...............................................................................
49
4.4.2.1 Interface dos parmetros de entrada ...................................................
49
4.4.2.2 Modelo de Blocos .................................................................................
50
4.4.2.3 Opes de Otimizao .........................................................................
50
4.4.2.4 Gerao da populao inicial ...............................................................
51
4.4.2.5 Parmetros de controle de loop ...........................................................
53
4.4.2.6 Parmetros de nicho ............................................................................
53
4.4.2.7 Opes de cruzamento e adaptao dinmica ....................................
53
4.4.2.8 Opes de mutao e seleo .............................................................
53
4.4.2.9 Opes de restries ............................................................................
60
4.4.3 Resultados ..................................................................................................
61
4.4.3.1 Visualizao das informaes do modelo de blocos processado ........
61
4.4.3.2 Histogramas dos blocos de minrio .....................................................
62
4.4.3.3 Resultados de todos os indivduos da populao por gerao ............
63
4.4.3.4 Visualizao dos blocos lavrados atravs de sees verticais ............
64
4.4.3.5 Grficos de evoluo do AG .................................................................
65
4.4.3.6 Resumo dos resultados para mais de um cenrio de lavra .................
67
4.4.3.7 Grfico dos resultados da otimizao multiobjetivo (Ob.1 x Ob.2) .......
68
5 Resultados dos algoritmos genticos implementados ..............................................
69
5.1 Testes e resultados encontrados AGS VBA ..................................................
69
5.1.1 Concluses dos resultados do AGS com elitismo VBA ..............................
74
5.2 Testes e resultados encontrados problema mono-objetivo - Evolpit Delphi ...
74
5.2.1 Concluses dos resultados do problema mono-objetivo - Evolpit Delphi .. 84

5.3 Testes e resultados para problema mono-objetivo com restries- Evolpit ......
85
5.3.1 Concluses para problema mono-objetivo com restries- Evolpit ............
88
5.4 Resultados do algoritmo gentico multiobjetivo NSGA VBA .........................
88
5.4.1 Testes e resultados encontrados das funes de teste ..............................
88
5.4.1.1 Concluses dos resultados encontrados das funes de teste ............
90
5.4.2 Resultados do algoritmo NSGA problema multiobjetivo VBA ..................
91
5.4.2.1 Concluses do algoritmo NSGA problema multiobjetivo VBA ..............
96
5.4.3 Resultados do algoritmo NSGA problema multiobjetivo Evolpit Delphi .... 98

5.4.3.1 Concluses do algoritmo NSGA problema mult. Evolpit Delphi ........
100
6 Concluses e trabalhos futuros ..................................................................................
101
7 Referncias bibliogrficas ...........................................................................................
102
8 Anexos ........................................................................................................................
108
8.1 Anexo I - Listagem do programa algoritmo gentico simples com elitismo .......
108
8.2 Anexo II - Listagem do programa multiobjetivo NSGA com elitismo .................
127
Lista de Figuras
Figura 1.1 Representao de um modelo de blocos .................................................
Figura 2.1.1.1 Modelo de blocos inicial valorizado economicamente ........................
Figura 2.1.1.2 Modelo de blocos econmico final ............................................. ........
Figura 2.1.1.3 Limite otimizado superposto ao modelo de blocos .............................
Figura 2.4.4.1 Representao do esquema de seleo da roleta ..................... ........
18
Figura 2.4.5.1 Cruzamento de um ponto ........................................................... ........
21
Figura 2.4.6.1 Mutao na codificao binria .................................................. ........
23
Figura 2.5.1.1 Fluxograma NSGA (Dias, 2000) ................................................. ........
31
Figura 3.1.1 Fluxograma do processo de modelagem ...............................................
34
Figura 4.2.2.1 Interface AGS (VBA) ...........................................................................
40
Figura 4.2.3.2.1 Modelo de blocos lido AGS (VBA) ...................................................
42
Figura 4.2.3.5.1 Seo vertical AGS (VBA) ...............................................................
43
Figura 4.3.2.1 Grfico da funo Schafferf2 no espao das variveis ......................
44
Figura 4.3.2.2 Grfico da funo Schafferf3 no espao das variveis ......................
45
Figura 4.3.2.3 Grfico da funo Schafferf2 no espao dos objetivos ......................
45
Figura 4.3.2.4 Funo Schafferf3 no espao dos objetivos ............................... .......
46
Figura 4.3.3.1 Interface NSGA (VBA) ................................................................ .......
46
Figura 4.3.4.1 Resultados grficos NSGA (VBA) .............................................. .......
47
Figura 4.4.2.1 Interface parmetros de entrada (Evolpit) .................................. .......
49
Figura 4.4.3.1.1 Modelo de blocos processado (Evolpit) ................................... .......
61
Figura 4.4.3.2 1 Histogramas dos blocos de valores monetrios positivos ....... .......
62
Figura 4.4.3.3.1 Resultados de todos os indivduos da populao por gerao .......
63
Figura 4.4.3.4.1 Visualizao dos blocos lavrados (Evolpit) ............................. ........
64
Figura 4.4.3.5.1 Grfico de evoluo (Evolpit) ...........................................................
65
Figura 4.4.3.5.2 Grfico de evoluo AG com diferentes resolues (Evolpit) ..........
66
Figura 4.4.3.6.1 Resumo dos resultados para mais de um cenrio de lavra .............
67
Figura 4.4.3.7.1 Grfico dos resultados da otimizao mult. (Recurso X Valor) .......
68
Figura 5.1.1 Grfico de % timo do tamanho da populao (AGS 1 Seo) .........
70
Figura 5.1.2 Grfico de % acerto do nmero de geraes (AGS 1 Seo) ...........
70
Figura 5.1.3 Grfico de % timo da probabilidade cruzamento (AGS 1 Seo) ....
71
Figura 5.1.4 Grfico de % timo da probabilidade de mutao (AGS 1 Seo) ....
72
Figura 5.1.5 Grfico de % timo da probabilidade de elitismo (AGS 1 Seo) .....
72
Figura 5.1.6 Grfico de % timo do tamanho da populao (AGS 2 Sees) ......
73
Figura 5.2.1 Grfico de % acerto dos mtodos de seleo (Evolpit 1 Seo) ......
75
Figura 5.2.2 Variao do % timo pela populao e seleo (Evolpit 1 seo) ...
76
Figura 5.2.3 Variao do % timo pelo cruzamento e seleo (Evolpit 1 seo)
77
Figura 5.2.4 Variao do % timo pela mutao e seleo (Evolpit 1 seo) ......
78
Figura 5.2.5 Variao do % timo pelo elitismo e seleo (Evolpit 1 seo) ........
78
Figura 5.2.6 Variao do % timo pela populao e nmero de sees (Evolpit) ...
79
Figura 5.2.7 Variao do % timo pelo cruzamento e nmero de sees ..............
80
Figura 5.2.8 Variao do % timo pela mutao e nmero de sees (Evolpit) ......
80
Figura 5.2.9 Variao do % timo pelo elitismo e nmero de sees (Evolpit) .......
81
Figura 5.2.10 Parmetros de entrada 100 sees (Evolpit) .....................................
82
Figura 5.2.11 Grfico de evoluo 100 sees (Evolpit) ..........................................
83
Figura 5.2.12 Grfico de evoluo por indivduo 100 sees (Evolpit) ....................
83
Figura 5.2.13 Parmetros e evoluo para 100 sees com agrup.(Evolpit) ...........
84
Figura 5.3.1 Parmetros Evolpit com restries de massa (fator R) ........................
85
Figura 5.3.2 Resultados com restries (fator R) ............................................. ......
86
Figura 5.3.3 Resultados Evolpit com restries de teor (1.2) ..................................
87
Figura 5.3.4 Resultados Evolpit com restries de teor (0.9) ..................................
87
Figura 5.4.1.1 Grfico dos resultados funo Schafferf2 .........................................
89
Figura 5.4.1.2 Grfico dos resultados funo Schafferf3 .........................................
90
Figura 5.4.2.1 Grfico espao dos objetivos NSGA (250 Geraes 1 seo) .....
91
Figura 5.4.2.2 Grfico espao dos objetivos NSGA (250 Geraes 2 sees) ....
92
93
94
Figura 5.4.2.5 Grfico espao dos objetivos NSGA (250 Geraes 6 sees) ...
95
Figura 5.4.2.6 Grfico espao dos objetivos NSGA (250 Geraes 22 sees) ..
96
Figura 5.4.2.1.1 Grfico espao dos objetivos NSGA (250 Geraes 2 sees) .
97
Figura 5.4.3.1 Parmetros e resultados NSGA Recursos/Valor 1 seo (Evolpit) .
98
Figura 5.4.3.2 Parmetros e resultados NSGA Rec./Valor 50 sees (Evolpit) .....
99
Figura 5.4.3.3 Parmetros e resultados NSGA Valor/Teor 1 seo (Evolpit) .... ....
99
Figura 5.4.3.4 Parmetros e resultados NSGA Recursos/Teor 1 seo (Evolpit) .
100
Lista de tabelas
Tabela 2.5.1 Algoritmos genticos multiobjetivos ....................................
28
RESUMO
Os tpicos descritos baseiam-se em desenvolvimentos e tcnicas divulgadas e

tm por objetivo avaliar a aplicabilidade dos algoritmos genticos no problema de
definio de cava final e seqenciamento de lavra para minas a cu aberto.
O objetivo desenvolver um conjunto de rotinas computacionais baseado nos
algoritmos genticos que, a partir de um modelo de blocos tecnolgicos conhecido
representando uma jazida, seja capaz de gerar um conjunto de solues timas, tendo
em vista os objetivos de maximizao de valor, respeitando as condicionantes de
qualidade (teores) e distribuio das massas no tempo (seqenciamento de lavra).
Foram desenvolvidos trs programas que abordam a teoria dos algoritmos
genticos. O primeiro calcula os limites de cava final, a partir de um modelo de blocos
visando a otimizao do lucro no descontado, por meio de programa de computador
baseado no algoritmo gentico simples com elitismo. O segundo um programa
baseado no algoritmo gentico multiobjetivo NSGA (Non-dominated Sorting Genetic
Algorithm), que foi inicialmente aplicado a dois problemas multiobjetivos disponveis na
literatura e, em seguida, na otimizao do lucro no descontado e para o problema
multiobjetivo de maximizao de reservas e do lucro. O terceiro, alm de conter os
algoritmos implementados anteriormente, comporta outros mtodos de seleo,
mutao, heursticas de agrupamento e gerao da populao inicial.
Todos os programas implementados resolveram os problemas at ento
simulados de maneira eficaz para um nmero reduzido de blocos.
ABSTRACT
Genetic Algorithms are stochastic search techniques based on natural selection

and genetic principles.
This work illustrates how genetic algorithms can be applied to optimize the final
pit and scheduling of open pit mines.
Three computer programs were developed. The first one calculates the final pit
based on a simple genetic algorithm with elitism maximizing the undiscounted pit value.
The second was based on the multi-objective method NSGA (Non-dominated Sorting
Genetic Algorithm), which was applied to two multi-objective classical problems, the
final pit problem maximizing the pit value and the multi-objective problem of maximizing
the pit value and the resources. The third one have more selection and mutation
methods and was added some cluster and initial population heuristics
All computer programs solved the formulated problems for small block models.
1 Introduo e Objetivos
Os limites finais da cava definem o tamanho e a forma de uma mina a cu
aberto no final de sua vida til e, geralmente, buscam a maximizao do lucro. Eles
definem a extenso das reservas lavrveis e a quantidade de material estril a ser
retirado e depositado. Normalmente marcam a fronteira-limite alm da qual a
explotao de um dado depsito no ser mais econmica. Os limites da cava na
superfcie delimitam uma fronteira dentro da qual as estruturas de superfcie da mina,
tais como plantas de beneficiamento e escritrios da mina, no devem ser locados.
Um dos problemas freqentemente enfrentados por gelogos e engenheiros de
minas o da definio dos limites do corpo mineral assim como a avaliao da
quantidade e da qualidade dos parmetros de interesse. Existe uma srie de mtodos
disponveis para definir os limites de um dado corpo mineral. O mtodo mais utilizado
atualmente a representao por um modelo de blocos (Kim, 1978), dividindo-se o
corpo mineral em um conjunto de blocos. Saydam e Yalcin (2002) comentam que o
planejamento de lavra baseado em um modelo de blocos envolve a deciso se um
bloco do modelo deve ser lavrado ou no. Em caso afirmativo, quando o mesmo ser
lavrado e, uma vez extrado, quando dever ser enviado ao processo. As respostas
para cada um desses itens abordados, quando combinadas no contexto global do
modelo de blocos, definem a progresso anual da cava e o fluxo de caixa advindo das
operaes mineiras (Dagdalen, 2001).
A figura a seguir apresenta um modelo conceitual de blocos. Segundo
Halatchev (2002), a produo de uma seqncia otimizada de uma cava um
procedimento que reflete as condies de explotao ao longo da vida til da mina.
Essas condies so determinadas pelas caractersticas geolgicas do depsito,
condies de lavra e tecnologias de processamento mineral, alm dos parmetros
econmicos. Do ponto de vista tecnolgico, a seqncia tima de lavra est
diretamente relacionada com dois aspectos espao e tempo.
Figura 1.1 Representao de um modelo de blocos.
Outro aspecto importante que a seqncia tima de produo da mina, em

princpio, usada como base para implementao de uma estratgia de teor de corte
no contexto dos desenvolvimentos recentes. Dessa maneira, a otimalidade do teor de
corte pode ser alcanada somente de maneira interativa considerando a otimalidade
da seqncia de produo (Lane, 1988).
Dentro da concepo de otimizao, que pode visar mxima lucratividade,
maior valor presente lquido e aproveitamento dos recursos minerais, existe uma srie
de algoritmos desenvolvidos que se propem a atingir tais objetivos porm os mtodos
que alcanaram a maior popularidade e conseqente implementao computacional
foram a tcnica dos cones flutuantes (Pana & Carlson, 1966; David et al., 1974;
Lemieux, 1979) e o algoritmo de Lerchs-Grossmann. (Lerchs e Grossmann, 1965).
Desde sua introduo, em 1965, o algoritmo de Lerchs-Grossmann (LG)
reconhecido por fornecer a soluo tima para o problema de projeto de cava a cu
aberto. Recentemente, vrios pesquisadores tm desenvolvido algoritmos e mtodos
alternativos para solucionar principalmente o problema de desempenho computacional
do algoritmo original de LG, particularmente para problemas de grande nmero de
blocos. Entre esses, autores como Zhao e Kim (1992), introduziram um novo algoritmo
de projeto, baseado tambm na teoria dos grafos, reduzindo significativamente o
nmero de arcos comparado com o algoritmo de LG. Huttagosol e Cameron (1992)
apresentaram uma formulao para o problema de modelo de transporte, comparando
os resultados obtidos com as abordagens de Ford e Fulkerson (1956) e os mtodos de
LG e cones flutuantes.
3
A gerao de um projeto de cava final tem sido o primeiro passo de um
planejamento de produo. Como resultado, muitos algoritmos de projeto de cava so
desenvolvidos, tanto na categoria dos mtodos heursticos, mtodo dos cones
flutuantes (Lemieux, 1979), na categoria dos mtodos matemticos, tal como o mtodo
de
Lerchs-Grossmann
(Lerchs
Grossmann,
1965;
Zhao
Kim,
1991).
Invariavelmente esses algoritmos contam com modelos de blocos e, para cada bloco,
atribudo um valor monetrio lquido (de ganho ou de perda). Desde que o valor do
bloco seja uma funo do preo do minrio e dos custos de processo, a cava
projetada com esse conjunto de valores fixos tornar-se- obsoleta com o passar do
tempo, quando os preos ou os custos sofrerem mudanas. Para acomodar as
mudanas nos valores dos blocos, a anlise dos limites da cava praticada. Nessa
anlise, os parmetros econmicos so sistematicamente modificados, um de cada
vez, e uma cava projetada aps cada mudana.
A sada da anlise de projeto uma srie de cavas onde cada uma possui seu
prprio potencial de ser minerada, sob condies econmicas especficas. De fato, a
anlise de projetos de cava nada mais do que uma parametrizao respeitando os
parmetros econmicos (Wang & Sevim, 1995).
Diferentes mtodos so usados para o projeto de limites finais de cava. A
simulao e a programao dinmica so as tcnicas mais utilizadas. As tcnicas de
simulao incluem a tcnica dos cones mveis. Os Mtodos de programao dinmica
incluem algoritmos bidimensionais e tridimensionais (Carmo, 2001).
De acordo com Takahashi (2004), os algoritmos genticos so caracterizados
pela evoluo de um conjunto de solues-tentativas (populao), segundo regras
estocsticas de busca e combinao que leva de uma populao seguinte, numa
seqncia de geraes. A existncia de trs regras bsicas ou operadores genticos
bsicos, de um Algoritmo Gentico:
i. Um operador de cruzamento, que combina a informao contida em
dois ou mais indivduos (ou seja, duas ou mais solues-tentativas),
assim gerando outros indivduos;
ii. Um operador de mutao que, utilizando a informao contida em um
indivduo, estocasticamente gera outro indivduo; e
4
iii. Um operador de seleo que, utilizando a avaliao da funo
objetivo sobre todos os indivduos da populao, produz rplicas de
alguns desses indivduos e elimina outros indivduos, assim gerando a
populao seguinte.
Um algoritmo gentico pode ser construdo a partir dessas trs regras ou pode
conter outros tipos de regras, tais como: nicho, busca local, etc.
Por meio dos algoritmos a serem desenvolvidos, pretende-se resolver os
problemas propostos:
a) Determinao da cava final maximizando o lucro no descontado;
b) Determinao da cava final maximizando o lucro no descontado com
restries de qualidade (teores);
c) Determinao da cava final maximizando o lucro com restries de qualidade e
massas no tempo (seqenciamento);
d) Gerao das famlias de cavas timas visando maximizar recursos e lucro no
descontado;
e) Gerao das famlias de cavas timas visando maximizar recursos e teor
mdio;
f) Gerao das famlias de cavas timas visando maximizar o lucro no
descontado e teor mdio.
2 Reviso Bibliogrfica
2.1 Descrio sumria de mtodos de otimizao de cava final
2.1.1 O algoritmo de Lerchs-Grossmann
Lerchs, H. e Grossmann, I. (1965), utilizando a tcnica de programao
dinmica, desenvolveram, juntamente com um algoritmo de otimizao bidimensional
de cavas, um tratamento algbrico para a discretizao da jazida em blocos
tecnolgicos. Um algoritmo derivado da teoria dos Grafos, trata o problema por meio
da procura do fecho mximo em um grafo associado. A partir do benefcio associado
de lavra de um bloco i, representado por Bi, o benefcio global pode ser otimizado
como a busca da combinatria de blocos que maximizem a somatria de Bi
respeitando as restries pertinentes ao estudo.
A maneira mais simples de apresentar o mtodo de Lerchs-Grossmann 2D
pelo uso de um exemplo (Peroni, 2002). Supondo um corpo mineral, onde os blocos
estreis tenham um valor (custo) de 4.000 unidades monetrias/bloco, e os blocos de
minrio apresentem um valor de 12.000 unidades/bloco, e ainda um ngulo de talude
de 45 graus. Para cada bloco so atribudos valores baseados em parmetros
econmicos conforme a figura abaixo:
Figura 2.1.1.1 Modelo de blocos inicial valorizado economicamente.
Como pode se observa, os blocos do limite do corpo mineral pertencem, tanto

ao domnio do minrio, quanto ao domnio do estril. Um valor mdio foi utilizado
conforme a configurao apresentada a seguir:
Figura 2.1.1.2 Modelo de blocos econmico final.
A posio dos blocos ser denotada utilizando-se a notao (i,j) para posicionar
espacialmente os blocos, onde i representa a linha e j a coluna em que um
determinado bloco est localizado.
Por meio de operaes de soma nas colunas existentes no modelo de blocos e
rotinas de procura de valores mximos, pode-se calcular o limite da cava final
conforme figura a seguir:
Figura 2.1.1.3 Limite otimizado superposto ao modelo de blocos.
Uma evoluo do algoritmo bidimensional de Lerchs-Grossmann foi proposta

por Johnson & Sharp (1971). Essa modificao referida em Barnes (1982) como o
algoritmo 2
D, pois considera um modelo tridimensional de blocos e analisa seo a
seo em 2D at encontrar o contorno da cava final.
2.1.2 Mtodo dos cones flutuantes

O mtodo baseado na pesquisa do contorno timo da cava final por
tentativas. O princpio de funcionamento do algoritmo considera as restries fsicas e
geomecnicas locais (ngulos de talude). O pex do cone movido de um bloco para
outro e a avaliao do cone feita em cada posio explorada. Quando a avaliao
positiva (cones fortes) o cone selecionado e todos os blocos nele contido so
extrados. O processo repete-se at que no existam mais cones economicamente
lavrveis. Esse mtodo tem a vantagem de ser rpido e possui apelo bastante intuitivo
(Underwood & Tolwinski, 1998). Yamatomi et al. (1995) apresentaram variantes dessa
tcnica.
Noronha (2001) afirma que esse mtodo tem boa aplicao em corpos
porfirticos em que se tem um corpo central de minrio e as encaixantes de estril.
2.1.3 Parametrizao tcnica de reservas

Baseados em estudos de Matheron, G. (1975), Bongaron, F. e Marechal, A.
(1976) utilizaram a tcnica de Anlise Convexa de Vallet, R. (1976) para tratarem o
problema de otimizao de cava final por meio de uma aproximao funcional.
Conforme descrito por Noronha (2001), a idia baseada em voltar o problema
para a determinao de uma funo de parametrizao tcnica (funo do teor mdio
dos blocos), a partir da qual torna-se possvel a obteno imediata de uma famlia de
cavas timas, independente da conjuntura econmica subjacente ao problema. Em
outras palavras, o conhecimento de todos os projetos potencialmente timos do ponto
de vista de maximizao da quantidade de metal com a minimizao da remoo de
material, ou seja, projetos timos do ponto de vista tcnico, permitindo a comparao
dos mesmos, com antecedncia, s flutuaes de parmetros econmicos, por
exemplo. A parametrizao tcnica de reservas, em resumo, a procura dos projetos
que pertenam superfcie convexa que se sobrepe ao conjunto de todas as cavas
possveis.
8
2.2 Aplicao de algoritmos genticos no planejamento de mina
A primeira utilizao especfica no planejamento de mina do Algoritmo Gentico
foi proposto por Tolwinski e Underwood (1992) e combina conceitos de otimizao
estocstica com conceitos de redes neurais para estabelecer um teor de corte timo
no sentido de maximizar o valor econmico da jazida. Da mesma forma e adaptando a
idia do Algoritmo Gentico, G. S. Thomas (1996) descreveu, em artigo especfico, o
conceito e a aplicao de um programa visando estabelecer uma seqncia tima de
lavra para uma mina a cu aberto (Toledo, 2003).
No Brasil, Toledo (2003) estudou duas aplicaes de algoritmos genticos. A
primeira mostra a tcnica da krigagem adaptativa cujo objetivo selecionar um modelo
variogrfico (tipo, patamar, alcance e anisotropias) que minimize o erro da validao
cruzada entre as amostras. Os resultados comprovaram a aderncia do mtodo em
populaes de comportamento conhecido. A segunda aplicao foi na seleo de
projetos mineiros concorrentes, buscando, em sistemas de muitas minas e vrias
opes de investimentos, a combinao mais atrativa. A utilizao do Algoritmo
Gentico solucionou o problema com preciso e agilidade e apresentou resultados
melhores do que as abordagens tradicionais de otimizao por programao linear.
Portanto o Algoritmo Gentico uma ferramenta que poder solucionar os problemas
de combinaes para seqenciamento de lavra.
Durante o APCOM de 2005, Wageningen, Dunn & Muldowney analisaram a
utilizao de algoritmos genticos combinados com Busca Tabu e simulao discreta
de eventos no planejamento de mina de longo prazo.
Segundo os autores a
abordagem utilizada mostrou-se eficaz na resoluo de problemas multiobjetivos e na

gerao de seqenciamentos de lavra.
No mesmo evento, Samanta e Bhattacherjee (2005) avaliaram a aplicao de
algoritmos genticos no problema de otimizao e controle de teores (Al2O3 e SiO2),
em um depsito de bauxita, gerando vrias seqncias de extrao de minrio no
tempo. Segundo os autores, a utilizao de tal abordagem possibilitou a gerao de
vrios cenrios de lavra, permitindo, ao tomador de deciso, escolher, em funo de
suas necessidades, a operacionalizao dos mesmos.
Outro exemplo de aplicao de algoritmos genticos foi realizado por Thomas
(1966) que ilustra sua aplicao e a utilizao de tcnicas de recozimento simulado
9
(Simulated Annealing) na determinao dos limites da cava final. O autor ressalta,
como principal vantagem na utilizao de algoritmos genticos, a grande quantidade
de solues quase timas geradas, o que no acontece nas abordagens tradicionais.
E, como principal desvantagem, o maior custo computacional exigido para atingir as
solues desejadas.
2.3 Otimizao Multiobjetivo

Otimizao Multiobjetivo, tambm chamada de otimizao multicritrio,
multiperformance ou otimizao vetorial pode ser definida como o problema de
encontrar (Osyczka, 1985):
um vetor de variveis de deciso que satisfaa um conjunto de restries e
otimize um vetor de funes cujos elementos representem a funo objetivo.
Estas funes formam a descrio matemtica do chamado critrio de
desempenho, as quais usualmente so conflitantes. Assim, pode-se dizer que o
termo otimizar significa descobrir uma soluo para a qual os valores de todas
as funes objetivo so considerados aceitveis pelo projetista.
Formalmente, pode-se descrever o problema como se segue:
Encontrar um vetor x* = [x1*, x2*, ... xn*] que satisfaa as m restries de
desigualdade:
gi(x) 0
i = 1, 2, ..., m
(2.3.1)
e as p restries de igualdade
hi(x) = 0
i = 1, 2, ..., p
(2.3.2)
de modo a otimizar o seguinte vetor de funes:

f(x) = [f1(x), f2(x), ..., fn(x)]T
(2.3.3)
onde o vetor x = [x1, x2, ... xn]T corresponde ao vetor de variveis de deciso ou de
otimizao.
10
Ou seja, deseja-se determinar, sobre o conjunto F de todos os nmeros que
satisfaam as restries de igualdade e desigualdade, um conjunto particular de
variveis x1*, x2*, ..., xn* que permitam atingir os valores eficientes de todas as funes
objetivos baseados em algum fator de deciso.
O conjunto Pareto-timo foi formulado por Pareto no sculo XIX e constitui a
origem das pesquisas envolvendo otimizao multiobjetivo (Pareto, 1896).
Um ponto x* pertencente ao conjunto vivel F Pareto-timo se
x* F
pode-se afirmar que:

i [1, 2, ...,n] / fi(x*) fi(x) e pelo menos uma dimenso j tal que fj(x*) < fj(x).
Em outras palavras, a definio diz que x* Pareto timo se no existe
nenhum vetor possvel x que possa decrescer algum objetivo sem causar um
acrscimo simultneo em pelo menos outro objetivo.
O Pareto-timo sempre gerar no apenas uma nica soluo, mas um
conjunto de solues chamadas no-inferiores, no-dominadas ou eficientes. O ponto
f* = [f1*, f2*, ... fn*] usualmente conhecido como utopia, ponto ideal ou ponto utpico.
Esse ponto impossvel de ser alcanado, na maioria dos problemas multiobjetivos
com objetivos conflitantes. Quando o ponto utpico pertence ao espao vivel de
solues, obviamente a melhor soluo e nenhuma pesquisa futura ser necessria
(Horn, 1997).
2.4 Elementos de um algoritmo gentico

O Algoritmo Gentico Simples - AGS, desenvolvido por Holland em seus
trabalhos iniciais (Holland, 1975), foi o primeiro algoritmo gentico inventado e o
prottipo no qual os outros se baseiam. Os algoritmos genticos simples so
importantes para o desenvolvimento terico e tm grande valor didtico, pois sua
estrutura a base sobre a qual as variaes que definem os algoritmos mais
avanados e recentes so desenvolvidas. Por isso, far-se- uma descrio geral dos
algoritmos genticos simples e de seu funcionamento, baseada principalmente no livro
de Goldberg (Goldberg, 1989) e no artigo de Tanomaru (Tanomaru, 1995).
11
As principais etapas de um algoritmo gentico so:
1) Codificao;
2) Gerao da populao inicial;
3) Clculo da avaliao e aptido;
4) Seleo dos indivduos;
5) Cruzamento dos indivduos;
6) Mutao;
8) Definio dos critrios de parada.
2.4.1 Codificao:
A definio de como codificar as solues nos cromossomos o primeiro
passo para a construo de um algoritmo gentico.
A representao por meio de cromossomos binrios a escolha tradicional
para codificao das variveis do algoritmo gentico. Segundo Srinivas e Patnaik
(1994), isso se deve a dois fatores: a) A simplificao da implementao,
especialmente no tocante s operaes genticas, que devem ser redefinidas se a
representao binria no for utilizada; b) Um resultado terico derivado da teoria dos
esquemas que diz que, quanto menor a cardinalidade do alfabeto utilizado na
codificao, i.e., quanto menor o nmero de smbolos possveis, maior ser o nmero
de esquemas processados simultaneamente e portanto mais eficiente ser o algoritmo
gentico.
Na grande maioria das aplicaes, as solues so codificadas em um nico
cromossomo e, por isso, s vezes, refere-se indistintamente a indivduos e
cromossomos como se fossem a mesma entidade. Em grande parte dos algoritmos
genticos, os cromossomos so binrios, i.e., constitudos por uma seqncia de 0s e
1s e portanto o esquema de codificao deve mapear o espao de busca original em
12
seqncias binrias. Para variveis binrias, a codificao trivial: os valores de cada
varivel so simplesmente copiados nos cromossomos.
Para o problema em pauta, cada cromossomo ser representado pelo conjunto
de blocos de valores positivos contidos no modelo de blocos que sero lavrados
considerando as restries geotcnicas. Nesse caso, o cromossomo ser do tamanho
do nmero de blocos de minrio que existe no modelo de blocos e corresponde a um
indivduo que um candidato soluo do problema.
2.4.2 Populao inicial
Em geral, a populao inicializada com pontos escolhidos aleatoriamente
mas, dependendo da aplicao, podem existir formas heursticas de selecionar uma
populao inicial mais favorvel.
importante que a populao inicial esteja bem distribuda pelo espao de
busca. Primeiro, para que todas as partes da populao sejam representadas e,
segundo, porque o algoritmo gentico necessita de uma boa diversidade inicial de
combinaes para funcionar bem, da mesma forma que populaes de organismos
vivos precisam de uma boa diversidade gentica para se adaptar eficientemente a seu
meio ambiente.
A eliminao de duplicatas (Davis, 1991) uma adaptao bvia e interessante
uma vez que a presena de indivduos idnticos numa populao implica em uma
menor diversidade gentica. Para se fazer isso, deve-se, primeiro, testar se existem
indivduos idnticos na populao. De cada grupo de indivduos idnticos encontrados,
eliminam-se todos menos um e substituem-se os eliminados por novos indivduos que
podem
ser
gerados
aleatoriamente.
Esse
mtodo
tambm
demanda
custo
computacional extra, devido necessidade de se comparar todos os indivduos e de

gerar substitutos.
2.4.3 Avaliao e aptido
Cada indivduo da populao avaliado no incio de cada gerao. Essa
avaliao feita externamente ao algoritmo gentico. O resultado dela deve ser um
valor numrico que expresse a qualidade relativa da soluo codificada em cada
indivduo. A avaliao correlaciona-se portanto com a funo objetivo do problema,
13
embora no seja necessrio que exista uma funo objetivo explicitamente formulada.
Os valores provenientes da avaliao de cada indivduo devem ento se transformar
em outro valor, necessariamente positivo, denominado aptido, que ser utilizado para
definir as probabilidades de reproduo de cada um, na fase de seleo (Srinivas e
Patnaik, 1994).
No problema em pauta, para cada cromossomo gerado, que ser um indivduo
caracterizado por um conjunto de blocos de minrio, a avaliao ser o valor da cava
(benefcio do minrio + despesas do estril) considerando-se as restries
geotcnicas. A avaliao ser realizada por uma funo especfica externa ao
algoritmo gentico que, em funo dos blocos de minrio do indivduo, extrair
tambm os blocos de estril considerando-se os ngulos dos taludes.
O valor de aptido dos indivduos tambm pode ser calculado de muitas
maneiras. A forma mais simples e bvia utilizar-se o prprio valor da avaliao
(funo objetivo) para cada indivduo o que , s vezes, chamado de aptido bruta.
Entretanto, como a aptido tem que ser necessariamente um valor positivo, para se
estabelecerem as probabilidades de seleo dos indivduos, pode ser impossvel usar
diretamente o valor da funo objetivo, dependendo do problema. Mesmo quando
possvel utilizar a aptido bruta, a prtica tem indicado que essa no , normalmente,
a melhor opo (Tanomaru, 1995), e diversas abordagens so propostas para
transformar os valores da funo objetivo de forma a melhorar o desempenho dos
algoritmos genticos.
A principal preocupao no clculo da aptido, a presso seletiva. A presso
seletiva pode entender-se como a intensidade com a qual o algoritmo gentico
favorece os indivduos mais aptos em detrimento dos menos aptos, o que est
basicamente relacionado s probabilidades de reproduo dos indivduos. A presso
seletiva influencia diretamente a diversidade da populao: uma alta presso seletiva
faz com que a diversidade diminua muito rapidamente, podendo ocasionar uma
convergncia prematura, enquanto uma baixa presso seletiva preserva a diversidade
mas dificulta a convergncia para o timo. Ao se analisar a execuo de um algoritmo
gentico que use a aptido bruta, percebe-se que a presso seletiva usualmente
mais alta no incio, porque os indivduos so bastante diferentes e, por isso, tendem a
apresentar valores muito dspares para a funo objetivo. No final da execuo, ao
contrrio, a presso seletiva normalmente baixa, porque os indivduos so mais
14
parecidos e tendem a apresentar valores bem semelhantes para a funo objetivo. O
que se deseja entretanto justamente o oposto: uma presso seletiva baixa, no incio
para que os indivduos menos aptos tenham alguma chance de reproduo e, assim
se possa explorar melhor o espao de busca; e uma presso seletiva mais alta, no
final, porque como os indivduos esto agora muito parecidos, fica mais difcil, para os
mtodos de seleo, privilegiar os mais aptos, podendo prejudicar a convergncia do
algoritmo gentico.
O escalamento de aptido uma adaptao que visa regular a presso
seletiva, durante o andamento do algoritmo, tentando obter os efeitos desejados
citados anteriormente. No escalamento, os valores da funo objetivo, para cada
indivduo, so transformados de modo que as aptides resultantes induzam um nvel
de presso seletiva desejado durante a evoluo do algoritmo gentico. O tipo de
escalamento mais utilizado o escalamento linear, proposto por Goldberg (Goldberg,
1989).
A janela de aptido outra adaptao usada para converter uma funo
objetivo em uma funo aptido vlida. Nela, a aptido calculada subtraindo-se do
valor da funo objetivo de cada indivduo, o valor mnimo desta para toda a
populao, em cada gerao. Esse mtodo muito simples de se implementar e
garante que valores de aptido negativos no sejam gerados. Mas no to eficaz na
regulao da presso seletiva, como o escalamento linear.
No mtodo de ordenao (Baker, 1985), no se usam os valores da funo
objetivo diretamente para o clculo das aptides. Ao invs disso, esses valores so
utilizados para ordenar os indivduos da populao, a cada gerao, e a aptido
ento atribuda a cada indivduo, em funo de sua posio nessa ordenao
(ranking). A forma mais simples de se atribuir um valor de aptido utilizando um
procedimento de ranking ordenar os indivduos do pior para o melhor e dar-lhes um
valor de aptido igual posio de cada um no ordenamento. Se houver, por exemplo,
uma populao de 100 indivduos, o pior receber aptido 1, o segundo pior aptido 2
e assim por diante at o melhor, que ter aptido 100. fcil perceber que, dessa
forma, a presso seletiva mantem-se constante durante a execuo do algoritmo e
muitas implementaes prticas utilizam esse mtodo.
15
A ltima adaptao referente ao clculo da aptido o chamado
compartilhamento que foi inspirado no conceito de nicho ecolgico. Duas espcies
diferentes ocupam o mesmo nicho. Quando os recursos de que precisam para
sobreviver (comida, abrigo, locais de reproduo, etc.) so muito parecidos, h
intensa competio entre as espcies. Se, ao contrrio, os nichos que as espcies
ocupam so distintos, i.e. se os recursos dos quais as espcies necessitam so
suficientemente diferentes, a competio entre elas ser pequena ou inexistente. A
extenso da idia de nicho para o algoritmo gentico simples considera que indivduos
que esto mais prximos no espao de busca estariam ocupando nichos muito
parecidos, enquanto os indivduos mais afastados estariam em nichos bastante
diferentes. Por isso, no compartilhamento, os valores de aptido so modificados de
forma que aqueles indivduos que esto mais distantes dos outros tenham a aptido
aumentada, enquanto os indivduos mais prximos no espao de busca tenham seus
valores de aptido diminudos.
O uso do compartilhamento diminui a presso seletiva sobre os indivduos mais
distantes e aumenta a presso sobre os mais prximos. Dessa forma, ele incentiva o
distanciamento entre os indivduos da populao, o que aumenta a diversidade e
provoca
uma
explorao
mais
global
no
espao
de
busca.
Embora
compartilhamento seja aparentemente vantajoso, ele acrescenta algum esforo

computacional, por causa do clculo das distncias e tem mostrado, na prtica, uma
tendncia a dificultar a convergncia para o timo (Tanomaru, 1995). Experimentos
com o uso do compartilhamento (Goldberg, 1989) mostram que, para funes objetivo
multimodais, os algoritmos genticos que no utilizam compartilhamento exibem um
padro onde os indivduos se concentram ao redor de algum dos mximos enquanto
que, nos algoritmos genticos que utilizam o compartilhamento, os indivduos
concentram-se ao redor de alguns dos mximos presentes, sendo o nmero de
indivduos, ao redor de cada mximo, proporcional altura relativa deles.
2.4.4 Seleo
Os algoritmos genticos utilizam o modelo populacional geracional onde todos
os indivduos da populao anterior so eliminados e substitudos a cada gerao.
Porm existem maneiras alternativas de compor as novas populaes a cada gerao.
Na denominada reproduo de estado estvel (Syswerda, 1991), produz-se, a cada
gerao, um nmero de descendentes, correspondente a apenas uma frao N/r da
16
populao, que ir substituir um nmero equivalente de indivduos da populao
anterior, em geral os N/r piores indivduos. Esse mtodo implica em algum trabalho
computacional adicional, visto que os indivduos da populao devem ser ordenados
para que se escolham os N/r piores. Mas tem a grande vantagem de permitir que se
trabalhe com populaes maiores, diminuindo-se a perda de variabilidade.
A adaptao de modelo populacional mais utilizada o chamado elitismo. Nele,
toda a populao , em primeira instncia, substituda por seus descendentes, como
nos algoritmos genticos geracionais. Porm, se os melhores indivduos da populao
anterior no estiverem presentes na nova populao devido seleo ou s
operaes genticas, eles so acrescentados no lugar dos piores indivduos novos.
Em princpio, esse mtodo tambm requereria a ordenao dos indivduos para a
escolha dos melhores mas isso, na verdade, no necessrio para o tipo mais comum
de elitismo onde apenas o melhor indivduo preservado. Sua principal vantagem
garantir que a(s) melhores(s) solues no sejam perdidas durante a execuo do
algoritmo gentico, mitigando possveis efeitos deletrios da seleo, recombinao e
mutao.
Nos chamados algoritmos genticos de gerao contnua (Michalewicz, 1992),
faz-se uma inverso na seqncia normal de operaes do algoritmo gentico e
ocorre uma competio direta entre os indivduos da populao anterior e seus
descendentes. Primeiro, todos os indivduos so copiados. Essas cpias sofrem a
recombinao e a mutao da forma usual, so avaliadas e recebem valores de
aptido. Depois se juntam os indivduos originais da populao e as cpias feitas no
passo anterior, formando uma populao temporria de 2n indivduos. Sobre essa
populao temporria faz-se uma seleo baseada na aptido dos 2n indivduos,
utilizando-se algum dos mtodos de seleo j estabelecidos, de forma a se ter
novamente uma populao de n indivduos, Todo esse processo completa uma
gerao do algoritmo gentico e repetido na execuo das prximas geraes.
Outra adaptao de modelo populacional o chamado genocdio peridico.
Assim como a reproduo de estado estvel, o genocdio peridico visa combater a
perda de variabilidade que pode ser crtica quando se trabalha com populaes
pequenas. A idia bsica executar um algoritmo gentico geracional que, em
intervalos de um certo nmero de geraes, sofra uma interveno. Nessa
interveno, a populao aumentada drasticamente, para 10n por exemplo e,
17
depois, passa por uma seleo que reduz o nmero a n novamente, de forma
semelhante ao que se faz nos algoritmos genticos de gerao contnua. Os
indivduos adicionais podem vir de um processo reprodutivo alterado onde se fazem
muito mais cpias, ou podem ser gerados aleatoriamente. Esse mtodo apresenta um
custo computacional significativamente maior, devido necessidade de se avaliar em
muitos indivduos em certas geraes e, alm disso, ainda introduz novos parmetros
que devem ser definidos, como a freqncia do genocdio e o quanto a populao
deve aumentar antes dele.
No modelo populacional conhecido como superseleo, divide-se a populao
em castas, de acordo com os valores de aptido e realiza-se uma reproduo
estratificada, com os indivduos das castas com maior aptido reproduzindo-se mais,
em mdia, do que os das castas de menor aptido. Por exemplo, pode-se dividir uma
populao de 200 indivduos em 3 castas: os melhores 10 indivduos, os prximos 40
e os outros 150. Pode-se, ento, estipular, por exemplo, que os 10 melhores
indivduos deixem 50 descendentes, que os 40 indivduos da segunda casta tenham
80 descendentes e os 150 da casta mais baixa produzam apenas 70 descendentes
para a prxima gerao. Esse mtodo visa contornar os problemas da seleo via
mtodo da roleta, diminuindo a chance de que indivduos com alta aptido no deixem
descendentes. Esse procedimento acarreta pequeno custo computacional adicional
por causa da necessidade de se ordenarem os indivduos e de se fazer seleo em
separado para cada casta.
Nesse modelo, deve-se primeiro verificar se existem indivduos idnticos na
populao aps a seleo, a reproduo e as operaes genticas. De cada grupo de
indivduos idnticos encontrados, eliminam-se todos menos um e substituem-se os
eliminados por novos indivduos, que podem ser gerados aleatoriamente ou obtidos
por seleo e operaes genticas. Esse mtodo tambm apresenta um custo
computacional extra, devido necessidade de se compararem todos os indivduos e
de se gerarem substitutos, caso indivduos idnticos sejam encontrados.
No processo de seleo, decidem-se quais os indivduos da populao se
reproduziro e quantos descendentes cada um deixar para a prxima gerao.
Nesse estgio do algoritmo gentico, os descendentes so apenas cpias dos
gentipos dos indivduos que foram selecionados mas sero posteriormente alterados
pelas operaes genticas. No algoritmo gentico, a definio de quais indivduos
18
sero copiados e de quantas cpias cada um deixar feita, a partir do valor de
aptido de cada indivduo, que usado para definir as probabilidades de reproduo
deles.
No algoritmo gentico simples, usa-se um esquema de reproduo geracional
onde se gera um nmero de descendentes igual ao nmero de indivduos da
populao e substitui-se toda a populao por esses descendentes, a cada gerao,
mantendo-se o tamanho da populao constante. Se forem produzidas n cpias a
cada gerao e Pi a probabilidade de que uma determinada cpia seja descendente
do i-simo indivduo, ento se pode concluir que o nmero esperado de descendentes
para esse indivduo, nPi. Assim, indivduos com valores de aptido acima da mdia
tendero a deixar mais de uma cpia, enquanto aqueles com aptido abaixo da mdia
tendero a deixar menos de uma cpia. O nmero esperado de cpias, para cada
indivduo, nPi, quase sempre fracionrio, mas o nmero de cpias efetivamente
deixadas, por cada indivduo, tem que ser forosamente um inteiro. Esse problema
solucionado no algoritmo gentico utilizando-se o esquema de seleo da roleta.
Nesse esquema, pensa-se em uma roleta onde cada casa refere-se a um dos
indivduos. Ao contrrio de uma roleta de cassino onde todas as casas tm o mesmo
tamanho, nessa roleta fictcia, os tamanhos das casas so diferentes e proporcionais
probabilidade de seleo de cada indivduo. A seleo dos indivduos para reproduo
feita ento girando a roleta n vezes e copiando o indivduo que foi sorteado em
cada rodada.
Figura 2.4.4.1 Representao do esquema de seleo da roleta.
Na figura anterior, cada um dos indivduos (A, B, C, D e E) tem uma casa na

roleta cujo tamanho proporcional a sua aptido. Cada vez que a roleta girada, um
19
dos indivduos selecionado para ser copiado e, posteriormente, sofrer as operaes
genticas.
importante notar que esse processo aleatrio e os indivduos com valores
de aptido mais alta no necessariamente sero copiados, embora tenham chance
proporcionalmente maior de serem escolhidos. Da mesma forma, esse processo
tampouco impede que os indivduos com aptides mais baixas sejam selecionados,
embora tenham menos chances. Assim, o mtodo da roleta introduz um certo grau de
aleatoriedade no processo, permitindo que o nmero efetivo de cpias deixadas para
cada indivduo varie consideravelmente em relao ao nmero esperado.
O mtodo da roleta um bom exemplo para o processo de seleo que ocorre
nos organismos vivos pois os indivduos mais aptos tm mais chance mas no tm a
garantia de deixar descendentes. Entretanto essa aleatoriedade introduzida pelo
mtodo da roleta faz com que muitos indivduos no se reproduzam com taxas
semelhantes a seu nmero esperado de cpias, o que dificulta a convergncia do
algoritmo gentico a longo prazo. Por isso, foram desenvolvidas algumas adaptaes
para o processo de seleo, que substituem o mtodo da roleta na tentativa de se
contornar esse problema. A seguir, faz-se uma descrio de algumas dessas
adaptaes.
O mtodo do valor esperado ou amostragem estocstica sem reposio, usa o
mesmo princpio da roleta mas limita o nmero de cpias que cada indivduo pode
deixar em funo de sua probabilidade de seleo. A diferena bsica com relao ao
mtodo da roleta, que, da seleo, calcula-se o nmero esperado de cpias para
todos os indivduos e, para cada vez que um indivduo selecionado, subtrai-se 1 de
seu nmero esperado de cpias. Quando o nmero esperado de cpias de qualquer
indivduo ficar nulo ou negativo, ele fica impedido de ser sorteado novamente. Assim,
o nmero de cpias de qualquer indivduo nunca ultrapassa o nmero esperado de
cpias, arredondado para o prximo inteiro.
O mtodo de amostragem determinstica tambm se baseia no nmero
esperado de cpias para cada indivduo. S que aqui se aloca imediatamente um
nmero de cpias para cada indivduo, correspondente parte inteira de seu nmero
esperado de cpias. Isso define o primeiro grupo de m cpias onde m n (o tamanho
da populao). Depois, os indivduos so ordenados, de acordo com a parte
20
fracionria de seu nmero esperado de cpias, de forma decrescente. As n m cpias
que ainda faltam para completar a populao so atribudas aos n-m primeiros
indivduos dessa lista ordenada.
Assim como na amostragem determinstica, no mtodo do resto estocstico,
tambm se aloca um nmero de cpias de indivduos correspondente parte inteira
dos nmeros esperados de cpias de cada um. A diferena entre os dois mtodos
que, no resto estocstico, as partes fracionrias so usadas para estabelecer novas
probabilidades de seleo, a partir das quais as n-m cpias restantes so alocadas por
sorteio, de forma idntica ao mtodo da roleta.
Dentre os mtodos alternativos de seleo, o torneio estocstico o mais
singular. Nele se utiliza o mtodo da roleta para sortear n grupos com um pequeno
nmero de indivduos em cada. De cada grupo, copia-se aquele indivduo com o valor
mais alto de aptido, obtendo-se n cpias no final do processo.
Todos esses mtodos resultam em um processo de seleo menos exposto a
flutuaes aleatrias do que o mtodo da roleta mas no existe consenso sobre se
eles so melhores e em quais situaes (Tanomaru, 1995).
2.4.5 Recombinao
As n cpias geradas no processo de seleo formam o chamado mating pool,
sobre o qual sero efetuadas as operaes de recombinao e mutao. Para a
recombinao, primeiro os cromossomos do mating pool so agrupados em duplas.
Depois, para cada dupla, escolhe-se aleatoriamente um nmero, com distribuio
uniforme entre 0 e 1. Nas duplas onde o nmero sorteado for menor ou igual a um
dado valor, chamado probabilidade de recombinao (Prec), a recombinao ser
efetuada. No algoritmo gentico, a recombinao feita pelo chamado cruzamento
(crossover) de um ponto onde se escolhe, para cada dupla de cromossomos que
sero efetivamente recombinados, um ponto de corte a partir do qual permutam-se,
entre dois cromossomos da dupla, todos os valores correspondentes s disposies
posteriores, como ilustrado na figura 2.11. Para se escolher o ponto de corte
simplesmente sorteia-se, para cada dupla de cromossomos que sofrer recombinao,
um nmero com distribuio uniforme entre 1 e c-1, onde c o comprimento do
cromossomo. Sero permutadas ento, as posies cujos ndices nos cromossomos
sejam maiores que o nmero sorteado.
21
Ponto de Corte
110001010000111 11011
110001010000111 10100
Cruzamento
001101100010001 10100
001101100010001 11011
Figura 2.4.5.1 Cruzamento com um ponto.
Devido ao importante papel que a recombinao desempenha nos algoritmos

genticos, h vrios estudos sobre seu funcionamento e suas caractersticas. Muitas
adaptaes e operadores alternativos so propostos e analisados. A maioria foi feita
para adaptar os operadores a representaes cromossmicas diferentes, usadas em
problemas especficos. Essas adaptaes tm o mrito de ilustrar como possvel
melhorar o desempenho de um algoritmo gentico desenvolvendo operadores sob
medida. Alguns operadores de recombinao alternativos tm um carter genrico,
podendo ser aplicados a algoritmos genticos em geral.
No cruzamento com dois pontos, escolhem-se dois pontos de corte, e trocamse, entre os cromossomos que formam pares, as seqncias que se encontrarem
entre esses dois pontos de corte. Esses pontos de corte devem ser escolhidos
sorteando-se dois nmeros entre 0 e c (onde c o comprimento do cromossomo), e
no entre 1 e c-1 como no crossover de um ponto, para permitir tambm a troca dos
bits das extremidades. Eventualmente ambos os pontos de corte podem cair na
mesma posio. Nesse caso, pode-se fazer outro sorteio ou simplesmente no se
trocar posio nenhuma. Tambm possvel generalizar a idia do crossover de dois
pontos estabelecendo operadores de crossover de trs ou mais pontos, dependendo
do tamanho dos cromossomos. Tais adaptaes entretanto no so relevantes do
ponto de vista terico e so muito utilizadas.
Outra adaptao importante do operador de recombinao o chamado
cruzamento uniforme, proposto por Syswerda (1989). Nesse mtodo, gera-se, para
cada par de recombinaes formado, uma seqncia binria aleatria com o mesmo
comprimento dos cromossomos, que se denomina padro de recombinao. Para
cada par de cromossomos, percorre-se o padro de recombinao correspondente e,
22
toda a vez que se encontra um 1 nele, trocam-se os bits que estejam na posio
equivalente. Obviamente, sempre que se encontra um 0 no padro, no se trocam os
smbolos equivalentes.
Analisando-se o funcionamento dos operadores de recombinao j descritos,
conclui-se que os cruzamentos de um e dois pontos tendem a preservar mais os
esquemas, enquanto o cruzamento uniforme mais disruptivo. Em compensao, o
cruzamento uniforme tende a promover uma explorao mais global do espao de
busca do que os outros dois. Srinivas e Patnaik (1994) sugerem que o crossover
uniforme mais adequado para populaes pequenas, porque mantm a diversidade
e aumenta a explorao do espao de busca. Por outro lado, para populaes grandes
onde a diversidade fatalmente maior, pode ser mais vantajoso utilizar-se o
cruzamento de um ou dois pontos pois preservam mais os blocos construtores, o que
pode acelerar a convergncia.
Alm dos prprios operadores de recombinao, pode-se tambm modificar a
forma pela qual os pares so escolhidos. Normalmente os pares para a recombinao
so formados sorteando-se, sem reposio, dois indivduos no mating pool de cada
vez. Ao invs disso, pode-se usar algum critrio para escolher os pares diretamente,
ou influenciar em seu sorteio. Uma idia j testada formar duplas de indivduos de
alta aptido com outros tambm de alta aptido e, correspondentemente, os de baixa
aptido com outros de baixa aptido. Essa abordagem pode aumentar a velocidade de
convergncia mas tambm pode prejudicar a explorao global do espao de busca.
2.4.6 Mutao
Para se realizar a mutao, sorteia-se para cada posio de cada cromossomo,
um nmero com distribuio uniforme entre 0 e 1, e compara-se com a Pmut
(probabilidade de mutao). Onde o nmero sorteado for menor ou igual a Pmut trocase o smbolo (alelo) que ocupa a posio correspondente. Como o algoritmo gentico
usa sempre cromossomos binrios, as nicas trocas possveis so de 1 para 0 e de 0
para 1.
23
11000101000011111011
Mutao
posies onde vai haver mutao
11010101000001111011
posies modificadas
Figura 2.4.6.1 Mutao na codificao binria.
Note-se que as mutaes no algoritmo gentico so independentes, i.e., o fato

de ocorrer ou no uma mutao, em uma dada posio, no altera a probabilidade de
ocorrerem mutaes nas outras posies.
Existem ainda mtodos que alteram as probabilidades de cruzamento e
mutao para cada indivduo, de acordo com seu desempenho e com o desempenho
mdio e mximo encontrados na populao. O objetivo manter um nvel adequado
de diversidade gentica no mbito da populao e evitar a convergncia prematura.
Se o nmero de indivduos da populao pequeno e/ou o algoritmo j executou
inmeras iteraes, provavelmente h pouca diversidade gentica dentro da
populao. Se no houver um mecanismo que restaure essa diversidade, pode-se
comprometer a convergncia para o timo global (Vasconcelos, 2004). Para a
aplicao desse mtodo, utilizam-se as equaes a seguir:
Pc = k1
( f max f ')
( f max f med )
se f ' f med
Pc = k 3 se f ' < f med

Pm = k 2
( f max f )
( f max f med )
(2.4.6.1)
(2.4.6.2)
se f f med
Pm = k 4 se f < f med
onde:
Pc: probabilidade de cruzamento;
Pm: probabilidade de mutao;
(2.4.6.3)
(2.4.6.4)
24
f ': representa o maior valor da funo desempenho entre os dois membros

participantes do cruzamento;
f : valor da funo avaliada para o indivduo sujeito mutao;

f max : valor de desempenho mximo;
f med : valor de desempenho mdio;
k1 , k 2 , k 3 e k 4 : usualmente k1=k3=1 e k2=k4=0,05.
2.4.7 Penalidades e restries

A questo da limitao do espao de busca a um determinado intervalo um
ponto-chave quando existem restries sobre as variveis de deciso da funo
objetivo. Para que uma determinada combinao dessas variveis tenha validade,
devero atender a todos os critrios de busca do domnio da funo.
Uma maneira de se contornar esse tipo de problema seria executar a avaliao
de cada indivduo da populao corrente: caso um determinado integrante no atenda
as restries, procura-se outro para satisfaz-las. Esse tipo de anlise, usualmente,
no eficaz. Outra opo seria acoplar as restries sobre as variveis funo
objetivo, mtodo conhecido na literatura como mtodo das penalidades.
Nos mtodos que lidam com penalidades, um problema com restries pode
ser transformado em um problema irrestrito associando uma funo de penalidade
funo objetivo. Dessa forma, um problema de maximizao com restrio pode ser
escrito matematicamente como sendo:
Max f(x)
(2.4.7.1)
Sujeito a m restries de igualdade e l restries de desigualdade:

gj(x) 0 com j = 1,2,3,...,m
(2.4.7.2)
25
hk(x) = 0 com k = 1,2,3,...,l
(2.4.7.3)
onde as funes f(x), gj(x) e hk(x) so respectivamente a funo objetivo, j-sima

restrio de desigualdade e k-sima restrio de igualdade.
Assim, o problema pode ser reescrito na forma de:
Max (x,r,s) = f(x) + r
{max[0, g
m
j =1
j ( x ) } + s [hk ( x )]
l
(2.4.7.4)
k =1
onde as constantes r e s correspondem aos pesos de cada um dos tipos de restries

violadas.
Existem, ainda, mtodos que penalizam dinamicamente, ou seja, na funo a
ser otimizada, pode-se incluir um parmetro de acordo com um contador de gerao t
(Joines e Houck, 1994):
Max (x,r,s) = f(x) +
(C.t )
l
m
r {max 0, g j ( x) } + s [hk ( x)]
j =1
k =1
(2.4.7.5)
onde C e so constantes definidas pelo usurio e geralmente possui valor igual a

2.
2.4.8 Definio dos parmetros
A probabilidade de recombinao, a probabilidade de mutao e o tamanho da
populao so definidos antes da execuo de um algoritmo gentico. Infelizmente,
no existe uma metodologia que possa definir os melhores valores para esses
parmetros em relao a um problema especfico. Por isso, necessrio testar
diversas possibilidades e investigar qual delas apresenta os melhores resultados.
Normalmente se empregam em algoritmos genticos, valores nas seguintes faixas: n:
10 a 200, Prec: 0,5 a 1,0 e Pmut: 0,001 a 0,10.
Nos algoritmos genticos em sua forma tradicional, os parmetros de controle,
como Pmut e Prec, so definidos pelo usurio no incio do algoritmo e permanecem
com os mesmos valores at o final. Entretanto, como a populao muda de acordo
com a evoluo do algoritmo gentico, razovel pensar-se que parmetros
26
adequados no incio do algoritmo gentico possam no ser muito eficientes mais
frente, em sua evoluo. Nos chamados algoritmos genticos adaptativos, alteraramse os valores dos parmetros de forma a aumentar a sua eficincia. O tipo mais
comum de algoritmo gentico adaptativo aquele no qual varia-se Pmut de forma a
regular o balano explorao/explotao. medida que o algoritmo gentico vai
evoluindo, os indivduos tendem a ficar mais parecidos e, assim, a recombinao vai
perdendo a capacidade de explorar o espao de busca. Porm, se se aumenta a taxa
de mutao, pode-se criar mais diversidade na populao, explorando-se uma rea
maior do espao de busca. Para se definir quando se deve aumentar
Pmut,
monitoram-se as distncias entre os indivduos da populao, que refletem a

homogeneidade desta. Caso seja necessrio, aumenta-se a taxa de mutao de forma
a recuperar a diversidade e manter o poder de busca global.
Curiosamente em outra abordagem de algoritmo gentico adaptativo, adota-se
um procedimento de certa forma contrrio ao anterior. Sabe-se que altas taxas de
mutao tornam a busca do algoritmo gentico mais global, mas tambm dificultam a
sua convergncia. Assim, um procedimento razovel para variar a taxa de mutao
comear com um Pmut alto, de forma a explorar amplas regies do espao de busca
no incio e diminu-lo paulatinamente, medida que o algoritmo gentico evolua e o
efeito disruptivo da mutao se torne um empecilho para sua convergncia. Ambas as
abordagens fazem sentido em relao teoria dos algoritmos genticos e no est
claro ainda qual delas seria melhor. Provavelmente a eficcia de cada uma est
relacionada a outros fatores, como o tamanho da populao, a natureza da funo
objetivo e a prpria evoluo que o algoritmo gentico est apresentando (Srinivas e
Patnaik, 1994).
2.4.9 Critrios de Parada

O ciclo de geraes deve ser repetido at que um certo critrio de parada seja
alcanado. O ideal seria prosseguir com o algoritmo at se encontrar o mximo ou
mnimo da funo. Mas isso s possvel em problema-exemplo onde j se conhece a
soluo e se quer apenas provar que tal mtodo permite de encontr-la. Em
problemas prticos, no se consegue conhecer todo o espao de busca. Portanto no
se capaz de reconhecer o timo global, mesmo que pudesse encontr-lo.
27
Alternativamente se pode parar o algoritmo gentico quando uma soluo satisfatria
for encontrada. Isso pode funcionar bem para alguns tipos de problemas mas, em
muitos casos, pode ser difcil determinar o que uma soluo satisfatria ou ento o
prprio conceito de soluo satisfatria pode no ter sentido pois se deseja encontrar
a melhor soluo possvel.
Os dois critrios de parada mais simples e mais freqentemente utilizados so:
fixar um nmero de geraes ou fixar um tempo mximo de processamento. Outro
critrio, teoricamente melhor, seria parar o algoritmo quando ele chegasse
estagnao. Para isso, seria necessrio definir, de forma objetiva, como se poderia
reconhecer que o algoritmo gentico chegou estagnao. Mas isso pode ser muito
complicado porque freqentemente a evoluo de um algoritmo gentico ocorre de
forma errtica, com a aptido mdia da populao podendo oscilar fortemente ou
apresentar longos perodos de aparente estagnao antes de conseguir alcanar
melhorias significativas.
2.5 Otimizao multiobjetivo utilizando algoritmos genticos

Das diferenas entre os algoritmos genticos e os mtodos de otimizao
tradicionais, citam-se (Goldberg, 1989):
i) Os algoritmos genticos trabalham com uma populao de solues
em cada iterao ao invs de uma nica soluo. Em cada iterao, os
algoritmos genticos processam um conjunto de solues. Essa
caracterstica denominada paralelismo implcito;
ii) Os algoritmos genticos no precisam de informao adicional a no
ser o valor de aptido das solues. Isso faz com que os algoritmos
genticos sejam aplicveis a uma grande variedade de problemas, para
alguns dos quais no tm informaes a priori;
iii) Os algoritmos genticos empregam regras probabilsticas para guiar
a busca. Por exemplo, o processo de seleo baseado na
aleatoriedade de duas solues (seleo por torneio), ou na
probabilidade de escolha (seleo proporcional) dessas solues. O
28
operador de mutao permite que os algoritmos genticos no recaiam
nos timos locais, mudando a busca para outra regio no espao. Alm
de que, as solues da populao inicial podem ser escolhidas
arbitrariamente. Em contrapartida, uma tcnica de regras fixas no ter
como escapar de timos locais, em caso de m deciso sobre a direo
de busca.
A tabela a seguir exibe uma lista dos principais modelos de algoritmos
genticos aplicados a problemas multiobjetivos, com seus autores conforme (Deb,
2001).
Tabela 2.5.1 Algoritmos genticos multiobjetivos.
29
2.5.1 Descrio do Algoritmo NSGA

Tendo em vista que os melhores resultados obtidos por Dias (2000), em sua
dissertao de mestrado Algoritmos Genticos Aplicados a Problemas com Mltiplos
Objetivos deveram-se utilizao do algoritmo baseado em ordenao no-dominada
(Nondominated Sorting Genetic Algorithm - NSGA), a seguir tem-se uma breve
descrio do mesmo, que ser utilizado na resoluo dos problemas propostos neste
trabalho.
A partir de uma idia de Goldberg (989), Deb e Srinivas (1993) propuseram um
esquema de ordenao de solues candidatas a serem solues eficientes. O
princpio bsico consiste de um mtodo de seleo por classificao buscando bons
pontos candidatos. A tcnica de partilha empregada como ferramenta auxiliar para
manter a diversidade da populao sobre a fronteira Pareto-timo.
Uma vez que o algoritmo baseado em um procedimento de ordenao dos
pontos candidatos a serem pontos eficientes da populao, esse mtodo conhecido
na literatura tcnica como Nondominated Sorting Genetic Algorithm (NSGA).
O NSGA difere do Algoritmo Gentico Simples (AGS) apenas na maneira como
o mtodo de seleo trabalha, uma vez que os operadores de cruzamento e mutao
permanecem idnticos. Antes de o mtodo de seleo atuar, a populao
classificada com base na definio de pontos eficientes (conceito de Pareto-timo).
Os indivduos eficientes presentes na populao corrente so primeiramente
identificados. Assim, esses indivduos definiro a primeira fronteira eficiente e tero
como valor, na funo aptido, um nmero no nulo. O mesmo valor da funo de
aptido assumido para todos da primeira fronteira para se ter uma nica
probabilidade de reproduo. Para se manter a diversidade da populao, os
indivduos so submetidos atuao da tcnica de formao de nichos com funo de
partilha triangular sobre os seus valores de aptido.
Com a funo de partilha, obtem-se a funo de aptido degradada, a qual
definida como sendo a funo de aptido original do indivduo dividida pela quantidade
proporcional de indivduos ao redor do mesmo (dado pelo tamanho do nicho). Aps a
partilha, os indivduos eficientes so ignorados temporariamente para se processar o
resto da populao de modo a identificar indivduos para a segunda fronteira eficiente.
30
Esses pontos eficientes assumiro um novo valor da funo de aptido que dever ser
menor que o valor mnimo da funo de aptido da fronteira anterior. O processo
continua at que toda a populao seja classificada em fronteiras eficientes ou nodominadas.
A populao ento reproduzida de acordo com a sua funo de aptido.
Inicialmente foi proposto um operador de seleo do tipo SRS (Stochastic Reminder
Sampling), mas qualquer tipo de seleo pode ser aplicado. Uma vez que os
indivduos da primeira fronteira apresentam o maior valor de aptido, tero sempre
mais cpias que o resto da populao corrente. Dessa forma, leva-se a pesquisa para
regies do espao vivel nas proximidades da fronteira Pareto-timo. Esse mtodo
apresenta uma convergncia acelerada e o processo de partilha auxilia a distribuio
dos indivduos sob a fronteira eficiente.
Conforme pode ser observado no fluxograma do NSGA (figura 2.5.1.1), o
algoritmo similar ao algoritmo gentico simples, com exceo da classificao das
fronteiras eficientes e da operao de partilha. A partilha, em cada fronteira,
determinada pelo clculo do valor da funo de partilha Sh(dij) entre dois indivduos da
mesma fronteira como abaixo:
Sh(dij)
1 (dij/shared)
se dij
<
shared
se dij
shared
(2.5.1.1)
Nessa equao, o parmetro dij corresponde distncia no espao em estudo

entre dois indivduos i e j da fronteira atual. A varivel shared corresponde distncia
mxima, nesse espao, permitida entre dois indivduos quaisquer para se tornarem
membros do nicho. O parmetro (geralmente com valor 2) tem por objetivo penalizar
os indivduos mais prximos. Algumas idias sobre como definir esses parmetros
podem ser encontradas em Goldberg (991), Deb (1999) e Srinivas e Deb (1994). O
parmetro tamanho de nicho, Ncount, calculado somando-se os valores da funo de
partilha de todos os indivduos presentes na fronteira eficiente. Finalmente, a funo
de partilha de cada indivduo calculada dividindo-se a funo de aptido definida na
classificao pelo tamanho do nicho.
31
Incio
Inicializa Populao
Gerao = 0
Avalia Populao
Fronteira = 1
Incrementa gerao
Populao foi
classificada
Identifica indivduos
eficientes
Seleo AG
Calcula a funo de
aptido
Cruzamento AG
Executa tcnica de
formao de nichos
Mutao AG
Incrementa fronteira
Gerao < Gmax.
Finalilzao
Figura 2.5.1.1 Fluxograma NSGA (Dias, 2000).
Usualmente esse tipo de funo de partilha conhecida como partilha

fenotpica (phenotypic sharing) (Deb, 1999). Em Goldberg (1987), Goldberg e
Richardson sugeriram, mas no simularam, o uso da partilha baseada na proximidade
gentica. A proximidade gentica de dois indivduos pode ser tomada como o nmero
de genes diferentes em seus cromossomos, ou seja, a distncia Hamming entre as
strings que os representam.
A distncia dij considerada na funo de partilha, baseada no espao de
variveis de otimizao, a distncia das seqncias de caracteres (strings) que
identificam o indivduo (considerando-se o caso de codificao binria) segundo Deb
(1999) e Srinivas e Deb (1993). Para funes de apenas uma varivel, essa distncia
pode ser calculada como a diferena absoluta da varivel decodificada. No caso mais
geral, para funes de p-variveis, a distncia pode ser calculada usando-se algum
32
critrio de norma para espaos de dimenso p. Como critrio de simplificao, a
distncia euclidiana adotada na formulao da distncia.
Dessa forma, dados os indivduos com p-variveis:
Xi = [X1,i
X2,i
X3,i
...
Xp,i]
Xj = [X1,j
X2,j
X3,j
...
Xp,j]
(2.5.1.2)
Onde X a k-sima varivel decodificada do i-simo indivduo.

A distncia dij pode ser calculada como:
(X
p
dij =
k =1
X k, j )
k ,i
(2.5.1.3)
Onde as variveis X1,i, X2,i, ..., Xp,i so parmetros de otimizao decodificados do

problema em estudo.
Deb (1998), props outra frmula de anlise que considera a distncia
euclidiana para p-dimenses normalizada:
X k ,i X k , j
k =1 X max k X min k
p
dij =
(2.5.1.4)
onde so citadas duas estimativas de parmetro shared:
[1]
shared =
1 p
2 p q
(2.5.1.5)
[2]
shared =
1p
0.1
2
(2.5.1.6)
Outra maneira de se implementar a funo de partilha utilizar o espao de

funes objetivo ao invs do espao de otimizao. sabido que diferentes escalas,
nas dimenses do espao de funes objetivo em um problema multiobjetivo, podem
afetar a distribuio dos indivduos na populao corrente.
33
Dessa forma, sugere-se uma mudana de escala normalizando todos os
valores das funes objetivo no intervalo [0,1]. Note-se que esse processo somente
possvel quando se conhecem os valores mximo e mnimo que cada funo objetivo
pode assumir, o que usualmente o caso.
Define-se ento um valor sugestivo para shared como sendo:
shared = 0.5 * n
1
10
(2.5.1.7)
a qual anloga equao da opo [2] (equao 2.5.1.6) anteriormente citada. Para
o clculo sobre os valores das funes objetivo, deve-se inicialmente definir pesos
positivos wi para cada uma das funes, de modo que:
n
w
i =1
=1
(2.5.1.8)
A distncia entre dois indivduos dij pode ento ser dada de forma anloga
distncia no espao de variveis de otimizao:
Fk ,i Fk , j
k =1 X max k X min k
r
dii =
(2.5.1.9)
34
3 Metodologia
3.1 Processo de Modelagem
Conforme descrito por Goldbarg e Luna (2005), possvel, de forma bastante
geral, resumir o processo de modelagem ou de construo de modelos na tica
operacional, pelos passos sugeridos no fluxograma a seguir, que foi utilizado neste
trabalho:
Definio do Problema
Formulao e Construo
do Modelo Inicial
Simulao do Modelo
Validao do Modelo
Reformulao do Modelo
Aplicao do Modelo
Figura 3.1.1 Fluxograma do processo de modelagem (Goldbarg e Luna, 2005).
35
3.2 Definio dos problemas

O objetivo principal deste trabalho avaliar a aplicabilidade dos algoritmos
genticos na definio de cava final e seqenciamento de lavra para minas a cu
aberto.
Para se atingir tal objetivo pretende-se desenvolver um conjunto de rotinas
computacionais que, a partir de um modelo de blocos tecnolgicos conhecido que
represente uma jazida, seja capaz de gerar um conjunto de solues timas, tendo em
vista os objetivos de maximizao de reservas (massa), maximizao de valor no
descontado (lucro), respeitando as condicionantes de qualidade e distribuio das
massas no tempo (seqenciamento de lavra).
Pode-se dividir nos seis problemas citados a seguir:
a) Otimizao mono-objetivo
I. Determinao da cava final maximizando o lucro no descontado;
II. Determinao da cava final maximizando o lucro no descontado com
restries de qualidade;
III. Determinao da cava final maximizando o lucro no descontado com
restries de qualidade e/ou massas no tempo.
b) Otimizao multiobjetivo
I. Gerao da famlia de cavas timas visando maximizar recursos e o lucro
no descontado;
II. Gerao da famlia de cavas timas visando maximizar recursos e teor
mdio;
III. Gerao da famlia de cavas timas visando maximizar o lucro no
descontado e teor mdio.
3.3 Construo dos modelos de blocos tericos
O modelo de blocos utilizado neste trabalho baseado no exemplo
originalmente apresentado em Lerchs e Grossmann (1965), elaborado por Sainsbury
(1970) e reapresentado por Hustrulid & Kuchta (1995), que descreve o algoritmo de
Lerchs-Grossmann em 2D, conforme item 2.1.1.
36
Alm dos valores econmicos dos blocos, so atribudos valores de massa
visando a gerao de cavas multiobjetivo, ou seja, gerao das cavas pertencentes
fronteira do Pareto-timo. Visando simplificar a estrutura da base de dados relativos
ao modelo de blocos, para o clculo das massas dos blocos, admitiu-se que todos os
blocos possuem a mesma densidade e, portanto, possuem a mesma massa cujo valor
considerado foi o de uma unidade de peso.
Com relao aos teores, tambm com o objetivo de simplificar a gerao dos
modelos de blocos a serem trabalhados, os valores de teor mdio foram calculados a
partir dos valores econmicos na razo de 10/1, ou seja, para os blocos com valores
econmicos positivos,
os valores de teor mdio tero dez vezes menos o valor
econmico. Por exemplo: um bloco de 12 unidades monetrias ter um teor mdio de

1,2%.
Abaixo algoritmo utilizado para gerao do arquivo ASCII referente ao modelo
de blocos.
Para i = 1 at NLinhas
Para j = 1 at NColunas
Para k = 1 at NNiveis
ValorBloco = CalculaValorBloco(k, j)
se ValorBloco >= 0 ento
TeorBloco = ValorBloco / 10
seno
TeorBloco = -1
fim-se
Escreve arquivo (i, j, K, ValorBloco, TeorBloco)
fim-para
fim-para
fim-para
3.4 Codificao das rotinas computacionais para os problemas propostos
Os algoritmos foram desenvolvidos em Microsoft Visual Basic
(VBA 6.3)
disponvel no aplicativo Microsoft Excel, possibilitando uma maior divulgao dos

conceitos envolvidos neste trabalho. claro que tal opo desfavorece uma aplicao
prtica real, uma vez que geralmente tem-se modelos de blocos de grandes
dimenses que, por sua vez, demandam altos custos computacionais. Tambm foram
codificados algoritmos em Delphi (V3.0 - Borland International) uma vez que esse
compilador tem desempenho superior ao do VBA.
37
Foram implementados trs algoritmos genticos. Destinou-se o primeiro
resoluo de problemas mono-objetivos. O segundo, soluo dos problemas
multiobjetivos. Ambos codificado em VBA. J o terceiro, codificado em Delphi, trabalha
tanto para o problema mono-objetivo quanto para os multiobjetivos. Os anexos do item
8 contm as listagens dos algoritmos codificados.
Para o primeiro programa de computador desenvolvido visando a resoluo
dos problemas mono-objetivos, utilizou-se a estrutura do algoritmo gentico simples
onde a populao inicial foi gerada aleatoriamente. O processo de seleo utilizado foi
o do mtodo da roleta, cruzamento de um ponto e mutao. Para o processo de
elitismo foi implementada uma variante que possibilita a definio de uma
probabilidade escolhida pelo tomador de deciso que copia os melhores indivduos no
processo de seleo.
A codificao do algoritmo multiobjetivo tve por base o algoritmo desenvolvido
por Dias (2000) em Matlab, disponvel na pgina do professor Dr. Joo Antnio de
Vasconcelos, que faz parte do Curso de Ps-Graduao em Engenharia Eltrica da
UFMG cujo endereo eletrnico www.cpdee.ufmg.br/~joao no link da disciplina
otimizao multiobjetivo.
Para o problema em pauta, cada cromossomo foi representado pelo conjunto
de blocos de valores positivos contidos no modelo de blocos que sero lavrados
considerando-se as restries geotcnicas. Nesse caso, o cromossomo ser do
tamanho do nmero de blocos de minrio que existe no modelo de blocos e
corresponde a um indivduo que um candidato soluo do problema.
3.5 Validao dos algoritmos
Uma vez que os trabalhos iniciais foram desenvolvidos no modelo apresentado
por Lerchs e Grossmann (1965), para o caso de maximizao do lucro no
descontado e reservas, j se conhece a soluo. Os resultados so apresentados no
item 5.
Para os trabalhos de otimizao multiobjetivo as rotinas computacionais
desenvolvidas foram validadas por funes-teste disponveis na literatura. Os
resultados so apresentados no item 6.
38
4 Descrio dos algoritmos e programas de computador codificados

4.1 Cdigos implementados
Conforme descrito no item 2.1, trata-se de um problema de maximizao. A
partir do modelo de blocos contendo um valor monetrio para cada bloco, o objetivo
maximizar o valor total dos blocos extrados, tendo em vista que existem blocos com
valores positivos e negativos e, ainda, as restries geomecnicas. Como resultado,
tem-se o valor mximo que se pode obter da cava, bem como sua conformao final,
ou seja, a geometria final da cava, conforme ilustrado na figura 2.9.
Ressalta-se que, nesse modelo, existem 36 blocos com valores positivos, que
foram trabalhados pelo algoritmo, uma vez que o mesmo faz a busca somente destes
blocos. A extrao dos blocos negativos conseqncia do ngulo geral de talude
aplicado que, no caso, foi de 45 graus.
Depois de devidamente validadas as rotinas computacionais desenvolvidas,
foram realizadas vrias simulaes visando obter os resultados gerados para os seis
tipos de problemas propostos.
Foram executados testes no algoritmo gentico simples com elitismo para o
problema de maximizao do lucro, segundo os dados descritos no item 2.1 algoritmo de Lerchs-Grossmann em 2D.
J para o programa baseado no modelo NSGA, foram realizados testes em
problemas multiobjetivos disponveis na literatura: Schafferf2 e Schafferf3. O mesmo
foi utilizado para otimizao do lucro no descontado e para os problemas
multiobjetivo de maximizao de reservas e lucro no descontado, maximizao de
recursos e teor mdio e, finalmente, maximizao do lucro no descontado e teor
mdio.
39
4.2 Descrio do algoritmo gentico simples (AGS) com elitismo em VBA

4.2.1 Caractersticas Gerais
O programa de computador Evolpit desenvolvido em VBA na plataforma
Windows, trabalha a partir de um arquivo ASCII que contem informaes relativas a
um recurso mineral que, por sua vez, representado por um modelo de blocos.
O modelo de recursos utilizado uma adaptao do modelo apresentado por
L&G onde se pode trabalhar com at 22 sees totalizando at 6.776 blocos (22
linhas, 22 colunas e at 14 nveis).
A funo de mrito (objetivo) inserida no algoritmo foi a de maximizao do
valor no descontado da cava final (otimizao mono objetivo).
Visando a aplicao de parte da teoria que engloba os algoritmos genticos,
existem os seguintes recursos no cdigo do algoritmo implementado:
Parmetros de entrada:
- Modelo de blocos:
- Origem;
- Tamanho dos blocos;
- Tamanho do modelo de blocos.
- Parmetros de controle de loop:
- Tamanho da populao;
- Probabilidade de cruzamento;
- Probabilidade de mutao;
- Percentual de elitismo;
- Nmero da semente.
40
Resultados:
- Visualizao das informaes do modelo de blocos processado;
- Resultados de todos os indivduos da populao por gerao;
- Visualizao dos blocos lavrados atravs de sees verticais;
- Resumo dos resultados no caso de processamento de mais de um
cenrio de lavra.
4.2.2 Interface de parmetros
Assim que carregada na memria, a interface responsvel pela entrada dos
parmetros a serem utilizados pelo programa exibida conforme figura a seguir:
Figura 4.2.2.1 Interface AGS (VBA).
41
4.2.2.1 Modelo de Blocos
Origem: definem-se as coordenadas x,y e z que correspondem ao vrtice do
canto superior anterior esquerdo do paraleleppedo que representa o modelo de
recursos em blocos discretizados de mesmo tamanho.
Tamanho dos Blocos: refere-se aos tamanhos de cada bloco regular, nas
direes dos trs eixos do paraleleppedo (x,y e z). Ressalta-se que todos os blocos
possuem o mesmo tamanho, ou seja, o algoritmo no trabalha com sub-blocos.
Tamanho do modelo: define as dimenses do paraleleppedo relativo ao
modelo de blocos nas trs direes (linhas, colunas e nveis).
Estrutura do arquivo de modelo de blocos: Arquivo ASCII separado por vrgulas
contendo seis colunas, necessariamente na seguinte ordem:
1)
Nmero da linha de cada bloco do modelo;
2)
Nmero da coluna de cada bloco do modelo;
3)
Nmero do nvel de cada bloco do modelo;
4)
Valor monetrio do bloco (poder ser positivo ou negativo).
Salienta-se que, na primeira linha, devem existir as descries de cada coluna

do arquivo.
4.2.2.2 Parmetros de controle de loop

Semente: parmetro utilizado para criao de nmeros aleatrios no algoritmo.
Esse parmetro importante para se obter repetibilidade dos cenrios avaliados.
Populao: tamanho da populao que ser utilizada no algoritmo gentico. O
tamanho mximo da populao permitido nesse cdigo de 2000 indivduos.
Cruzamento: refere-se taxa de cruzamento que ser utilizada no algoritmo
gentico. Geralmente varia de 0,5 a 1,0.
42
Mutao: refere-se taxa de mutao que ser utilizada no algoritmo gentico.
Geralmente varia de 0,001 a 0.1.
Elitismo: ser a taxa utilizada para cpia do melhor indivduo de cada gerao.
Por exemplo, uma taxa de 0,2 em uma populao de 100 indivduos: sero copiados
20 indivduos iguais ao melhor indivduo da gerao. Mesmo com uma taxa de zero, o
algoritmo sempre manter o melhor indivduo em cada gerao.
4.2.3 Resultados
Aps o processamento dos clculos, so geradas vrias planilhas conforme
descrito a seguir:
4.2.3.1 Modelo Lido
A planilha Model_CSV contem os parmetros referentes posio geomtrica
dos blocos (linha, coluna e nvel), bem como ao valor monetrio de cada bloco.
4.2.3.2 Visualizao sees verticais
Sero geradas tantas planilhas de linhas quantas existirem no arquivo de
modelo de blocos lido. Tero o nome r_nome da linha, por exemplo: r1 que representa
a linha (row) 1. A figura a seguir exibe a seo vertical referente linha 1 de um
modelo de blocos de apenas uma linha:
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
8
0
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
12
12
8
0
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
12
12
12
12
8
0
-4
-4
-4
-4
-4
-4
-4
-4
0
8
12
12
12
12
8
0
-4
-4
-4
-4
-4
-4
-4
-4
0
8
12
12
12
12
8
-4
-4
-4
-4
-4
-4
-4
-4
-4
0
8
12
12
12
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
0
8
12
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
0
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
Figura 4.2.3.2.1 Modelo de blocos lido AGS (VBA).
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
-4
43
4.2.3.3 Planilhas auxiliares
PopIni: contem os dados referentes populao inicial cujos valores podem ser
verdadeiro (extrair bloco) ou falso (no extrair bloco).
PopFit: contem os valores da aptido calculada para cada individuo para todas
as geraes.
NCopias: contem o nmero de cpias de cada indivduo calculado pelo
algoritmo gentico de acordo com a sua aptido.
Resultados Grupo: Caso sejam utilizadas algumas opes de loop, o resultado
dos melhores indivduos de cada condio simulada ser armazenado nessa planilha.
4.2.3.4 Planilha de Resultados
Nessa planilha, cada clula representa um indivduo, ou seja, uma cava final. O
valor contido em cada clula representa o valor no descontado do lucro da cava.
Cada linha representa uma gerao. Assim, o nmero de linhas da planilha ser igual
ao nmero de geraes definido na interface de parmetros. O nmero de colunas
ser equivalente ao tamanho da populao utilizado.
4.2.3.5 Sees verticais cava final
A geometria final da cava final ser visualizada por meio de sees verticais
conforme a figura a seguir:
FALSE
FALSE
FALSE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
TRUE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
TRUE
TRUE
TRUE
TRUE
TRUE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
TRUE
TRUE
TRUE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
TRUE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
FALSE
Figura 4.2.3.5.1 Seo vertical AGS (VBA).
44
Nessa figura, cada clula representa um bloco. Os blocos que sero lavrados
esto na cor verde e possuem valor verdadeiro (true). J os blocos em amarelo
representam os blocos que permanecero in situ e possuem valor falso (false).
4.3 Descrio programa NSGA - VBA
4.3.1 Caractersticas Gerais
Conforme citado anteriormente, a codificao do algoritmo multiobjetivo teve
por base o algoritmo desenvolvido por Dias (2000) em Matlab, disponvel na pgina do
professor Dr. Joo Antnio de Vasconcelos, que faz parte do Curso de Ps-Graduao
em
Engenharia
Eltrica
da
UFMG
cujo
endereo
eletrnico
www.cpdee.ufmg.br/~joao no link da disciplina otimizao multiobjetivo.

O objetivo da elaborao dessa planilha que contem o cdigo VBA foi validar a
migrao do cdigo em Matlab para o Visual Basic, por meio de duas funes de teste
disponveis na literatura.
4.3.2 Descrio das funes de teste utilizadas
As funes testadas so denominadas Schafferf2 e Schafferf3 cujos grficos no
espao das variveis so apresentados a seguir:
Funo Schafferf2 - Espao das variveis

4.00
3.50
3.00
2.50
2.00
Schafferf2 f1
Schafferf2 f2
1.50
1.00
0.50
0.00
-2
-1
Figura 4.3.2.1 Grfico da funo Schafferf2 no espao das variveis.
45
Funo Schafferf3 - Espao das variveis

10
8
6
4
2
0
-2
Schafferf3 f1
10
-2
Schafferf3 f2
Figura 4.3.2.2 Grfico da funo Schafferf3 no espao das variveis.
Os grficos a seguir exibem as funes Schafferf2 e Schafferf3 no espao dos

objetivos:
Funo Schafferf2 - Espao dos Objetivos

6
5
4
3
2
1
0
0
Figura 4.3.2.3 Grfico da funo Schafferf2 no espao dos objetivos.
46

20
18
16
14
12
10
8
6
4
2
0
-1.5
-1
-0.5
0.5
1.5
Figura 4.3.2.4 Funo Schafferf3 no espao dos objetivos.
4.3.3 Parmetros de entrada

A figura abaixo exibe a interface do programa NSGA II codificado em Excel
VBA:
Tamanho da populao:
Tamanho da populao externa (elitismo):
Nmero mximo de geraes:
Problemas: (1) Schafferf2; (2) = Schafferf3
Probabilidade de cruzamento [0,1]:
Probabilidade de mutao [0,1]:
Semente:
Percentagem de elitismo [0,1]:
Fator de partilha: (0) automtico; (valor personalizado):
Limite mnimo Schafferf2
Limite mximo Schafferf2
Limite mnimo Schafferf3
Limite mximo Schafferf3
Figura 4.3.3.1 Interface NSGA (VBA).
100
200
120
2
0.9
0.01
12345
0.9
0
-12
12
-2
10
47
4.3.4 Resultados
Os resultados para as duas funes de teste so disponibilizados por meio dos
recursos grficos disponveis no MS Excel conforme a figura abaixo:
4.5
4
3.5
3
2.5
2
1.5
1
0.5
0
18
16
14
12
10
8
6
4
0
-1.5
-1
-0.5
0.5
1.5
Figura 4.3.4.1 Resultados grficos NSGA (VBA).
4.4 Descrio do programa EvolPit - Delphi

4.4.1 Caractersticas gerais
O programa de computador Evolpit desenvolvido em Delphi na plataforma
Windows, trabalha a partir de um arquivo ASCII que contem informaes relativas a
um recurso mineral que, por sua vez, representado por um modelo de blocos. O
objetivo do programa avaliar a utilizao dos algoritmos genticos na gerao de
cavas finais e seqenciamentos matemticos em minas a cu aberto.
O modelo de recursos utilizado uma adaptao do modelo apresentado por
L&G onde se pode trabalhar com at 999 sees totalizando at 307.692 blocos (999
linhas, 22 colunas e at 14 nveis).
As funes de mrito (objetivo) inseridas no algoritmo foram a de maximizao
do valor no descontado da cava final (otimizao mono objetivo), e trs opes de
otimizao multiobjetivo: a) Valor & massa minrio, b) Valor & teor e c) Massa minrio
& teor.
48
Utilizando-se das opes de restries de massa (nmero de blocos) e teores
(mnimo e mximo) disponveis na interface do programa, pode-se trabalhar com a
construo de cenrios de seqenciamentos de lavra.
Visando a aplicao de parte da teoria que engloba os algoritmos genticos,
existem os seguintes recursos no cdigo do algoritmo implementado:
- Modelo de blocos;
- Opes de otimizao;
- Gerao da populao inicial;
- Parmetros de controle de loop;
- Parmetros de nicho;
- Opes de cruzamento e adaptao dinmica;
- Opes de mutao e seleo;
- Opes de restries.
Resultados:
- Visualizao das informaes do modelo de blocos processado;
- Histogramas do nmero de blocos com valores no negativos;
- Resultados de todos os indivduos da populao por gerao (Valor e
Aptido);
- Visualizao dos blocos lavrados por meio de sees verticais;
- Grficos de evoluo do AG;
49
- Resumo dos resultados no caso de processamento de mais de um
cenrio de lavra;
- Grfico dos resultados da otimizao multiobjetivo (Objetivo1 x
Objetivo2).
4.4.2 Parmetros de entrada
4.4.2.1 Interface dos parmetros de entrada
Assim que carregada na memria, a interface responsvel pela
entrada dos parmetros a serem utilizados pelo programa est na janela de
Parmetros conforme afigura a abaixo:
Figura 4.4.2.1 Interface parmetros de entrada (Evolpit).
50
4.4.2.2 Modelo de Blocos
As definies de origem, tamanho dos blocos e tamanho do modelo so as
mesmas do AGS com elitismo codificado em VBA descritas no item 4.2.2.1.
Estrutura do arquivo de modelo de blocos: Arquivo ASCII separado por vrgulas
contendo seis colunas, necessariamente na seguinte ordem:
1)
Nmero da linha de cada bloco do modelo;
2)
Nmero da coluna de cada bloco do modelo;
3)
Nmero do nvel de cada bloco do modelo;
4)
Valor monetrio do bloco (poder ser positivo ou negativo);
5)
Teor mdio do bloco;
6)
Valor 0 ou 1 que representa a populao inicial. O zero representa
blocos no lavrados e o valor igual unidade blocos dentro da cava final.

Salienta-se que, na primeira linha, devem estar as descries de cada coluna
do arquivo.
4.4.2.3 Opes de Otimizao

Utilizando-se aa interface do programa, pode-se optar por quatro tipos de
funo de otimizao:
- Valor: que corresponde maximizao do valor no descontado da
cava final;
- Valor_Minrio: otimizao multiobjetivo onde se quer maximizar o valor
no descontado da cava final e os recursos, ou seja, o nmero de blocos no
negativos;
51
- Valor_Teor: otimizao multiobjetivo onde se quer maximizar o valor
no descontado da cava final e o teor mdio;
- Minrio_Teor: otimizao multiobjetivo onde se quer maximizar o
nmero de blocos no negativos e o teor mdio.
4.4.2.4 Gerao da populao inicial
Aleatria: o processo de seleo dos blocos de minrio que sero lavrados
aleatrio, ou seja, independe do valor e da posio espacial do bloco dentro do
modelo.
Modelo: os blocos de minrio que sero lavrados na populao inicial so os
que possuem o valor 1 no arquivo de modelo de blocos na sexta coluna do arquivo.
Opes de Agrupamento: Consistem em agrupar os blocos positivos que
estejam aflorando na superfcie, ou seja, sem blocos negativos bloqueando os
mesmos. Alm disso, os cones contendo somente blocos de minrio tambm so
agrupados. A opo de agrupar trabalha em conjunto com a barra de agrupamento,
logo abaixo da mesma, na interface do programa. Quando essa opo est marcada
alm da posio de mnimo (Min.), a seguinte expresso utilizada para agrupar os
cones dos blocos:
round((InicioEsteril + k)*AG.FCluster/10)-1
(4.4.2.4.1)
onde,
InicioEsteril: corresponde posio da lista de cones fortes (aflorantes +
somente blocos positivos) mais um;
k: posio na lista em que, aps ordenao da mesma, o valor da cava
foi mximo;
AG.FCluster: Fator de agrupamento que varia de 0 a 5 de acordo com a
posio selecionada na interface.
Heurstica 1 (H1): o processo de seleo dos blocos de minrio que sero
lavrados na populao inicial baseado no algoritmo seguinte:
52
VMax = Populacao.Valor
troca = verdadeiro
para k = 1 at AG.FCluster + 1 faa
para i = InicioEsteril at Len_Cromos faa
Populacao.Cromos[i] = Troca
Avalia_Individuo
se Populacao.Valor >= VMax ento
VMax = Populao.Valor
seno
Populacao.Cromos[i] = no Troca
fim-se
fim-para;
Troca = no Troca
fim-para;
A idia bsica desse algoritmo lavrar os blocos que agregam valor cava
final simplesmente avaliando se a extrao do bloco aumenta o valor total da cava.
Heurstica 2 (H2): o processo de seleo dos blocos de minrio que sero
lavrados na populao inicial baseado no seguinte algoritmo:
para i = IEsteril to Len_Cromos faa

Populacao[2].Cromos[i] = falso
Populacao[1].Cromos[i] = verdadeiro
Avalia_Individuo(1)
ConeMin[i] = Populacao[1].Valor
Para j = IEsteril at Len_Cromos faa
Populacao[1].Cromos[j] = falso
Fim-para
Fim-para
QuickSortDM(IEsteril,Len_Cromos)
k = 0
para i = IEsteril at IEsteril + AG.FCluster - 1 faa
k = k +1
para j = 1 at AG.SizePop faa
Populacao[j].Cromos[i] = verdadeiro
Fim-para
Fim-para
IEsteril = IEsteril + k
Nessa heurstica faz-se a ordenao de todos os blocos positivos de acordo
com o seu valor monetrio e, em seguida, lavram-se os blocos de acordo com o fator
de agrupamento definido na interface.
53
4.4.2.5 Parmetros de controle de loop
Os parmetros semente, populao cruzamento, mutao e elitismo so os
mesmos utilizados no algoritmo gentico simples com elitismo conforme descrito no
item 4.2.2.2.
Boto Calc N.Iter.: utilizado para calcular o nmero de cenrios que sero
processados pelo algoritmo, de acordo com os parmetros de loop definidos na
interface.
4.4.2.6 Parmetros de nicho

Alpha: corresponde ao termo da equao 2.5.1.1 e tem por objetivo penalizar
os indivduos mais prximos.
Sigma: corresponde ao termo shared da equao 2.5.1.1 e indica o grau de
vizinhana entre dois indivduos.
4.4.2.7 Opes de cruzamento e adaptao dinmica

Cruz1pt: nessa opo, o processo de cruzamento do algoritmo gentico ser
realizado com apenas um ponto. Caso essa opo seja desmarcada, o algoritmo
utilizar o cruzamento com dois pontos.
ADI (Adaptao Dinmica por indivduo): Conforme descrito no item 2.4.6, as
probabilidades de cruzamento e mutao, para cada indivduo, variam de acordo com
o seu desempenho e com os valores de desempenho mdio e mximo encontrados na
populao. Nesse critrio, deseja-se evitar que as boas solues se percam com
facilidade, e que as ms sejam totalmente destrudas.
4.4.2.8 Opes de mutao e seleo
Foram implementados 10 diferentes tipos de seleo, 4 tipos de mutao e
ainda uma opo denominada mutao induzida.
54
A seguir, a lista dos 10 diferentes mtodos de seleo implementados no
programa:
RO Mtodo da Roleta:
Para i = 1 at AG.SizePop faa

NAleat = Random
Para j = 1 at AG.SizePop - 1 faa
se (NAleat >= ProbPopAc[j]) E
(NAleat<ProbPopAc[j+1])
ento
NCopias[j] = NCopias[j] + 1
NC = NC + 1
Fim-se
Fim-para
Fim-para
se NC < AG.SizePop ento
para i = NC + 1 at AG.SizePop faa
NCopias[i] = NCopias[i] + 1
Fim-para
Fim-se
AA Amostragem Aleatria:
Para i = 1 at AG.SizePop faa

j = round((AG.SizePop -1) * Random) + 1
NC = NC + 1
fim-para
NCopias[j] := NCopias[j] + 1
fim-para
fim-se
AE Amostragem Estocstica:
NC = 0
para i = 1 at AG.SizePop faa
NCopias[i] :=
trunc(Populacao[i].Fitness/(AcumAP/AG.SizePop))
se NCopias[i] > 0 ento NC := NC + 1
fim-para
enquanto NC <= AG.SizePop faa
NAleatorio = Random
se (Populacao[i].Fitness/Mediatrunc(Populacao[i].Fitness/Media))/(AG.SizePop-
55
ento
NC+1)>NAleatorio
NCopias[i] := NCopias[i] + 1;
NC := NC + 1;
Fim-se
if NC >= AG.SizePop ento Sair
fim-para
fim-enquanto
AD Amostragem Determinstica:
NC = 0
NCopias[i] = trunc(Populacao[i].Fitness/Media)
NC = NC + NCopias[i]
fim-para
j = Round((AG.SizePop - 1) * Random) + 1
se ((Populacao[j].Fitness / Media)
trunc(Populacao[j].Fitness / Media)) > Random
ento
NC = NC + 1
fim-se
fim-enquanto
D1 Amostragem Determinstica Variante 1:

NCopias[i] = trunc(Populacao[i].Fitness / Media)
fim-para
NC = 0
fim-para
k = 1
k = k - 0.1
para i := 1 at AG.SizePop faa
se ( (Populacao[i].Fitness / Media)
trunc(Populacao[i].Fitness / Media) ) > k
ento
NC = NC + 1
se NC >= AG.SizePop ento sair
fim-se
56
fim-enquanto
NC = 0
Fim-para
se NCopias[i] > 0 ento
NC = NC + 1
if NC >= AG.SizePop ento sair
fim-se
fim-para
fim-enquanto
TR Mtodo de Torneio:
NC = 0
para i = 1 at AG.SizePop -1 faa
se Populacao[i].Fitness > Populacao[i+1].Fitness
ento
seno
NCopias[i+1] = NCopias[i+1] + 1
Fim-se
NC = NC + 1
Fim-para
Fim-para
Fim-se
57
T1 Mtodo de Torneio Variante 1:
para i = 1 at AG.SizePop - 1 faa

se Populacao[i].Fitness > Populacao[i + 1].Fitness
ento
NCopias[i] := NCopias[i] + 1
seno
NCopias[i + 1] := NCopias[i + 1] + 1
Fim-se
Fim-para
k = 1
k = k - 0.1
se ( (Populacao[i].Fitness / Media)
trunc(Populacao[i].Fitness / Media) ) > k
ento
NC := NC + 1;
NCopias[i] := NCopias[i] + 1;
Se NC >= AG.SizePop ento sair
fim-se
fim-enquanto
T2 Mtodo de Torneio Variante 2:
NC = 0
NC = NC + 1
j = Round((AG.SizePop - 1) * Random) + 1
i = Round((AG.SizePop - 1) * Random) + 1
se Populacao[j].Fitness > Populacao[i].Fitness ento
se Random < 0.75 ento
NCopias[j] := NCopias[j] + 1
seno
NCopias[i] := NCopias[i] + 1
fim-se
fim-se
fim-enquanto
58
A seguir, a lista dos 4 tipos de mutao ora implementados:
M1 Heurstica de Mutao 1
PM = AG.PMut
para j = InicioEsteril at Len_Cromos faa
se Random <= PM ento
se Populacao[i].Cromos[j] = True ento
Populacao[i].Cromos[j] = False
seno
Populacao[i].Cromos[j] = True
fim-se
fim-se
fim-para
fim-para
se AG.PMut * Len_Cromos < 1 ento

para j = 1 at Len_Cromos faa
seno
fim-se
fim-para
seno
para z = 1 at round(AG.Pmut*Len_Cromos) faa
para i = 2 To AG.SizePop faa
k = round(Random * (Len_Cromos-1))+1
para j = 1 To k do
seno
fim-para
fim-para
fim-para
fim-se
59
se AG.SizePop * AG.PMut * Len_Cromos < 1 ento

para j = 1 at Len_Cromos faa
se Random <= AG.PMut Then
seno
fim-se
fim-se
seno
para z=1 at round(AG.SizePop*AG.Pmut*Len_Cromos)
faa
i = round((AG.SizePop-1) * Random) +1
se i = 1 ento i = 2
k = round(Random * (Len_Cromos-1))+1
para j = 1 at k faa
seno
fim-se
fim-para
fim-para
fim-se

PM = AG.PMut*PercMut[i]
para j = InicioEsteril at Len_Cromos faa
se Random <= PM ento
seno
fim-se
fim-se
fim-para
fim-para
60
Para a opo denominada mutao induzida, foi implementado o seguinte
algoritmo:
ValorAntigo = Populacao[1].Valor
para j = 1 at AG.NIterMut faa
para i = 1 at Len_Cromos faa
Populacao[1].Cromos[i] = not Populacao[1].Cromos[i]
Avalia_Individuo(1)
se Populacao[1].Valor <= ValorAntigo ento
Populacao[1].Cromos[i] = not
Populacao[1].Cromos[i]
seno
ValorAntigo := Populacao[1].Valor
fim-se
fim-para
fim-para
Essa mutao aplicada de acordo com a barra de fator de incremento
(Opo: Fat.Inc.) da interface que funo do nmero de geraes. Por exemplo, para
100 Geraes (opo Max.Iter.), com a barra totalmente direita, sero executadas 10
operaes de mutao; da o nome mutao induzida.
4.4.2.9 Opes de restries

Esto disponveis, na interface, dois tipos de restries que podem trabalhar
em separado ou em conjunto. A primeira corresponde ao nmero mximo de blocos
que se pode conter na cava final (opo NB). A segunda permite a definio de um
intervalo de teores entre um valor mnimo (opo Min.) e um valor mximo (opo
Max.).
Uma vez definido(s) o(s) tipo(s) de restrio(es), deve-se estabelecer como
ser tratada a restrio na funo objetivo, ou seja, o valor do parmetro R (fator de
penalizao) e, caso se queira, fazer uso da iterao na funo de penalizao,
conforme descrito em 4.4.2.6 o parmetro Alpha de restrio.
61
4.4.3 Resultados
4.4.3.1 Visualizao das informaes do modelo de blocos processado
Uma vez processados os clculos, as informaes relativas ao modelo de
blocos processadas pelo programa podem ser visualizadas na janela de Modelo da
interface, conforme se segue:
Figura 4.4.3.1.1 Modelo de blocos processado (Evolpit).
62
4.4.3.2 Histogramas dos blocos de minrio

Na janela histogramas, so construdos trs grficos relativos ao nmero de
blocos com valores positivos no modelo lido por linhas, colunas e nveis, conforme a
figura abaixo:
Figura 4.4.3.2 1 Histogramas dos blocos de valores monetrios positivos.
63
4.4.3.3 Resultados de todos os indivduos da populao por gerao (Valor e Aptido)

Na janela Resultados, cada linha representa uma gerao e em cada coluna o
valor no descontado da cava final conforme figura abaixo:
Figura 4.4.3.3.1 Resultados de todos os indivduos da populao por gerao (Evolpit).
Nessa interface possvel visualizar a evoluo do algoritmo gentico. Cada

linha representa uma gerao, e cada coluna um indivduo. Por exemplo, o valor de
-60 na linha 8 e coluna 10 significa que na oitava gerao o dcimo indivduo da
populao obteve uma cava com um valor de menos sessenta unidades monetrias.
Na primeira coluna, ter-se- sempre o melhor indivduo e, na ltima, o valor mdio da
populao.
64
4.4.3.4 Visualizao dos blocos lavrados atravs de sees verticais

A janela Sees permite a visualizao de sees verticais do modelo de
blocos, a partir da seleo da linha do modelo. Os blocos com valor negativo tero
sempre a cor vermelha, e os de valores maiores ou igual a zero tero a cor azul. Os
blocos contidos na cava final tero cor de fundo verde, conforme a figura abaixo:
Figura 4.4.3.4.1 Visualizao dos blocos lavrados (Evolpit).
65
4.4.3.5 Grficos de evoluo do AG

Aps o processamento dos clculos existem duas maneiras de se visualizar a
evoluo do algoritmo gentico implementado. Na primeira, existente na janela
Gr.Evol. pode-se visualizar, a cada gerao (eixo X), os valores encontrados (eixo Y)
conforme se segue:
Figura 4.4.3.5.1 Grfico de evoluo (Evolpit).
A segunda maneira de se visualizar a evoluo do algoritmo pela utilizao

dos recursos de cores por meio da combinao de um conjunto de seis barras verticais
de corres e de uma barra horizontal que define a densidade de cores a ser utilizada
pelo programa.
66
As figuras a seguir exibem em cada linha os mesmos parmetros de entrada,
porm com cores e densidades de cores diferentes:
Pop/Iter/Sel: 400/460/AA
Pop/Iter: 230/200/AA
Pop/Iter: 80/80/TR
Pop/Iter: 80/80/TR
Pop/Iter: 80/80/TR
Figura 4.4.3.5.2 Grfico de evoluo AG com diferentes resolues (Evolpit).
67
4.4.3.6 Resumo dos resultados para mais de um cenrio de lavra
Quando se define uma ou mais opes de loop nos parmetros de semente,
populao, cruzamento, mutao e elitismo, pode-se visualizar um resumo dos
resultados encontrados na janela Resultados, conforme abaixo:
Figura 4.4.3.6.1 Resumo dos resultados para mais de um cenrio de lavra.
68
4.4.3.7 Grfico dos resultados da otimizao multiobjetivo (Objetivo1 x Objetivo2)

Os resultados, quando so utilizados os recursos de otimizao multiobjetivo
por meio das opes Valor_Minrio, Valor_Teor e Minrio_Teor, podem ser
visualizados pelo o grfico contido na janela da interface conforme a seguir:
Figura 4.4.3.7.1 Grfico dos resultados da otimizao multiobjetivo (Recurso X Valor).
69
5 Resultados dos algoritmos genticos implementados
5.1 Testes e resultados encontrados AGS - VBA

No intuito de validar o funcionamento do algoritmo codificado e de analisar os
diversos parmetros de funcionamento do algoritmo gentico ora implementado, foram
realizadas inicialmente quatro baterias (25, 50, 100 e 200 geraes) de 32.400
simulaes (para uma seo) com os diferentes parmetros abaixo:
Nmero de geraes:
25; 50; 100 e 200
Tamanho da populao:
10; 30; 50; 70 e 90
Probabilidade de cruzamento:
0,5; 0,6; 0,7; 0,8; 0,9 e 1,0
Probabilidade de mutao:
0; 0,02; 0,04; 0.06; 0,08 e 0,1
Probabilidade de elitismo:
0; 0,1; 0,2; 0,3; 0,4 e 0,5
Semente:
1234 a 1263 (trinta valores)
Para cada grupo de testes, foi calculado o percentual do timo que a mdia
do valor obtido dividido pela soluo exata do problema. O grfico a seguir ilustra a
importncia do tamanho da populao para o problema proposto.
70
% Otimo
% Otimo para diferentes tamanhos de populao e geraes
100
90
80
70
60
50
40
30
20
10
0
73
77
82
85
10
84
90 92
87
87
93
89 92
30
93 94
89 91
94 95
90 92
70
90
50
Tamanho da populao
25 Geraes
50 Geraes
100 Geraes
200 Geraes
Figura 5.1.1 Grfico de % timo do tamanho da populao (AGS 1 Seo).
Conforme pode se observa, quanto maior o tamanho da populao,

maior a chance de o algoritmo convergir para a soluo tima.
O grfico abaixo exibe a variao do percentual de acerto para as
diversas combinaes de nmero de geraes utilizadas:
50%
66
40%
64
30%
62
20%
60
10%
58
0%
Mdia Populao
% Acerto
% Acerto para diferentes geraes
56
25
50
100
200
Nmero de Geraes
Figura 5.1.2 Grfico de % acerto do nmero de geraes (AGS 1 Seo).
71
Observa-se uma relao direta do nmero de geraes com o percentual de
acerto, ou seja, quanto maior o nmero de geraes, maior o percentual de sucesso.
Nota-se que, com o aumento do nmero de geraes, menor a mdia da populao
que convergiu para a soluo correta.
O grfico a seguir ilustra o comportamento da probabilidade de cruzamento
para o problema proposto:
% Otimo
Anlise das probabilidades de cruzamento

100
90
80
70
60
50
40
30
20
10
0
84.2
87.4 89.8
0.5
91.8
84.4
87.4 90.0
91.8
84.3
87.3 89.9
0.6
91.9
84.5
87.4 90.0
0.7
92.0
84.4
87.2 89.8
0.8
92.0
0.9
Probabilidade de Cruzamento
25 Geraes
50 Geraes
100 Geraes
200 Geraes
Figura 5.1.3 Grfico de % timo da probabilidade de cruzamento (AGS 1 Seo).
Percebe-se que, para a faixa de valores de probabilidade de cruzamento

utilizados no problema proposto, no houve diferenas significativas.
O grfico a seguir ilustra o comportamento da probabilidade de mutao para o
problema proposto:
72
% Otimo
Anlise das probabilidades de mutao

110
100
90
80
70
60
50
40
30
20
10
0
84
91
88
94
90
87
93 96
88
91
94 97
89
92
95 97
89
97
93 95
69 70 70 71
0.00
0.02
0.04
0.06
0.08
0.10
Probabilidade de Mutao
25 Geraes
50 Geraes
100 Geraes
200 Geraes
Figura 5.1.4 Grfico de % timo da probabilidade de mutao (AGS 1 Seo).
Conforme exibido no grfico, houve aumento crescente na convergncia do

algoritmo, de acordo com o aumento da probabilidade de mutao, principalmente
para a faixa inicial dos valores simulados.
O grfico a seguir ilustra o comportamento da probabilidade de elitismo para o
problema proposto.
% Otimo
Anlise das probabilidades de elitismo

100
90
80
70
60
50
40
30
20
10
0
82
85
89
0.0
91
84
88
90 92
85
0.1
88
90 92
0.2
85
88
90 92
85
0.3
88
90 92
85
0.4
92
88 90
0.5
Probabilidade de elitismo
25 Geraes
50 Geraes
100 Geraes
200 Geraes
Figura 5.1.5 Grfico de % timo da probabilidade de elitismo (AGS 1 Seo).
73
Observa-se que, mesmo com o aumento do nmero de cpias do melhor
indivduo nas diversas geraes, o algoritmo permaneceu praticamente constante,
para as diversas taxas de elitismo simuladas.
Como para uma seo o algoritmo conseguiu convergir para a soluo tima,
foi realizado mais um conjunto de simulaes, com a mesma combinao de
parmetros utilizados anteriormente, para duas sees anlogas primeira.
O grfico abaixo ilustra a importncia do tamanho da populao para o
problema proposto (duas sees).
% Otimo
% Otimo para diferentes tamanhos de populao e geraes (2 Sees)
100
90
80
70
60
50
40
30
20
10
0
63
67
71
10
75
73
81
77
85
76
80
30
84
86
78
82
50
85 87
80
70
83
86 88
90
Tamanho da populao
25 Geraes
50 Geraes
100 Geraes
200 Geraes
Figura 5.1.6 Grfico de % timo do tamanho da populao (AGS 2 Sees).
Conforme pode se observa, quanto maior o tamanho da populao,

maior a chance de o algoritmo convergir para a soluo tima. Percebe-se, ainda, que
o percentual do timo inferior para a populao de noventa indivduos (88%) quando
comparado ao obtido para uma seo (95%).
Um terceiro teste foi realizado considerando o mesmo problema para trs
sees, com a mesma combinao de parmetros, porm somente com 100 geraes,
ou seja, mais 32.400 simulaes. Nesse teste, obteve-se somente um resultado
positivo, ou seja, apenas uma simulao conseguiu convergir para a soluo correta.
A combinao de parmetros foi de 0,5 de probabilidade de cruzamento, 0,06 de
mutao, e 0,5 de elitismo. Obtiveram-se, ainda, dois resultados com valor de 320 o
74
que equivale a 98,8% da soluo tima e 482 valores com valor de 312
correspondente a 96,3% do valor da soluo tima.
5.1.1 Concluses dos resultados do algoritmo gentico simples com elitismo

VBA
O algoritmo gentico simples (AGS) com elitismo implementado mostrou-se
eficaz na resoluo do problema para uma seo. Quando o nmero de sees
aumenta h uma demanda computacional maior e maior risco de o algoritmo no
convergir para a soluo tima.
Percebe-se que o tamanho da populao e o nmero de geraes influem
fortemente nos resultados, ou seja, com populaes e geraes menores, o risco de o
algoritmo convergir para mximos locais maior.
Com relao identificao dos melhores parmetros de probabilidade de
cruzamento, mutao e elitismo, para os problemas formulados para um tamanho fixo
do nmero de geraes igual a duzentos e para uma seo, obteve-se Pc = 0,5 e 0,8,
Pm = 0,06 e 0,08 e Pe = 0,2, considerando o percentual de sucesso das simulaes
realizadas para uma seo. Para o problema de duas sees, os melhores parmetros
foram Pc = 0,7; Pm = 0,06 e 0,08 e Pe = 0,5.
5.2 Testes e resultados encontrados problema mono-objetivo - Evolpit - Delphi

Analogamente aos testes realizados no algoritmo codificado em VBA, foram
analisados os diversos parmetros de funcionamento do algoritmo gentico codificado
em Delphi. Foram realizadas inicialmente dez baterias (todos os mtodos de seleo
com 25 geraes) totalizando 32.400 simulaes/mtodo (para uma seo) conforme
os diferentes parmetros abaixo:
Mtodo de seleo:
RO; AA; AE; AD; D1; D2; D3; TR;

T1 e T2
Tamanho da populao:
10; 30; 50; 70 e 90
75
0,5; 0,6; 0,7; 0,8; 0,9 e 1,0
0; 0,02; 0,04; 0.06; 0,08 e 0,1
Percentual de elitismo:
0; 0,1; 0,2; 0,3; 0,4 e 0,5
Semente:
Para cada grupo de testes, foi calculado o percentual de acerto, que o

nmero de sucessos obtidos dividido pelo nmero de testes realizados em
percentagem. O grfico abaixo ilustra os resultados obtidos para os diversos tipos de
seleo codificados.
90
80
70
60
50
40
30
20
10
0
% Acerto
Tempo Mdio
0.14
0.12
0.10
0.08
0.06
0.04
0.02
D1
T2
D3
AE
AD
TR
T1
RO
D2
AA
77
74
18
15
13
12
12
11
0.04
0.10
0.07
0.13
0.12
0.09
0.08
0.11
0.09
0.12
Tempo mdio (segundos)
% Acerto
% Acerto para diferentes mtodos de seleo
0.00
Mtodo de Seleo
Figura 5.2.1 Grfico de % acerto dos mtodos de seleo (Evolpit 1 Seo).
Nesse grfico, os resultados foram ordenados de acordo com o % de acerto

para cada mtodo de seleo implementado. Conforme se observa, o mtodo de
seleo de amostragem determinstica variante 1 foi o mais eficiente pois obteve maior
percentual de acerto (77%) e menor tempo de mdio processamento (0.04 segundos).
Como era esperado, o pior mtodo foi o de amostragem aleatria, pois nele no
considerada a aptido do indivduo. Nota-se que existem 7 mtodos de seleo
superiores ao mtodo da roleta que foi codificado em VBA.
76
O grfico a seguir apresenta a influncia do tamanho da populao nos
diferentes tipos de seleo codificados:
Variao do % otimo pela populao e seleo

100
90
80
70
% Otimo
60
50
40
30
20
10
0
D1
T2
D3
AE
AD
TR
T1
RO
D2
AA
Pop. 10
90.1
76.8
73.7
75.9
75.1
75.8
75.8
72.9
65.7
72.2
Pop. 30
99.9
98.9
85.0
86.2
86.0
87.0
87.2
84.0
57.3
82.8
Pop. 50
99.0
99.5
88.0
89.2
88.8
90.2
90.3
86.6
54.5
85.1
Pop. 70
99.3
99.9
90.0
91.2
91.1
92.1
91.9
89.0
52.1
87.2
Pop. 90
99.4
99.8
91.1
92.2
92.0
93.2
93.0
89.9
51.2
88.0
Figura 5.2.2 Variao do % timo pela populao e seleo (Evolpit 1 seo).
Somente para o mtodo de amostragem determinstica variante 2 (D2), o

aumento da populao no incidiu sobre o percentual de timo. Sendo que, para o
mtodo de amostragem determinstica variante 1, o tamanho que obteve maior
percentual do timo foi o de 30 indivduos (99,9%). J o mtodo de torneio variante 2
foi para o tamanho da populao igual a 70, o que obteve o maior percentual do timo
(99.9%).
77
O grfico a seguir apresenta a influncia da probabilidade de cruzamento nos

diferentes tipos de seleo:
Variao do % otimo pelo cruzamento e seleo

100
90
80
% Otimo
70
60
50
40
30
20
10
0
D1
T2
D3
AE
AD
TR
T1
RO
D2
AA
Cruz. 0.5
99.4
98.1
85.5
86.7
86.2
87.1
87.4
84.3
56.4
82.3
Cruz. 0.6
98.6
94.6
85.7
86.8
86.5
87.4
87.3
84.1
56.4
82.8
Cruz. 0.7
97.7
94.2
85.3
86.8
86.5
87.6
87.3
84.5
56.4
83.0
Cruz. 0.8
96.9
94.2
85.7
87.0
86.5
87.9
87.7
84.6
55.8
83.3
Cruz. 0.9
96.6
94.5
85.8
87.2
86.9
87.9
88.0
84.8
55.9
83.8
Cruz. 1.0
96.1
94.2
85.6
87.1
87.0
88.1
88.0
84.6
55.9
83.0
Figura 5.2.3 Variao do % timo pelo cruzamento e seleo (Evolpit 1 seo).
Conforme se observa no grfico 5.2.3, existe uma tendncia de que, quanto

menor for a taxa de cruzamento, maior a probabilidade de acerto para os dois
primeiros mtodos (D1 e T2). Para os demais mtodos de seleo, as melhores taxas
de cruzamento variam de mtodo para mtodo. Por exemplo, para o mtodo de
amostragem determinstica, a melhor taxa de cruzamento foi de 0.9. J para o mtodo
de amostragem aleatria, a taxa de 0.5 foi a pior.
A influncia da probabilidade de mutao nos diferentes tipos de seleo
apresentada no grfico a seguir:
78
Variao do % otimo pela mutao e seleo

100
90
80
% Otimo
70
60
50
40
30
20
10
0
D1
T2
D3
AE
AD
TR
T1
RO
D2
AA
Mut 0
95.2
92.9
67.0
71.4
72.3
74.6
74.5
69.5
67.5
71.5
Mut 0.02
97.7
95.0
83.8
86.0
85.7
87.1
87.3
83.7
58.1
81.3
Mut 0.04
98.1
98.1
95.2
95.6
88.2
90.5
89.7
91.0
89.1
90.3
90.5
91.2
90.3
91.1
86.9
88.2
54.8
53.2
84.6
86.1
98.1
95.5
91.6
91.8
91.0
91.3
91.3
89.1
51.8
87.1
98.0
95.4
92.4
91.9
91.1
91.2
91.3
89.5
51.4
87.8
Mut 0.06
Mut 0.08
Mut 0.10
Figura 5.2.4 Variao do % timo pela mutao e seleo (Evolpit 1 seo).
Observa-se que, mesmo na ausncia de mutao, o algoritmo obteve um alto

percentual do timo, principalmente nos dois primeiros mtodos (D1 e T2). Para os
outros mtodos de seleo, houve a tendncia de que, com o aumento da taxa de
mutao, maior a probabilidade de o algoritmo convergir para a soluo tima.
O grfico a seguir apresenta a influncia do percentual de elitismo nos
diferentes tipos de seleo codificados:
Variao do % otimo pelo elitismo e seleo

100
90
80
% Otimo
70
60
50
40
30
20
10
0
D1
T2
D3
AE
AD
TR
T1
RO
D2
AA
Elit. 0
97.8
95.0
86.7
87.6
86.1
86.8
86.5
82.2
56.3
79.8
Elit. 0.1
97.6
94.8
86.4
87.7
87.2
87.8
87.6
84.6
56.0
82.2
Elit. 0.2
97.5
97.5
94.7
95.0
86.1
85.4
87.5
87.0
87.1
87.0
88.0
88.1
87.8
88.3
84.8
85.3
56.3
56.2
83.1
84.1
97.5
95.1
84.7
86.3
86.5
87.9
87.9
84.9
56.2
84.4
97.4
95.1
84.2
85.6
85.7
87.4
87.6
84.9
56.0
84.6
Elit. 0.3
Elit. 0.4
Elit. 0.5
Figura 5.2.5 Variao do % timo pelo elitismo e seleo (Evolpit 1 seo)
79
Mesmo com a variao do percentual de elitismo, no houve uma tendncia de
convergncia para o timo quando se comparam todos os mtodos de seleo.
Como os melhores resultados para uma seo foram obtidos pelo mtodo de
amostragem determinstica variante 1, foram realizadas mais trs baterias de 32.400
simulaes para duas, trs e cinco sees. O grfico abaixo ilustra o impacto do
tamanho da populao nos resultados:
Variao do % otimo pela populao e nmero de sees

100
90
80
% Otimo
70
60
50
40
30
20
10
0
10
30
50
70
90
1 Seo
90.1
99.9
99.0
99.3
99.4
2 Sees
82.6
99.7
97.4
97.6
97.4
3 Sees
82.8
95.9
94.7
95.7
96.5
5 Sees
79.4
90.4
90.5
90.7
91.2
Tamanho da Populao
Figura 5.2.6 Variao do % timo pela populao e nmero de sees (Evolpit).
Conforme se observa, para os modelos de recursos contendo uma e duas

sees verticais, os melhores resultados foram para a populao de 30 indivduos. J
para os modelos de 3 e 5 sees, quanto maior o tamanho da populao, maior a
probabilidade de o algoritmo convergir para a soluo correta.
O grfico a seguir apresenta a influncia da probabilidade de cruzamento nos
diferentes modelos de recursos minerais:
80
Variao do % otimo pelo cruzamento e nmero de sees

100
98
96
% Otimo
94
92
90
88
86
84
82
80
Cruz. 0.5
Cruz. 0.6
Cruz. 0.7
Cruz. 0.8
Cruz. 0.9
Cruz. 1.0
1 Seo
99.4
98.6
97.7
96.9
96.6
96.1
2 Sees
3 Sees
98.0
96.0
95.0
94.1
93.6
93.0
94.9
94.1
93.4
92.7
92.0
91.5
5 Sees
89.8
89.3
88.2
88.3
87.7
87.3
Probabilidade de cruzamento
Figura 5.2.7 Variao do % timo pelo cruzamento e nmero de sees (Evolpit).
Em geral, quanto menor a taxa de cruzamento, maior o percentual do timo.

O grfico a seguir apresenta a variao do percentual do timo em funo da
probabilidade de mutao para os 4 modelos de recursos construdos.
% Otimo
Variao do % otimo pela mutao e nmero de sees

100
98
96
94
92
90
88
86
84
82
80
78
1 Seo
2 Sees
3 Sees
5 Sees
Mut 0
Mut 0.02
Mut 0.04
Mut 0.06
Mut 0.08
Mut 0.10
95.2
91.0
97.7
96.2
98.1
96.2
98.1
95.8
98.1
95.5
98.0
94.9
90.3
95.1
94.8
94.0
92.9
91.5
85.8
91.4
90.7
89.4
87.8
85.5
Probabilidade de mutao
Figura 5.2.8 Variao do % timo pela mutao e nmero de sees (Evolpit).
81
Percebe-se que, com o aumento do nmero de blocos no modelo de recursos,
por meio do incremento do nmero de sees, a taxa de mutao de 0.02 foi a que
obteve melhores resultados.
A influncia do percentual de elitismo, nos diferentes modelos de recursos,
apresentada no grfico a seguir:
Variao do % otimo pelo elitismo e nmero de sees

100
98
96
% Otimo
94
92
90
88
86
84
82
Elit. 0
Elit. 0.1
Elit. 0.2
Elit. 0.3
Elit. 0.4
Elit. 0.5
1 Seo
97.8
97.6
97.5
97.5
97.5
97.4
2 Sees
95.2
94.9
94.8
94.9
94.9
95.0
3 Sees
93.1
92.9
93.0
93.1
93.2
93.4
5 Sees
88.4
88.1
88.3
88.5
88.6
88.7
Percentual de Elitismo
Figura 5.2.9 Variao do % timo pelo elitismo e nmero de sees (Evolpit).
Observa-se que no houve variaes na % do timo para os diversos

percentuais de elitismo analisados.
De acordo com os melhores resultados obtidos para o modelo de recursos de 5
sees verticais, foram simulados mais 3.600 parmetros, visando aumentar as
chances de o algoritmo convergir para a melhor soluo, conforme abaixo:
Mtodo de seleo:
D1
Tamanho da populao:
90
0,7
0.001 a 0.02 (20 incrementos)
82
Percentual de elitismo:
0,5 a 1,0 (6 incrementos)
Semente:
Para o nmero de geraes igual a 25, no houve nenhum resultado que

convergiu para a soluo correta do problema nas 3.600 simulaes (5 sees). O
percentual mdio da soluo tima foi de 68%. J para um nmero de geraes de
150 utilizando com PCruz = 0.7; PMut = 0.02 e PElit = 0.3 com 30 valores de semente,
obtiveram-se 28 resultados corretos em 30, o que equivale a 93% de acerto.
Utilizando-se os mesmos parmetros com 50 geraes, obtiveram-se 14 acertos, ou
seja, 47% de acerto.
Foi criado um modelo de recursos com 10 sees verticais e utilizando 150
geraes com uma populao de 150 indivduos, obtiveram-se 4 resultados corretos
em 30 (sementes). Para um modelo de 100 sees, com os seguintes parmetros temse:
Figura 5.2.10 Parmetros de entrada 100 sees (Evolpit).
83
Sem nicho (valor = 9.564)
Com nicho (valor = 9.620)
Figura 5.2.11 Grfico de evoluo 100 sees (Evolpit).
Sem nicho
Com nicho
Figura 5.2.12 Grfico de evoluo por indivduo 100 sees (Evolpit).
Conforme pode se observa nas figuras 5.2.11 e 5.2.12, houve uma pequena
melhora nos resultados para o modelo de recursos contendo 100 sees verticais,
utilizando-se os recursos de nicho do algoritmo (de 9.564 para 9.620 unidades
monetrias), o que corresponde a 89% da soluo tima.
Utilizando-se os recursos de agrupamento do algoritmo, conforme descrito no
item 4.4.2.4, aps vrios testes com os diversos parmetros do algoritmo, foram
obtidos os seguintes resultados:
84
Parmetros de entrada
Evoluo do AG (100 sees)
Figura 5.2.13 Parmetros e evoluo para 100 sees com agrupamento (Evolpit).
Conforme pode se observa, o algoritmo conseguiu convergir para 94,4%

(10200/10800) da soluo tima, para um modelo de recursos de 100 sees verticais
(36.000 positivos).
5.2.1 Concluses dos resultados do problema mono-objetivo - Evolpit Delphi

Quando comparados os resultados obtidos com o algoritmo gentico simples
AGS com elitismo, percebe-se que o Evolpit obteve um desempenho melhor, tanto em
termos de convergncia para a soluo tima, quanto em tempo de processamento.
Tal diferena pode ser atribuda aos mtodos de seleo que foram mais eficientes
para o problema proposto, bem como utilizao do compilador Delphi.
O algoritmo implementado no programa Evolpit foi capaz de gerar solues
eficientes com um relativo baixo custo computacional para o modelo de blocos de
uma, duas e dez sees. Porm, quando o nmero de sees aumenta, o mesmo
possui um custo computacional elevado, alm de no conseguir convergir para a
soluo tima, como para o exemplo do modelo de recursos contendo 100 sees.
85
5.3 Testes e resultados para problema mono-objetivo com restries- Evolpit
Inicialmente foram realizados testes considerando um modelo de recursos de
uma seo com o nmero mximo de blocos igual a 4. Primeiramente foi utilizado o
fator R de penalizao na funo de mrito, conforme descrito no item 2.4.7.
Figura 5.3.1 Parmetros Evolpit com restries de massa (fator R).
86
Fator R = 0 (36 blocos)
Figura 5.3.2 Resultados com restries (fator R).
Como se esperava, medida que o fator de penalizao R aumentou, o

algoritmo tendeu a convergir para a soluo correta que, no caso, era de quatro blocos
positivos. Tal modelo presta-se representao da necessidade no seqenciamento
de lavra com relao quantidade de massa. No caso, est sendo considerada a
quantidade de blocos.
87
Com o objetivo de simular a procura por uma qualidade especfica de teor
mdio, foram estabelecidos como limites mximos e mnimos os teores de 1.2 e 0.9
unidades. Abaixo, os parmetros utilizados bem como os resultados encontrados:
Parmetros do AG (teores 1.2)
Resultados seo vertical
Figura 5.3.3 Resultados Evolpit com restries de teor (1.2).
Parmetros do AG (teores 0.9)
Resultados seo vertical
Figura 5.3.4 Resultados Evolpit com restries de teor (0.9).
Conforme se observa, para ambos os limites estabelecidos de teores (1,2 e

0,9), o algoritmo conseguiu convergir para as solues corretas.
88
5.3.1 Concluses dos resultados para problema mono-objetivo com restriesEvolpit
Por meio das opes disponveis na interface do programa Evolpit podese definir o nmero mximo de blocos que podem estar contidos dentro da cava final
visando simular restries de massa em um seqenciamento de lavra; alm da
definio de um intervalo de teores entre um valor mnimo e um valor mximo, cujo
objetivo controlar a qualidade especfica de um determinado bem mineral ou
contaminante.
Uma vez definido(s) o(s) tipo(s) de restrio(es) e como ser tratada a
restrio na funo objetivo, ou seja, o valor do parmetro R (fator de penalizao), foi
possvel gerar cenrios de seqenciamento de lavra controlando-se as massas e
teores para uma seo.
5.4 Resultados do algoritmo gentico multiobjetivo NSGA - VBA

Inicialmente foi implementado um algoritmo para as funes Schafferf2 e
Schafferf3 disponveis na literatura.
Validado o algoritmo, procedeu-se implementao do programa de
maximizao do benefcio para os problemas propostos no algoritmo gentico simples
(AGS) com elitismo.
5.4.1 Testes e resultados encontrados das funes de teste
Foram realizados vrios testes com diferentes conjuntos de parmetros
conforme abaixo:
a) Tamanho da populao:
40, 100, 200 e 250 com uma
populao externa sempre com o valor em dobro (80, 200, 400 e 500).
b) Nmero de geraes:
12, 120, 200 e 2000
c) Probabilidade de cruzamento:
0.9
89
d) Probabilidade de mutao:
0.01 e 0.08
e) Percentagem de elitismo:
30% e 90%
O melhor resultado apresentado a seguir:

Parmetros utilizados: (populao maior, nmero de geraes e elitismo maior)
Tamanho da populao:
100
Tamanho da populao externa (elitismo): 200

120
0.9
0.01
Semente:
12345
0.9
Limite mnimo Schafferf2:
-12
Limite mximo Schafferf2:
12
Limite mnimo Schafferf3:
-2
Limite mximo Schafferf3:
10
Resultados:
4.5
4
3.5
3
2.5
2
1.5
1
0.5
0
0
Figura 5.4.1.1 Grfico dos resultados funo Schafferf2.
90

20
15
10
5
0
-1.5
-1
-0.5
0.5
1.5
Figura 5.4.1.2 Grfico dos resultados funo Schafferf3.
Nesse teste gerou-se um conjunto de solues prximas ao conjunto Paretotimo para as duas funes analisadas de maneira eficiente.
5.4.1.1 Concluses dos resultados encontrados das funes de teste

O algoritmo gentico multiobjetivo com elitismo, baseado no mtodo NSGA
(Non-dominated Sorting Genetic Algorithm), originalmente desenvolvido por Srinivas &
Deb (1993) e adaptado por ex-alunos da UFMG, ora implementado, mostrou-se eficaz
na resoluo das duas funes de teste analisadas. Porm exige do projetista uma
anlise dos resultados encontrados.
Percebe-se, ainda, que o tamanho da populao influi fortemente nos
resultados, ou seja, com populaes menores, o risco de o algoritmo gerar solues
no pertencentes ao conjunto Pareto-timo maior.
Com relao identificao dos melhores parmetros utilizados para os limites
adotados, o teste ora apresentado foi eficiente para os dois primeiros problemas. Para
a definio desses parmetros foram necessrios vrios testes. Portanto, para
utilizao desse algoritmo envolvendo outros problemas, interessante que se faa
um conjunto razovel de testes com diferentes parmetros a fim de se encontrar o
conjunto de solues no dominadas.
91
5.4.2 Resultados do algoritmo NSGA problema multiobjetivo - VBA
O objetivo desses testes avaliar a aplicao do algoritmo gentico
multiobjetivo NSGA com elitismo que, a partir de modelos de blocos tecnolgicos
conhecidos, que representem uma jazida, seja capaz de gerar um conjunto de
solues timas, tendo em vista os objetivos de maximizao de reservas e
maximizao de valor da cava final.
Foram executados vrios testes com diferentes combinaes de parmetros. A
seguir, so apresentados os melhores resultados onde so exibidos os grficos com
os pontos encontrados para cada conjunto de parmetros referente ao modelo de
recurso de uma seo vertical.
Tamanho da populao [1:250]:
250
Tamanho da populao externa (elitismo): 500

250
(1) Mono-objetivo; (2) = Multiobjetivo:
0.9
0.02
Semente:
1234
0.9
Fator de partilha: (0) automtico;
Ponderador Valor [0,1]:
Ponderador Massa [0,1]:
Nmero de sees [1,22]:
Famlia de cavas - Valor X Massa
Massa de Minri
40
30
20
10
0
-50
50
100
150
Valor Monetrio
Figura 5.4.2.1 Grfico espao dos objetivos NSGA multi (250 Geraes - 1 seo) VBA.
92
Conforme pode ser observado, o algoritmo conseguiu gerar um conjunto de
cavas timas que maximizam dois objetivos.
A seguir, so apresentados os resultados dos testes para duas sees onde o
tamanho da populao utilizado foi de 250 indivduos:
250
Tamanho da populao externa:
500
250
0.9
0.02
Semente:
1234
0.9
Fator de partilha: (0) automtico:
1.0
Famlia de cavas - Valor X Massa
Massa de Minri
80
60
40
20
0
0
50
100
150
200
250
Valor Monetrio
Figura 5.4.2.2 Grfico espao dos objetivos NSGA (250 Geraes - 2 sees) VBA.
Nesse teste, o algoritmo conseguiu gerar os dois pontos timos dos dois
objetivos formulados.
93
Parmetros utilizados: 3 Sees
250
500
250
0.9
0.02
Semente:
1234
0.9
Famlia de cavas - Valor X Massa (3 Sees)
Massa de Minr
105
90
75
60
0
100
200
300
Valor Monetrio
Como pode ser observado, o algoritmo conseguiu encontrar a cava que

maximiza o valor monetrio como tambm o valor mximo dos recursos.
250
94
500
250
0.9
0.02
Semente:
1234
0.9
Massa de Minr
140
130
120
110
100
0
100
200
300
400
Valor Monetrio
Como pode ser observado, o algoritmo no conseguiu encontrar a cava que

maximiza o valor monetrio. O valor mximo encontrado foi de 380 unidades
monetrias que corresponde a 90% da soluo tima.
250
500
95
250
0.9
0.02
Semente:
1234
0.9
Massa de Minr
216
206
196
186
176
0
150
300
450
600
Valor Monetrio
Como se observa, o algoritmo no conseguiu encontrar a cava que maximiza o

valor monetrio. O valor mximo encontrado foi de 444 unidades monetrias que
corresponde a 69% da soluo tima. J para a maximizao dos recursos, a soluo
tima foi encontrada no indivduo 79 que possui 216 unidades de massa.
250
500
250
96
0.9
0.02
Semente:
1234
0.9
22
Massa de Minr
Famlia de cavas - Valor X Massa (22 sees)
780
760
740
720
700
0
500
1000
1500
2000
Valor Monetrio
O algoritmo no conseguiu encontrar a cava que maximiza o valor monetrio. O

valor mximo encontrado foi de 376 unidades monetrias que correspondem a 58% da
soluo tima J para a maximizao dos recursos obtiveram-se 784 unidades de
massa, que correspondem a 99% da soluo tima.
5.4.2.1 Concluses do algoritmo NSGA problema multiobjetivo VBA
(Non-dominated Sorting Genetic Algorithm), originalmente desenvolvido por Srinivas &
97
Deb em 1993 e adaptado por ex-alunos da UFMG, ora implementado, mostrou ser
capaz de gerar famlias de cavas timas para modelos com at trs sees de blocos.
A seguir, o grfico com a famlia tima de cavas obtidas para duas sees.
Famlia de Cavas timas - Testes 9 a 14 (2 Sees)
80
Massa de Min
70
60
50
40
0
50
100
150
200
Valor monetrio
Figura 5.4.2.1.1 Grfico espao dos objetivos NSGA multi (250 Geraes 2 sees) VBA.
Como se observa no grfico para duas sees, o algoritmo conseguiu gerar, de

maneira eficiente, um conjunto de famlias de cavas que maximiza o lucro no
descontado e as reservas.
Para um nmero maior de sees e considerando-se o objetivo de
maximizao de recursos, o algoritmo conseguiu gerar um conjunto razovel de
pontos. Porm, para o objetivo de maximizao do lucro, percebe-se que o algoritmo
NSGA no conseguiu gerar cavas prximas das solues timas.
98
5.4.3 Resultados do algoritmo NSGA problema multiobjetivo Evolpit - Delphi

Conforme descrito no item 4.4.2.3, alm dos objetivos de maximizao de
recursos e valor monetrio, foram implementados os pares de objetivos (Valor
Monetrio X Teor) e (Recursos x Teor).
A seguir, figura contendo os parmetros e os resultados encontrados no
programa Evolpit para o problema multiobjetivo de maximizao dos recursos e o valor
monetrio considerando apenas uma seo vertical.
Parmetros NSGA
Resultados 1 seo
Figura 5.4.3.1 Parmetros e resultados NSGA Recursos/Valor 1 seo (Evolpit).
Observa-se que o algoritmo foi capaz de gerar um conjunto de cavas timas

tendo em vista os dois objetivos formulados para o modelo de recursos contendo uma
seo vertical.
Foi simulado ainda um modelo de recursos contendo 50 sees verticais.
Ressalta-se que, no VBA, tal simulao no seria possvel, tendo em vista o limite de
64k de memria.
99
Parmetros NSGA
Resultados 50 sees
Figura 5.4.3.2 Parmetros e resultados NSGA Recursos/Valor 50 sees (Evolpit).
Conforme se observa, o algoritmo atingiu 3108 unidades monetrias e 1398

unidades de massa que correspondem respectivamente a 58% e 78% das solues
timas dos dois objetivos respectivamente.
A seguir, parmetros e resultados encontrados para a otimizao multiobjetivo
de valor monetrio e massa para o modelo de recursos de 1 seo.
Parmetros NSGA
Resultados 1 seo
Figura 5.4.3.3 Parmetros e resultados NSGA Valor/Teor 1 seo (Evolpit).
100
Percebe-se que o algoritmo conseguiu convergir para as duas solues timas,
porm gerou relativamente poucas cavas timas quando comparado otimizao
Recursos X Valor.
Foi simulada, ainda, a otimizao considerando-se os objetivos de recursos e
teor mdio para o modelo de uma seo, conforme abaixo:
Parmetros NSGA
Resultados 1 seo
Figura 5.4.3.4 Parmetros e resultados NSGA Recursos/Teor 1 seo (Evolpit).
O algoritmo conseguiu gerar um conjunto de cavas timas tendo em vista os

dois objetivos de maximizao dos recursos e teor mdio para o modelo de 1 seo.
5.4.3.1 Concluses do algoritmo NSGA problema multiobjetivo Evolpit Delphi

Tendo em vista as opes de otimizao para os problemas multiobjetivos
propostos: Recursos x Valor, Recursos x Teor e Valor x Teor, foi possvel gerar vrias
famlias de cavas timas utilizando-se o programa Evolpit.
So necessrios testes adicionais, principalmente para modelos de recursos
maiores com o objetivo de validar sua aplicabilidade do mesmo em problemas reais.
101
6 Concluses e trabalhos futuros

Todos
os
algoritmos
implementados,
para
os
problemas
analisados,
conseguiram convergir para as solues tericas conhecidas para um nmero

reduzido de blocos. O tamanho da populao e o nmero de geraes influram
fortemente nos resultados, ou seja, com populaes menores, o risco de o algoritmo
convergir para mximos locais maior, bem como a gerao de pontos dominados na
fronteira do Pareto-timo.
Para o algoritmo gentico simples com elitismo e o NSGA desenvolvidos, foi
possvel identificar uma combinao de parmetros (probabilidade de cruzamento,
mutao e elitismo), para os problema propostos. Ressalta-se que tais valores so
vlidos somente para os problemas analisados, tendo em vista ainda a quantidade de
blocos de minrio no modelo de blocos utilizado.
(Non-dominated Sorting Genetic Algorithm), exige que se faam vrios testes e uma
anlise a posteriori dos resultados encontrados.
E interessante que se faam testes utilizando-se diferentes modelos de
recursos e reservas reais e que se comparem os resultados obtidos com os
encontrados em outros sistemas disponveis no mercado. Tais testes podero realizarse, tanto para determinao dos limites de cava final, quanto para seqenciamento de
lavra considerando-se metas de massas e teores.
Com pequenas alteraes no cdigo do programa de computador Evolpit
possvel utiliz-lo para validao de modelos j simulados, pois existe a opo de se
ler um modelo com os limites de cava final previamente definido na gerao da
populao inicial.
Sugere-se investigar, implementar e testar outros algoritmos de agrupamento,
seleo, mutao e adaptao dinmica, no intuito de melhorar os resultados do
programa, tendo em vista modelos de recursos e reservas maiores.
102
7 Referncias bibliogrficas
BAKER, J.E. Adaptive Selection Methods for Genetic Algorithms. Proceedings of the
First International Congress on Genetic Algorithms, pp. 101-111, 1985.
BARNES, R.J. Optimizing the ultimate pit. Colorado School of Mines, MSc. Thesis,
1982. 120p, 1982.
BONGARON, D.F. e MARCHAL, A. A New Method for Open-Pit Design
Parametrization of the Final Pit-Contour, 14th APCOM, Pennsylvania, p. 573-583, 1976.
CARMO, F. A. R. Metodologias para o Planejamento de Cavas Finais de Minas a Cu
Aberto Otimizadas. Dissertao de Mestrado - UFOP. Ouro Preto, 2001.
COELHO, C. A. C. e TOSCANO, G. A micro-genetic algorithm for multi-objective
optimization. Technical Report Lania-RI-2000-06, Laboratoria Nacional de Informatica
Avanzada, Xalapa, Veracruz, Mexico, 2000.
CORNE, D., KNOWLES, J. e OATES, M. The Pareto envelope-based selection
algorithm for multiobjective optimization. Proceedings of the Sixth International
Conference on Parallel Problem Solving from Nature VI (PPSN-VI), pp. 839-848, 2000.
DAGDALEN, K. Open Pit Optimization Strategies for Improving Economics of Mining
Projects Through Mine Planning. 17th International Mining Congress of Turkey, Ankara.
The Cahmber of Mining Engineers of Turkey. pp 117-122, 2001.
DAVID, M., P. DOWD e KOROBOV S. Forecasting departure from planning in open pit
design and grade control. APCOM, Golden, CO. 1974.
DAVIS, L. Handbook of Genetic Algorithms. Van Nostrand Reinhold. New York, 1991.
DEB, K. Genetic Algorithms in multimodal function optimization. Master Thesis, TGGA
report n. 89002. University of Alabama, 1998.
DEB, K. Evolutionary Algorithms for Multi-Criterion Optimization in Engineering Design.
Evolutionary Algorithms in Engineering and Computer Science, cap. 8, pp.135-161.
John Wiley & Sons, Ltd. Chichester, UK, 1999.
103
DEB, K., AGRAWAL, S., PRATAP, A. e MEYARIVAN, T. A fast and elitist multiobjective genetic algorithm: NSGA-II. Technical Report 200001, Indian Institute of
Technology, Kanpur: Kanpur Genetic Algorithm Laboratory (KanGAL), 2000.
DEB, K. Multi-Objective Optimization using Evolutionary Algorithms. 1 ed. England,
John Wiley & Sons, 2001. 515p.
DIAS, A.H.F. Algoritmos Genticos Aplicados a Problemas com Mltiplos Objetivos.
UFMG 2000, 136p. (Dissertao, Mestrado em Engenharia Eltrica).
FONSECA, C. M. e FLEMING, P. J. Genetic algorithms for multiobjective optimization:
Formulation, discussion, and generalization. Proceedings of the Fifth International
Conference on Genetic Algorithms, pp. 416-423. 1993.
FORD, L. R. e FULKERSON D. R. Maximum flow through a network. Canadian Journal
of Mathematics, vol. 8: pp. 399-404, 1956.
GOLDBARG, M.C. e LUNA, H.P.L. Otimizao combinatria e programao linear. 2
ed. Rio de Janeiro: Elsevier Editora Ltda, 2005. 518p.
GOLDBERG, D.E. e RICHARDSON, J. Genetic algorithm with sharing for multimodal
function. Proceedings of the Second International Conference on Genetic Algorithms,
pp 41-49. Lawrence Erlbaum, 1987.
GOLDBERG, D.E. Genetic Algorithm in Search, Optimization and Machine Learning.
Reading, Addison-Wesley. USA, 1989.
GOLDBERG, D.E. e DEB, K. A comparison of selection schemes used in genetic
algorithms. Foundations of Genetic Algorithms, pp. 69-93. Morgan Kaufmann, San
mateo, California, 1991.
HAJELA, P. e LIN, C.Y. Genetic Serach Strategies in multi-criterion optimal design.
Structural Optimization, 4(2), pp. 99-107. 1992.
HALATCHEV, R. The Time Aspect of the Optimum Long-Term Open Pit Production
Sequencing. 30th. Application of Computers and Operations Research in the Mineral
Industry, Littletown, SME. 2002.
104
HOLLAND, J.H. Adaptation in natural and Artificial Systems. Ann Arbor, University of
Michigan Press. USA, 1975.
HORN, J., NAFPLOITIS, N. e GOLDBERG, D. A niched Pareto genetic algorithm for
multi-bjective optimization. Proceedings of the First IEEE Conference on Evolutionary
Computation, pp. 82-97, 1994.
HORN, J. Muticriterion decision making. Handbook of Evolutionary Computation,
volume I, pp. F1.9:1-F1.9:15. IOP Publishing Ltd. And Oxford University Press, 1997.
HUSTRULID, W. e KUCHTA, M. Open Pit Mine Planning & Design. 1. Rotterdam: A.A.
Balkema, 1995, 636p.
HUTTAGOSOL, P. e CAMERON R. E. A computer design of ultimate pit limit by using
transportation algorithm. 23rd APCOM, Tucson. pp. 443-460, 1992.
JOINES, J.A. e HOUCK, C.R. On the use of nonstationary penalty functions to solve
nonlinear constrained optimization problems with GAs. Proceedings of the International
Conference on Evolucionary Computation, pp. 579-584, 1994.
JOHNSON, T.B. e SHARP, W.R. A three dimensional dynamic programming method
for optimal ultimate open-pit design. U.S. Bureau of Mines Report of Investigations.
1971.
KIM, Y.G. Open Pit Limit Analysis. Computer Methods for the 80s in the Mineral
Industry, SME-AIME, pp. 297-303, 1978.
KITA, H., YABUMOTO, Y., MORI, N. e NISHIKAWA, Y. Multi-objective optimization by
means of thermodynamical genetic algorithm. Proceedings of Parallel Problem Solving
from Nature IV (PPSN-IV), pp. 504-512, 1996.
KNOWLES, J. D. e CORNE, D. W. Approximating the non-dominated front using the
Pareto archived evolution strategy. Evolutionary Computation Journal 8(2), 149-172,
2000.
LANE, K. The Economic Definition of Ore. London: Mining Journal Books, 1988.
105
LAUMANNS, M., RUDOLPH, G. e SCHWEFEL, H. P. A spatial predator-prey approach
to multi-objeticve optimization: A preliminary study. Proceedings of the Parallel Problem
Solving from Nature V (PPSN-V), pp. 241-249, 1998.
LEMIEUX, M. Moving cone optimizing algorithm. Computer methods for the 80s in the
mining industry, SME. pp. 329-345, 1979.
LERCHS, H. e GROSSMANN I. F. Optimum design of open pit mines. CIM Bulletin,
vol. 58 (January), pp. 47-54, 965.
MATHERON, G. Le paramtrage des contours optimaux. Technical notes 401 and
403, Centre de Gostatistique de IEcole des Mines de Paris, Fontainebleau, France,
19p. et 5 4p., 1975.
MICHALEWICZ, Z. Genetic Algorithms + Data Structures = Evolution Programs.
Springer-Verlag. New York, 1992.
NORONHA, R. A. Tomada de Deciso em Projeto de Minerao: Quantificao de
Riscos e Incertezas. Dissertao de Mestrado - UFMG. Belo Horizonte, 2001.
OSYCZKA, A. Multicriteria optimization for engineering design. In John S. Gero, editor,
Design Optimization, pp. 193-227. Academic Press, 1985.
PANA, M. T. e CARLSON T. R.. Description of a Computer Technique Used in Mine
Planning of the Utah Mine of Kennnecott Copper Corp. 6th APCOM. 1966.
PARETO, V. Cours DEconomic Politique. Volume I e II. F. Rouge, Lausanne, 1896.
PERONI, R. L. Anlise de sensibilidade do sequenciamento de lavra em funo da
incerteza do modelo geolgico. Tese de Doutorado UFRS. Porto Alegre, 2002.
RUDOLPH, G. Evolutionary search under partially ordered fitness sets. Proceedings ot
the International Symposium on Information Science Innovations in Engineering of
Natural and Artificial Intelligent Systems (ISI), pp. 818-822, 2001.
SAINSBURY, G.M. Computer-based design of open cut mines. Australasian Institute of
Mining and Metallurgy Conference. Pp 49-57. 1970.
106
SAMANTA, B. e BHATTACHERJEE, A. A genetic algorithms approach for grade
control planning. APCOM, 2005.
SAYDAM, S. e YALCIN, E. Reserve and Ultimate Pit Limit Design Analisys of Caldagi
Nickel Deposit, Turkey. 30th Application of Computers and Operations Research in the
Mineral Industry, Littletown, SME. Pp 121-131, 2002.
SCHAFFER, J. D., Multiple objective optimization with vector evaluated genetic
algorithms. Proceedings of the First International Conference on Genetic Algorithms,
pp93-100, 1985.
SRINIVAS, N. e DEB, K. Multiobjective optimization using nondominated sorting in
genetic algortihms. Technical report, Departament of Mechanical Engineering, Indian
Institute of Technology, Kanput. ndia, 1993.
SRINIVAS, G. e PATNAIK, L.M. Genetic Algorithms: A Survey. IEEE Computer, v.27,
n.6, pp.17-26, 1994.
SYSWERDA, G. Uniform Crossover in Genetic Algorithms. Proceedings of the Third
International Congress on Genetic Algorithms, pp.2-9, 1989.
SYSWERDA, G. A Study of Reproduction in Generational and Steady-State Genetic
Algorithm. Foundations of Genetic Algorithms, pp. 94-101. Morgan Kaufmann, 1991.
TAKAHASHI, R. H. C. Otimizao Escalar e Vetorial. Notas de aula UFMG. Belo
Horizonte, 2004.
TANOMARU, J. Motivao, Fundamentos e Aplicaes de Algoritmos Genticos. II
Congresso de Redes Neurais. Curitiba, 1985.
THOMAS, G.S. Optimization and Scheduling of Open Pits via Genetic Algorithms and
Simulated Annealing. Proceedings 1st International Symposium on Mine Simulation via
the Internet, Paper TG085A. 1996.
TOLEDO, J. P. Utilizao do algoritmo gentico aplicado ao planejamento de lavra.
Monografia MBA USP. So Paulo, 2003.
107
TOLWINSKI, B. e UNDERWOOD R. An Algorithm to Estimate the Optimal Evolution of
an Open Pit. 23rd APCOM. pp. 399-409, 1992.
UNDERWOOD, R. e B. TOLWINSKI. A mathematical programming viewpoint for
solving the ultimate pit problem. European Journal of Operational Research, (107): pp.
96-107, 1998.
VALLET, R. Optimization mathmatique de Ixploitation dune mine ciel ouvert ou le
problme de envelope, Annales des mines de Belgique, Fvrier, p.113-135, 1976.
VASCONCELOS, J.A. Notas de aula da disciplina Computao Evolucionria.
Departamento de Engenharia Eltrica/Eletrnica, UFMG, 2004.
VELDHUIZEN, D. V. Multiobjective Evolutionary Algorithms: Classifications, Analyses,
and New Innovations. Ph. D. Thesis, Dayton, OH: Air Force Institute of Technology
AFIT/DS/ENG/99-01, 1999.
YAMATOMI, J., MOGI, A. e YAMAGUCHI, U. Selective Extraction Dynamic Cone
Algorithm for Three Dimensional Open Pit Designs. XXV APCOM, pp. 267-274, 1995.
WAGENINGEN, A.V.; DUNN,P.G.;MULDOWEY, D.M. Sequence optimization for longterm mine planning. APCOM, 2005.
WANG, Q. e SEVIM, H. Alternative to parameterization in finding a series of maximummetal pits for production planning. Mining Engineering. pp. 178-182, 1995.
ZHAO, Y. e KIM, Y. C. A New Graph Theory Algorithm for Optimal Pit Design. SME
Transactions, vol. 290:, pp. 1832-1838, 1991.
ZHAO, Y. e KIM, Y. C. A New Optimum Pit Limit Design Algorithm. 23rd APCOM,
Tucson. pp. 432-434, 1992.
ZITZLER, E. e THIELE, L. An evolutionary algorithm for multiobjective optimization:
The strength Pareto approach. Thechnical Report 43, Zrich, Switzerland: Computer
Engineering and Networks Laboratory (TIK), Swiss Federal Institute of Technology
(ETH), 1998.
108
8 Anexos
8.1 Anexo I - Listagem do programa algoritmo gentico simples com elitismo

Baseado em Goldberg, D.E. (1989)
109
'EvolPit Veso 1.00 - Algoritmo Gentico Simples com Elitismo
Option Explicit
Public Const PopMax
As Integer = 500 'Tamanho Mximo da
populao
Public Const CompMax
As Integer = 500 'Tamanho Mximo do
cromossomo
Public Const NV
As Integer = 1
'Numero de variaveis
Public Linha
As Integer
'Varivel de controle dos
resultados na planilha
Public Comp_Cromossomo
As Integer
'Tamanho do cromossomo
(nmero de blocos de minrio)
Public Cold(500)
As Boolean
'Cromossomo antigo
Public Niter
As Integer
'Nmero de iteraes
Public ProbPop(500)
As Single
'Probabilidade de selecao
do individuo
Public NCopias(500)
As Integer
'Nmero de cpias de cada
individuo
Public ProbPopAc(500)
As Single
'Probabilidade acumulada
de seleo do indivduo
Public CopiaCromos(PopMax, CompMax) As Boolean 'Nova populao dos
cromossomos
Public Populacao(500)
As TIndividuo
'Conjunto de individuos
Public Lamb
As Single
'Parmetro de ajuste da
funo de aptido
Public AGS
As TAGS
'Contem os parmetros do
AGS
Public GAParam
As TGAParam
'Contem os parmetros do
AGS em grupo
Public BlockModel
As TBlockModel
'Parmetros do modelo de
blocos
Public BeginTime
As Date
'Varivel de controle de
tempo de processamento incio
Public EndTime
As Date
'Varivel de controle de
tempo de processamento fim
Public NExec
As Integer
'Nmero de execues a
serem realizadas
Type TIndividuo
Cromossomo(CompMax) As Boolean
variveis do indivduo (bloco)
Valor
As Single
Aptidao
As Single
End Type
Type TAGS
TamPop
GerMax
Precisao
PCruz
PMut
PElit
Semente
End Type
As
As
As
As
As
As
As
Type TGAParam
PopBegin
PopEnd
Integer
Integer
Single
Single
Single
Single
Long
'Estrutura do indivduo
'Vetor relativo ao valor binrio das
'Valor da funo do indivduo
'Valor da aptido do indivduo
'Tamanho da populao
'Numero de geraes
'Preciso
'Probabilidade de cruzamento
'Probabilidade de mutao
'Percentagem de elitismo
'Semente para gerao de nmeros aleatrios
As Integer 'Tamanho da populao inicial

As Integer 'Tamanho da populao final
110
PopStep
SeedBegin
SeedEnd
SeedStep
RecombBegin
RecombEnd
RecombStep
MutatBegin
MutatEnd
MutatStep
Niter
ElitBegin
ElitEnd
ElitStep
End Type
As
As
As
As
As
As
As
As
As
As
As
As
As
As
Type TBlockModel
OrigX
As
OrigY
As
OrigZ
As
SizeBX As
SizeBY As
SizeBZ As
NRow
NCol
NLevel
Angle
Value
ASCI
As
As
As
As
As
Integer
Integer
Integer
Integer
Single
Single
Single
Single
Single
Single
Integer
Single
Single
Single
Single
Single
Single
Single
Single
Single
'Incremento do tamanho da populao

'Valor da semente inicial
'Valor da semente final
'Incremento da semente
'Probabilidade de cruzamento inicial
'Probabilidade de cruzamento final
'Incremento do cruzamento
'Probabilidade de mutao inicial
'Probabilidade de mutao final
'Incremento da mutao
'Nmero da gerao
'Probabilidade de elitismo inicial
'Probabilidade de elitismo final
'Incremento do elitismo
'Coordenada X do modelo de blocos

'Coordenada Y do modelo de blocos
'Cota inicial do modelo de blocos
'Tamanho do bloco na direo X
'Tamanho do bloco na direo Y
'Tamanho do bloco na direo Z
Integer
Integer
Integer
Integer
Single
'Nmero de linhas do modelo de blocos

'Nmero de colunas do modelo de blocos
'Nmero de nveis do modelo de blocos
'ngulo geral de talude
'Valor do bloco
Values(22, 22, 14) As Single
'Valor do bloco lido do arquivo
CodMin(500)
As String
'Linha, coluna e nvel dos blocos
de minrio
Extract(22, 22, 14) As Boolean 'Indica se o bloco ser lavrado
ou no
End Type
Sub ShowForm()
'Exibe interface de entrada de parmetros
UserFormAGC.Show
End Sub
Sub Executa_Macro()
'Excecuta o programa de acordo com os parmetros definidos na
interface
'Inicializa o modelo de blocos
Call InitModel(CSng(UserFormAGC.TextBoxOX.Text),
CSng(UserFormAGC.TextBoxOY.Text), CSng(UserFormAGC.TextBoxOZ.Text), _
CSng(UserFormAGC.TextBoxSX.Text),
CSng(UserFormAGC.TextBoxSY.Text), CSng(UserFormAGC.TextBoxSZ.Text), _
Int(UserFormAGC.TextBoxNR.Text),
Int(UserFormAGC.TextBoxNC.Text), Int(UserFormAGC.TextBoxNL.Text))
'L o modelo de blocos a partir do arquivo ASCII
Call Read_Model(UserFormAGC.TextBoxFile.Text, True, True, 0,
Int(UserFormAGC.TextBoxNR.Text), Int(UserFormAGC.TextBoxNC.Text),
Int(UserFormAGC.TextBoxNL.Text))
111
Update_GAParam ' Inicializa os parmetros iniciais e finais do AGS

Calcula_NExecucoes
Linha = 1
'Atualiza planilha do modelo lido
Update_Rows
Format_Read_Data
'Chama o programa principal
BeginTime = Now
Call Execute_Main_Program("C:\Resultados.txt")
'UserFormAGC.StatusBarAGC.SimpleText = "Pronto"
EndTime = Now
'Atualiza resultados na interface
With UserFormAGC.TextBoxResults
.Text = .Text + "Data/Hora Incio: " + CStr(BeginTime) + Chr(13)
.Text = .Text + "Data/Hora Fim:
" + CStr(EndTime) + Chr(13)
.Text = .Text + "Valor da Cava: " + CStr(Populacao(1).Valor) +
Chr(13)
End With
End Sub
Sub InitModel(OX As Single, OY As Single, OZ As Single, SX As Single,
SY As Single, SZ As Single, _
NR As Integer, NC As Integer, NL As Integer)
'Inicializa modelo
BlockModel.OrigX = OX
BlockModel.OrigY = OY
BlockModel.OrigZ = OZ
BlockModel.SizeBX = SX
BlockModel.SizeBY = SY
BlockModel.SizeBZ = SZ
BlockModel.NRow = NR
BlockModel.NCol = NC
BlockModel.NLevel = NL
BlockModel.Angle = 45
End Sub
Sub Read_Model(Name As String, FillSheet As Boolean, WasteModel As
Boolean, WasteValue As Single, _
NRowMax As Integer, NColMax As Integer, NLevelMax As
Integer)
'L
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
modelo de blocos a partir do arquivo ASCII

Aux
As String
i
As Integer
j
As Integer
k
As Integer
Value As Single
NLine As Integer
fs
As Object
F
As Object
Const ForReading = 1, ForWriting = 2, ForAppending = 3

Set fs = CreateObject("Scripting.FileSystemObject")
Set F = fs.OpenTextFile(Name, ForReading)
112
'Le o cabeaho
Aux = F.ReadLine
'Leitura dos valores dos blocos
While Not F.AtEndOfStream
Aux = F.ReadLine
Call Read_IJK_Values(Aux, i, j, k, Value)
BlockModel.Values(i, j, k) = Value
If (Not WasteModel) And (Value < 0) Then BlockModel.Values(i, j,
k) = WasteValue
Wend
F.Close
'Atualiza planilha de acordo com o arquivo ASCII
NLine = 1
Comp_Cromossomo = 0
For i = 1 To NRowMax
For j = 1 To NColMax
For k = 1 To NLevelMax
NLine = NLine + 1
BlockModel.Extract(i, j, k) = False
If BlockModel.Values(i, j, k) >= 0 Then
Comp_Cromossomo = Comp_Cromossomo + 1
BlockModel.CodMin(Comp_Cromossomo) = IJK_to_string(i, j, k)
End If
Next k
Next j
Next i
'Limpa planilha
Clear_Sheet ("Model_CSV")
If FillSheet Then
NLine = 0
NLine = NLine + 1
Worksheets("Model_CSV").Cells(NLine,
BlockModel.Values(i, j, k)
Next k
Next j
Next i
End If
End Sub
1).Value
2).Value
3).Value
4).Value
= i
= j
= k
=
Sub Read_IJK_Values(Aux As String, i As Integer, j As Integer, k As

Integer, Value As Single)
'Converte a variavel
de blocos
Dim Begin_String(10)
Dim Len_String(10)
Dim Index
Aux (linha) para os indices e valores do modelo

As Integer
As Integer
As Integer
113
Dim z
As Integer
Index = 1
Begin_String(0) = 0
Len_String(0) = 0
Begin_String(Index) = 1
For z = 1 To Len(Aux)
If (Mid(Aux, z, 1) = ",") Then
Len_String(Index) = z - 1 - Len_String(Index - 1) Begin_String(Index - 1)
Index = Index + 1
Begin_String(Index) = z + 1
End If
Next z
Len_String(Index) = Len(Aux) - Begin_String(Index - 1) - 1
i = Int(Mid(Aux, Begin_String(1), Len_String(1)))
j = Int(Mid(Aux, Begin_String(2), Len_String(2)))
k = Int(Mid(Aux, Begin_String(3), Len_String(3)))
Value = CDbl(Mid(Aux, Begin_String(4), Len_String(4)))
End Sub
Sub Execute_Main_Program(FileResult As String)
' Executa o
definidos
Dim fs As
Dim F As
Dim i As
AGS tantas vezes quanto forem os parmetros iniciais

Object
Object
Integer
Set F = fs.CreateTextFile(FileResult)
' Inicializa arquivo de resultados
F.WriteLine ("Sem.,Pop.,Cruz.,Mut,Elit,Iter.,Valor")
With AGS
.TamPop = GAParam.PopBegin
'Tamanho da populao
.GerMax = GAParam.Niter
'Nmero mximo de
geraes
.Semente = GAParam.SeedBegin
'Semente
.PCruz = GAParam.RecombBegin
'Probabilidade de
cruzamento
.PMut = GAParam.MutatBegin
.PElit = GAParam.ElitBegin
End With
While AGS.Semente <= GAParam.SeedEnd
While AGS.TamPop <= GAParam.PopEnd
While AGS.PCruz <= GAParam.RecombEnd
While AGS.PMut <= GAParam.MutatEnd
While AGS.PElit <= GAParam.ElitEnd
Executa_AGS
EscreveResultados
Linha = Linha + 1
F.WriteLine (Str(AGS.Semente) + "," + Str(AGS.TamPop) +
"," + Str(AGS.PCruz) + "," + _
Str(AGS.PMut) + "," + Str(AGS.PElit) + "," +
Str(GAParam.Niter) + "," + _
114
Str(Populacao(1).Valor))
AGS.PElit = AGS.PElit + GAParam.ElitStep
Wend
AGS.PElit = GAParam.ElitBegin
AGS.PMut = AGS.PMut + GAParam.MutatStep
Wend
AGS.PMut = GAParam.MutatBegin
AGS.PCruz = AGS.PCruz + GAParam.RecombStep
Wend
AGS.PCruz = GAParam.RecombBegin
AGS.TamPop = AGS.TamPop + GAParam.PopStep
Wend
AGS.PCruz = GAParam.RecombBegin
AGS.TamPop = GAParam.PopBegin
AGS.Semente = AGS.Semente + GAParam.SeedStep
Wend
F.Close
For i = 1 To Comp_Cromossomo
'Marca blocos que necessitam ser extrados do modelo de blocos
(estril+minrio)
If Populacao(1).Cromossomo(i) Then
Call Extract_Block(Int(Mid(BlockModel.CodMin(i), 1, 3)),
Int(Mid(BlockModel.CodMin(i), 4, 3)), _
Int(Mid(BlockModel.CodMin(i), 7, 3)))
End If
Next i
Update_Extract_Rows
Format_Extract_Data
End Sub
Sub Update_GAParam()
' Atualiza Parmetros do AGS de acordo com a interface
With GAParam
.PopBegin = Int(UserFormAGC.TextBoxPopB.Text)
If Not UserFormAGC.CheckBoxPop.Value Then
.PopEnd = Int(UserFormAGC.TextBoxPopE.Text)
Else
.PopEnd = .PopBegin
End If
.PopStep = Int(UserFormAGC.TextBoxPopS.Text)
.SeedBegin = Int(UserFormAGC.TextBoxSeedB.Text)
If Not UserFormAGC.CheckBoxSeed.Value Then
.SeedEnd = Int(UserFormAGC.TextBoxSeedE.Text)
Else
.SeedEnd = .SeedBegin
End If
.SeedStep = Int(UserFormAGC.TextBoxSeedS.Text)
.RecombBegin = CSng(UserFormAGC.TextBoxRecB.Text)
If Not UserFormAGC.CheckBoxRec.Value Then
.RecombEnd = CSng(UserFormAGC.TextBoxRecE.Text)
Else
.RecombEnd = .RecombBegin
115
End If
.RecombStep = CSng(UserFormAGC.TextBoxRecS.Text)
.MutatBegin = CSng(UserFormAGC.TextBoxMutB.Text)
If Not UserFormAGC.CheckBoxMut.Value Then
.MutatEnd = CSng(UserFormAGC.TextBoxMutE.Text)
Else
.MutatEnd = .MutatBegin
End If
.MutatStep = CSng(UserFormAGC.TextBoxMutS.Text)
.ElitBegin = CSng(UserFormAGC.TextBoxElitB.Text)
If Not UserFormAGC.CheckBoxElit.Value Then
.ElitEnd = CSng(UserFormAGC.TextBoxElitE.Text)
Else
.ElitEnd = .ElitBegin
End If
.ElitStep = CSng(UserFormAGC.TextBoxElitS.Text)
.Niter = Int(UserFormAGC.TextBoxIter.Text)
End With
End Sub
Sub Executa_AGS()
'Programa principal do Algoritmo Gentico Simples (AGS) com elitismo
Dim i
As Integer
Inicializa_Populacao 'Gera populao aleatria inicial
Niter = 0
'Varivel de controle do nmero de iteraes
(geraes)
While (Niter < AGS.GerMax)
Niter = Niter + 1
If Niter = 1 And Linha = NExec Then Clear_Sheet ("Resultados")
For i = 1 To AGS.TamPop
Call Avalia_Individuo(i) 'Calcula valores da populacao segundo
a funcao original
Next i
Call Seleciona_MelhorInd
'Coloca na posio 1 o melhor
individuo
'UserFormAGC.StatusBarAGC.SimpleText = "Calculando... Gerao [" +
CStr(Niter) + "] de " + CStr(AGS.GerMax) + _
' " - Pit Value: " + CStr(Populacao(1).Valor)
Reproducao
'Seleciona os indivduos da prxima gerao
Cruzamento
'Efetua o cruzamento de acordo com a pc
Mutacao
'Efetua a mutao de acordo com a pm
Wend
Call Avalia_Individuo(i) 'Calcula valores da populacao segundo
a funcao original
Next i
Call Seleciona_MelhorInd 'Coloca na posio 1 o melhor individuo
End Sub
Sub Inicializa_Populacao()
Dim i As Integer
Dim j As Integer
If Linha = NExec Then
Clear_Sheet ("PopIni")
Clear_Sheet ("PopFit")
116
End If
Randomize (AGS.Semente) 'Reseta a funo de gerao de nmero
aleatrio
'Inicializa cromossomos e calcula valores dos parmetros da funo
For j = 1 To Comp_Cromossomo
If Round(Rnd) = 1 Then
Populacao(i).Cromossomo(j) = True
Else
Populacao(i).Cromossomo(j) = False
End If
If Linha = NExec Then Worksheets("PopIni").Cells(j, i).Value =
Populacao(i).Cromossomo(j)
Next j
Next i
End Sub
Sub Avalia_Individuo(Indiv As Integer)
Dim i As Integer
(estril+minrio)
If Populacao(Indiv).Cromossomo(i) Then
Call Extract_Block(Int(Mid(BlockModel.CodMin(i), 1, 3)),
Int(Mid(BlockModel.CodMin(i), 4, 3)), _
Int(Mid(BlockModel.CodMin(i), 7, 3)))
End If
Next i
Call Pit_Value(Indiv)
If Linha = NExec Then Worksheets("Resultados").Cells(Niter,
Indiv).Value = Populacao(Indiv).Valor
End Sub
Sub Pit_Value(Indiv As Integer)
'Atualiza o valor da cava de acordo com os blocos extrados
Dim i As Integer
Dim j As Integer
Dim k As Integer
BlockModel.Value = 0
For i = 1 To BlockModel.NRow
For j = 1 To BlockModel.NCol
For k = 1 To BlockModel.NLevel
If BlockModel.Extract(i, j, k) Then
BlockModel.Value = BlockModel.Value + BlockModel.Values(i,
j, k)
End If
Next k
Next j
Next i
Populacao(Indiv).Valor = BlockModel.Value
End Sub
Sub Seleciona_MelhorInd()
Dim i
As Integer
117
Dim
Dim
Dim
Dim
j
VMax
Vold
Vindex
As
As
As
As
Integer
Single
Single
Integer
'Procura mellhor indivduo na populacao baseado no valores do modelo

de blocos
VMax = -1E+32
Lamb = 1E+32
If Populacao(i).Valor > VMax Then
Vindex = i
VMax = Populacao(i).Valor
End If
'Determina o valor de lambida segundo o menor valor da funo
If Populacao(i).Valor < Lamb Then Lamb = Populacao(i).Valor
Next i
Lamb = Abs(Lamb) + 0.001
If Vindex <> 1 Then
'Preserva valores antigos do primeiro individuo
Cold(i) = Populacao(1).Cromossomo(i)
Next i
Vold = Populacao(1).Valor
'Transfere o melhor individuo para a primeira posio da populao
Populacao(1).Cromossomo(i) = Populacao(Vindex).Cromossomo(i)
Next i
Populacao(1).Valor = Populacao(Vindex).Valor
Populacao(Vindex).Cromossomo(i) = Cold(i)
Next i
Populacao(Vindex).Valor = Vold
End If
' Copia melhor individuo de acordo com ao percentual de elitismo
For i = 2 To Round(AGS.PElit * AGS.TamPop) - 1
Populacao(i).Cromossomo(j) = Populacao(1).Cromossomo(j)
Next j
Populacao(i).Valor = Populacao(1).Valor
Next i
End Sub
Sub Reproducao()
Dim i
Dim j
Dim AcumAp
Dim AcumProb
Dim NC
Dim NAleatorio
Dim NCmax
Dim IndMax
cpias
As
As
As
As
As
As
As
As
Integer
Integer
Single
Single
Integer
Single
Integer
Integer
'Somatrio da funo de mrito

'Somatrio da probabilidade
'Nmero de cpias do indivduo
'Nmero aleatrio entre 0 e 1
'Nmero de cpias mxima da populao
'Indivduo que possui o maior nmero de
'Calcula a funo de mrito da populao

AcumAp = 0
118
Populacao(i).Aptidao = Populacao(i).Valor + Lamb
If Linha = NExec Then Worksheets("PopFit").Cells(Niter, i).Value =
Populacao(i).Aptidao
AcumAp = AcumAp + Populacao(i).Aptidao
Next i
AcumProb = 0
'Calcula a probabilidade de cada individuo da populao
ProbPop(i) = Populacao(i).Aptidao / AcumAp
AcumProb = AcumProb + ProbPop(i)
NCopias(i) = 0
ProbPopAc(i) = AcumProb
Next i
'Calcula o nmero de cpias de cada indivduo baseado no mtodo da
roleta
NC = 0
NAleatorio = Rnd
For j = 1 To AGS.TamPop - 1
If (NAleatorio >= ProbPopAc(j)) And (NAleatorio < ProbPopAc(j +
1)) Then
NCopias(j) = NCopias(j) + 1
NC = NC + 1
End If
Next j
Next i
If NC < AGS.TamPop Then
For i = NC + 1 To AGS.TamPop
NCopias(AGS.TamPop) = NCopias(AGS.TamPop) + 1
Next i
End If
'Caso o melhor individuo no seja selecionado faz-se a seleo deste
e decrementa-se
'do individuo com o menor nmero de cpias
NCmax = 0
If NCopias(1) = 0 Then
NCopias(1) = 1
If NCmax < NCopias(i) Then
NCmax = NCopias(i)
IndMax = i
End If
Next i
NCopias(IndMax) = NCopias(IndMax) - 1
End If
'Escreve na planilha o nmero de cpias da populao
If Niter = 1 And Linha = NExec Then Clear_Sheet ("NCopias")
NC = 0
NC = NC + NCopias(i)
If Linha = NExec Then Worksheets("NCopias").Cells(Niter, i).Value
= NCopias(i)
Next i
If Linha = NExec Then Worksheets("NCopias").Cells(Niter, AGS.TamPop
+ 1).Value = NC
119
End Sub
Sub Cruzamento()
Dim i
As Integer
Dim j
As Integer
Dim k
As Integer
Dim NC
As Integer
Dim NAleatorio As Single
'Gera a nova populao baseado na seleo da varivel "NCopias"
NC = 0
If NCopias(i) > 0 Then
For j = 1 To NCopias(i)
NC = NC + 1
For k = 1 To Comp_Cromossomo
CopiaCromos(NC, k) = Populacao(i).Cromossomo(k)
Next k
Next j
End If
Next i
'Executa cruzamento e atualiza populao
i = 1
While i <= (AGS.TamPop - 2)
NAleatorio = Rnd
If NAleatorio <= AGS.PCruz Then
Call Crossover(i + 1)
Else
Populacao(i + 1).Cromossomo(j) = CopiaCromos(i + 1, j)
Populacao(i + 2).Cromossomo(j) = CopiaCromos(i + 2, j)
Next j
End If
i = i + 2
Wend
'Escreve cpia da populacao inicial
If Niter = 1 Then
If Linha = NExec Then Clear_Sheet ("PopCopy")
If Linha = NExec Then Worksheets("PopCopy").Cells(j, i).Value
= CopiaCromos(i, j)
Next j
Next i
End If
End Sub
Sub Crossover(IndPop As Integer)
'Executa cruzamento de um ponto
Dim i
As Integer
Dim Fim
As Integer
Dim NAleatorio As Integer
NAleatorio = Round((Comp_Cromossomo - 1 + 1) * Rnd + 1)
For i = 1 To (NAleatorio - 1)
Populacao(IndPop).Cromossomo(i) = CopiaCromos(IndPop, i)
Populacao(IndPop + 1).Cromossomo(i) = CopiaCromos(IndPop + 1, i)
Next i
Fim = Comp_Cromossomo
120
For i = NAleatorio To Fim
Populacao(IndPop).Cromossomo(i) = CopiaCromos(IndPop + 1, i)
Populacao(IndPop + 1).Cromossomo(i) = CopiaCromos(IndPop, i)
Next i
End Sub
Sub Mutacao()
Dim i
As Integer
Dim j
As Integer
Dim NAleatorio As Single
NAleatorio = Rnd
If NAleatorio <= AGS.PMut Then
If Populacao(i).Cromossomo(j) = True Then
Populacao(i).Cromossomo(j) = False
Else
Populacao(i).Cromossomo(j) = True
End If
End If
Next j
Next i
End Sub
Sub EscreveResultados()
If Linha = 1 Then Clear_Sheet ("Resultados_Grupo")
Sheets("Resultados_Grupo").Activate
With Worksheets("Resultados_Grupo")
Cells(Linha, 1).Value = Linha
Cells(Linha, 2).Value = AGS.Semente
Cells(Linha, 3).Value = AGS.TamPop
Cells(Linha, 4).Value = AGS.PCruz
Cells(Linha, 5).Value = AGS.PMut
Cells(Linha, 6).Value = AGS.PElit
Cells(Linha, 7).Value = GAParam.Niter
Cells(Linha, 8).Value = Populacao(1).Valor
End With
End Sub
Function
String
Dim si
Dim sj
Dim sk
IJK_to_string(i As Integer, j As Integer, k As Integer) As

As String
As String
As String
si = Insert_Zero_Left(i)
sj = Insert_Zero_Left(j)
sk = Insert_Zero_Left(k)
IJK_to_string = Trim(Trim(si) + Trim(sj) + Trim(sk))
End Function
Function Insert_Zero_Left(N As Integer) As String
If N <= 9 Then
Insert_Zero_Left = Trim("00" + Trim(Str(N)))
Else
If N <= 99 Then
121
Else
Insert_Zero_Left = Trim(Str(N))
End If
End If
End Function
Sub Extract_Block(i As Integer, j As Integer, k As Integer)
'Lavra os blocos de acordo com ndices ijk e do angulo geral de
talude
Dim L As Integer
Dim N As Integer
Call Extract_Block_Above(i, j, k)
N = 1
For L = k - 1 To 1 Step -1
Call Extract_Block_Around(i, j, L, N)
N = N + 1
Next L
End Sub
Sub Extract_Block_Around(i As Integer, j As Integer, k As Integer, N
As Integer)
'Lavra os blocos de acordo com o ngulo de talude
Dim TanAngle As Single
Dim Pi
As Single
Dim iRow
As Integer
Dim iRowMax As Integer
Dim iRowMin As Integer
Dim iCol
As Integer
Dim iColMax As Integer
Dim iColMin As Integer
Dim Aux
As Single
Pi = 3.14159265358979
TanAngle = Tan(BlockModel.Angle * Pi / 180)
iRowMax = i + (BlockModel.SizeBZ / BlockModel.SizeBY + 1) *
If iRowMax > BlockModel.NRow Then iRowMax = BlockModel.NRow
iRowMin = i - (BlockModel.SizeBZ / BlockModel.SizeBY + 1) *
If iRowMin < 1 Then iRowMin = 1
iColMax = j + (BlockModel.SizeBZ / BlockModel.SizeBX + 1) *
If iColMax > BlockModel.NCol Then iColMax = BlockModel.NCol
iColMin = j - (BlockModel.SizeBZ / BlockModel.SizeBX + 1) *
If iColMin < 1 Then iColMin = 1
N
N
N
N
For iRow = iRowMin To iRowMax

For iCol = iColMin To iColMax
Aux = Sqr((i - iRow) * BlockModel.SizeBY * (i - iRow) *
BlockModel.SizeBY + (j - iCol) * BlockModel.SizeBX * (j - iCol) *
BlockModel.SizeBX)
If (Aux <= (BlockModel.SizeBZ * N / TanAngle)) Then
BlockModel.Extract(iRow, iCol, k) = True
End If
Next iCol
Next iRow
End Sub
Sub Extract_Block_Above(i As Integer, j As Integer, k As Integer)
122
'Lavra os blocos acima do bloco atual
Dim L As Integer
If (i <= BlockModel.NRow) And (j <= BlockModel.NCol) And (k <=
BlockModel.NLevel) And (i > 0) And (j > 0) Then
For L = 1 To k
BlockModel.Extract(i, j, L) = True
Next L
End If
End Sub
Sub Clear_Sheet(Name As String)
'Apaga a planilha repassada em Name
Dim NewSheet As Worksheet
Set NewSheet = Worksheets.Add
NewSheet.Name = Name
With Worksheets(Name)
Sheets(Name).Select
Sheets(Name).Activate
Cells.Select
Selection.ClearContents
Range("A1").Select
ActiveWindow.DisplayGridlines = False
End With
End Sub
Sub Update_Rows()
'Atualiza as planilhas da linhas do modelo de blocos
Dim i As Integer
Dim j As Integer
Dim k As Integer
'Apaga dados existentes
Clear_Sheet (Trim("r" + Trim(Str(i))))
Next i
'Atualiza planilha de acordo com o modelo de blocos
Worksheets("r" + Trim(Str(i))).Cells(k, j).Value =
Next k
Next j
Next i
End Sub
Sub Format_Read_Data()
'Formata os dados lidos da linhas
Dim i
As Integer
Dim Name As String
Name = Trim("r" + Trim(Str(i)))
Format_Read_Data_Color (Name)
Next i
End Sub
Sub Format_Read_Data_Color(Name As String)
With Sheets(Name)
.Activate
123
Range("A1").Select
Range(Selection, ActiveCell.SpecialCells(xlLastCell)).Select
'Desenha as linhas de contorno das clulas
Draw_Gridlines
'Ajusta autmaticamnete altura e largura da planilha
Cells.EntireColumn.AutoFit
'Define as cores
Range(Selection,
ActiveCell.SpecialCells(xlLastCell)).FormatConditions.Delete
Range(Selection,
ActiveCell.SpecialCells(xlLastCell)).FormatConditions.Add
Type:=xlCellValue, Operator:=xlBetween, _
Formula1:="-9999999", Formula2:="-0.001"
Range(Selection,
ActiveCell.SpecialCells(xlLastCell)).FormatConditions(1).Interior.Colo
rIndex = 36
Range(Selection,
Formula1:="0", Formula2:="8"
Range(Selection,
rIndex = 8
Range(Selection,
Formula1:="8.001", Formula2:="99999999"
Range(Selection,
rIndex = 3
Range("A1").Select
End With
End Sub
Sub Update_Extract_Rows()
'Atualiza planilha dos blocos lavrados
Dim i As Integer
Dim j As Integer
Dim k As Integer
'Apaga dados atuais
Clear_Sheet (Trim("Er" + Trim(Str(i))))
Next i
Worksheets("Er" + Trim(Str(i))).Cells(k, j).Value = True
Else
Worksheets("Er" + Trim(Str(i))).Cells(k, j).Value = False
End If
Next k
Next j
Next i
124
End Sub
Sub Format_Extract_Data()
'Formata planilha dos blocos lavrados
Dim i
As Integer
Dim Name As String
Name = Trim("Er" + Trim(Str(i)))
Format_Extract_Data_Color (Name)
Next i
End Sub
Sub Format_Extract_Data_Color(Name As String)
'Formata planilha dos blocos lavrados
With Sheets(Name)
.Activate
Range("A1").Select
Range(Selection, ActiveCell.SpecialCells(xlLastCell)).Select
'Draw Gridlines
Draw_Gridlines
'Adjust width and height cells automatic
Cells.EntireColumn.AutoFit
'Set colors
Range(Selection,
ActiveCell.SpecialCells(xlLastCell)).FormatConditions.Delete
Range(Selection,
Type:=xlCellValue, _
Operator:=xlEqual, Formula1:="TRUE"
Range(Selection,
rIndex = 35
Range(Selection,
Type:=xlCellValue, _
Operator:=xlEqual, Formula1:="FALSE"
Range(Selection,
rIndex = 36
Range("A1").Select
End With
End Sub
Sub Draw_Gridlines()
'Desenha contornos nas clulas
Selection.Borders(xlDiagonalDown).LineStyle = xlNone
Selection.Borders(xlDiagonalUp).LineStyle = xlNone
With Selection.Borders(xlEdgeLeft)
.LineStyle = xlContinuous
.Weight = xlThin
.ColorIndex = xlAutomatic
End With
With Selection.Borders(xlEdgeTop)
.Weight = xlThin
125
End With
With Selection.Borders(xlEdgeBottom)
.Weight = xlThin
End With
With Selection.Borders(xlEdgeRight)
.Weight = xlThin
End With
With Selection.Borders(xlInsideVertical)
.Weight = xlThin
End With
If BlockModel.NRow > 1 Then
With Selection.Borders(xlInsideHorizontal)
.Weight = xlThin
End With
End If
End Sub
Sub Calcula_NExecucoes()
Dim NIPop As Integer
Dim NIRec As Integer
Dim NIMut As Integer
Dim NIElit As Integer
Dim NISeed As Integer
With UserFormAGC
If .CheckBoxPop.Value Then
NIPop = 1
Else
NIPop = Round(GAParam.PopEnd - GAParam.PopBegin) /
(GAParam.PopStep + 1)
End If
If .CheckBoxRec.Value Then
NIRec = 1
Else
NIRec = Round(GAParam.RecombEnd - GAParam.RecombBegin) /
(GAParam.RecombStep + 1)
End If
If .CheckBoxMut.Value Then
NIMut = 1
Else
NIMut = Round(GAParam.MutatEnd - GAParam.MutatBegin) /
(GAParam.MutatStep + 1)
End If
If .CheckBoxSeed.Value Then
NISeed = 1
Else
NISeed = Round(GAParam.SeedEnd - GAParam.SeedBegin) /
(GAParam.SeedStep + 1)
End If
If .CheckBoxElit.Value Then
NIElit = 1
126
Else
NIElit = Round(GAParam.ElitEnd - GAParam.ElitBegin) /
(GAParam.ElitStep + 1)
End If
End With
NExec = Int(NIPop * NIRec * NIMut * NISeed * NIElit)
End Sub
127
8.2 Anexo II - Listagem do programa multiobjetivo NSGA II com elitismo

Baseado em Deb et al. (2000).
128
Option Explicit
Public MPop()
As Byte
' Matriz mxn com populao de
indivduos gerados (binrio) indiv=col
Public Lvar(2, 2)
As Single
' Vetor com os limites das variveis
Public poptemp()
As Single
'
Public MIDelit()
As Single
' Populao externa para o elitismo
Public FxI()
As Single
' Matriz dos valores das funces
(Linhas so os individuos na FxI)
Public avalia()
As Single
'
Public AVAelit()
As Single
'
Public nvar
As Integer '
Public nfunc
As Integer ' Nmero de funes objetivo
Public Nbpop
As Integer ' Tamanho da populao de indivduos
Public NbMIDelit(2) As Integer ' Varivel de controle do tamanho da
populao externa para o elitismo 1 inicio, 2 fim
Public rank()
As Integer '
Public ja
As Integer '
Public shar()
As Single
'
Public garank()
As Single
'
Public F1()
As Single
'
Public F2()
As Single
'
Public X1()
As Single
'
Public X2()
As Single
'
Public MaxF()
As Single
'
Public MinF()
As Single
'
Public MaxX()
As Single
'
Public MinX()
As Single
'
Public FatPar
As Single
' Fator de partilha
Public PNS
As Single
' Percentagem de elitismo
Public Vmul()
As Integer
Public ngen
As Integer ' Nmero de genes do indivduo
Public BlockModel As TBlockModel
Public AGS
As TAGS
Public nger
As Integer
Public Pond(2)
As Single
na funo monoobjetivo
Type TAGS
TamPop
GerMax
Precisao
PCruz
PMut
PElit
Semente
End Type
As
As
As
As
As
As
As
Integer
Integer
Single
Single
Single
Single
Long
Type TBlockModel
OrigX
As
OrigY
As
OrigZ
As
SizeBX As
SizeBY As
SizeBZ As
NRow
'
'
'
'
Parmetros do modelo de blocos

Contem os parmetros do AGS
Nmero de geraes
Ponderadores a serem utilizados
'Tamanho da populao
'Numero de geraes
'Preciso
'Probabilidade de cruzamento
'Semente para gerao de nmeros aleatrios
Single
Single
Single
Single
Single
Single
'Coordenada X do modelo de blocos

'Coordenada Y do modelo de blocos
'Cota inicial do modelo de blocos
'Tamanho do bloco na direo X
'Tamanho do bloco na direo Y
'Tamanho do bloco na direo Z
As Integer 'Nmero de linhas do modelo de blocos
129
NCol
NLevel
Angle
Value
Mass
ASCI
As
As
As
As
As
Integer
Integer
Integer
Single
Single
'Nmero de colunas do modelo de blocos

'Nmero de nveis do modelo de blocos
'ngulo geral de talude
'Valor da cava
'Massa da cava
Values(22, 22, 14) As Single
'Valor do bloco lido do arquivo
CodMin(792)
As String
'Linha, coluna e nvel dos blocos
de minrio
Extract(22, 22, 14) As Boolean 'Indica se o bloco ser lavrado
ou no
End Type
Sub Executa_AG_Multi_Mono()
Call InitModel
Call Read_Model(Worksheets("Parametros").Cells(14, 2).Value,
False, True, 0, _
BlockModel.NRow, BlockModel.NCol,
BlockModel.NLevel)
' Executa o AG NSGA para os dois problemas propostos
Worksheets("Parametros").Cells(5, 2).Value = 1
Call Programa_MNSGA
Worksheets("Parametros").Cells(5, 2).Value = 2
Call Programa_MNSGA
MsgBox "Processamento concludo para os dois problemas!"
End Sub
Sub Executa_AG_Selecionado()
Call InitModel
Call Read_Model(Worksheets("Parametros").Cells(14, 2).Value,
False, True, 0, _
BlockModel.NRow, BlockModel.NCol,
BlockModel.NLevel)
' Executa o AG NSGA para o problema selecionado
Call Programa_MNSGA
MsgBox "Processamento concludo para o problema selecionado!"
End Sub
Sub InitModel()
'Inicializa modelo
BlockModel.OrigX = -5
BlockModel.OrigY = -5
BlockModel.OrigZ = 0
BlockModel.SizeBX = 10
BlockModel.SizeBY = 10
BlockModel.SizeBZ = 10
BlockModel.NRow = Worksheets("Parametros").Cells(13, 2).Value
BlockModel.NCol = 22
BlockModel.NLevel = 14
BlockModel.Angle = 45
Pond(1) = Worksheets("Parametros").Cells(11, 2).Value
Pond(2) = Worksheets("Parametros").Cells(12, 2).Value
End Sub
130
Sub Read_Model(Name As String, FillSheet As Boolean, WasteModel As
Boolean, WasteValue As Single, _
NRowMax As Integer, NColMax As Integer, NLevelMax As
Integer)
'L
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
modelo de blocos a partir do arquivo ASCII

Aux
As String
i
As Integer
j
As Integer
k
As Integer
Value As Single
NLine As Integer
fs
As Object
F
As Object
Const ForReading = 1, ForWriting = 2, ForAppending = 3

Set F = fs.OpenTextFile(Name, ForReading)
'Le o cabeaho
Aux = F.ReadLine
'Leitura dos valores dos blocos
While Not F.AtEndOfStream
Aux = F.ReadLine
Call Read_IJK_Values(Aux, i, j, k, Value)
BlockModel.Values(i, j, k) = Value
If (Not WasteModel) And (Value < 0) Then BlockModel.Values(i, j,
k) = WasteValue
Wend
F.Close
'Atualiza planilha de acordo com o arquivo ASCII
NLine = 1
ngen = 0
NLine = NLine + 1
If BlockModel.Values(i, j, k) >= 0 Then
ngen = ngen + 1
BlockModel.CodMin(ngen) = IJK_to_string(i, j, k)
End If
Next k
Next j
Next i
'Limpa planilha
'Clear_Sheet ("Model_CSV")
If FillSheet Then
NLine = 0
NLine = NLine + 1
Worksheets("Model_CSV").Cells(NLine, 1).Value = i
131
Worksheets("Model_CSV").Cells(NLine, 2).Value = j
Worksheets("Model_CSV").Cells(NLine, 3).Value = k
Worksheets("Model_CSV").Cells(NLine, 4).Value =
Next k
Next j
Next i
End If
End Sub
Sub Read_IJK_Values(Aux As String, i As Integer, j As Integer, k As
Integer, Value As Single)
'Converte a variavel
de blocos
Dim Begin_String(10)
Dim Len_String(10)
Dim Index
Dim z
Aux (linha) para os indices e valores do modelo

As
As
As
As
Integer
Integer
Integer
Integer
Index = 1
Begin_String(0) = 0
Len_String(0) = 0
Begin_String(Index) = 1
For z = 1 To Len(Aux)
If (MID(Aux, z, 1) = ",") Then
Len_String(Index) = z - 1 - Len_String(Index - 1) Begin_String(Index - 1)
Index = Index + 1
Begin_String(Index) = z + 1
End If
Next z
Len_String(Index) = Len(Aux) - Begin_String(Index - 1) - 1
i = Int(MID(Aux, Begin_String(1), Len_String(1)))
j = Int(MID(Aux, Begin_String(2), Len_String(2)))
k = Int(MID(Aux, Begin_String(3), Len_String(3)))
Value = CSng(MID(Aux, Begin_String(4), Len_String(4)))
End Sub
Function IJK_to_string(i As Integer, j As Integer, k As Integer) As
String
Dim si As String
Dim sj As String
Dim sk As String
si = Insert_Zero_Left(i)
sj = Insert_Zero_Left(j)
sk = Insert_Zero_Left(k)
IJK_to_string = Trim(Trim(si) + Trim(sj) + Trim(sk))
End Function
Function Insert_Zero_Left(N As Integer) As String
If N <= 9 Then
Else
If N <= 99 Then
Else
Insert_Zero_Left = Trim(Str(N))
132
End If
End If
End Function
Sub Programa_MNSGA()
' Inicializao de Variveis
Dim Nbgen
As Integer ' Nmero de geraes
Dim Nopt
As Integer ' Nmero de variveis de otimizao
(cromossomos)
Dim Nbit
As Integer ' Tamanho do cromossomo (nmero de bits)
Dim Pcros
As Single ' Probabilidade de cruzamento
Dim PMut
As Single ' Probabilidade de mutao de cada bit
(gene)
Dim adapt
As Integer ' Entrada do tipo de adaptao
Dim Iselec
As Integer ' Entrada do tipo de seleo
Dim FI()
As Single ' Vetor de desempenho gerado pelo NSGA
Dim M()
As Single ' Matriz com as variveis de otimizao
Dim G
As Single ' Fator g
Dim NPext
As Integer ' Tamanho mximo da populao externa
Dim NOVO
As Integer ' Tamanho da populao externa
Dim Ntype
As Integer ' Tipo de problema
Dim Tcruz
As Integer ' Tipo de cruzamento
Dim NSel
As Integer ' Nmero de indivduos as serem
processados
Dim F
As Integer
Dim Dt
As Single
Dim DrI()
As Single
Dim DrIM()
As Single
Dim InDrIM() As Integer
Dim Isort()
As Integer
Dim MTop()
As Byte
Dim ki
As Integer
Dim kk
As Integer
Dim maiorvar As Single
Dim imaiorvar As Integer
Dim i
As Integer
Dim j
As Integer
'Dim Nred As Integer
do intervalo
' Limite para iniciar o processo de reduo
'Parmetros de Entrada
Nbpop = Worksheets("Parametros").Cells(2,
populao de indivduos
NPext = Worksheets("Parametros").Cells(3,
mximo da populao externa
Nbgen = Worksheets("Parametros").Cells(4,
geraes
Ntype = Worksheets("Parametros").Cells(5,
Schaffer2; (2) = Schaffer3 ; (3) Parabolas:
2).Value ' Tamanho da

2).Value ' Tamanho
2).Value ' Nmero de
2).Value ' (1)
' Inicializa variveis de acordo com o problema:(1) Valor; (2) =

Massa; (3) Valor e Massa
If Ntype = 1 Then
ReDim FxI(Nbpop, 2)
ReDim F1(2)
ReDim F2(2)
ReDim avalia(Nbpop, 2)
ReDim AVAelit(Nbpop + NPext * 2, 2)
nfunc = 1
133
Nopt = 1
ElseIf Ntype = 2 Then
ReDim FxI(Nbpop, 2)
ReDim F1(2)
ReDim F2(2)
ReDim avalia(Nbpop, 2)
ReDim AVAelit(Nbpop + NPext * 2, 2)
nfunc = 2
Nopt = 1
End If
nvar = Nopt
ReDim poptemp(nfunc, Nbpop, ngen)
ReDim shar(Nbpop)
ReDim DrI(Nbpop)
ReDim DrIM(Nbpop)
ReDim InDrIM(Nbpop)
ReDim Isort(Nbpop)
ReDim garank(Nbpop)
ReDim X1(Nopt)
ReDim X2(Nopt)
ReDim MaxF(nfunc)
ReDim MinF(nfunc)
ReDim MaxX(Nopt)
ReDim MinX(Nopt)
' Tamanho dos cromossomos
'Nbit = 12
' Tipo de seleo
Iselec = 2 'Amostragem Determ.
' Tipo de cruzamento
Tcruz = 2 'Cruzamento de 2Pt
' Probabilidade de cruzamento
Pcros = Worksheets("Parametros").Cells(6, 2).Value
' Probabilidade de mutao
PMut = Worksheets("Parametros").Cells(7, 2).Value
' Percentagem de elitismo
PNS = Worksheets("Parametros").Cells(9, 2).Value
' Fator de partilha
FatPar = Worksheets("Parametros").Cells(10, 2).Value
adapt = 0
' Nmero de genes do indivduo
ReDim MTop(ngen, Nbpop)
' Populao inicial gerada aleatoriamente
Call gerapop(Nbpop)
' Nmero de geraes
nger = 1
' Calcula o nmero de indivduos a serem processados - SSGA
G = 1
NSel = Fix(G * Nbpop)
ReDim rank(NSel)
ReDim Vmul(Nbit, 1)
ReDim MIDelit(nfunc, Nbpop + NPext * 2, ngen) As Single
134
' Limita o valor mnimo de NSel em 2 indivduos

If (NSel < 2) Then NSel = 2
NbMIDelit(2) = 0
' Loop para processamento das geraes
While ((nger <= Nbgen) And (NOVO <= NPext))
' Avaliao da funo de otimizao (FxI)
If Ntype = 1 Then
Call FuncaoMonoOb 'Atualiza FxI
Else
Call FuncaoMultiOb 'Atualiza FxI
End If
' Elitismo
Call elitismo(NSel, NPext / 2)
If (ja = 1) Then
' Avaliao da funo de otimizao
If Ntype = 1 Then
Call FuncaoMonoOb
Else
Call FuncaoMultiOb
End If
End If
' Aplica o NSGA com as duas funes objetivo bsicas
Call NSGA(NSel, 0)
' Para os mtodos de seleo e cruzamento
For i = 1 To ngen
For j = 1 To Nbpop
MTop(i, j) = MPop(i, j)
' Populao total de
indivduos
Next j
Next i
' Calcula o desempenho total
Dt = 0
For i = 1 To Nbpop
Dt = Dt + shar(i)
Next i
' Calcula o desempenho relativo de cada indivduo - FITNESS
FUNCTION
For i = 1 To Nbpop
DrI(i) = shar(i) / Dt
Next i
' Seleo pelo mtodo da Amostragem Determinstica
If (Iselec = 2) Then
maiorvar = -1E-34
For i = 1 To Nbpop
Isort(i) = 0
' Limpa vetor de indivduos
For j = 1 To ngen
MPop(j, i) = 0
' Apaga a populao a ser
processada
Next j
135
DrIM(i) = DrI(i) * NSel
InDrIM(i) = Fix(DrIM(i)) 'nmero de cpias do individuo
If InDrIM(i) > maiorvar Then
maiorvar = InDrIM(i)
imaiorvar = i
End If
Next i
ki = 1
' Seleciona somente o percentual G de indivduos
For F = 1 To Nbpop
kk = InDrIM(F)
While (kk >= 1) And (ki <= NSel)
Isort(ki) = F
For i = 1 To ngen
MPop(i, ki) = MTop(i, Isort(ki))
Next i
kk = kk - 1
ki = ki + 1
Wend
Next F
For i = 1 To Nbpop
InDrIM(i) = DrIM(i) - InDrIM(i)
Next i
While ki <= NSel
'[maiorvar,mind] = Max(InDrIM)
Isort(ki) = imaiorvar
For i = 1 To ngen
MPop(i, ki) = MTop(i, Isort(ki))
Next i
InDrIM(imaiorvar) = 0
ki = ki + 1
Wend
End If
' Cria nova gerao
nger = nger + 1
' Operador cruzamento na populao
Call cruzam(Nbpop, Pcros, Nopt, Tcruz)
' Operador mutao na populao
Call mutac(Nbpop, PMut)
Wend
Call noequal2(Nbpop)
Call domina3(Nbpop)
Call EscreveResultados(Ntype)
End Sub
Sub gerapop(Tpop)
' GERAPOP - Gerador de populao de indivduos para Algoritmo
'
Gentico Simples - SGA
'
'
Mpop = GERAPOP(Tpop,Ngen)
136
'
'
Argumentos de Entrada:
'
Tpop - Tamanho da polpulao de indivduos.
'
Ngen - Nmero de genes por indivduo.
'
'
Argumentos de Sada
'
Mpop - Matriz mxn com populao de indivduos gerados,
sendo
'
n indivduos dispostos em colunas com m genes
dispostos
'
em linhas.
' Copyright (c) Marcos Fonseca - 18/09/99
' Gera uma populao de Tpop indivduos com Ngen genes cada
Dim i As Integer
Dim j As Integer
ReDim MPop(ngen, Tpop)
Randomize (Worksheets("Parametros").Cells(8, 2).Value) 'Le semente
For i = 1 To ngen
For j = 1 To Tpop
MPop(i, j) = Round(Rnd)
Next j
Next i
End Sub
Sub FuncaoMonoOb()
Dim i As Integer
'Linhas so os individuos na FxI
MaxF(1) = -1E-34
MinF(1) = 1E+34
For i = 1 To Nbpop
Call Avalia_Individuo(i, False)
If MaxF(1) < FxI(i, 1) Then MaxF(1) = FxI(i, 1)
If MinF(1) > FxI(i, 1) Then MinF(1) = FxI(i, 1)
Next i
End Sub
Sub FuncaoMultiOb()
Dim i As Integer
MaxF(1)
MinF(1)
MaxF(2)
MinF(2)
=
=
=
=
-1E-34
1E+34
-1E-34
1E+34
For i = 1 To Nbpop
Call Avalia_Individuo(i, True)
If MaxF(1) < FxI(i, 1) Then MaxF(1)
If MaxF(2) < FxI(i, 2) Then MaxF(2)
If MinF(1) > FxI(i, 1) Then MinF(1)
If MinF(2) > FxI(i, 2) Then MinF(2)
Next i
End Sub
=
=
=
=
FxI(i,
FxI(i,
FxI(i,
FxI(i,
1)
2)
1)
2)
Sub Avalia_Individuo(indiv As Integer, Multi As Boolean)

Dim i As Integer
For i = 1 To ngen
137
(estril+minrio)
If MPop(i, indiv) Then
Call Extract_Block(Int(MID(BlockModel.CodMin(i), 1, 3)),
Int(MID(BlockModel.CodMin(i), 4, 3)), _
Int(MID(BlockModel.CodMin(i), 7, 3)))
End If
Next i
Call Pit_Value(indiv, Multi)
End Sub
Sub Pit_Value(indiv As Integer, Multi As Boolean)
'Atualiza o valor da cava de acordo com os blocos extrados
Dim i As Integer
Dim j As Integer
Dim k As Integer
BlockModel.Mass = 0
j, k)
If BlockModel.Values(i, j, k) >= 0 Then BlockModel.Mass =
BlockModel.Mass + 1
End If
Next k
Next j
Next i
If Multi Then
FxI(indiv, 1) = BlockModel.Value
FxI(indiv, 2) = BlockModel.Mass
Else
FxI(indiv, 1) = Pond(1) * BlockModel.Value + Pond(2) *
BlockModel.Mass
End If
End Sub
Sub Extract_Block(i As Integer, j As Integer, k As Integer)
'Lavra os blocos de acordo com ndices ijk e do angulo geral de
talude
Dim L As Integer
Dim N As Integer
Call Extract_Block_Above(i, j, k)
N = 1
For L = k - 1 To 1 Step -1
Call Extract_Block_Around(i, j, L, N)
N = N + 1
Next L
End Sub
Sub Extract_Block_Around(i As Integer, j As Integer, k As Integer, N
As Integer)
138
'Lavra os blocos de acordo com o ngulo de talude
Dim TanAngle As Single
Dim Pi
As Single
Dim iRow
As Integer
Dim iRowMax As Integer
Dim iRowMin As Integer
Dim iCol
As Integer
Dim iColMax As Integer
Dim iColMin As Integer
Dim Aux
As Single
Pi = 3.14159265358979
TanAngle = Tan(BlockModel.Angle * Pi / 180)
iRowMax = i + (BlockModel.SizeBZ / BlockModel.SizeBY + 1) *
If iRowMax > BlockModel.NRow Then iRowMax = BlockModel.NRow
iRowMin = i - (BlockModel.SizeBZ / BlockModel.SizeBY + 1) *
If iRowMin < 1 Then iRowMin = 1
iColMax = j + (BlockModel.SizeBZ / BlockModel.SizeBX + 1) *
If iColMax > BlockModel.NCol Then iColMax = BlockModel.NCol
iColMin = j - (BlockModel.SizeBZ / BlockModel.SizeBX + 1) *
If iColMin < 1 Then iColMin = 1
N
N
N
N
For iRow = iRowMin To iRowMax

For iCol = iColMin To iColMax
Aux = Sqr((i - iRow) * BlockModel.SizeBY * (i - iRow) *
BlockModel.SizeBY + (j - iCol) * BlockModel.SizeBX * (j - iCol) *
BlockModel.SizeBX)
If (Aux <= (BlockModel.SizeBZ * N / TanAngle)) Then
BlockModel.Extract(iRow, iCol, k) = True
End If
Next iCol
Next iRow
End Sub
Sub Extract_Block_Above(i As Integer, j As Integer, k As Integer)
'Lavra os blocos acima do bloco atual
Dim L As Integer
If (i <= BlockModel.NRow) And (j <= BlockModel.NCol) And (k <=
BlockModel.NLevel) And (i > 0) And (j > 0) Then
For L = 1 To k
BlockModel.Extract(i, j, L) = True
Next L
End If
End Sub
Sub elitismo(NSel, NPext)
Dim i
As Integer
Dim j
As Integer
Dim z
As Integer
Dim NS
As Integer
Dim r()
As Integer
Dim T()
As Integer
Dim NOVO
As Integer
Dim ind
As Integer
Dim Verifica As Integer
ReDim r(NSel)
ReDim T(NSel)
139
' Verifica se o tamanho da populao externa no excedeu Pext
(tamanho mximo)
NOVO = 0
ja = 0
If (NbMIDelit(2) <= NPext) Then
' acrescenta os indivduos eficientes populao externa
Call domina1(NSel)
For j = NbMIDelit(1) To NbMIDelit(2)
For i = 1 To nvar
For z = 1 To ngen
MIDelit(i, j, z) = poptemp(i, j - NbMIDelit(1) + 1, z)
Next z
Next i
Next j
For i = NbMIDelit(1) To NbMIDelit(2)
For j = 1 To nfunc
AVAelit(i, j) = avalia(i - NbMIDelit(1) + 1, j)
Next j
Next i
Else
'acrescenta novos indivduos eficientes Pext e elimina os
ineficientes
Call domina1(NSel)
For j = NbMIDelit(1) To NbMIDelit(2)
For i = 1 To nvar
For z = 1 To ngen
MIDelit(i, j, z) = poptemp(i, j - NbMIDelit(1) + 1,
z)
Next z
Next i
Next j
For i = NbMIDelit(1) To NbMIDelit(2)
For j = 1 To nfunc
AVAelit(i, j) = avalia(i - NbMIDelit(1) + 1, j)
Next j
Next i
Call domina2(NbMIDelit(2))
'retira individuos iguais
Call noequal1
NOVO = NbMIDelit(2)
' realiza substituio de PNS (porcento) de elementos de MID
por MIDelit
NS = Round(NSel * PNS)
externa
' limita o # de indiv substitudos pelo tamanho da populao

If (NS > NOVO) Then
NS = NOVO
End If
' inicializa variveis
For i = 1 To NS
T(i) = 0
r(i) = 0
Next i
ind = 1
ReDim T(NbMIDelit(2))
' substitui o # de indivduos desejados
140
While (ind <= NS)
r(ind) = Int((Rnd * NSel) + 1)
T(ind) = Int(Rnd * NbMIDelit(2) + 1)
Verifica = 1
' verifica se indivduo j foi substituido
For i = 1 To (ind - 1)
If ((r(i) = r(ind)) And (T(i) = T(ind))) Then
Verifica = 0
End If
Next i
' substitui inidivduo
If Verifica = 1 Then
For i = 1 To nvar
For z = 1 To ngen
'Xb10(i, r(ind)) = MIDelit(i, T(ind))
MPop(z, r(ind)) = MIDelit(i, T(ind), z)
Next z
Next i
ind = ind + 1
ja = 1
End If
Wend
End If
End Sub
Sub domina1(nindiv) 'atualiza matrizes poptemp e avalia (argumentos
FxI e Xb10)
Dim i
As Integer
Dim j
As Integer
Dim k
As Integer
Dim c_rank
As Integer
Dim c_dom
As Integer
Dim rank()
As Integer
ReDim rank(nindiv) As Integer
Dim c
As Integer
Dim z
As Integer
' Cobre toda a populao corrente
For i = 1 To nindiv
' Classificao para o indivduo i
c_rank = 0
'Compara indivduo "i" com a populao usando a definio de
dominncia
For j = 1 To nindiv
If i <> j Then
' Define dominncia
c_dom = 1
' Conceito de dominancia e empregado aqui.
' Dimenso de FxI(a,b
a: Tamanho da Populao
'
b: Nmero de funes objetivo
' Exemplo: FxI(1,2):
Valor da funo objetivo 2 do
indivduo 1.
'
For k = 1 To nfunc
If (FxI(i, k) > FxI(j, k)) Then c_dom = c_dom * 0
If (FxI(i, k) = FxI(j, k)) Then c_dom = c_dom * 1
If (FxI(i, k) < FxI(j, k)) Then c_dom = c_dom * 2
Next k 'Fim do conceito de dominncia
'Checa "i" eficiente
141
If (c_dom > 1) Then c_rank = c_rank + 1
End If 'Fim da comparao do indivduo atual com a
populao
Next j
' Classificao do indivduo "i" pelo conceito de dominncia
rank(i) = 1 + c_rank
Next i
c = 1
For i = 1 To nindiv
If (rank(i) = 1) Then
For j = 1 To nvar
For z = 1 To ngen
'poptemp(j, c) = Xb10(j, i) sapos
poptemp(j, c, z) = MPop(z, i)
Next z
Next j
For j = 1 To nfunc
avalia(c, j) = FxI(i, j)
Next j
c = c + 1
End If
Next i
If c > 1 Then
NbMIDelit(1) = NbMIDelit(2) + 1
NbMIDelit(2) = NbMIDelit(2) + c - 1
End If
End Sub
AVAelit e MIDElit)
Dim i
As Integer
Dim j
As Integer
Dim k
As Integer
Dim z
As Integer
Dim c_rank
As Integer
Dim c_dom
As Integer
Dim rank()
As Integer
Dim c
As Integer
For i = 1 To nindiv
c_rank = 0
dominncia
For j = 1 To nindiv
If i <> j Then
' Define dominncia
c_dom = 1
'
indivduo 1.
'
For k = 1 To nfunc
If (AVAelit(i, k) > AVAelit(j, k)) Then c_dom =
c_dom * 0
142
c_dom * 1
c_dom * 2
If (AVAelit(i, k) = AVAelit(j, k)) Then c_dom =

If (AVAelit(i, k) < AVAelit(j, k)) Then c_dom =
populao
Next j
Next i
c = 1
For i = 1 To nindiv
For j = 1 To nvar
For z = 1 To ngen
MIDelit(j, c, z) = MIDelit(j, i, z)
Next z
Next j
For j = 1 To nfunc
AVAelit(c, j) = AVAelit(i, j)
Next j
c = c + 1
End If
Next i
If c > 1 Then
NbMIDelit(1) = 1
NbMIDelit(2) = c - 1
End If
End Sub
FxI e Xb10)
Dim i
As Integer
Dim j
As Integer
Dim k
As Integer
Dim z
As Integer
Dim c_rank
As Integer
Dim c_dom
As Integer
Dim rank()
As Integer
Dim c
As Integer
For i = 1 To nindiv
c_rank = 0
dominncia
For j = 1 To nindiv
If i <> j Then
' Define dominncia
c_dom = 1
'
143
indivduo 1.
'
For k = 1 To nfunc
If (FxI(i, k) > FxI(j, k)) Then c_dom = c_dom * 0
If (FxI(i, k) = FxI(j, k)) Then c_dom = c_dom * 1
If (FxI(i, k) < FxI(j, k)) Then c_dom = c_dom * 2
populao
Next j
Next i
c = 1
For i = 1 To nindiv
For j = 1 To nvar
For z = 1 To ngen
'Xb10(j, c) = Xb10(j, i)
MPop(z, c) = MPop(z, i)
Next z
Next j
For j = 1 To nfunc
FxI(c, j) = FxI(i, j)
Next j
c = c + 1
End If
Next i
End Sub
Sub NSGA(nindiv, NICHOS)

'
' O algoritmo NSGA baseado em um procedimento de classificao
dos pontos eficientes da populao
'
' Antes do Operador Seleo Atuar, so realizados os seguintes
passos:
'
'
(1) Populao classificada com base no conceito de
dominncia. Todos os indivduos inicialmente
'
classificados assumem um valor de funo de aptido
inicial (DUMMY FITNESS). Para manter a
'
diversidade, estes indivduos so submetidos a uma funo
de partilha triangular.
'
'
(2) Os indivduos anteriormente classificados so
"esquecidos" da populao e o processo de
'
classificao iniciado novamente. A funo de aptido
desta segunda classificao deve
'
ser menor que o MENOR valor de aptido da classificao
anterior
'
'
(3) O processo continua at todos os indivduos serem
classificados
'
144
'
Este processo de classificao dar origem fronteiras
eficientes na
'
populao corrente.
'
'
Argumentos de Entrada do NSGA:
'
F - Matriz com os valores de cada funo objetivo para
toda a populao
' nindiv - Nmero de indivduos da populao a serem analisados
'
Lvar - Vetor com os limites das variveis de otimizao
'
nvar - Nmero de variveis de otimizao do problema
' nfunc - Nmero de funes objetivo a serem usadas na definio
de eficincia
'
MID - Matriz com dados das variveis de otimizao
decodificadas
' NICHOS - Tipo da tcnica de nichos a ser utilizada pelo NSGA
'
Argumentos de sada:
'
MFxI - Vetor com a nova funo de aptido da populao
' Copyright (c) Alexandre Henrique Farah Dias - 15/07/00
Dim i
As Integer
Dim j
As Integer
Dim k
As Integer
Dim Ssort()
As Single
Dim c_Sort
As Integer
Dim dshared
As Single
Dim ini_dummy_f As Single
Dim del_dummy_f As Single
Dim min_dummy_f As Single
Dim c_rank
As Integer
Dim nfront
As Integer
Dim fron()
As Integer
Dim pop_ndom() As Integer
Dim c_dom
As Integer
ReDim Ssort(nindiv)
ReDim fron(nindiv)
ReDim pop_ndom(nindiv)
' Inicializao das variveis
For i = 1 To nindiv
garank(i) = 0
shar(i) = 0
Ssort(i) = 0
Next i
' Fronteira Pareto timo classificada
nfront = 0
' Valores iniciais para funo de partilha triangular
ini_dummy_f = 100
del_dummy_f = 0.05 * ini_dummy_f
' Raio de
If FatPar
dshared
nvar)
Else
dshared
End If
partilha estimado
= 0 Then
= 0.5 / Application.WorksheetFunction.Power(nindiv, 1 /
= FatPar
145
c_Sort = 0
' Realiza definio das fronteiras PO
While (c_Sort < nindiv)
For i = 1 To nindiv
c_rank = 0
' Indivduo i ainda no rankeado
If (Ssort(i) = 0) Then
'Compara indivduo "i" com a populao usando a
definio de dominncia
For j = 1 To nindiv
'Indivduo j ainda no rankeado
If ((Ssort(j) = 0) And (i <> j)) Then
' Define dominncia
c_dom = 1
For k = 1 To nfunc
If (FxI(i, k) > FxI(j, k)) Then c_dom =
c_dom * 0
If (FxI(i, k) = FxI(j, k)) Then c_dom =
c_dom * 1
If (FxI(i, k) < FxI(j, k)) Then c_dom =
c_dom * 2
Next k
End If 'Fim do conceito de dominncia
' Checa se "j" domina "i"
Next j
populao
' Classificao do indivduo "i" pelo conceito de
dominncia
garank(i) = 1 + c_rank
Next i
' Atualiza nmero de fronteiras
nfront = nfront + 1
k = 0
' Determina valor da avaliao para a fronteira corrente
For i = 1 To nindiv
' Indivduo "i" eficiente?
If (garank(i) = 1) Then
'Total de indivduos ordenados at o momento
c_Sort = c_Sort + 1
'Total de indivduos da fronteira atual
k = k + 1
Ssort(i) = 1
'Indica que indivduo j foi
classificado
garank(i) = -2
'Desabilita flag de classificacao
fron(i) = nfront 'Indica fronteira do indivduo
classificado
' Funo de aptido do indivduo
If (nfront = 1) Then
shar(i) = ini_dummy_f 'Se a primeira fronteira,
assume um valor default
Else
146
shar(i) = min_dummy_f - del_dummy_f
End If
End If
Next i
' Determina valor da avaliao para a fronteira corrente
pop_ndom(nfront) = k
' Realiza a tcnica de formao de nichos para os indivduos
classificados
Call nichoAG(NICHOS, nindiv, dshared)
' Atualiza classificao corrente
For i = 1 To nindiv
If (garank(i) = -2) Then
garank(i) = -1
End If
Next i
Wend
End Sub
Sub cruzam(Nbpop, Pcru, Nopt, Tcruz)
' CRUZAM - Cruzamento de indivduos de uma populao para
'
Algoritmo Gentico Simples. No permitido o cruzamento
'
entre os mesmos indivduos. O ponto de corte escolhido
'
aleatoriamente. So permitidos mltiplos cruzamentos de
'
um mesmo casal.
'
'
MIC = CRUZAM(Mpop,Pcru)
'
'
Argumentos de Entrada:
'
Mpop - Matriz mxn com a populao de n indivduos
'
dipostos em colunas.
'
Pcru - Probabilidade de cruzamento para cada indivduo,
'
com valor entre 0 e 1.
'
'
Argumentos de Sada
'
MIC - Matriz mxn com a nova populao resultante do
cruzamento,
'
sendo n indivduos dipostos em colunas.
' Copyright (c) Marcos Fonseca - 19/09/99
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
F As Integer
ii As Integer
v As Integer
Vind() As Integer
Pind() As Single ' Probabilidade de cada indivduo
Icru() As Single ' Indivduos que cruzam
i As Integer
j As Integer
Npop() As Byte
Pcor1 As Integer
Pcor2 As Integer
Cut1 As Integer
Cut2 As Integer
Pai As Integer
Mae As Integer
Aux As Integer
147
Dim Ncru As Integer
Dim vpar() As Integer ' Vetor de parceiros
ReDim
ReDim
ReDim
ReDim
ReDim
Vind(Nbpop)
Pind(Nbpop)
Icru(Nbpop)
Npop(ngen, Nbpop)
vpar(Nbpop)
' Vetor de indivduos

j = 0
For i = 1 To Nbpop
Vind(i) = i
Pind(i) = Int((Nbpop) * Rnd + 1)
If Pind(i) <= Pcru Then
j = j + 1
Icru(j) = i
End If
Next i
' Vetor com os indivduos que cruzam
Ncru = j
' Nmero de cruzamentos
For i = 1 To ngen
For j = 1 To Nbpop
Npop(i, j) = MPop(i, j) ' Nova populao
Next j
Next i
If Ncru > 0 Then
' Continua somente se existirem
cruzamentos
' Parceiros para formao do casal
For F = 1 To Ncru
vpar(F) = Int((Nbpop) * Rnd + 1)
Next F
If Tcruz = 2 Then
' Cruzamento com 2 Pontos de corte para cada indivduo que
cruza
Pcor1 = Round(Int((Ncru) * Rnd + 1) * (ngen - 2)) + 1
Pcor2 = Pcor1
While Pcor2 = Pcor1
Pcor2 = Round(Int((Ncru) * Rnd + 1) * (ngen - 2)) + 1
Wend
' Faz o cruzamento
For F = 1 To Ncru
Pai = Icru(F)
Mae = vpar(F)
Cut1 = Pcor1
Cut2 = Pcor2
If Cut1 > Cut2 Then
Aux = Cut1
Cut1 = Cut2
Cut2 = Aux
End If
If Cut1 = Cut2 Then
If Cut1 = ngen Then
Cut1 = Cut1 - 1
ElseIf Cut2 = 1 Then
Cut2 = Cut2 + 1
End If
148
End If
For i = Cut1 To Cut2
Npop(i, Pai) = MPop(i, Mae)
Npop(i, Mae) = MPop(i, Pai)
Next i
Next F
End If
End If
For i = 1 To ngen
For j = 1 To Nbpop
MPop(i, j) = Npop(i, j) ' Atualiza Mpop
Next j
Next i
End Sub
Sub mutac(Nbpop, PMut)
' MUTAC
- Mutao dos bits (genes) de indivduos de uma
populao para
'
Algoritmo Gentico Simples.
'
'
Mpop - Matriz mxn com a populao de n indivduos
'
dipostos em colunas.
'
Pmut - Probabilidade de mutao para cada bit (gene) dos
indivduos,
'
com valor entre 0 e 1.
Dim i As Integer
Dim j As Integer
' Mutao bit a bit com probabilidade 100'/No. de bits do
individuo
' Indivduos e bits que sofrero mutao
For i = 1 To ngen
For j = 1 To Nbpop
If Rnd <= PMut Then
MPop(i, j) = MPop(i, j) * (-1) + 1
End If
Next j
Next i
End Sub
Sub noequal1()
Dim i
As Integer
Dim j
As Integer
Dim k
As Integer
Dim z
As Integer
Dim N
As Integer
Dim Acum As Single
i = 1
While i <= NbMIDelit(2)
For j = NbMIDelit(2) To i + 1 Step -1
Acum = 0
For k = 1 To nfunc
Acum = Acum + (AVAelit(i, k) - AVAelit(j, k)) ^ 2
Next k
If Sqr(Acum) < 0.1 Then
For N = j To NbMIDelit(2)
For k = 1 To nfunc
AVAelit(N, k) = AVAelit(N + 1, k)
149
Next k
For k = 1 To nvar
For z = 1 To ngen
MIDelit(k, N, z) = MIDelit(k, N + 1, z)
Next z
Next k
Next N
NbMIDelit(2) = NbMIDelit(2) - 1
End If
Next j
i = i + 1
Wend
End Sub
Sub noequal2(Nbpop)
Dim i
As Integer
Dim j
As Integer
Dim k
As Integer
Dim z
As Integer
Dim N
As Integer
Dim Acum As Single
i = 1
While i <= Nbpop
For j = Nbpop To i + 1 Step -1
Acum = 0
For k = 1 To nfunc
Acum = Acum + (FxI(i, k) - FxI(j, k)) ^ 2
Next k
If Sqr(Acum) < 0.1 Then
For N = j To Nbpop
For k = 1 To nfunc
If N < Nbpop Then FxI(N, k) = FxI(N + 1, k)
'Falta
Next k
For k = 1 To nvar
If N < Nbpop Then
'Xb10(k, N) = Xb10(k, N + 1)
For z = 1 To ngen
MPop(z, N) = MPop(z, N + 1)
Next z
End If
Next k
Next N
Nbpop = Nbpop - 1
End If
Next j
i = i + 1
Wend
End Sub
Sub nichoAG(TIPOPAR, nindiv, dshared)
' Esta funo realiza a funo de partilha triangular a partir dos
' valores assumidos durante a classificacao da fronteira corrente
'
' Argumentos de Entrada da nichosAG:
'
' TIPOPAR - Tipo da tcnica de nicho a ser empregada
'
MID - Matriz com variveis de otimizao decodificadas
'
F - Matriz com dados das funes objetivo
150
'
Lvar - Vetor com os limites das variveis de otimizao
'
shar - Vetor classificao degradada da populao em
fronteiras PO
'
rank - Vetor de classificao da populao em fronteiras PO
' nindiv - Nmero de indivduos na populao
'
nvar - Nmero de variveis
'
nfunc - Nmero de funes a serem usadas na definio de
eficincia
' dshared - Valor mximo do raio de partilha para indivduo
pertencer ao nicho
' Argumentos de Sada da nichosAG:
'
shar - Vetor com a nova funo de partilha da fronteira PO
atual
' Define os limites para aplicao da tcnica de nicho
Dim i
As Integer
Dim j
As Integer
Dim k
As Integer
Dim nichecount As Integer
Dim d
As Single
For i = 1 To nvar
MaxX(i) = Lvar(2, i)
MinX(i) = Lvar(1, i)
Next i
d = 0
' Aplicao da tcnica de formao de nichos
For i = 1 To nindiv
' Nmero de indivduos pertencentes ao nicho
nichecount = 1
' Fronteira Pareto timo atual
If (garank(i) = -2) Then
For j = 1 To nindiv
If (i <> j) Then
' Indivduo pertencente a PO atual?
If (garank(j) = -2) Then
' Variveis da dimenso
For k = 1 To nfunc
F1(k) = FxI(i, k)
F2(k) = FxI(j, k)
Next k
For k = 1 To nvar
'X1(k) = Xb10(k, i) sapos
'X2(k) = Xb10(k, j)
Next k
' Determina distncia entre os dois indivduos
cujo espao dado pela varivel TIPOPAR
d = distanciaAG(1)
' Aplica-se a tcnica de formao de nichos
If (d < dshared) Then
nichecount = nichecount + (1 - (d /
dshared) * (d / dshared))
End If
End If
End If
Next j
151
End If
' Recalcula valor de aptido usando a informao dos
indivduos
' pertencentes ao nicho.
shar(i) = (shar(i) / nichecount)
Next i
End Sub
Function distanciaAG(TIPOPAR) As Single
' Esta funo calcula a distncia entre dois indivduos a partir
' do parmetro TIPOPAR que seleciona o espao para medio
'
' Argumentos de entrada da distanciaAG:
' TIPOPAR - Espao utilizado no clculo da distncia
'
F1 - Vetor de funes para indivduo 1
'
F2 - Vetor de funes para indivduo 2
'
X1 - Vetor das variveis de otimizao para indivduo 1
'
X2 - Vetor das variveis de otimizao para indivduo 2
'
MaxF - Valores mximos das funes objetivo na gerao
corrente
'
MinF - Valores mnimos das funes objetivo na gerao
corrente
'
MaxX - Valores mximos das variveis
'
MinX - Valores mnimos das variveis
'
' Argumentos de sada da distanciaAG:
'
d - Distncia calculada
Dim k
As Integer
Dim dst As Single
dst = 0
2)
2)
' calcula a distncia entre dois indivduos

If TIPOPAR = 0 Then ' espao das variveis de otimizao
' Partilha no espao de parmetros
For k = 1 To nvar
dst = dst + (X1(k) - X2(k)) ^ 2 / ((MaxX(k) - MinX(k)) ^
Next k
Else ' espao das funes objetivo
' Partilha no espao de funes
For k = 1 To nfunc
If (MaxF(k) - MinF(k)) ^ 2 > 0 Then
dst = dst + (F1(k) - F2(k)) ^ 2 / ((MaxF(k) - MinF(k)) ^
Else
dst = 0
End If
Next k
End If
' Distncia medida

dst = Application.WorksheetFunction.Power(dst, 0.5)
distanciaAG = dst
End Function
Sub EscreveResultados(Ntype As Integer)
152
AG
' Atualiza pasta de "Resultados" com as solues encontradas pelo

Dim
Dim
Dim
Dim
i As Integer
j As Integer
k As Integer
Coluna As Integer
If Ntype = 1 Then
Coluna = 0
Coluna = 3
Else
Coluna = 6
End If
For i = 1 To Nbpop
For j = 1 To nfunc
For k = 1 To nvar
Worksheets("Resultados").Cells(i + 2, 1).Value = i
If Ntype = 1 Then
If i = 1 Then
Worksheets("Resultados").Cells(i + 2, j + 1).Value =
FxI(i, j)
Call Atualiza_Desenho_Cava(i, 0)
End If
'Worksheets("Resultados").Cells(i + 2, k + 4).Value =
Xb10(k, i)
Worksheets("Resultados").Cells(i + 2, j + 5).Value =
FxI(i, j)
Call Atualiza_Desenho_Cava(i, 3)
End If
Next k
Next j
Next i
End Sub
Sub Clear_Sheet(Name As String)
'Apaga a planilha repassada em Name
Dim NewSheet As Worksheet
Set NewSheet = Worksheets.Add
NewSheet.Name = Name
With Worksheets(Name)
Sheets(Name).Select
Sheets(Name).Activate
Cells.Select
Selection.ClearContents
Range("A1").Select
ActiveWindow.DisplayGridlines = False
End With
End Sub
Sub Atualiza_Desenho_Cava(indiv As Integer, Coluna As Integer)
'Calcula Valores de Valor, Massa e desenha cava final
Dim i As Integer
Dim j As Integer
Dim k As Integer
153
Next k
Next j
Next i
For i = 1 To ngen
(estril+minrio)
If MPop(i, indiv) Then
Call Extract_Block(Int(MID(BlockModel.CodMin(i), 1, 3)),
Int(MID(BlockModel.CodMin(i), 4, 3)), _
Int(MID(BlockModel.CodMin(i), 7, 3)))
End If
Next i
BlockModel.Mass = 0
j, k)
If BlockModel.Values(i, j, k) >= 0 Then BlockModel.Mass =
BlockModel.Mass + 1
If Coluna = 0 Then Worksheets("Resultados").Cells(k, 11 +
j).Value = True
Else
If Coluna = 0 Then Worksheets("Resultados").Cells(k, 11 +
j).Value = False
End If
Next k
Next j
Next i
Worksheets("Resultados").Cells(indiv + 2, 3 + Coluna).Value =
BlockModel.Value
Worksheets("Resultados").Cells(indiv + 2, 4 + Coluna).Value =
BlockModel.Mass
End Sub

Aplicação de Algoritmos Genéticos

Enviado por

Dados do documento

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

Aplicação de Algoritmos Genéticos

Enviado por

Direitos autorais:

Formatos disponíveis

UNIVERSIDADE FEDERAL DE MINAS GERAIS

Curso de Ps Graduao em Engenharia Metalrgica e de Minas

Aplicao de algoritmos genticos na determinao

Autor: Octvio Rosa de Almeida Guimares

UNIVERSIDADE FEDERAL DE MINAS GERAIS

Octvio Rosa de Almeida Guimares

APLICAO DE ALGORITMOS GENTICOS

Dissertao de Mestrado apresentada ao Curso de PsGraduao em Engenharia Metalrgica e de Minas da

rea de concentrao: Tecnologia Mineral

ateno, apoio e contribuio a minha formao profissional.

Lista de tabelas .............................................................................................................

1 Introduo e objetivos ................................................................................................

2 Reviso Bibliogrfica ..................................................................................................

2.1 Descrio sumria de mtodos de otimizao de cava final .........................

2.1.1 O algoritmo de Lerchs-Grossmann .........................................................

2.1.2 Mtodo dos cones flutuantes ...................................................................

2.1.3 Parametrizao tcnica de reservas .......................................................

2.2 Aplicao de algoritmos genticos no planejamento de mina .......................

2.3 Otimizao Multiobjetivo ................................................................................

2.4 Elementos de um algoritmo gentico ............................................................

2.4.1 Codificao ..............................................................................................

2.4.2 Populao inicial ......................................................................................

2.4.3 Avaliao e aptido .................................................................................

2.4.4 Seleo ....................................................................................................

2.4.5 Recombinao .........................................................................................

2.4.6 Mutao ...................................................................................................

2.4.7 Penalidades e restries..........................................................................

2.4.8 Definio dos parmetros ........................................................................

2.4.9 Critrios de Parada ..................................................................................

2.5 Otimizao multiobjetivo utilizando algoritmos genticos ...........................

2.5.1 Descrio do Algoritmo NSGA .................................................................

3.1 Processo de Modelagem ..................................................................................

3.2 Definio dos problemas ..................................................................................

3.3 Construo dos modelos de blocos tericos ....................................................

3.4 Codificao das rotinas computacionais para os problemas propostos ...........

3.5 Validao dos algoritmos ..................................................................................

4 Descrio dos algoritmos e programas de computador codificados .........................

4.1 Cdigos implementados ....................................................................................

4.2.1 Caractersticas Gerais ................................................................................

4.2.2 Interface de parmetros ..............................................................................

4.2.2.1 Modelo de Blocos .................................................................................

4.2.2.2 Parmetros de controle de loop ...........................................................

4.2.3 Resultados ..................................................................................................

4.2.3.1 Modelo Lido ..........................................................................................

4.2.3.2 Visualizao sees verticais ................................................................ 42

4.2.3.3 Planilhas auxiliares ...............................................................................

4.2.3.4 Planilha de Resultados .........................................................................

4.2.3.5 Sees verticais cava final ...................................................................

4.3 Descrio programa NSGA VBA ..................................................................

4.3.1 Caractersticas Gerais ................................................................................

4.3.2 Descrio das funes de teste utilizadas ..................................................

4.3.3 Parmetros de entrada ...............................................................................

4.3.4 Resultados ..................................................................................................

4.4 Descrio do programa EvolPit Delphi ..........................................................

4.4.1 Caractersticas gerais .................................................................................

4.4.2 Parmetros de entrada ...............................................................................

4.4.2.1 Interface dos parmetros de entrada ...................................................

4.4.2.2 Modelo de Blocos .................................................................................

4.4.2.3 Opes de Otimizao .........................................................................

4.4.2.4 Gerao da populao inicial ...............................................................

4.4.2.5 Parmetros de controle de loop ...........................................................

4.4.2.6 Parmetros de nicho ............................................................................

4.4.2.7 Opes de cruzamento e adaptao dinmica ....................................

4.4.2.8 Opes de mutao e seleo .............................................................