Optimization of Location Allocation

710077 Final Project

Nohora España Mejía

Suppose there are customers fixed at locations in the plane given by .

Suppose that there are depots at locations in the plane given by .

Delivery trips are required to customer j at a rate of per year, . The trips per year from depot
i to customer j is denoted by . The round-trip travel cost from i to j is proportional to the Euclidean distance
between and . Minimizing the local travel costs is represented by

Análisis del problema

Para resolver el problema se establece una cantidad de clientes en y una cantidad de depósitos en
. Sus localizaciones en el espacio se determinan con la función random. Por otro lado, también se define
con la función random la tasa anual de viajes de entrega por cliente.

El problema es lineal ya que y son conocidos y fijos tratandose de las localizaciones en el espacio tanto

de clientes como de los depósitos. De esta forma la cantidad será para cada para un
valor fijo y conocido. Así que, lo que se pretende encontrar es la cantidad de viajes desde cada depósito hasta
cada cliente, considerando que se satisfagan la tasa de viajes anual por cada cliente con menor costo, que a su
vez depende de la distancia entre dichos depósitos y los clientes.

Inicialmente, se plantea el uso de linprog como algoritmo de optimización, dado que el problema es lineal de la
forma con límites inferiores. Entonces se tiene:

1
donde corresponde a la matriz de restricciones del problema, el vector t corresponde a la reorganización de
la matriz .

Programación del problema

clear all;
close all;
%------------------ PROBLEM CONDITIONS ------------------%

N = 20; % customers number

M = 5; % depots number
rng(1)
dj = randi([10 50],N,1); % rate per year of deliver trips per customer

cj = rand(N,2); % customers locations

xi = rand(M,2); % depots locations

scatter(cj(:,1),cj(:,2)); hold on
scatter(xi(:,1),xi(:,2),'r')
title('Localización de clientes y depósitos')
xlabel('Coordenada x [x 100Km]')
ylabel('Coordenada y [x 100Km]')
legend('Clientes','Depósitos')

2
 ObjectiveFunction = @objective;

distance = zeros(M,N);
for i = 1 : M
for j = 1 : N
distance(i,j) = ObjectiveFunction(xi(i,:),cj(j,:));
end
end
vec_distance = reshape(distance,N*M,1);

Aeq = zeros(N,N*M);
for k = 1:N
Aeq(k,(k-1)*M+1:k*M) = ones(1,M);
end

beq = dj;
lb = zeros(N*M,1);

Solución 1: linprog

A continuación, a partir de los parámetros del problema se presenta el algoritmo linprog, para el cual, se
obtiene la matriz la cual expresa cuantos viajes se hacen desde el depósito i hasta el cliente j. Para verificar
la la solución obtenida se presenta la matriz de distancias ( ) desde el depósito i hasta el cliente j.

3
 distance

distance = 5×20
0.8324 0.8916 0.3314 0.6421 0.8868 0.7971 0.3731 0.2504
0.5052 0.5606 0.3963 0.3053 0.7266 0.5268 0.4101 0.5269
0.4858 0.3597 0.4473 0.2744 0.4501 0.2111 0.7255 0.6917
0.3891 0.5879 0.6717 0.3186 0.9600 0.6910 0.3311 0.7513
0.8518 0.9324 0.4039 0.6736 0.9574 0.8560 0.3239 0.2931

Por ejemplo, la distancia entre el depósito 1 y el cliente 1 es mientras que la distancia entre el
depósito 4 y el cliente 5 es .

Aquí, se han marcado las mínimas distancias existentes para cada cliente.

%------------------ SOLUTION 1: LINPROG SOLUTION ------------------%

tic
[solution , f_min, exitflag, output] = linprog(vec_distance,[],[],Aeq,beq,lb,[]);

Optimal solution found.

toc

Elapsed time is 0.593336 seconds.

exitflag

exitflag = 1

output

output = struct with fields:

iterations: 0
constrviolation: 0
message: 'Optimal solution found.'
algorithm: 'dual-simplex'
firstorderopt: 0

tij = reshape(solution,M,N)

tij = 5×20
0 0 10 0 0 0 0 24 26 0 27 0 0
0 0 0 0 0 0 0 0 0 0 0 38 0
0 39 0 22 16 13 0 0 0 32 0 0 18
27 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 17 0 0 0 0 0 0

A continuación se indica el vector para verificar que la sumatoria de los viajes por cada cliente desde todos
los depósitos obtenidos en la matriz . De este modo se verifica que el algortimo satisface las restricciones.
Por otro lado, la matriz indica lo siguiente: para el cliente 1 se hacen 27 viajes desde el depósito 4, porque
esta es la menor distancia que existe entre dicho cliente y todos los depósitos.

