1. ANEXOS Código Matlab Programa...

____________________________________________________________________________ Escuela Técnica Superior de Ingeniería

Germán Jerez Muñoz

1

Universidad de Sevilla

1. ANEXOS

1.1. Código Matlab

1.1.1. Programa principal

%inicializar variables/constantes principales

tic % inicia cronómetro ejecución del código

contador=1;

tipospeso=4;

tiposprioridad=4;

num_columnas=8;

num_filas=2*num_columnas;

num_alturas=6;

num_contenedores=450

max_mom=num_columnas*5; %momento máximo permitido

pmax=5000; %nº máximo de iteraciones

contadormaxtabu=ceil(pmax*0.25);% longitud de la lista tabú

contadorlista=1; % contador para la lista tabú

auxtabu=contadormaxtabu+10;%antes de introducir una modificación en la

lista tabú, se crea una posición auxiliar.

max_col_Zonas=(num_filas*num_columnas)/4; % define el nº de

contenedores de cada zona (nº columnas de la matris Zonas)

Q=ceil(num_columnas*num_filas*num_alturas*(tipospeso*0.75));% se toma

como carga máxima del barco

resultado=0;

recomp=0;% vale 1 cuando dos contenedores son compatibles para

permutar

crearnuevogreedymax=1000;

tmax=1800; % tiempo máximo del algoritmo

tiempo=0;

t_nuevo=40;

[Compatibilidad]=crearcompatibilidad(tipospeso,tiposprioridad); % se

crea la matriz de compatibilidad

for i=1:contadormaxtabu % se crea la lista tabú

lista_tabu(i).zona1.fila=0;

lista_tabu(i).zona1.columna=0;

lista_tabu(i).zona1.altura=0;



2


lista_tabu(i).zona2.fila=0;

lista_tabu(i).zona2.columna=0;

lista_tabu(i).zona2.altura=0;

lista_tabu(i).tipo1.peso=0;

lista_tabu(i).tipo1.prioridad=0;

lista_tabu(i).tipo2.peso=0;

lista_tabu(i).tipo2.prioridad=0;

lista_tabu(i).repeticiones=0;

end

%cargar el fichero con información de los contenedores

load lista_62_grande.m

lista_62_grande;

lista_ordenada=lista_62_grande;

% ordenar la matriz según peso

for i=1:num_contenedores-1

for j=i+1:num_contenedores

if lista_ordenada(i,2)<lista_ordenada(j,2)

x=lista_ordenada(j,:);

lista_ordenada(j,:)=lista_ordenada(i,:);

lista_ordenada(i,:)=x;

end

end

end

% ordenar matriz (una vez ordenada por peso, por prioridades, dentro

de cada peso)

for i=1:num_contenedores-1

for j=i+1:num_contenedores

if

lista_ordenada(i,3)>lista_ordenada(j,3)&&lista_ordenada(i,2)==lista_or

denada(j,2)

x=lista_ordenada(j,:);

lista_ordenada(j,:)=lista_ordenada(i,:);

lista_ordenada(i,:)=x;

end

end

end



3


%guardar esa matriz en un vector de estructuras llamado

lista_ordenada_s

for i=1:num_contenedores %% se crean 32 contenedores aleatoriamente

por excel

lista_ordenada_s(i).num=lista_ordenada(i,1);

end

for i=1:num_contenedores

lista_ordenada_s(i).peso=lista_ordenada(i,2);

end


lista_ordenada_s(i).prior=lista_ordenada(i,3);

end

% guardo también lista_32 en una estructura.


lista_62_s(i).num=lista_62_grande(i,1);

end


lista_62_s(i).peso=lista_62_grande(i,2);

end


lista_62_s(i).prior=lista_62_grande(i,3);

end

% ya está ordenado el vector correctamente

p=1;

while resultado==0 % algoritmo asignación GREEDY

Baux=soluciongreedy(num_filas,num_columnas,num_alturas,lista_ordenada_

s,num_contenedores);

sol(p).B=Baux;

%evaluar las restricciones de la solución

