Producción en máquinas en serie con SA

Producción en máquinas en serie con tiempos dependientes de la secuencia Pág.
ANEXO B.- Programación en C
B.1.Programación en C del Algoritmo No Exhaustivo de Descenso (ANED).....................2

B.2. Programación en C del Recocido Simulado (SA).......................................................9
B.3. Programación en C de la Búsqueda Tabú (TS)........................................................20
Pág. 2 Anexo B
B.1. Programación en C del Algoritmo No Exhaustivo de Descenso (ANED)

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <assert.h>
#define D_max 100

#define N_max 100
#define M_max 10
#define F_max 10
#define ITER_MAX 4615380
#define alfa 0.999999
#define T_inicial 100
typedef int lista_tabu[D_max][N_max];

typedef double ret_vec[N_max];
typedef int secuencia[N_max];
typedef int matrizNM[N_max][M_max];
typedef int matrizMFF[M_max][F_max][F_max];
typedef int vec[N_max][N_max];
int SolucionTabu(secuencia s,lista_tabu re_ta,int d_lis,int n);

void GenerarVecindario(secuencia const sec,vec v,int n);
void GenerarVecino(secuencia const sec,secuencia s_vecina,int n,int a1,int a2);
double CalcularRetrasoMedio(secuencia sec,secuencia f_venc,secuencia fam,matrizMFF
prep,matrizNM proc,int n,int m);
double FUP(double z_c,double z_v,double t);
void main (void){
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
/*INICIO LECTURA DE DATOS*/

scanf("%d",&p);
n_ejemplares=p;
printf("ANED\n");
printf("numero de iteraciones =%d\n",ITER_MAX);
ejem=1;
while(ejem<=n_ejemplares){
scanf("%d",&p);
n_ejemplar=p;
scanf("%d",&p); /*Numero de piezas*/

N=p;
scanf("%d",&p); /*Numero de maquinas*/

M=p;
scanf("%d",&p); /*Numero de familias*/

F=p;
scanf("%d",&p); /*Familia inicial*/

familia[0]=p;
/*Instante de disponibilidad de las piezas*/

t=1;
while (t<=N){
salida[t][0]=0;
t=t+1;
}
s[0]=0; /*Datos sin significados*/

proceso[0][0]=0;
salida[0][0]=0;
/*Instante de disponibilidad de las maquinas*/

t=1;
while (t<=M){
salida[0][t]=0;
t=t+1;
}
/*Lectura de los datos de cada pieza*/

t=1;
while(t<=N){
scanf("%d",&p);/*Indica el numero de pieza*/
Pág. 4 Anexo B
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;
}*//*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;
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;
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;
}
}
void GenerarVecino(secuencia const sec,secuencia s_v,int n,int a1,int a2){
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;
}
}

prep,matrizNM proc,int n,int m){
/* Calcular el retraso de cada pieza*/
int j,k,l,sum,tot,t;
double RetrasoMedio;
matrizNM entrada,salida;
secuencia Retraso;
sec[0]=0; /*Datos sin significados*/

proc[0][0]=0;
salida[0][0]=0;

t=1;
while (t<=n){
salida[t][0]=0;
t=t+1;
}
t=1;
while (t<=m){
salida[0][t]=0;
t=t+1;
}
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);
}
B.2. Programación en C del Recocido Simulado (SA)
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <assert.h>
#define D_max 100

#define N_max 100
#define M_max 10
#define F_max 10
#define ITER_MAX 100000
#define alfa 0.95
#define T_inicial 10.0