dj'

ans = 1×20
27 39 10 22 16 13 17 24 26 32 27 38 18

4
La función objetivo evaluada en la solución tiene el siguiente valor.

f_min

f_min = 149.0990

Solución 2: Replicator Dynamics

Un replicador es una unidad fundamental en un proceso evolutivo y es análogo a un individuo en una

población. Este concepto se ha utilizado para modelar diferentes sistemas con agentes dinámicos que
cooperan y compiten en función de su bienestar (o fitness). La función de fitness de un individuo representa
la retribución en este juego evolutivo, que depende de la estrategia propia y de las elegidas por el resto de la
población. La dinámica del replicador se basa en la comparación del fitness de cada individuo con el fitness
promedio de la población. Si es la cantidad de individuos que juegan la i-ésima estrategia de un
conjunto de N estrategias, las ecuaciones del replicador vienen dadas por

Para el problema se define la función fitness como la distancia euclideana negativa entre y .
representa a y será . Se define una condición inicial para el cual se determina la misma cantidad
de viajes desde todos los depósitos a cada uno de los clientes satisfaciendo la restricción con .

%------------------ SOLUTION 2: REPLICATOR DYNAMICS ------------------%

Tspan = 1;
% rng(1)
% tij0 = rand(M,N);
for k = 1:N
for g = 1:M
tij0(g,k) = dj(k)/M;
end
end
iter = 0;
tic
while iter<1000
[t,tij1] = ode23s('objective2',Tspan,tij0,[],N,M,dj,xi,cj);
tij0 = reshape(tij1(length(t)-1,:),M,N);
iter = iter + 1;
end
toc

Elapsed time is 57.818369 seconds.

5
El algoritmo proporciona la siguiente solución para la matriz en la cual se puede apreciar un comportamiento
similar al algortimo anterior. Sin embargo, también se asignan pequeños valores de viajes para distancias
menores pero no mínimas, encontrando así una solución suboptima al problema. La solución también respeta
la restricción con .

tij1 = reshape(tij1(length(t),:),M,N)

tij1 = 5×20
0.0000 0.0002 10.1765 0.0000 0.0000 0.0000 0.7118 19.9770
0.5311 0.3728 0.0294 4.3023 0.0000 0.0000 0.1004 0.0006
1.0145 38.4282 0.0003 15.2028 16.0056 13.0000 0.0000 0.0000
25.4544 0.1987 0.0000 2.4949 0.0000 0.0000 6.5796 0.0000
0.0000 0.0001 0.0149 0.0000 0.0000 0.0000 9.6082 4.0224

sum(tij1)

ans = 1×20
27.0000 39.0000 10.2212 22.0000 16.0056 13.0000 17.0000 24.0000

distance

distance = 5×20
0.8324 0.8916 0.3314 0.6421 0.8868 0.7971 0.3731 0.2504
0.5052 0.5606 0.3963 0.3053 0.7266 0.5268 0.4101 0.5269
0.4858 0.3597 0.4473 0.2744 0.4501 0.2111 0.7255 0.6917
0.3891 0.5879 0.6717 0.3186 0.9600 0.6910 0.3311 0.7513
0.8518 0.9324 0.4039 0.6736 0.9574 0.8560 0.3239 0.2931

for i=1:M
for j=1:N
s(i,j) = tij1(i,j)*distance(i,j);
end
end

La evaluación de la solución en la función objetivo proporcina el siguiente valor

f_val2 = sum(sum(s))

f_val2 = 151.9810

Comparación

Precisión:
Por los resultados de simulación el algortimo linprog tiene un 100% de precisión mientras que para el replicador
la precisión sería del 98% ya que este último encontró una solución suboptima. Cabe aclarar que no se tuvo en
cuenta restricción de número entero de viajes.

Eficiencia:

6
El algoritmo linprog reporta un tiempo de ejecución de 1.037090 segundos tras los cuales encuentra la solución
óptima sin iteraciones. Por otro lado, el replicador toma 1000 iteraciones y 57.818369 segundos en encontrar
una solución subóptima. En este caso, el algortimo linprog es eficiente.

Robustes:
El algoritmo linprog no hace uso de condiciones iniciales predefinidas pero el replicador si, y es altamente
dependiente de ellas, ya que una mala definición de esas condiciones iniciales, por ejemplo: que no satisfagan
la restricción con , provoca que el algortimo no converga o que tome muchas más iteraciones para lograrlo.
Nuevamente, se debe mencionar que el replicador logra encontrar una solución suboptima, confirmando así
que entre los dos algoritmos quien tiene mayor robustes es linprog.

Se adjuntan al presente los códigos usados tanto del LiveScript y las funciones usadas.