resultado=restricciones(num_filas,num_columnas,num_alturas,Baux,num_co

ntenedores,lista_62_grande,Q,max_mom);

end

sol(p).fo=FO2(num_filas,num_columnas,num_alturas,sol,lista_62_grande,p

,num_contenedores);

tiempo(p,1)=toc;

tiempo(p,2)=tiempo(p,1);



4


while p<pmax && tiempo(p)<tmax % condiciones para finalizar el

programa

resultado=0;

crearnuevogreedy=0;

comp=0;

fo=0;

retabu=0;

while resultado==0 || (fo<sol(p).fo) || retabu==0 %

while comp==0 % mientras no sean compatibles

af1=randi(num_filas); % genera un nº entero aleatorio

entre 1 y num_filas.

ac1=randi(num_columnas);

aa1=randi(num_alturas);

af2=randi(num_filas);

ac2=randi(num_columnas);

aa2=randi(num_alturas);

[comp1,comp2,comp3,comp]=compatibles2(af1,ac1,aa1,af2,ac2,aa2,tipospes

o,Compatibilidad,lista_62_grande,sol,num_alturas,p);

end

comp=0;

% comp(i) define el tipo de intercambio entre contenedores

Baux=sol(p).B;

Baux=permutar(af1,ac1,aa1,af2,ac2,aa2,Baux);



if resultado==0

crearnuevogreedy=crearnuevogreedy+1;

else

fo=FO(num_filas,num_columnas,num_alturas,Baux,lista_62_grande,num_cont

enedores);

end



5


if crearnuevogreedy>crearnuevogreedymax % para que no se

atasque el programa, comienzo en otra solución inicial greedy

while resultado==0

Baux=soluciongreedy(num_filas,num_columnas,num_alturas,lista_ordenada_

s,num_contenedores);

sol(p).B=Baux;



end


,num_contenedores);

crearnuevogreedy=0;

fo=0;

end

retabu=comprobar_lista_tabu(contadormaxtabu,af1,ac1,aa1,af2,ac2,aa2,Ba

ux,lista_tabu,lista_62_grande,num_columnas,contadorlista,max_col_Zonas

,auxtabu); % compruebo si está el movimiento en la lista tabú

end

Zonas=crearzonas2(num_filas,num_columnas,num_alturas,sol,lista_62_gran

de,max_col_Zonas,contador,p); % se actualiza la matriz Zonas

[lista_tabu,contadorlista]=listatabu(contadormaxtabu,af1,ac1,aa1,af2,a

c2,aa2,Baux,lista_tabu,lista_62_grande,num_columnas,contadorlista,max_

col_Zonas,auxtabu);

p=p+1

sol(p).B=Baux;


,num_contenedores);

tiempo(p,1)=toc;

tiempo(p,2)=tiempo(p,1)-tiempo(p-1,1); % se calcula el tiempo

entre iteración

end

[mejorfo,mejorB]=mejorsolucion(p,sol)



6


toc

for i=1:p

h(i,2)=sol(i).fo;

h(i,3)=tiempo(i,2);

h(i,1)=tiempo(i,1);

end

xlswrite('testdata.xls',[h]); % genera el archive excel

1.1.2. Funciones

1.1.2.1. Crearcompatibilidad

Function

[Compatibilidad]=crearcompatibilidad(tipospeso,tiposprioridad)

Compatibilidad_prueba=zeros(tipospeso*tiposprioridad,tipospeso*tipospr

ioridad);

t=2;

y=5;

c=1;

for i=1:tipospeso*tiposprioridad

if c<=3

Compatibilidad_prueba(i,t)=1;

Compatibilidad_prueba(t,i)=Compatibilidad_prueba(i,t);

if y<=tipospeso*tiposprioridad

Compatibilidad_prueba(i,y)=1;

Compatibilidad_prueba(y,i)=Compatibilidad_prueba(i,y);

end

y=y+1;

t=t+1;

c=c+1;

else

Compatibilidad_prueba(i,y)=1;

Compatibilidad_prueba(y,i)=Compatibilidad_prueba(i,y);

t=t+1;