void main (void){
int k,t,a,b,aux,iterSA,dim_lista_tabu,tabu,rep;
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
int p,t2,t3,N,M,F;
dim_lista_tabu=7;
MAX=1000;

scanf("%d",&p);
n_ejemplares=p;
ejem=1;
/*printf("\niteraciones=%d",ITER_MAX);
printf("\nT_inicial=%f",T_inicial);
printf("\nalfa=%f",alfa);*/
scanf("%d",&p);
n_ejemplar=p;

N=p;

M=p;

F=p;

familia[0]=p;

t=1;
while (t<=N){
salida[t][0]=0;
t=t+1;
}

proceso[0][0]=0;
salida[0][0]=0;

t=1;
while (t<=M){
salida[0][t]=0;
t=t+1;
}

t=1;
while(t<=N){
scanf("%d",&p);
scanf("%d",&p);
t2=1;
while(t2<=M){
scanf("%d",&p);
t2=t2+1;
}
t=t+1;
}
t=1;
while(t<=M){
t2=1;
while(t2<=F){
t3=1;
while(t3<=F){
scanf("%d",&p);
t3=t3+1;
}
t2=t2+1;
}
t=t+1;
}
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
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_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);
a=1+rand()%N;
b=1+rand()%N;
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;
t=1;
while(t<=N){
t=t+1;
}
}
k=k+1;
}
time(&tiempo2);
t=1;
while(t<=N){
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)*/
/*A continuacion se aplica la metaheuristica de recocido simulado(SIMULATED

ANNEALING)a:
1. La mejor solucion obtenida con ANED
2. La solucion inicial
*/
/*1.SA partiendo de la mejor solucion obtenida con ANED*/

k=1;
while(k<=N){
s_curs[k]=s_mejor[k];
k=k+1;
}
z_curs=z_mejor;
iterSA=1;
T=T_inicial;
srand(time(NULL));
time(&tiempo1);
prob=1;
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);*/
/*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;
}
time(&tiempo2);
/*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;
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_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_curs);*/
a=1+rand()%N;
b=1+rand()%N;
Pág. 16 Anexo B
/*printf("\n%f",z_curs);
printf("\t%f",z_mejor);*/
/* 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);
/*printf("AN+SA \t");*/
k=1;
while(k<=N){
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;
s_v[k]=sec[k];
k=k+1;
}
}

Pág. 18 Anexo B
secuencia Retraso;

proc[0][0]=0;
salida[0][0]=0;

t=1;
while (t<=n){
salida[t][0]=0;
t=t+1;
}
t=1;
while (t<=m){
salida[0][t]=0;
t=t+1;
}
j=1;
k=1;
while (k<=n){
Retraso[k]=0;
k=k+1;
}
k=1;
while (k<=n){
j=1;
while (j<=m){
}
j=j+1;
}
Retraso[k]=0;
}else{
}
k=k+1;
}
sum=0;
tot=0;
l=1;
while (l<=n){
sum=sum+Retraso[l];
tot=tot+1;
l=l+1;
}
double FUP(double z_c,double z_v,double t){

return(exp(-(z_v-z_c)/t)*100);
}
Pág. 20 Anexo B
B.3. Programación en C de la Búsqueda Tabú (TS)
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <assert.h>
#define D_max 1000

#define N_max 100
#define M_max 10
#define F_max 10
#define ITER_MAX_ANED 384615
#define ITER_MAX_TABU 305900
#define alfa 0.999999
#define T_inicial 100


