def principal(argv):
INSTANCIAS = read_data_XLSX()
num_alphas = 5
ALPHAS = [round(i * (1 / num_alphas), 3) for i in range(num_alphas + 1)]
print(ALPHAS)
for a in ALPHAS:
workbook = xlsxwriter.Workbook('Results_Tardiness ALPHA(' + str(a) +
').xlsx')
ti = time.time()
for inst in INSTANCIAS:
## Parámetros de la instancia
tp = inst.tiempos_procesamiento
dd = inst.due_dates
num_trabajos = len(tp)
num_maquinas = len(tp[0])
## Obtener secuencia de Grasp_Makespan
ALPHA = a
t_max = 0.01 * num_trabajos * num_maquinas
repeticiones = 1
minimo = 10000000000000
print("AlPHA: ", a, "; Inst:", INSTANCIAS.index(inst))
for _ in range(repeticiones):
t1 = time.time()
s, s_bl = GRASP_Tardiness(tp, dd, ALPHA, t_max)
f = fo.calcular_tardanza_blocking_secuencia(s_bl, tp, dd)
print(f)
if (f < minimo):
minimo = f
secuencia = s
secuencia_bl = s_bl
tiempo_funcion = time.time() - t1
print("----------------------------")
## Indicadores
makespan = fo.calcular_makespan_blocking_secuencia(secuencia, tp)
tardanza = fo.calcular_tardanza_blocking_secuencia(
secuencia, tp, dd)
makespan_bl, mat_t = fo.mat_calcular_makespan_blocking_secuencia(
secuencia_bl, tp)
tardanza_bl, dd_sec = fo.dd_calcular_tardanza_blocking_secuencia(
secuencia_bl, tp, dd)
## Imprimir archivo
nombre_hoja = "Inst" + str(INSTANCIAS.index(inst) + 1)
imprimir_XLSX(workbook, nombre_hoja, secuencia, secuencia_bl,
makespan, tardanza, makespan_bl, tardanza_bl,
tiempo_funcion, mat_t, dd_sec)
tt = time.time() - ti
worksheet = workbook.add_worksheet("TIEMPO TOTAL")
worksheet.merge_range(1, 1, 1, 3, "Tiempo total de ejecución")
worksheet.merge_range(1, 4, 1, 5, round(tt, 2))
workbook.close()
workbook.close()
def principal(argv):
INSTANCIAS = read_data_XLSX()
for inst in INSTANCIAS:
workbook = xlsxwriter.Workbook('Results_Tardiness_MO Inst(' +
str(INSTANCIAS.index(inst) + 1) +
').xlsx')
print("\n============== Inst: ", INSTANCIAS.index(inst),
" ===============")
## Parámetros de la instancia
tp = inst.tiempos_procesamiento
dd = inst.due_dates
num_trabajos = len(
tp) ## Obtener número de trabajos y número de máquinas
num_maquinas = len(tp[0])
## Obtener secuencia de Grasp_Makespan
ALPHA = 0.4 ## No se está usando
t_max = 1.5 * num_trabajos * num_maquinas
ALPHA_make = 0.2
t_max_make = 0.01 * num_trabajos * num_maquinas
repeticiones = 3
for rep in range(repeticiones):
print("--- Rep: ", rep, " ---")
t1 = time.time()
secuencia, secuencia_bl, min_makespan = GRASP_Tardanza_MO(
tp, dd, ALPHA, t_max, ALPHA_make, t_max_make)
tiempo_funcion = time.time() - t1
## Indicadores
makespan = fo.calcular_makespan_blocking_secuencia(secuencia, tp)
tardanza = fo.calcular_tardanza_blocking_secuencia(
secuencia, tp, dd)
makespan_bl = fo.calcular_makespan_blocking_secuencia(
secuencia_bl, tp)
tardanza_bl = fo.calcular_tardanza_blocking_secuencia(
secuencia_bl, tp, dd)
## Imprimir archivo
nombre_hoja = "Inst" + str(INSTANCIAS.index(inst) +
1) + "(REP" + str(rep + 1) + ")"
imprimir_XLSX(workbook, nombre_hoja, secuencia, secuencia_bl,
makespan, tardanza, makespan_bl, tardanza_bl,
tiempo_funcion, min_makespan)
workbook.close()
def principal(argv):
INSTANCIAS = read_data_XLSX()
for inst in INSTANCIAS:
## Crear Archuvo de impresión
workbook = xlsxwriter.Workbook('Results_Tardiness Inst(' +
str(INSTANCIAS.index(inst) + 1) +
').xlsx')
## Parámetros de la instancia
tp = inst.tiempos_procesamiento
dd = inst.due_dates
num_trabajos = len(tp)
num_maquinas = len(tp[0])
## Obtener secuencia de Grasp_Makespan
ALPHA = 0.5
t_max = 0.01 * num_trabajos * num_maquinas
repeticiones = 10
print("Inst:", INSTANCIAS.index(inst))
for rep in range(repeticiones):
t1 = time.time()
secuencia, secuencia_bl = GRASP_Tardiness(tp, dd, ALPHA, t_max)
tiempo_funcion = time.time() - t1
## Indicadores
makespan = fo.calcular_makespan_blocking_secuencia(secuencia, tp)
tardanza = fo.calcular_tardanza_blocking_secuencia(
secuencia, tp, dd)
makespan_bl = fo.calcular_makespan_blocking_secuencia(
secuencia_bl, tp)
tardanza_bl = fo.calcular_tardanza_blocking_secuencia(
secuencia_bl, tp, dd)
## Imprimir archivo
nombre_hoja = "Inst" + str(INSTANCIAS.index(inst) +
1) + "(REP" + str(rep + 1) + ")"
imprimir_XLSX(workbook, nombre_hoja, secuencia, secuencia_bl,
makespan, tardanza, makespan_bl, tardanza_bl,
tiempo_funcion)
workbook.close()
def busqueda_local_GRASP(secuencia, TP, due_date, num_iteraciones):
minimo = 100000000000
for iteraciones in range(num_iteraciones):
for i in range(len(secuencia)):
for j in range(i + 1, len(secuencia)):
s = copy.deepcopy(secuencia)
aux = s[i]
s[i] = s[j]
s[j] = aux
#print(s, calcular_makespan_blocking_secuencia(s,TP))
f = fo.calcular_tardanza_blocking_secuencia(s, TP, due_date)
if (f < minimo):
minimo = f
secuencia_aux = s
secuencia = copy.deepcopy(secuencia_aux)
#print(minimo, secuencia_aux)
return (secuencia,
fo.calcular_tardanza_blocking_secuencia(secuencia, TP, due_date))
def busqueda_local_GRASP(secuencia, TP, due_date, t_max):
minimo = fo.calcular_tardanza_blocking_secuencia(secuencia, TP, due_date)
num_trabajos = len(TP)
i = 0
j = 1
iteraciones = 0
t_inicial = time.time()
t_final = time.time() - t_inicial
while (i < num_trabajos - 1 and t_final <= t_max):
# print("\n============== ITERACIÓN ", iteraciones," ===============")
s = copy.deepcopy(secuencia)
aux = s[i]
s[i] = s[j]
s[j] = aux
# print("Secuencia actual: ", secuencia)
# print(s, fo.calcular_tardanza_blocking_secuencia(s,TP, due_date))
# print(i,j)
# print(t_max)
f = fo.calcular_tardanza_blocking_secuencia(s, TP, due_date)
if (f < minimo):
minimo = f
secuencia = s
i = 0
j = 1
else:
if (j < num_trabajos - 1):
j = j + 1
elif (i < num_trabajos - 1):
i = i + 1
j = i + 1
else:
i = i + 1
iteraciones += 1
t_final = time.time() - t_inicial
#elihw
return (secuencia,
fo.calcular_tardanza_blocking_secuencia(secuencia, TP, due_date))
def busqueda_local_GRASP(secuencia, TP, due_date, num_iteraciones):
minimo = fo.calcular_tardanza_blocking_secuencia(secuencia, TP, due_date)
num_trabajos = len(TP)
i = 0
j = 1
iteraciones = 0
while (i < num_trabajos - 1 and iteraciones <= num_iteraciones):
# print("\n============== ITERACIÓN ", iteraciones," ===============")
s = copy.deepcopy(secuencia)
aux = s[i]
s[i] = s[j]
s[j] = aux
#print(s, calcular_makespan_blocking_secuencia(s,TP))
# print(i,j)
f = fo.calcular_tardanza_blocking_secuencia(s, TP, due_date)
# print("Secuencia actual: ", secuencia)
# print(s, f)
if (f < minimo):
minimo = f
secuencia = s
i = 0
j = 1
else:
if (j < num_trabajos - 1):
j = j + 1
elif (i < num_trabajos - 1):
i = i + 1
j = i + 1
else:
i = i + 1
iteraciones += 1
#elihw
return (secuencia,
fo.calcular_tardanza_blocking_secuencia(secuencia, TP, due_date))
def construccion_GRASP(TP, due_date, ALPHA):
## Número de trabajos
num_trabajos = len(TP)
solucion = [] ## Secuencia final que será retornada
solucion_TP = [
] ## Tiempos de procesamiento de cada elemento que se guarde en solucion
## Conjunto de candidatos a ser seleccionados. Si se selecciona un candidato se removerá de candidatos
## y se agregará al conjunto solución. Inicialmente en candidatos estarán todos los trabajos i.e.
## candidatos = {1,...,num_trabajos}
candidatos = [i for i in range(1, num_trabajos + 1)]
t = 0 ## Parámetro para mdd
## Pj: parámetro usado en mdd. Suma para cada trabajo el tiempo de procesamiento de cada máquina
P = []
for i in range(num_trabajos):
P.append(sum(TP[i]))
# print("P: ", P, "Due date: ", due_date)
## El siguiente ciclo selecciona en cada iteración un posible trabajo para agregarlo a la solución
## Paso 1: Determinar conjunto de mdd para cada trabajo candidato, el mínimo de los mdd = min_mdd
## y el máximo de los mdd = max_mdd
## Paso 2: Determinar conjunto RCL = {c in candidatos: makespan(c) < indicador}; indicador = min_mp + ALPHA * ( max_mp - min_mp )
## Paso 3: Seleccionar aleatoriamente un trabajo del RCL
## Paso 4: Agregrar el trabajo escogido a solución, agregar los tiempos de procesamiento del trabajo
## escogido a solucion_TP y remover el elemento de candidatos
for it in range(num_trabajos):
MMD = [
] ## conjunto donde se almacenará el MMD de cada trabajo candidato
min_mdd = 100000000000 ## variable que guardará el mínimo de los makespan
max_mdd = 0 ## variable que guardará el máximo de los makespan
## Paso1
for candidato in candidatos:
y = max(P[candidato - 1], due_date[candidato - 1] - t)
MMD.append(y)
## Determinar mínimo makespan
if (y < min_mdd):
min_mdd = y
## Determinar máximo makespan
if (y > max_mdd):
max_mdd = y
# print("====== Iteración ", it + 1," ======")
# print("Candidatos: ", candidatos, "MMD: ", MMD, "Min: ", min_mdd, "Max: ", max_mdd)
## Paso2: Determinar RCL
indicador = min_mdd + ALPHA * (max_mdd - min_mdd)
RCL = []
trabajo = 0
for m in MMD:
if (m <= indicador): ## Si el makespan es menor que el indicador
RCL.append(candidatos[trabajo]) ## guardar el trabajo en RCL
trabajo += 1
# print("RCL: ", RCL,"... Menor que: ", indicador)
## Paso 3: seleccionar aleatoriamente un trabajo del RCL
pos = random.randint(
1, len(RCL)
) ## Obtener una posicion aleatoria del RCL(funcion aleatorio entre arriba)
seleccion = RCL[pos - 1] ## Obtener un trabajo del RCL
# print("Seleccionado: ", seleccion)
## Paso 4
solucion.append(seleccion) ## Agregrar el trabajo escogido a solución
candidatos.remove(
seleccion
) ## escogido a solucion_TP y remover el elemento de candidatos
solucion_TP.append(
TP[seleccion - 1]
) ## agregar los tiempos de procesamiento del trabajo escogido a solucion_TP
t = fo.calcular_makespan_blocking(solucion_TP)
# print("Solucion: ", solucion, "Candidatos: ", candidatos)
# print("t: ", t)
return (solucion,
fo.calcular_tardanza_blocking_secuencia(solucion, TP, due_date))
def imprimir_XLSX(workbook, nombre_hoja, secuencia, secuencia_bl, makespan,
make_mat_i, make_mat_f, tardanza, due_date_sec, tp, dd):
worksheet = workbook.add_worksheet(nombre_hoja)
worksheet.set_column(1, 1, 9.5)
cell_format_bold = workbook.add_format({
'bold': 1,
'align': 'center',
'valign': 'vcenter'
})
cell_format = workbook.add_format({'align': 'center'})
worksheet.merge_range("B2:D2", "FASE DE CONSTRUCCIÓN", cell_format_bold)
worksheet.write("B3", "Secuencia", cell_format_bold)
row = 2
col = 2
for s in secuencia:
worksheet.write(row, col, s, cell_format)
col += 1
worksheet.write("B4", "Tardanza", cell_format_bold)
worksheet.write(
"C4", fo_aux.calcular_tardanza_blocking_secuencia(secuencia, tp, dd),
cell_format)
worksheet.write("B5", "Makespan", cell_format_bold)
worksheet.write("C5",
fo_aux.calcular_makespan_blocking_secuencia(secuencia, tp),
cell_format)
worksheet.merge_range("B7:D7", "FASE DE BUSQUEDA LOCAL", cell_format_bold)
worksheet.write("B8", "Secuencia", cell_format_bold)
row = 7
col = 2
for s in secuencia_bl:
worksheet.write(row, col, s, cell_format)
col += 1
worksheet.write("B9", "Tardanza", cell_format_bold)
worksheet.write("C9", tardanza, cell_format)
worksheet.write("B10", "Makespan", cell_format_bold)
worksheet.write("C10", makespan, cell_format)
row = 11
col = 1
worksheet.merge_range(row, col, row, col + 4, "Matriz Tiempos Inicio",
cell_format_bold)
worksheet.merge_range(row, col + len(make_mat_i[0]) + 1, row,
col + len(make_mat_i[0]) + 5,
"Matriz Tiempos Finales", cell_format_bold)
worksheet.merge_range(row, col + 2 * len(make_mat_i[0]) + 2, row,
col + 2 * len(make_mat_i[0]) + 3, "Due Dates(SEC)",
cell_format_bold)
row += 1
for i in range(len(make_mat_i)):
col = 1
col2 = 2 + len(make_mat_i[i])
for j in range(len(make_mat_i[i])):
worksheet.write(row, col, make_mat_i[i][j], cell_format)
col += 1
worksheet.write(row, col2, make_mat_f[i][j], cell_format)
col2 += 1
worksheet.merge_range(row, col2 + 1, row, col2 + 2, due_date_sec[i],
cell_format)
row += 1