y=y+1;

c=1;

end



7


Compatibilidad_prueba;

end

% Formar la matriz Compatibilidad

Compatibilidad

=zeros(tipospeso*tiposprioridad,tipospeso*tiposprioridad);

for i=1:tipospeso*tiposprioridad

for j=1:tipospeso*tiposprioridad

Compatibilidad(i,j)=Compatibilidad_prueba(i,j);

end

end

Compatibilidad;

end

1.1.2.2. Compatibles

function

[comp1,comp2,comp3,comp]=compatibles2(af1,ac1,aa1,af2,ac2,aa2,tipospes

o,Compatibilidad,lista_62_grande,sol,num_alturas,p)

comp1=0;

comp2=0;

comp3=0;

comp=0;

if sol(p).B(af1,ac1,aa1)~=0

pos_fila=tipospeso*(lista_62_grande(sol(p).B(af1,ac1,aa1),2)-

1)+lista_62_grande(sol(p).B(af1,ac1,aa1),3);

recomp1=1; % si hay contenedor vale 1, si no hay vale 0

else

recomp1=0;

end


pos_columna=tipospeso*(lista_62_grande(sol(p).B(af2,ac2,aa2),2)-

1)+lista_62_grande(sol(p).B(af2,ac2,aa2),3);

recomp2=1;

else

recomp2=0;

end

if recomp1+recomp2==2;

if(Compatibilidad(pos_fila,pos_columna)==1)

comp1=1;



8


end

end

if recomp1==0 && aa2<num_alturas

if sol(p).B(af2,ac2,aa2+1)==0 && sol(p).B(af2,ac2,aa2)~=0

comp2=1;

end

end

if recomp1==0 && aa2==num_alturas


comp2=1;

end

end

if recomp2==0 && aa1<num_alturas

if sol(p).B(af1,ac1,aa1+1)==0 && sol(p).B(af1,ac1,aa1)~=0

comp3=1;

end

end

if recomp2==0 && aa1==num_alturas


comp3=1;

end

end

if comp1==1 || comp2==1 || comp3==1

comp=1;

end

end

1.1.2.3. Comprobar_lista_tabu

function

retabu=comprobar_lista_tabu(contadormaxtabu,af1,ac1,aa1,af2,ac2,aa2,Ba

ux,lista_tabu,lista_62_grande,num_columnas,contadorlista,max_col_Zonas

,auxtabu)

[filaaux1,columnaaux1,alturaaux1]=finddd(num_columnas,af1,ac1,aa1,max_

col_Zonas);


col_Zonas);



9


if Baux(af1,ac1,aa1)~=0 && Baux(af2,ac2,aa2)~=0

lista_tabu(auxtabu).zona1.fila=filaaux1; %% esto es para la matriz

Zonas

lista_tabu(auxtabu).zona1.columna=columnaaux1;

lista_tabu(auxtabu).zona1.altura=alturaaux1;

lista_tabu(auxtabu).zona2.fila=filaaux2;



lista_tabu(auxtabu).tipo1.peso=lista_62_grande(Baux(af1,ac1,aa1),2);

lista_tabu(auxtabu).tipo1.prioridad=lista_62_grande(Baux(af1,ac1,aa1),

3);

lista_tabu(auxtabu).tipo2.peso=lista_62_grande(Baux(af2,ac2,aa2),2);

lista_tabu(auxtabu).tipo2.prioridad=lista_62_grande(Baux(af2,ac2,aa2),

3);

end

if Baux(af1,ac1,aa1)==0

lista_tabu(auxtabu).zona1.fila=filaaux1; %% esto es para la

matriz Zonas



end

if Baux(af2,ac2,aa2)==0




end

retabu=1;

if contadorlista<=contadormaxtabu

for t=1:contadorlista %compruebo que no esté en la lista

if

lista_tabu(auxtabu).zona1.fila==lista_tabu(t).zona1.fila &&

lista_tabu(auxtabu).zona1.altura==lista_tabu(t).zona1.altura &&



lista_tabu(auxtabu).tipo1.peso==lista_tabu(t).tipo1.peso &&



