

@@ 1,4 +1,5 @@ 


using StatsBase 


using PyPlot 


#= 


Parents <— {randomly generated population} 


While not (termination criterion) 

@@ 40,7 +41,7 @@ function initialize_population(populationSize::Int, chromosomeSize::Int, bounds: 


row = [] 


# Create member elements based on bounds 


for bound in bounds 


push!(row, rand(bound[1]:0.10:bound[2])) 


push!(row, rand(bound[1]:0.01:bound[2])) 


end 


# Add another element to the end to keep score 


push!(row, 1.0) 

@@ 122,7 +123,7 @@ function mutate(population::Array{Array{Float64}}, mutateRate::Float64, bounds:: 


for member in population 


for i = 1:length(member)1 


if rand() < mutateRate 


member[i] = rand(bounds[i][1]:0.10:bounds[i][2]) 


member[i] = rand(bounds[i][1]:0.01:bounds[i][2]) 


end 


end 


end 

@@ 150,28 +151,103 @@ function GA(populationSize::Int, chromosomeSize::Int, fitness_function::Function 


# Set recombination and mutation rate, lower and upper bound 


recombRate = 0.7 


mutateRate = 0.05 


maxIterations = 1000 


maxIterations = 100 


runs = 20 


# First initialize the population 


population = initialize_population(populationSize, chromosomeSize, bounds) 





# Then loop for the required iterations 


bestScores = Array{Float64}(0) 


# Initialize iteration counter, run counter, and array to hold generations of best population 


i = 0 


while i < maxIterations 


# Score and sort the population 


population = score_sort_population(population, fitness_function) 


push!(bestScores,population[1][end]) 


population = create_next_generation(population, recombRate) 


population = mutate(population, mutateRate, bounds) 


i += 1 


run = 0 


bestGenerations = [[[0.0,0.0,Inf]]] 


generations = Array{Array{Array{Float64}}}(0) 





# For each run 


while run < runs 


nextPopulation = initialize_population(populationSize, chromosomeSize, bounds) 


# Iterate through max amount of generations 


while i < maxIterations 


# Score and sort the population 


population = score_sort_population(nextPopulation, fitness_function) 


# Push current population to generations array 


push!(generations, deepcopy(population)) 


# Create children 


nextPopulation = create_next_generation(population, recombRate) 


# Mutate children 


nextPopulation = mutate(nextPopulation, mutateRate, bounds) 


i += 1 


end 


#= 


At the end of the run, if the last generations best solution 


# is better than that of the best of all runs so far 


set new best run so we can graph later 


=# 


if generations[end][1][end] < bestGenerations[end][1][end] 


bestGenerations = deepcopy(generations) 


end 


clear!(:generations) 


clear!(:population) 


clear!(:children) 


run += 1 


end 





# Reporting and plotting 


# Report best solution and value 


bestVariables = bestGenerations[end][1][1:end1] 


bestScore = bestGenerations[end][1][end] 


println("Best solution\nVariables: $bestVariables\nScore: $bestScore") 





# Generate best fitness vs. # generation 


# Init score array 


y = Array{Float64}(0) 


# Get scores, push to array 


for g in bestGenerations 


push!(y,g[1][end]) 


end 


# Plot and label 


PyPlot.plot(y) 


xlabel("Generation #") 


ylabel("Fitness") 


# Save and close 


PyPlot.savefig("BestFitness.png") 


PyPlot.close() 





# Contour 


# Check to make sure we only have two variables, otherwise exit 


if length(bestGenerations[1][1]) > 3 


println("Plotting the 4th dimension currently disabled to avoid tearing the spacetime continuum") 


quit() 


end 


println(bestScores) 


println(population) 





# Init x and y z for contour plots 


x = y = z = Array{Float64}(0) 


for (index, gen) in enumerate(bestGenerations) 


if (index == 1)  (mod(index,10) == 0) 


for m in gen 


push!(x,m[1]) 


push!(y,m[2]) 


end 


size = length(x) 


z = rand(size,size) 


for i in 1:size 


for j in 1:size 


z[i,j] = fitness_function([x[i],y[j]]) 


end 


end 


contour(x,y,z) 


savefig("contour_gen$index.png") 


close() 


clear!(:x) 


clear!(:y) 


clear!(:z) 


end 


end 





end 





function ackley(X) 


function fitness_function(X) 


return e  20*exp(0.2*sqrt((X[1]^2 + X[2]^2)/2))  exp((cos(2*pi*X[1]) + cos(2*pi*X[2]))/2) 


end 





bounds = [(2.0,2.0), (2.0,2.0)] 


GA(25,2,ackley,bounds) 


GA(25,2,fitness_function,bounds) 