def busquedaTabu(datos,iteraciones,tamMemoria,vecinos,porcMod):
t1 = time() #Para contabilizar el tiempo
sol = solucion(datos) #Solución inicial S0
tempS = evaluar(sol,datos) #Factibilidad de la solución inicial
c = 0 #Contador de iteraciones
sBest = sol #Se asigna como sBest a la solución inicial
#PARA Verificar si no hay cambios y romper el ciclo tabú
#cambiosCiclos = 0
#anterior = 0
#out = 15 # parametro para verificar cada ciertas iteraciones si ya se estanco el algoritmo en una solucion
#noHayCambios = 0
tabuList = []
while (c <= iteraciones): #and noHayCambios != 1):
candidateList = []
sVecinos = SNeighborhood(sol,vecinos,porcMod,datos)
for sCand in sVecinos:
if sCand not in tabuList:
candidateList.append(sCand)
sCandidate = mejorCandidato(candidateList,datos)
sol = sCandidate
if (evaluar(sCandidate,datos) < evaluar(sBest,datos)):
tabuList.append(sCandidate)
sBest = sCandidate
if len(tabuList) > tamMemoria:
fin = len(tabuList)
inicio = fin-tamMemoria
tabuList = tabuList[inicio:fin]
fact = evaluar(sBest,datos)
print "factibilidad: ",fact, " iteración: ",c
# Salirse si no hay cambios en un determinado número de iteraciones
# if c > 0:
# cambiosCiclos = cambiosCiclos + abs(anterior - fact) #Ir sumando los cambios de 5 generaciones
# if c % out == 0:#Hacerlo cada ciertas iteraciones (cada 15 )
# if cambiosCiclos != 0:
# if abs(cambiosCiclos) == 0: # Si no hay mucho cambio en 5 generaciones salirse del ciclo porque ya no tiene caso buscar mas soluciones
# noHayCambios = 1
# cambiosCiclos = 0 # Se reinicia el contador para volver a calcular otras 5 generaciones
# anterior = fact
c = c+1
t2 = time()
tiempo = t2 - t1
return tiempo,fact,sBest,tempS
#################################################################################
#############################################################################################
def recocidoSimulado(datos,iteraciones,tempI,tempMin,vecinos,cambiosPorc,reduccion):
# PARAMETROS
t1 = time()
e = 2.7182818284 #numero de Euler
sol = solucion(datos) #Solución inicial S0
S = evaluar(sol,datos) #factibilidad de la solucion inicial
c = 0 #contador de iteraciones
tempS = S #para retornar la factibilidad de la solución inicial
#PARA romper ciclo cuando se repitan valores en cierta cantidad de iteraciones
#out = 15 # parametro para verificar cada ciertas iteraciones si ya se estanco el algoritmo en una solucion
#cambiosCiclos = 0
#anterior = 0
#noHayCambios = 0
while (c <= iteraciones and tempI >= tempMin):# and noHayCambios != 1):
Sprima,solAux = mejorVecino(sol,vecinos,cambiosPorc, datos)
delta = Sprima-S
if (delta <= 0):
S = Sprima
sol = solAux
else:
exp = -delta/tempI
n = e**exp
a = random.uniform(0,1)
if(a <= n):
S = Sprima
sol = solAux
tempI = tempI*reduccion
print "factibilidad: ",S, " iteración: ",c
#PARA verificar que no se quede estancado el algoritmo y romper el ciclo
# if c > 0:
# cambiosCiclos = cambiosCiclos + abs(anterior - S) #Ir sumando los cambios de 5 generaciones
# if c % out == 0:#Hacerlo cada ciertas iteraciones (cada 15 )
# if cambiosCiclos != 0:
# if abs(cambiosCiclos) == 0: # Si no hay mucho cambio en 5 generaciones salirse del ciclo porque ya no tiene caso buscar mas soluciones
# noHayCambios = 1
# cambiosCiclos = 0 # Se reinicia el contador para volver a calcular otras 5 generaciones
# anterior = S
c = c + 1
t2 = time()
tiempo = t2 - t1
return tiempo,S,sol,tempS
def busquedaArmonica(datos, iteraciones, HMS, HMCR, BW, PAR):
t1 = time()
HM = generaPoblacion(HMS, datos)
tempS = evaluar(minimoP(HM, datos), datos)
c = 0 # contador de iteraciones
#Para romper ciclo en caso de estancamiento
#noHayCambios = 0
#anterior = 0
#cambiosCiclos = 0
#out = 15 # parametro para decidir si ya se estanco el algoritmo en una solucion
while (c <= iteraciones): # and noHayCambios != 1):
obtenerMemoria = random.random()
if (obtenerMemoria < (HMCR / 100.00)):
elem = getRandomHM(HM)
#modificar la armonía en un porcentaje
copia = elem[:]
modificar(PAR, BW, copia, datos)
else:
copia = solucion(datos)
#ESCOJER LA PEOR DE LA MEMORIA ARMÓNICA PARA SUSTITUIRLA CON EL NUEVO SI ES MEJOR
[indice, maximo] = peorS(HM, datos)
nuevo = evaluar(copia, datos)
if nuevo < maximo:
HM[indice] = copia
vecMin = minimoP(HM, datos)
fact = evaluar(vecMin, datos)
print "fact: ", fact, " iteración: ", c
#VERIFICAR que no haya estancamiento en el algoritmo
#if c > 0:
# cambiosCiclos = cambiosCiclos + abs(anterior - fact) #Ir sumando los cambios de 5 generaciones
# if c % out == 0:#Hacerlo cada ciertas iteraciones (cada 15 )
# if cambiosCiclos != 0:
# if abs(cambiosCiclos) == 0: # Si no hay mucho cambio en 5 generaciones salirse del ciclo porque ya no tiene caso buscar mas soluciones
# noHayCambios = 1
# cambiosCiclos = 0 # Se reinicia el contador para volver a calcular otras 5 generaciones
#anterior = fact
c = c + 1
t2 = time()
tiempo = t2 - t1
return tiempo, fact, vecMin, tempS
def busquedaArmonica(sol, datos, posicion, iteraciones, HMS, HMCR, BW, PAR):
HM = generaPoblacion(HMS, sol)
#HM.append(sol)
#out = 15 # parametro para decidir si ya se estancó el algoritmo en una solucion
c = 0 # contador de iteraciones
#noHayCambios = 0
#anterior = 0
#cambiosCiclos = 0
while (c <= iteraciones): # and noHayCambios != 1):
obtenerMemoria = random.random()
if (obtenerMemoria < (HMCR / 100.00)):
elem = getRandomHM(HM)
#modificar la armonía en un porcentaje
copia = elem[:]
modificar(PAR, BW, copia, datos, posicion)
else:
copia = solucion(datos)
#ESCOJER LA PEOR DE LA MEMORIA ARMÓNICA PARA SUSTITUIRLA CON EL NUEVO SI ES MEJOR
[indice, maximo] = peorS(HM, datos)
nuevo = evaluar(copia, datos)
if nuevo < maximo:
HM[indice] = copia
vecMin = minimoP(HM, datos)
#PARA romper ciclo en caso de que se quede estancado
#fact = evaluar(vecMin,datos)
#if c > 0:
# cambiosCiclos = cambiosCiclos + abs(anterior - fact) #Ir sumando los cambios de 5 generaciones
# if c % out == 0:#Hacerlo cada ciertas iteraciones (cada 15 )
# if cambiosCiclos != 0:
# if abs(cambiosCiclos) == 0: # Si no hay mucho cambio en 5 generaciones salirse del ciclo porque ya no tiene caso buscar mas soluciones
# noHayCambios = 1
# cambiosCiclos = 0 # Se reinicia el contador para volver a calcular otras 5 generaciones
#anterior = fact
c = c + 1
return vecMin
def generaPoblacion(N, datos):
poblacion = []
for i in range(N):
poblacion.append(solucion(datos))
return poblacion