10


lista_tabu(auxtabu).tipo1.prioridad==lista_tabu(t).tipo1.prioridad &&


lista_tabu(auxtabu).tipo2.prioridad==lista_tabu(t).tipo2.prioridad

retabu=0;

end

end

else

for t=1:contadormaxtabu % compruebo si está en la lista

if






lista_tabu(auxtabu).tipo1.prioridad==lista_tabu(t).tipo1.prioridad &&


lista_tabu(auxtabu).tipo2.prioridad==lista_tabu(t).tipo2.prioridad

retabu=0;

end

end

end

end

1.1.2.4. Crearzonas

function

Zonas=crearzonas2(num_filas,num_columnas,num_alturas,sol,lista_62_gran

de,max_col_Zonas,contador,p)

Zonas=zeros((num_columnas*num_filas/max_col_Zonas),max_col_Zonas,num_a

lturas);

for k=1:num_alturas

fila_aux=1;%comienza por la fila 1 de la matriz Zonas

for i=1:num_filas

for j=1:num_columnas



11


if contador==max_col_Zonas

if sol(p).B(i,j,k)~=0

Zonas(fila_aux,contador,k)=lista_62_grande(sol(p).B(i,j,k),1);

fila_aux=fila_aux+1;

contador =1;

else

Zonas(fila_aux,contador,k)=0;

fila_aux=fila_aux+1;

contador =1;

end

else

if sol(p).B(i,j,k)~=0

Zonas(fila_aux,contador,k)=lista_62_grande(sol(p).B(i,j,k),1);

contador=contador+1;

end

if sol(p).B(i,j,k)==0

Zonas(fila_aux,contador,k)=0;

contador=contador+1;

end

end

end

end

end

end

1.1.2.5. finddd

function

[fila,columna,altura]=finddd(num_columnas,af1,ac1,aa1,max_col_Zonas)

altura=aa1;

fila=1;

af1prima=af1;

q=(af1prima-1)*num_columnas+ac1;

while q > max_col_Zonas

q=q-max_col_Zonas;

fila=fila+1;

end

columna=q;



12


end

1.1.2.6. FO

function

fo=FO(num_filas,num_columnas,num_alturas,B,lista_62_grande,num_contene

dores)

% evaluar la FUNCIÓN OBJETIVO

fo1=0;

fo2=0;%aux. para calcular la FO

for k=1:num_alturas


if j<=num_columnas/2

for i=1:num_filas/2

if B(i,j,k)~=0

fo1inst=j^4*lista_62_grande(B(i,j,k),3)*k^2*i;

% cuadráticamente hacia las zonas

centrales*prioridad*piso en el que se encuentra

fo1=fo1+fo1inst;

end

end

for i=num_filas/2+1:num_filas

if B(i,j,k)~=0

fo1inst=j^4*lista_62_grande(B(i,j,k),3)*k^2*(num_filas-i+1);



fo1=fo1+fo1inst;

end

end

else

for i=1:num_filas/2

if B(i,j,k)~=0

fo2inst=(num_columnas-

j+1)^4*lista_62_grande(B(i,j,k),3)*k^2*i;




13


% centrales*prioridad*piso en el que se

encuentra^2

fo2=fo2+fo2inst;

end

end

for i=num_filas/2+1:num_filas

if B(i,j,k)~=0

fo2inst=(num_columnas-

j+1)^4*lista_62_grande(B(i,j,k),3)*k^2*(num_filas-i+1);



fo2=fo2+fo2inst;

end

end

end

end

end

fo=(fo1+fo2)/num_contenedores;

end

1.1.2.7. Listatabu

function

[lista_tabu,contadorlista]=listatabu(contadormaxtabu,af1,ac1,aa1,af2,a

c2,aa2,B,lista_tabu,lista_62_grande,num_columnas,contadorlista,max_col

_Zonas,auxtabu)


col_Zonas);


col_Zonas);

if B(af1,ac1,aa1)~=0 && B(af2,ac2,aa2)~=0

lista_tabu(auxtabu).zona1.fila=filaaux1; %% esto es para la matriz

