Professional Documents
Culture Documents
int k,t,a,b,aux,rep;
long int tiempo1,tiempo2;
double z_curs,z_mejor,z_vec;
int n_ejemplares,n_ejemplar,ejem;
secuencia s,s_curs,f_vencimiento,familia,s_vec,s_mejor;
matrizNM proceso,salida;
matrizMFF preparacion;
int p,t2,t3,N,M,F;
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 3
scanf("%d",&p);
n_ejemplar=p;
scanf("%d",&p);
familia[t]=p;/*Indica la familia de la pieza*/
scanf("%d",&p);
f_vencimiento[t]=p;/*Indica la fecha de vencimiento de la pieza*/
t2=1;
while(t2<=M){
scanf("%d",&p);
proceso[t][t2]=p;/*Indica los tiempos de proceso de la pieza en cada maquina*/
t2=t2+1;
}
t=t+1;
}
/*Lectura de los tiempos de preparacion de cada maquina*/
t=1;
while(t<=M){
scanf("%d",&p);/*Indica el numero de maquina*/
t2=1;
while(t2<=F){
t3=1;
while(t3<=F){
scanf("%d",&p);
preparacion[t][t2][t3]=p;/*Indica el tiempo de preparacion de la maquina para pasar
de la familia t2 a la t3*/
t3=t3+1;
}
t2=t2+1;
}
t=t+1;
}
/*Obtener secuencia inicial al azar*/
k=1;
while(k<=N){
s_curs[k]=k;
s_mejor[k]=k;
k=k+1;
}
/* t=1;
srand(time(NULL));
while(t<=10000){
a=1+rand()%N;
b=1+rand()%N;
GenerarVecino(s_curs,s_vec,N,a,b);
k=1;
while(k<=N){
s_curs[k]=s_vec[k];
k=k+1;
}
t=t+1;
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 5
time(&tiempo1);
while(k<=ITER_MAX){
/*z_curs=CalcularRetrasoMedio(s_curs,f_vencimiento,familia,preparacion,proceso,N,
M);
printf("\n%f",z_curs);
printf("\t% f",z_mejor);*/
a=1+rand()%N;
b=1+rand()%N;
GenerarVecino(s_curs,s_vec,N,a,b);
z_vec=CalcularRetrasoMedio(s_vec,f_vencimiento,familia,preparacion,proceso,N,M);
if(z_vec<z_mejor){
t=1;
while(t<=N){
aux=s_vec[t];
s_curs[t]=aux;
s_mejor[t]=aux;
t=t+1;
}
z_mejor=z_vec;
}else if(z_vec>=z_mejor){
t=1;
}
k=k+1;
}
time(&tiempo2);
Pág. 6 Anexo B
/* printf("ANED \t");*/
/*REPRESENTAR LA SECUENCIA MEJOR:
t=1;
while(t<=N){
printf(" %d",s_mejor[t]);
t=t+1;
}*/
printf("\n%f",z_mejor);/*Hasta aqui: Se genera una solucion inicial al azar y se le aplica
un metodo de optimizacion local(ANED)*/
printf("\t%d",tiempo2-tiempo1);
ejem=ejem+1;
}
}
int k;
s_v[a1]=sec[a2];
s_v[a2]=sec[a1];
k=1;
while(k<=n){
if(k==a1){
k=k+1;
}else if(k==a2){
k=k+1;
}else if(k!=a1 && k!=a2){
s_v[k]=sec[k];
k=k+1;
}
}
int j,k,l,sum,tot,t;
double RetrasoMedio;
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 7
matrizNM entrada,salida;
secuencia Retraso;
j=1;
k=1;
while (k<=n){
Retraso[k]=0;
k=k+1;
}
k=1;
while (k<=n){
j=1;
while (j<=m){
if (salida[k][j-1]>salida[k-1][j]+prep[j][fam[sec[k-1]]][fam[sec[k]]]){
entrada[k][j]=salida[k][j-1];
}else if (salida[k][j-1]<=salida[k-1][j]+prep[j][fam[sec[k-1]]][fam[sec[k]]]){
entrada[k][j]=salida[k-1][j]+prep[j][fam[sec[k-1]]][fam[sec[k]]];
}
salida[k][j]=entrada[k][j]+proc[k][j];
j=j+1;
}
if(salida[k][m]-f_venc[sec[k]]<=0){
Retraso[k]=0;
}else{
Retraso[k]=(salida[k][m]-f_venc[sec[k]]);
}
k=k+1;
}
/* Calcula el retraso medio*/
Pág. 8 Anexo B
sum=0;
tot=0;
l=1;
while (l<=n){
sum=sum+Retraso[l];
tot=tot+1;
l=l+1;
}
RetrasoMedio=(double)sum/(double)tot;
return (RetrasoMedio);
}
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 9
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <assert.h>
int k,t,a,b,aux,iterSA,dim_lista_tabu,tabu,rep;
long int tiempo1,tiempo2;
double z_curs,z_mejor,z_vec,T,z_mejor_vecino;
int iter,MAX,n_ejemplares,n_ejemplar,ejem;
int n_mejor_vecino,n_mejor_vecino_no_tabu,iter_sin_mejora;
double z_mejor_vecino_no_tabu,prob;
secuencia mejor_vecino_no_tabu;
lista_tabu regla_tabu;
ret_vec z_vecino;
vec vecino;
secuencia s,s_curs,f_vencimiento,familia,s_vec,s_mejor,mejor_vecino;
Pág. 10 Anexo B
matrizNM proceso,salida;
matrizMFF preparacion;
int p,t2,t3,N,M,F;
dim_lista_tabu=7;
MAX=1000;
scanf("%d",&p);
n_ejemplar=p;
while (t<=M){
salida[0][t]=0;
t=t+1;
}
t3=t3+1;
}
t2=t2+1;
}
t=t+1;
}
/*Obtener secuencia inicial al azar*/
k=1;
while(k<=N){
s_curs[k]=k;
s_mejor[k]=k;
k=k+1;
}
t=1;
while(t<=10000){
a=1+rand()%N;
b=1+rand()%N;
Pág. 12 Anexo B
GenerarVecino(s_curs,s_vec,N,a,b);
k=1;
while(k<=N){
s_curs[k]=s_vec[k];
k=k+1;
}
t=t+1;
}/*En este momento se dispone de una secuencia de N piezas ordenadas al azar*/
z_mejor=CalcularRetrasoMedio(s_curs,f_vencimiento,familia,preparacion,proceso,N,M);
z_curs=z_mejor;
k=1;
srand(time(NULL));
time(&tiempo1);
while(k<=ITER_MAX){
/*z_curs=CalcularRetrasoMedio(s_curs,f_vencimiento,familia,preparacion,proceso,N,M);
printf("\n%f",z_curs);
printf("\t% f",z_mejor);*/
a=1+rand()%N;
b=1+rand()%N;
GenerarVecino(s_curs,s_vec,N,a,b);
z_vec=CalcularRetrasoMedio(s_vec,f_vencimiento,familia,preparacion,proceso,N,M);
if(z_vec<z_mejor){
t=1;
while(t<=N){
aux=s_vec[t];
s_curs[t]=aux;
s_mejor[t]=aux;
t=t+1;
}
z_mejor=z_vec;
}else if(z_vec>=z_mejor){
t=1;
while(t<=N){
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 13
t=t+1;
}
}
k=k+1;
}
time(&tiempo2);
/* printf("ANED \t");*/
/*REPRESENTAR LA SECUENCIA MEJOR:
t=1;
while(t<=N){
printf(" %d",s_mejor[t]);
t=t+1;
}*/
printf("\n%f",z_mejor);/*Hasta aqui: Se ha generado una solucion inicial al azar y se le
aplica
un metodo de optimizacion local(ANED)*/
printf("\t%d",tiempo2-tiempo1);
iterSA=1;
/*printf("\nANED+SA");
printf("\n%d",n_ejemplar);*/
while(iterSA<=ITER_MAX){
/* printf("\n%d",iterSA);
printf("\t%f",z_mejor);
printf("\t%f",z_curs);*/
a=1+rand()%N;
b=1+rand()%N;
Pág. 14 Anexo B
/*printf("\n%f",z_curs);
printf("\t%f",z_mejor);*/
GenerarVecino(s_curs,s_vec,N,a,b);
z_vec=CalcularRetrasoMedio(s_vec,f_vencimiento,familia,preparacion,proceso,N,M);
/*printf("\t%f",z_vec);
printf("\n %f",z_curs);
prob=FUP(z_curs,z_vec,T);
if(prob>100.0){
prob=100.0;
}
printf("\t%f",prob);
*/
if(z_vec<=z_curs){
if(z_vec<z_mejor){
k=1;
while(k<=N){
s_curs[k]=s_vec[k];
s_mejor[k]=s_vec[k];
k=k+1;
}
z_mejor=z_vec;
z_curs=z_mejor;
/*printf("\n%f",z_mejor);*/
}else{
z_curs=z_vec;
k=1;
while(k<=N){
s_curs[k]=s_vec[k];
k=k+1;
}
}
}else if(z_vec>z_curs){
p=rand()%101;
if(p<FUP(z_curs,z_vec,T)){
z_curs=z_vec;
T=alfa*T;
k=1;
while(k<=N){
s_curs[k]=s_vec[k];
k=k+1;
}
}else if(p>=FUP(z_curs,z_vec,T)){
k=k+1;
}
}
iterSA=iterSA+1;
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 15
}
time(&tiempo2);
printf("\t%f",z_mejor);
printf("\t%d",tiempo2-tiempo1);
/*printf("AN+SA \t");*/
/*REPRESENTAR LA SOLUCION MEJOR
k=1;
while(k<=N){
printf(" %d",s_mejor[k]);
k=k+1;
}*/
k=1;
while(k<=N){
s_curs[k]=N+1-k;
s_mejor[k]=N+1-k;
k=k+1;
}
t=1;
while(t<=10000){
a=1+rand()%N;
b=1+rand()%N;
GenerarVecino(s_curs,s_vec,N,a,b);
k=1;
while(k<=N){
s_curs[k]=s_vec[k];
k=k+1;
}
t=t+1;
}/*En este momento se dispone de una secuencia de N piezas ordenadas al azar*/
z_mejor=CalcularRetrasoMedio(s_curs,f_vencimiento,familia,preparacion,proceso,N,M);
z_curs=z_mejor;
T=T_inicial;
/*printf("\nSA");
prob=1;*/
iterSA=1;
time(&tiempo1);
while(iterSA<=ITER_MAX){
/*printf("\n%d",iterSA);
printf("\t%f",z_mejor);
printf("\t%f",z_curs);*/
a=1+rand()%N;
b=1+rand()%N;
Pág. 16 Anexo B
/*printf("\n%f",z_curs);
printf("\t%f",z_mejor);*/
GenerarVecino(s_curs,s_vec,N,a,b);
z_vec=CalcularRetrasoMedio(s_vec,f_vencimiento,familia,preparacion,proceso,N,M);
/* printf("\t%f",z_vec);
prob=FUP(z_curs,z_vec,T);
printf("\t%f",prob);*/
if(z_vec<=z_curs){
if(z_vec<z_mejor){
k=1;
while(k<=N){
s_curs[k]=s_vec[k];
s_mejor[k]=s_vec[k];
k=k+1;
}
z_mejor=z_vec;
z_curs=z_mejor;
/*printf("\n%f",z_mejor);*/
}else{
z_curs=z_vec;
k=1;
while(k<=N){
s_curs[k]=s_vec[k];
k=k+1;
}
}
}else if(z_vec>z_curs){
p=rand()%101;
if(p<FUP(z_curs,z_vec,T)){
z_curs=z_vec;
T=alfa*T;
k=1;
while(k<=N){
s_curs[k]=s_vec[k];
z_curs=z_vec;
k=k+1;
}
}else if(p>=FUP(z_curs,z_vec,T)){
k=k+1;
}
}
/* printf("\n %f",z_curs);*/
iterSA=iterSA+1;
}
time(&tiempo2);
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 17
printf("\t%f",z_mejor);
printf("\t%d",tiempo2-tiempo1);
/*printf("AN+SA \t");*/
/*REPRESENTAR LA SOLUCION MEJOR
k=1;
while(k<=N){
printf(" %d",s_mejor[k]);
k=k+1;
}*/
ejem=ejem+1;
}
int k;
s_v[a1]=sec[a2];
s_v[a2]=sec[a1];
k=1;
while(k<=n){
if(k==a1){
k=k+1;
}else if(k==a2){
k=k+1;
}else if(k!=a1 && k!=a2){
s_v[k]=sec[k];
k=k+1;
}
}
int j,k,l,sum,tot,t;
double RetrasoMedio;
matrizNM entrada,salida;
Pág. 18 Anexo B
secuencia Retraso;
j=1;
k=1;
while (k<=n){
Retraso[k]=0;
k=k+1;
}
k=1;
while (k<=n){
j=1;
while (j<=m){
if (salida[k][j-1]>salida[k-1][j]+prep[j][fam[sec[k-1]]][fam[sec[k]]]){
entrada[k][j]=salida[k][j-1];
}else if (salida[k][j-1]<=salida[k-1][j]+prep[j][fam[sec[k-1]]][fam[sec[k]]]){
entrada[k][j]=salida[k-1][j]+prep[j][fam[sec[k-1]]][fam[sec[k]]];
}
salida[k][j]=entrada[k][j]+proc[k][j];
j=j+1;
}
if(salida[k][m]-f_venc[sec[k]]<=0){
Retraso[k]=0;
}else{
Retraso[k]=(salida[k][m]-f_venc[sec[k]]);
}
k=k+1;
}
/* Calcula el retraso medio*/
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 19
sum=0;
tot=0;
l=1;
while (l<=n){
sum=sum+Retraso[l];
tot=tot+1;
l=l+1;
}
RetrasoMedio=(double)sum/(double)tot;
return (RetrasoMedio);
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <assert.h>
int k,t,a,b,aux,iterSA,dim_lista_tabu,tabu,rep;
long int tiempo1,tiempo2;
double z_curs,z_mejor,z_vec,T,z_mejor_vecino;
int iter,MAX,n_ejemplares,n_ejemplar,ejem;
int n_mejor_vecino,n_mejor_vecino_no_tabu,iter_sin_mejora;
double z_mejor_vecino_no_tabu;
secuencia mejor_vecino_no_tabu;
lista_tabu regla_tabu;
ret_vec z_vecino;
vec vecino;
secuencia s,s_curs,f_vencimiento,familia,s_vec,s_mejor,mejor_vecino;
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 21
matrizNM proceso,salida;
matrizMFF preparacion;
int p,t2,t3,N,M,F;
dim_lista_tabu=100;
MAX=1000;
scanf("%d",&p);
n_ejemplar=p;
t3=t3+1;
}
t2=t2+1;
}
t=t+1;
}
/*Obtener secuencia inicial al azar*/
k=1;
while(k<=N){
s_curs[k]=k;
s_mejor[k]=k;
k=k+1;
}/*
t=1;
while(t<=10000){
a=1+rand()%N;
b=1+rand()%N;
GenerarVecino(s_curs,s_vec,N,a,b);
k=1;
while(k<=N){
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 23
s_curs[k]=s_vec[k];
k=k+1;
}
t=t+1;
}*//*En este momento se dispone de una secuencia de N piezas ordenadas al azar*/
z_mejor=CalcularRetrasoMedio(s_curs,f_vencimiento,familia,preparacion,proceso,N,M);
k=1;
GenerarVecino(s_curs,s_vec,N,a,b);
z_vec=CalcularRetrasoMedio(s_vec,f_vencimiento,familia,preparacion,proceso,N,M);
if(z_vec<z_mejor){
t=1;
while(t<=N){
aux=s_vec[t];
s_curs[t]=aux;
s_mejor[t]=aux;
t=t+1;
}
z_mejor=z_vec;
}else if(z_vec>=z_mejor){
t=1;
}
k=k+1;
}
/* printf("ANED \t");*/
/*REPRESENTAR LA SECUENCIA MEJOR:
Pág. 24 Anexo B
t=1;
while(t<=N){
printf(" %d",s_mejor[t]);
t=t+1;
}*/
printf("\n%f",z_mejor);
printf("\t%d",tiempo2-tiempo1);
z_mejor=CalcularRetrasoMedio(s_mejor,f_vencimiento,familia,preparacion,proceso,N,M);
z_curs=z_mejor;
k=1;
while(k<=N){
s_curs[k]=s_mejor[k];
k=k+1;
}
iter=1;
srand(time(NULL));
while(iter<=ITER_MAX_TABU){
/*
z_curs=CalcularRetrasoMedio(s_curs,f_vencimiento,familia,preparacion,proceso,N,M);
printf("\n%f",z_curs);
printf("\t% f",z_mejor);*/
k=1;
GenerarVecindario(s_curs,vecino,N);/*Se genera todos los vecinos de s*/
/*En este momento debo obtener el mejor de todos los vecinos. Vamos a ello*/
k=1;
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 25
n_mejor_vecino=1;
z_mejor_vecino=z_vecino[1];
while(k<=N){
if(z_vecino[k]<z_mejor_vecino){
z_mejor_vecino=z_vecino[k];
n_mejor_vecino=k;
k=k+1;
}else if(z_vecino[k]>=z_mejor_vecino){
k=k+1;
}
}
t=1;
while(t<=N){
mejor_vecino[t]=vecino[n_mejor_vecino][t];
t=t+1;
}
/*Ahora ya tengo el mejor vecino (mejor_vecino es una secuencia de piezas) y su valor
(z_mejor_vecino)*/
if(z_mejor_vecino<z_mejor){
z_mejor=z_mejor_vecino;
k=1;
while(k<=N){
s_mejor[k]=mejor_vecino[k];
s_curs[k]=mejor_vecino[k];
k=k+1;
}
iter=iter+1;
iter_sin_mejora=0;
/*Vaciar la lista tabu*/
tabu=1;
while(tabu<=dim_lista_tabu){
k=1;
while(k<=N){
regla_tabu[tabu][k]=0;
k=k+1;
}
tabu=tabu+1;
}
/*Lista tabu inicializada*/
}else if(z_mejor_vecino>=z_mejor){
/*Seguidamente, intento conseguir el mejor vecino no tabu*/
n_mejor_vecino_no_tabu=0;
z_mejor_vecino_no_tabu=10000000;
k=1;
while(k<=N){
if(z_vecino[k]<z_mejor_vecino_no_tabu){
if(SolucionTabu(vecino[k],regla_tabu,dim_lista_tabu,N)!=0){
Pág. 26 Anexo B
k=k+1;
}else if(SolucionTabu(vecino[k],regla_tabu,dim_lista_tabu,N)==0){
z_mejor_vecino_no_tabu=z_vecino[k];
n_mejor_vecino_no_tabu=k;
k=k+1;
}
}else if(z_vecino[k]>=z_mejor_vecino){
k=k+1;
}
}
k=1;
while(k<=N){
mejor_vecino_no_tabu[k]=vecino[n_mejor_vecino_no_tabu][k];
k=k+1;
}
/*En este momento se dispone del mejor vecino no tabu (mejor_vecino_no_tabu es
una secuencia de piezas) y su valor(z_mejor_vecino_no_tabu)*/
iter_sin_mejora=iter_sin_mejora+1;
k=1;
while(k<=N){
s_curs[k]=mejor_vecino_no_tabu[k];
k=k+1;
}
iter=iter+1;
if(iter_sin_mejora<=dim_lista_tabu){
tabu=iter_sin_mejora;
a=n_mejor_vecino_no_tabu;
b=n_mejor_vecino_no_tabu+1;
regla_tabu[tabu][a]=s_curs[b];
regla_tabu[tabu][b]=s_curs[a];
}else if(iter_sin_mejora>dim_lista_tabu){
tabu=1+iter_sin_mejora % dim_lista_tabu;
k=1;
while(k<=N){
regla_tabu[tabu][k]=0;
k=k+1;
}
a=n_mejor_vecino_no_tabu;
b=n_mejor_vecino_no_tabu+1;
regla_tabu[tabu][a]=s_curs[b];
regla_tabu[tabu][b]=s_curs[a];
}
}
/*REPRESENTAR LA SOLUCION MEJOR
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 27
k=1;
while(k<=N){
printf(" %d",s_mejor[k]);
k=k+1;
} */
}
time(&tiempo2);
printf("\t%f",z_mejor);
printf("\t%d",tiempo2-tiempo1);
ejem=ejem+1;
}
}
t=1;
while(t<=n){
if(t!=n){
v[t][t]=sec[t+1];
v[t][t+1]=sec[t];
Pág. 28 Anexo B
t=t+1;
}else if(t==n){
v[t][t]=sec[1];
v[t][1]=sec[n];
t=t+1;
}
}
t=1;
k=1;
while(t<=n){
if(t!=n){
k=1;
while(k<=n){
if(k!=t && k!=t+1){
v[t][k]=sec[k];
k=k+1;
}else{k=k+1;
}
}
}else if(t==n){
k=2;
while(k<=n-1){
v[t][k]=sec[k];
k=k+1;
}
}
v[t][n+1]=v[t][1];
t=t+1;
}
int k;
s_v[a1]=sec[a2];
s_v[a2]=sec[a1];
k=1;
while(k<=n){
if(k==a1){
k=k+1;
Producción en máquinas en serie con tiempos dependientes de la secuencia Pág. 29
}else if(k==a2){
k=k+1;
}else if(k!=a1 && k!=a2){
s_v[k]=sec[k];
k=k+1;
}
}
int j,k,l,sum,tot,t;
double RetrasoMedio;
matrizNM entrada,salida;
secuencia Retraso;
j=1;
k=1;
while (k<=n){
Retraso[k]=0;
k=k+1;
}
k=1;
while (k<=n){
j=1;
while (j<=m){
if (salida[k][j-1]>salida[k-1][j]+prep[j][fam[sec[k-1]]][fam[sec[k]]]){
Pág. 30 Anexo B
entrada[k][j]=salida[k][j-1];
}else if (salida[k][j-1]<=salida[k-1][j]+prep[j][fam[sec[k-1]]][fam[sec[k]]]){
entrada[k][j]=salida[k-1][j]+prep[j][fam[sec[k-1]]][fam[sec[k]]];
}
salida[k][j]=entrada[k][j]+proc[k][j];
j=j+1;
}
if(salida[k][m]-f_venc[sec[k]]<=0){
Retraso[k]=0;
}else{
Retraso[k]=(salida[k][m]-f_venc[sec[k]]);
}
k=k+1;
}
/* Calcula el retraso medio*/
sum=0;
tot=0;
l=1;
while (l<=n){
sum=sum+Retraso[l];
tot=tot+1;
l=l+1;
}
RetrasoMedio=(double)sum/(double)tot;
return (RetrasoMedio);