void main (void){
int k,t,a,b,aux,iterSA,dim_lista_tabu,tabu,rep;
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;
int p,t2,t3,N,M,F;
dim_lista_tabu=100;
MAX=1000;

scanf("%d",&p);
n_ejemplares=p;
ejem=1;
scanf("%d",&p);
n_ejemplar=p;

N=p;

M=p;

F=p;

familia[0]=p;

t=1;
while (t<=N){
salida[t][0]=0;
t=t+1;
}

proceso[0][0]=0;
salida[0][0]=0;

t=1;
while (t<=M){
salida[0][t]=0;
t=t+1;
}
Pág. 22 Anexo B

t=1;
while(t<=N){
scanf("%d",&p);
scanf("%d",&p);
t2=1;
while(t2<=M){
scanf("%d",&p);
t2=t2+1;
}
t=t+1;
}
t=1;
while(t<=M){
t2=1;
while(t2<=F){
t3=1;
while(t3<=F){
scanf("%d",&p);
t3=t3+1;
}
t2=t2+1;
}
t=t+1;
}
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;
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*/
k=1;
/*Ahora se aplica ANED a la secuencia aleatoria que se tiene hasta el momento*/

srand(time(NULL));
time(&tiempo1);
while(k<=ITER_MAX_ANED){
/*z_curs=CalcularRetrasoMedio(s_curs,f_vencimiento,familia,preparacion,proceso,N,M);
a=1+rand()%N;
b=1+rand()%N;
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;
t=1;
}
k=k+1;
}
Pág. 24 Anexo B
t=1;
while(t<=N){
t=t+1;
}*/
printf("\n%f",z_mejor);
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;
}
/*Ahora debo inicializar (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*/
iter=1;
srand(time(NULL));
while(iter<=ITER_MAX_TABU){
/*
z_curs=CalcularRetrasoMedio(s_curs,f_vencimiento,familia,preparacion,proceso,N,M);
k=1;
GenerarVecindario(s_curs,vecino,N);/*Se genera todos los vecinos de s*/
/*A continuacion se calculan los retrasos medios de todos los vecinos*/

k=1;
while(k<=N){
z_vecino[k]=CalcularRetrasoMedio(vecino[k],f_vencimiento,familia,preparacion,proc
eso,N,M);
k=k+1;
}
/*Ya se han evaluado todos los vecinos*/
/*En este momento debo obtener el mejor de todos los vecinos. Vamos a ello*/
k=1;
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){
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;
/*Ahora actualizo la lista tabu*/
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){
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];
}
}
k=1;
while(k<=N){
k=k+1;
} */
}
time(&tiempo2);
ejem=ejem+1;
}
}
int SolucionTabu(secuencia s,lista_tabu re_ta,int d_lis,int n){

int t,k,resp,es_solucion_tabu;
t=1;
k=1;
resp=0;
es_solucion_tabu=0;
while(t<=d_lis){
if(resp<2){
resp=0;
k=1;
while(k<=n){
if(re_ta[t][k]==s[k]){
resp=resp+1;
k=k+1;
}else if(re_ta[t][k]!=s[k]){
k=k+1;
}
}
t=t+1;
}else if(resp>=2){
es_solucion_tabu=1;
t=t+1;
}
}
return (es_solucion_tabu);
}
void GenerarVecindario(secuencia const sec,vec v,int n){

int t,k;
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;
}
/*En este momento se ha generado todo el vecindario de una secuencia dada*/

}
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;
s_v[k]=sec[k];
k=k+1;
}
}

secuencia Retraso;

proc[0][0]=0;
salida[0][0]=0;

t=1;
while (t<=n){
salida[t][0]=0;
t=t+1;
}
t=1;
while (t<=m){
salida[0][t]=0;
t=t+1;
}
j=1;
k=1;
while (k<=n){
Retraso[k]=0;
k=k+1;
}
k=1;
while (k<=n){
j=1;
while (j<=m){
Pág. 30 Anexo B
}
j=j+1;
}
Retraso[k]=0;
}else{
}
k=k+1;
}
sum=0;
tot=0;
l=1;
while (l<=n){
sum=sum+Retraso[l];
tot=tot+1;
l=l+1;
}
double FUP(double z_c,double z_v,double t){

return(exp(-(z_v-z_c)/t)*100);
}

Producción en máquinas en serie con SA

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Producción en máquinas en serie con SA

Uploaded by

Copyright:

Available Formats

Producción en máquinas en serie con tiempos dependientes de la secuencia Pág.

ANEXO B.- Programación en C

B.1.Programación en C del Algoritmo No Exhaustivo de Descenso (ANED).....................2

B.1. Programación en C del Algoritmo No Exhaustivo de Descenso (ANED)

#define D_max 100

typedef int lista_tabu[D_max][N_max];

int SolucionTabu(secuencia s,lista_tabu re_ta,int d_lis,int n);

/*INICIO LECTURA DE DATOS*/

scanf("%d",&p); /*Numero de piezas*/

scanf("%d",&p); /*Numero de maquinas*/

scanf("%d",&p); /*Numero de familias*/

scanf("%d",&p); /*Familia inicial*/

/*Instante de disponibilidad de las piezas*/

s[0]=0; /*Datos sin significados*/

/*Instante de disponibilidad de las maquinas*/

/*Lectura de los datos de cada pieza*/

}*//*En este momento se dispone de una secuencia de N piezas ordenadas al azar*/