Zonas






14




lista_tabu(auxtabu).tipo1.peso=lista_62_grande(B(af1,ac1,aa1),2);

lista_tabu(auxtabu).tipo1.prioridad=lista_62_grande(B(af1,ac1,aa1),3);

lista_tabu(auxtabu).tipo2.peso=lista_62_grande(B(af2,ac2,aa2),2);

lista_tabu(auxtabu).tipo2.prioridad=lista_62_grande(B(af2,ac2,aa2),3);

end

if B(af1,ac1,aa1)==0

lista_tabu(auxtabu).zona1.fila=filaaux1; %% esto es para la

matriz Zonas



end

if B(af2,ac2,aa2)==0




end

retabu=1;

if contadorlista<=contadormaxtabu

for w=1:contadorlista %compruebo que no esté en la lista

if

lista_tabu(auxtabu).zona1.fila==lista_tabu(w).zona1.fila &&

lista_tabu(auxtabu).zona1.altura==lista_tabu(w).zona1.altura &&



lista_tabu(auxtabu).tipo1.peso==lista_tabu(w).tipo1.peso &&

lista_tabu(auxtabu).tipo1.prioridad==lista_tabu(w).tipo1.prioridad &&


lista_tabu(auxtabu).tipo2.prioridad==lista_tabu(w).tipo2.prioridad

retabu=0;

lista_tabu(w).repeticiones=lista_tabu(w).repeticiones+1;

end

end



15


if retabu==1 % lo añado en la lista

lista_tabu(contadorlista).zona1.fila=lista_tabu(auxtabu).zona1.fila;

%% esto es para la matriz Zonas

lista_tabu(contadorlista).zona1.columna=lista_tabu(auxtabu).zona1.colu

mna;

lista_tabu(contadorlista).zona1.altura=lista_tabu(auxtabu).zona1.altur

a;

lista_tabu(contadorlista).zona2.fila=lista_tabu(auxtabu).zona2.fila;

lista_tabu(contadorlista).zona2.columna=lista_tabu(auxtabu).zona2.colu

mna;

lista_tabu(contadorlista).zona2.altura=lista_tabu(auxtabu).zona2.altur

a;

lista_tabu(contadorlista).tipo1.peso=lista_tabu(auxtabu).tipo1.peso;

lista_tabu(contadorlista).tipo1.prioridad=lista_tabu(auxtabu).tipo1.pr

ioridad;

lista_tabu(contadorlista).tipo2.peso=lista_tabu(auxtabu).tipo2.peso;

lista_tabu(contadorlista).tipo2.prioridad=lista_tabu(auxtabu).tipo2.pr

ioridad;

contadorlista=contadorlista+1;

end

else

for w=1:contadormaxtabu % compruebo si está en la lista

if








16


lista_tabu(auxtabu).tipo1.prioridad==lista_tabu(w).tipo1.prioridad &&


lista_tabu(auxtabu).tipo2.prioridad==lista_tabu(w).tipo2.prioridad

retabu=0;

lista_tabu(w).repeticiones=lista_tabu(w).repeticiones+1;

end

end

if retabu==1 %lo añado al principio de la lista tabú

for w=contadormaxtabu:-1:2

lista_tabu(w).zona1.fila=lista_tabu(w-1).zona1.fila;

lista_tabu(w).zona1.columna=lista_tabu(w-

1).zona1.columna;

lista_tabu(w).zona1.altura= lista_tabu(w-

1).zona1.altura;

lista_tabu(w).zona2.fila=lista_tabu(w-1).zona2.fila;

lista_tabu(w).zona2.columna=lista_tabu(w-

1).zona2.columna;

lista_tabu(w).zona2.altura=lista_tabu(w-

1).zona2.altura;

lista_tabu(w).tipo1.peso=lista_tabu(w-1).tipo1.peso;

lista_tabu(w).tipo1.prioridad=lista_tabu(w-

1).tipo1.prioridad;

lista_tabu(w).tipo2.peso=lista_tabu(w-1).tipo2.peso;

