Algoritmo Genetico Simple2

from Tkinter import *
import random
import math
from random import shuffle


size_population = 60
mutation_probability = 0.1
accuracy = 3
lower_bound = 0
upper_bound =  20
long_string = 0
number_generation = 20
intial_population = [] #almacena los cromosomas
decoded_population = []#almacena el valor de los cromosomas en decimal
evaluated_in_function = [] #alamacena el valor  evaluado en la funcion objetivo
parents1 = []#almacena el numero del primer padre obtenido en el torneo
parents2 = []#almacena el numero del segundo padre obtenido en el torneo
to_next_generation = []#cuando se realiza el cruce aqui se guardaran los hijos y luego la poblacion inicial
                       #sera reemplazada por estos
thebest = []
vacia = [] #para limpiar los valores de las listas y estas vuelvan a llenarse desde el principio

def long_string():

    return   (int) (math.ceil(math.log(abs(upper_bound - lower_bound) * math.pow(10.0, accuracy) ,2)))
def decode_number(binary):#nueva funcion decodifica
    binary_inside = []
    binary_inside = binary[:]
    binary_inside.reverse()
    decimal_value =0
    decimal_value2 = 0


    for i in range(0,long_string):
        decimal_value += math.pow(2,i)*binary_inside[i]
    (int)(decimal_value)

    for i in range(0,long_string2):
        decimal_value2 += math.pow(2,i)*binary_inside[i+long_string2]
    (int)(decimal_value2)

    value_X = (float)(lower_bound+decimal_value*((upper_bound-lower_bound)/(math.pow(2,long_string)-1)))
    value_Y = (float)(lower_bound+decimal_value2*((upper_bound-lower_bound)/(math.pow(2,long_string)-1)))

    return (value_X,value_Y)
def elitism(evaluated, original):
    new_eval = []
    new_ori = []
    valor  = 0
    temp = []
    new_eval = evaluated[:]
    new_ori = original[:]
    temp = evaluated[:]
    temp.sort(reverse = True)
    for i in range(0,size_population):
        if(temp[0] == new_eval[i]):
            valor = i
            break

    return new_ori[valor]
def random_gene():
    gene=[]
    for i in range(0,long_string+long_string2):
        if random.random()<0.5:  #Uniform population
            gene.append(0)
        else:
            gene.append(1)
    return gene
def FO1(X,Y):

    return ((X + 5*math.sin(3*X)+ 8*math.cos(5*X) + Y + 5*math.sin(3*Y) + 8*math.cos(5*Y))/2 )
def crossover_2_point(parent1,parent2):

    children1 = []
    children2 = []

    cross1 = 0
    cross2 = 0

    cross1  = (int)(random.random()*long_string)
    cross2  = (int)(random.random()*long_string)

    while( cross1 >= cross2):
        cross1  = (int)(random.random()*long_string)
        cross2  = (int)(random.random()*long_string)
        if( cross2 > cross1):
            break

    #print("cruce 1",cross1,"cruce 2", cross2)
    for i in range (0,cross1):
        children1.append(parent2[i])
        children2.append(parent1[i])

    for i in range (cross1,cross2):
        children1.append(parent1[i])
        children2.append(parent2[i])

    for i in range ( cross2,long_string+long_string2):
        children1.append(parent2[i])
        children2.append(parent1[i])


    #print(parent1)
    #print(parent2)
    #print("TERMINA PADRES")
    #print(children1)
    #print(children2)
    to_next_generation.append(children1)
    to_next_generation.append(children2)
def make_pairs(genes):
    rand1 = []
    rand2 = []
    erase = []
    rand1 = range(size_population)
    rand2 = range(size_population)
    shuffle(rand1)
    shuffle(rand2)
    #print(rand1)
    #print(rand2)
    index3 = 1
    index2 = 1

    for i in range(0,size_population,2):

        if(genes[rand1[i]] >= genes[rand1[index2]]):
            parents1.append(rand1[i])
        else:
            parents1.append(rand1[index2])
        index2 =  index2 + 2

    for i in range(0,size_population,2):

        if(genes[rand2[i]] >= genes[rand2[index3]]):
            parents2.append(rand2[i])
        else:
            parents2.append(rand2[index3])
        index3 =  index3 + 2

    rand1 = erase[:]
    rand2 = erase[:]
    index2 = 1
    index3 = 1
    #print(parents1,"luego",parents2)
def mutation():

    gen = 0
    for i in range(0,size_population):
        rand =  random.random()
        if( rand < mutation_probability):
            gen = (int)(random.random()*long_string)
            #print("Se mutara el chromosoma ",i+1,"en la posicion ",gen)
            if(intial_population[i][gen] ==1):
                intial_population[i][gen] = 0
            else:
                intial_population[i][gen] = 1



#PRIMEROS PASOS
long_string2 = 0
long_string = long_string()
long_string2 = long_string
aux1 = []
aux2 = []
decoded_populationX = []
decoded_populationY = []


for i in range(0,size_population): #generamos la poblacion aleatoria
    intial_population.append(random_gene())

for hh in range(0,number_generation):

    for j in range(0,size_population): #decodificamos la poblacion inicial
        value1 = decode_number(intial_population[j])[0]
        value2 = decode_number(intial_population[j])[1]
        decoded_populationX.append(value1)
        decoded_populationY.append(value2)

    for k in range(0,size_population): #evaluamos en la funcion objetivo FO1
                evaluated_in_function.append(FO1(decoded_populationX[k] ,decoded_populationY[k]))



    thebest.append(elitism(evaluated_in_function,intial_population))

    make_pairs(evaluated_in_function)#realizamos la seleccion de parejas por torneo


    for l in range(0,len(parents1)): #realizamos la cruza de los padres seleccionados y generamos los dos hijos que se iran a la siguiente
                                             #generacion
        crossover_2_point(intial_population[parents1[l]],intial_population[parents2[l]])
    intial_population = to_next_generation[:]
    intial_population[0] = thebest[0] #ya seleccionado el mejor siempre pasa a la siguiente generacion

    mutation()

    decoded_populationY[:] = []
    decoded_populationX[:] = []
    evaluated_in_function[:] = []



    for j in range(0,size_population): #decodificamos la poblacion inicial
        value1 = decode_number(intial_population[j])[0]
        value2 = decode_number(intial_population[j])[1]
        decoded_populationX.append(value1)
        decoded_populationY.append(value2)

    for k in range(0,size_population):
        evaluated_in_function.append(FO1(decoded_populationX[k] ,decoded_populationY[k]))

    #print(decoded_population)
    #print(evaluated_in_function)
    #evaluated_in_function.sort(reverse= True)



    for p in range(0,size_population):
        print ("%.3f" % ( evaluated_in_function[p]) , "%.3f" % (decoded_populationX[p]), "%.3f" % (decoded_populationY[p]))
    print("end generation :", hh+1)


    funcion_generacion = vacia[:]
    to_next_generation = vacia[:]
    decoded_population = vacia[:]
    evaluated_in_function = vacia[:]
    parents1 = vacia[:]
    parents2 = vacia[:]
    decode_numberparents2 = vacia[:]
    thebest = vacia[:]
    aux1 = vacia[:]
    aux2 = vacia[:]
    decoded_populationY[:] = []
    decoded_populationX[:] = []
    evaluated_in_function[:] = []
    value1 = 0
    value2 = 0