# une fonction unidimensionnelle
library(GA)

f <- function(x)
{
  abs(x)+cos(x)
}
curve(f, -20, 20)

#on cherche le minimum. La fonction de fitness est donc la fonction elle même.
fit <- function(x) -f(x) #l'algorithme maximise !

GA <- ga(type = "real-valued", fitness = fit, lower = -20, upper = 20,
         monitor = plot, popSize = 50, maxiter = 100 )

# les résultats
# elitism = 2 signifie que 5% de la population de chromosomes 
# (les meilleurs) sont conserves d'une generation sur l'autre
# elitism = max(1, round(popSize*0.05))

summary(GA)

# la dynamique de la convergence
plot(GA)

#examen graphique de la solution
curve(f, -20, 20)
abline(v = GA@solution, lty = 3)

###-----------------------------------------------------------------------

# 2) plus complexe
f <- function(x)
{
  (x^2+x)*cos(x) # -10 < x < 10
}

curve(f, -10, 10)
#On cherche le maximum de f La fonction de fitness est donc f elle même

GA <- ga(type = "real-valued", fitness = f, lower = -10, upper = 10,
         monitor = NULL,popSize = 50, maxiter = 100)

summary(GA)
monitor(GA)
abline(v = GA@solution, lty = 3)

###--------------------------------------------------------------------------

# 3) fonction de Rastrigin (2D)

# Trace permet d'afficher la dynamique de l'algorithme
trace <- function(obj) 
{ 
  contour(x1, x2, f, drawlabels = FALSE, col = grey(0.5))
  title(paste("iteration =", obj@iter), font.main = 1)
  points(obj@population, pch = 20, col = 2)
  Sys.sleep(0.2)
}

Rastrigin <- function(x1, x2)
{
  20 + x1^2 + x2^2 - 10*(cos(2*pi*x1) + cos(2*pi*x2))
}

# pour l'affichage
x1 <- x2 <- seq(-5.12, 5.12, by = 0.1)
f <- outer(x1, x2, Rastrigin)

#un graphique 3D de la fonction
persp3D(x1, x2, f, theta = 50, phi = 20)

# puis en 2D
filled.contour(x1, x2, f, color.palette = jet.colors)

# maintenant on cherche le minimum avec le GA

fit <- function(x) -Rastrigin(x[1], x[2])

GA <- ga(type = "real-valued", fitness = fit,
        #Si on ne veut pas de monitor il suffit de mettre à NULL
        lower = c(-5.12, -5.12), upper = c(5.12, 5.12), monitor = trace,
        popSize = 50, maxiter = 100)

summary(GA)
plot(GA)


# Maintenant on optimise avec la fonction de base "optim" de R,
# entierement parametrable avec plusieurs methodes au choix
# pour ceux qui sont interesses faire help(optim)
# run indique le nombre de generations consecutives sans amelioration
# avant que l'algo ne stoppe (utile car maxiter est grand)

GA <- ga(type = "real-valued", fitness = fit,
         lower = c(-5.12, -5.12), upper = c(5.12, 5.12),monitor = NULL,
         popSize = 50, maxiter = 1000, run = 100,
         optim = TRUE)

# comparez avec le GA précédent. Le résultat est bien meilleur
# la convergence rapide

summary(GA)

###-------------------------------------------------------------------------
#                           Calcul parallele: mise en oeuvre
# voir l'aide : help(ga)
####------------------------------------------------------------------------

library(parallel)
library(doParallel)
library(foreach)
library(iterators)

Rastrigin <- function(x1, x2)
{
  Sys.sleep(0.001)      # On ralenti le process 
  20 + x1^2 + x2^2 - 10*(cos(2*pi*x1) + cos(2*pi*x2))
}

fit <- function(x) -Rastrigin(x[1], x[2])

system.time(GA <- ga(type = "real-valued", fitness = fit,
                     lower = c(-5.12, -5.12), upper = c(5.12, 5.12), 
                     popSize = 50, maxiter = 100, 
                     monitor = NULL,seed = 12345) )

#   Sous windows, seule la fonctionalite "snow" est dsiponible   ##

system.time(GA2 <- ga(type = "real-valued", fitness = fit, 
                     lower = c(-5.12, -5.12), upper = c(5.12, 5.12),
                      popSize = 50, maxiter = 100, 
                      monitor = NULL, seed = 12345, 
                      parallel = "snow") ) 

#) les resultats sont identiques
summary(GA)
summary(GA2)

##-----------------------------------------------------------------------------