lista_tabu(w).tipo2.prioridad=lista_tabu(w-

1).tipo2.prioridad;

end

lista_tabu(1).zona1.fila=lista_tabu(auxtabu).zona1.fila; %% esto es

para la matriz Zonas

lista_tabu(1).zona1.columna=lista_tabu(auxtabu).zona1.columna;

lista_tabu(1).zona1.altura=lista_tabu(auxtabu).zona1.altura;

lista_tabu(1).zona2.fila=lista_tabu(auxtabu).zona2.fila;

lista_tabu(1).zona2.columna=lista_tabu(auxtabu).zona2.columna;

lista_tabu(1).zona2.altura=lista_tabu(auxtabu).zona2.altura;



17


lista_tabu(1).tipo1.peso=lista_tabu(auxtabu).tipo1.peso;

lista_tabu(1).tipo1.prioridad=lista_tabu(auxtabu).tipo1.prioridad;

lista_tabu(1).tipo2.peso=lista_tabu(auxtabu).tipo2.peso;

lista_tabu(1).tipo2.prioridad=lista_tabu(auxtabu).tipo2.prioridad;

end

end

end

1.1.2.8. Mejorsolucion

function [mejorfo,mejorB]=mejorsolucion(pmax,sol)

mejorfo=sol(1).fo;

mejorB=sol(1).B;

for i=1:pmax

if sol(i).fo>mejorfo

mejorfo=sol(i).fo;

mejorB=sol(i).B;

end

end

end

1.1.2.9. Permutar

function B=permutar(af1,ac1,aa1,af2,ac2,aa2,B)

temp=B(af1,ac1,aa1);

B(af1,ac1,aa1)=B(af2,ac2,aa2);% se realiza la permutación.

B(af2,ac2,aa2)=temp;

end

1.1.2.10. Restricciones

function

resultado=restricciones(num_filas,num_columnas,num_alturas,B,num_conte

nedores,lista_62_grande,Q,max_mom)



18


re1=0;

if num_filas*num_columnas*num_alturas>=num_contenedores %nº huecos

mayor que nº contenedores

re1=1;

end

re2=0;

if num_filas*num_columnas*num_alturas-

numel(B(B==0))==num_contenedores % el nº de contenedores asignados es

igual al nº de contenedores

re2=1;

end

re3=0;

pesototal=0; %peso total menos que capacidad

for k=1:num_alturas


for i=1:num_filas

if B(i,j,k)~=0

pesototal=pesototal+lista_62_grande(B(i,j,k),2);

end

end

end

end

if pesototal<=Q

re3=1;

end

%% que el contenedor de abajo pese mas o igual que el de arriba

% se debe englobar en una función aparte, y llamarla desde el programa

% principal

re4=1;

contador_peso=0;

for i=1:num_filas


for k=1:num_alturas-1

if B(i,j,k)~=0 && B(i,j,k+1)~=0

if lista_62_grande(B(i,j,k),2)-

lista_62_grande(B(i,j,k+1),2)<0

re4=0;



19


end

end

if B(i,j,k)==0 && B(i,j,k+1)~=0

re4=0;

end

end

end

end

% para que sea correcto, r4 debe valer 1.

%%%equilibrio de momentos (lateral) por filas,

re5=1;

mom_total31=0;

mom_total2=0;

for k=1:num_alturas

for i=1:num_filas

suma_mom1=0;

suma_mom2=0;

for j=1:num_columnas/2

p=B(i,j,k);% obtenemos el nº del contenedor de dicha

posición, debemos

% buscar su peso, para hallar el momento.

if B(i,j,k)~=0

momento=((num_columnas/2)-j+1)*lista_62_grande(p,2);

suma_mom1=suma_mom1+momento;

end

end

for j=(num_columnas/2)+1:num_columnas

p=B(i,j,k);

if B(i,j,k)~=0

momento=(j-(num_columnas/2))*lista_62_grande(p,2);


end

end



20


mom_total2=mom_total2+suma_mom2-suma_mom1;

end

mom_total31=mom_total31+mom_total2;

