EDITORIAL

TEMA DA CAPA
PROGRAMAÇÃO GENÉTICA
o campo fitness é definido como Maybe Float. Depois
de calculada a função objetivo para um individuo o
valor da sua aptidão é guardada aqui. Enquanto não
for calculada a função objetivo o seu valor é Nothing.
Podemos pensar no Nothing como o que em Java ou
C++ é o valor Null. Em Haskell um valor do tipo Maybe
pode ser Nothing ou aquilo que foi definido, neste
caso um real (float).
Continuemos a ver o módulo Individual.hs. De seguida
o tipo derivado Individual é estendido com Eq e Ord. Estas
duas definições permitem ordenar os indivíduos da população
de acordo com a sua aptidão. Desta forma torna-se
trivial detetar o elemento mais válido da população.
instance Eq Individual where
Individual { fitness = a } == Individual
{ fitness = b } = Just a == Just b
instance Ord Individual where
compare Individual { fitness = a } Individual
{ fitness = b } = compare (Just a) (Just b)
A função newIndividual, definida abaixo, é uma interface
conveniente para construir um indivíduo a partir de um
novo cromossoma. O valor inicial da aptidão é Nothing.
newIndividual :: [ (Int, Int) ] -> Individual
newIndividual gs = Individual { chromosome = gs
, fitness = Nothing }
A função createIndividual devolve um novo indivíduo.
De cada vez que é invocada um indivíduo com um diferente
cromossoma é gerado. A ordem da visita às cidades é gerada
aleatoriamente.
createIndividual :: Int -> IO Individual
createIndividual n = do
gen Float
calcTotalDistance [] = error "Unsuficient number
of cities, module Popoulation, function calcFitness"
calcTotalDistance [_] = 0
calcTotalDistance (c1:c2:cs) = squareDistance c1
c2
+ calcTotalDistance
(c2:cs)
calcFitness :: Cities -> Population -> Population
calcFitness _ [] = []
calcFitness cities (p:ps) =
p { fitness = Just (calcTotalDistance (map
(findCity cities . snd) (chromosome p))) }
: calcFitness cities ps
Finalmente a função calcFitnessPopulation faz a méida
das distâncias percorridas em todos os elementos da
população.
calcFitnessPopulation :: Population -> Float
calcFitnessPopulation p =
(sum $ map fit p) / fromIntegral (length p)
where
fit x = fromMaybe (error "Clashes unknown,
module Population, function calcFitnessPopulation")
(fitness x)
No módulo Population.hs são ainda definidas outras
importantes funções, como por exemplo a função ordPopulation
que reorganiza os indivíduos de uma população do mais
apto para o menos apto.
ordPopulation :: Population -> Population
ordPopulation = sort
A função tournamentSelection escolhe n elementos
da população de forma aleatória e, no final, retorna o indivíduo
mais apto desse grupo.
tournamentSelection :: Int -> Population -> IO Individual
tournamentSelection n p = do
is Population -> IO
(Individual, Individual)
selectParents n p = do -- tournament size, previous
population
parent1