void GenerarVecino(secuencia const sec,secuencia s_v,int n,int a1,int a2){

double CalcularRetrasoMedio(secuencia sec,secuencia f_venc,secuencia fam,matrizMFF

/* Calcular el retraso de cada pieza*/

sec[0]=0; /*Datos sin significados*/

/*Instante de disponibilidad de las piezas*/

B.2. Programación en C del Recocido Simulado (SA)

#define D_max 100

#define T_inicial 10.0

typedef int lista_tabu[D_max][N_max];

int SolucionTabu(secuencia s,lista_tabu re_ta,int d_lis,int n);

void main (void){

/*INICIO LECTURA DE DATOS*/

scanf("%d",&p); /*Numero de piezas*/

scanf("%d",&p); /*Numero de maquinas*/

scanf("%d",&p); /*Numero de familias*/

scanf("%d",&p); /*Familia inicial*/

/*Instante de disponibilidad de las piezas*/

s[0]=0; /*Datos sin significados*/

/*Instante de disponibilidad de las maquinas*/

/*Lectura de los datos de cada pieza*/

/*A continuacion se aplica la metaheuristica de recocido simulado(SIMULATED

/*1.SA partiendo de la mejor solucion obtenida con ANED*/

void GenerarVecino(secuencia const sec,secuencia s_v,int n,int a1,int a2){

double CalcularRetrasoMedio(secuencia sec,secuencia f_venc,secuencia fam,matrizMFF

/* Calcular el retraso de cada pieza*/

sec[0]=0; /*Datos sin significados*/

/*Instante de disponibilidad de las piezas*/

double FUP(double z_c,double z_v,double t){

B.3. Programación en C de la Búsqueda Tabú (TS)

#define D_max 1000

typedef int lista_tabu[D_max][N_max];

int SolucionTabu(secuencia s,lista_tabu re_ta,int d_lis,int n);

void main (void){

/*INICIO LECTURA DE DATOS*/

scanf("%d",&p); /*Numero de piezas*/

scanf("%d",&p); /*Numero de maquinas*/

scanf("%d",&p); /*Numero de familias*/

scanf("%d",&p); /*Familia inicial*/

/*Instante de disponibilidad de las piezas*/

s[0]=0; /*Datos sin significados*/

/*Instante de disponibilidad de las maquinas*/

/*Lectura de los datos de cada pieza*/

/*Ahora se aplica ANED a la secuencia aleatoria que se tiene hasta el momento*/

/*Ahora debo inicializar (vaciar) la lista tabu*/

/*A continuacion se calculan los retrasos medios de todos los vecinos*/

/INICIO LECTURA DE DATOS/

scanf("%d",&p); /Numero de piezas/

scanf("%d",&p); /Numero de maquinas/

scanf("%d",&p); /Numero de familias/

scanf("%d",&p); /Familia inicial/

/Instante de disponibilidad de las piezas/

s[0]=0; /Datos sin significados/

/Instante de disponibilidad de las maquinas/

/Lectura de los datos de cada pieza/

}//En este momento se dispone de una secuencia de N piezas ordenadas al azar*/

sec[0]=0; /Datos sin significados/

/Instante de disponibilidad de las piezas/

/INICIO LECTURA DE DATOS/

scanf("%d",&p); /Numero de piezas/

scanf("%d",&p); /Numero de maquinas/

scanf("%d",&p); /Numero de familias/

scanf("%d",&p); /Familia inicial/

/Instante de disponibilidad de las piezas/

s[0]=0; /Datos sin significados/

/Instante de disponibilidad de las maquinas/

/Lectura de los datos de cada pieza/

/1.SA partiendo de la mejor solucion obtenida con ANED/

sec[0]=0; /Datos sin significados/

/Instante de disponibilidad de las piezas/

/INICIO LECTURA DE DATOS/

scanf("%d",&p); /Numero de piezas/

scanf("%d",&p); /Numero de maquinas/

scanf("%d",&p); /Numero de familias/

scanf("%d",&p); /Familia inicial/

/Instante de disponibilidad de las piezas/

s[0]=0; /Datos sin significados/

/Instante de disponibilidad de las maquinas/

/Lectura de los datos de cada pieza/

/Ahora se aplica ANED a la secuencia aleatoria que se tiene hasta el momento/

/Ahora debo inicializar (vaciar) la lista tabu/

/A continuacion se calculan los retrasos medios de todos los vecinos/

/Ahora actualizo la lista tabu/

/En este momento se ha generado todo el vecindario de una secuencia dada/

sec[0]=0; /Datos sin significados/

/Instante de disponibilidad de las piezas/