if mom_total31>max_mom || mom_total31<-max_mom;

re5=0;

end

end

%%%equilibrio de momentos (longitudinal) por filas,

re6=1;

mom_total32=0;

mom_total2=0;

for k=1:num_alturas


suma_mom1=0;

suma_mom2=0;

for i=1:num_filas/2

p=B(i,j,k);% obtenemos el nº del contenedor de dicha

posición, debemos

% buscar su peso, para hallar el momento.

if B(i,j,k)~=0

momento=((num_filas/2)-i+1)*lista_62_grande(p,2);


end

end

for i=(num_filas/2)+1:num_filas

p=B(i,j,k);

if B(i,j,k)~=0

momento=(i-(num_filas/2))*lista_62_grande(p,2);


end

end

mom_total2=mom_total2+suma_mom2-suma_mom1;

end

mom_total32=mom_total32+mom_total2;

if mom_total32>max_mom || mom_total32<-max_mom

re6=0;

end

end



21


re7=1;% cada contenedor sólo puede estar asignado una vez.


x(i)=numel(B(B==i));

if x(i)~=1

re7=0;

end

end

if re1+re2+re3+re4+re5+re6+re7==7

resultado=1;

else

resultado=0;

end

end

1.1.2.11. Soluciongreedy

function

B=soluciongreedy(num_filas,num_columnas,num_alturas,lista_ordenada_s,n

um_contenedores)

B=zeros(num_filas,num_columnas,num_alturas); % matriz que representa

el barco

kpiso1(num_alturas)=0;




k1=1;

for piso=1:ceil(num_contenedores/(num_filas*num_columnas))

for i=1:num_filas/2 %%% ejemplo de algoritmo para repartir a

partir de a, se rellena cada filas hasta la mitad.


if k1<=num_contenedores

B(i,j,piso)=lista_ordenada_s(k1).num;

k1=k1+4;

end

end

end



22


if piso<ceil(num_contenedores/(num_filas*num_columnas))

k1=(num_filas*num_columnas)*piso;

r1=randi(4);%k1, para la siguiente planta, empieza en una esquina

aleatoria, para hacer más homogenea la solución

k1=k1+r1;

kpiso1(piso)=k1;

end

end

k2=2;


for i=num_filas:-1:(num_filas/2+1)

for j=num_columnas:-1:((num_columnas/2)+1)



k2=k2+4;

end

end

end



p2=k2;

r2=randi(4); % genera nº aleatorio

k2=p2+r2;

kpiso2(piso)=k2;

% se añade esta función que aleatoriamente asigna la esquina por

la que

% se empieza a rellenar, a fin de que la suma de todos los piso

sea lo

% más homogénea posible.

for p=1:piso

while kpiso2(piso)==kpiso1(p)% || kpiso2(piso)==kpiso2(p)

r2=randi(4);

k2=p2+r2;

kpiso2(piso)=k2;

end

end

end



23


end

k3=3;


for i=num_filas:-1:(num_filas/2+1)




k3=k3+4;

end

end

end



p3=k3;

r3=randi(4);

k3=p3+r3;

kpiso3(piso)=k3;

for p=1:piso

while kpiso3(piso)==kpiso2(p) || kpiso3(piso)==kpiso1(p) %||

kpiso3(piso)==kpiso3(p)

r3=randi(4);

k3=p3+r3;

kpiso3(piso)=k3;

end

end

end

end

k4=4;


for i=1:num_filas/2

for j=num_columnas:-1:((num_columnas/2)+1)





24


k4=k4+4;

end

end

end



p4=k4;

r4=randi(4);

k4=p4+r4;

kpiso4(piso)=k4;

for p=1:piso

while kpiso4(piso)==kpiso1(p) || kpiso4(piso)==kpiso2(p) ||

kpiso4(piso)==kpiso3(p) %|| kpiso4(piso)==kpiso4(p)

r4=randi(4);

k4=p4+r4;

kpiso4(piso)=k4;

end

end

end

end

end

1. ANEXOS Código Matlab Programa...

Documents

Transcript of 1. ANEXOS Código Matlab Programa...