Ejercicio de modelaje en un Call center

Germán Riaño
5 de febrero de 2005

A un call center llegan llamadas de acuerdo con un proceso de Poisson de tasa λ. Las llamadas tienen
una duración exponencial de media µ−1 . Hay k agentes atendiendo las llamadas, que trabajan de manera
independiente. El conmutador puede mantener en espera tantas llamadas como sea necesario.

a. Halle la probabilidad de que en estado estable todos los operarios estén ocupados. Respuesta:
k−1
! k−1
!
X rm X rm rk 1
C(k, r) = 1 − / + ,
m=0
m! m=0
m! k! 1 − r/k

donde r = λ/µ = kρ. Nota esta se conoce como la fórmula Erlang-C.

Respuesta:
La probabilidad de que en estado estable todos los operarios estén ocupados es:

C(k, r) = 1 − (p0 + p1 + p2 + . . . + pk−1 ) (1)

pero para la M/M/k se sabe que

ri
pi = p0 para 0 ≤ i ≤ k − 1 (2)
i!
k−1
!−1
X rm rk 1
p0 = + (3)
m=0
m! k! 1 − r/k

reemplazando (2) en (1) se tiene:

r1 r2 rk−1
 
C(k, r) = 1 − p0 1+ + + ... +
1! 2! (k − 1)!
k−1
!
X rm
= 1 − p0 (4)
m=0
m!

reemplazando (3) en (4) se tiene:

k−1
! k−1
!
X rm X rm rk 1
C(k, r) = 1 − / + .
m=0
m! m=0
m! k! 1 − r/k

b. Llamaremos Wq la espera tı́pica de un cliente antes de ser atendido si encuentra el sistema en estado
estable. La distribución de el número de personas que encuentra enfrente un arribo al llegar al sistema
es igual a la distribución de estado estable. esto se conoce como PASTA (Poisson arrivals see time
averages).

1
 Demuestre que
P (Wq > 0) = C(k, r)

Respuesta:
La probabilidad de que un cliente tenga que esperar es la probabilidad de que cuando llegue al sistema
no encuentre servidores disponibles para ser atendido. De acuerdo con la propiedad de pasta esto es
igual a la probabilidad en estado estable todos los servidores estén ocupados, es decir C(k, r).
c. Demuestre que si hay espera esta se distribuye exponencialmente, es decir

P (Wq < t|Wq > 0) = 1 − e−(kµ−λ)t t>0

Respuesta:

Primero se define:

H(t) = P (Wq ≤ t|Wq > 0),

Esta distribución se obtiene condicionando en el número de personas que encuentra un arribo en la

cola ası́:
∞
X
H(t) = P (Wq ≤ t|Wq > 0, i en cola) P (i en cola|Wq > 0) . (5)
i=0
| {z }| {z }
2 1

De la parte 1 de la ecuación (5) se define

qi = P (i en cola|Wq > 0),

que se calcula como sigue

P (i en cola, Wq > 0)
qi =
P (Wq > 0)
P (i + k en el sistema)
=
P (Wq > 0)
pi+k
= i = 0, 1, 2...
C(k, r)
 k k+i 
1 k ρ
= p0
C(k, r) k!
1
= p k ρi . (6)
C(k, r)

En la página 270 del libro de Kulkarni azul se tiene la demostración del siguiente reslutado:

pk
C(k, r) =
1−ρ
pk = (1 − ρ)C(k, r), (7)

reemplazando (7) en (6) se tiene que:

2
 qi = (1 − ρ)ρi i = 0, 1, . . .

Para la componente 2 de (5) razonamos de la siguiente manera. Si hay i en cola cuando llega un cliente
entonces el tiempo en cola para este arribo es la suma de (i + 1) esperas, donde cada una de estas
esperas es el mı́nimo de k exponenciales independientes de parámetro µ, es decir una exponencial de
parámetro kµ. L espera en cola condicional es, por lo tanto la suma de (i + 1) exponenciales que como
se sabe es Erlang, por lo tanto

P (Wq ≤ t|Wq > 0, i en cola) = Fi+1 (t; kµ)

donde Fr (t; λ) es la fda de una Erlang de parámetros r y λ es decir

Z t r r−1 −λx
λ x e
Fr (t; λ) = dx
0 (r − 1)!)

Reemplazando en (5) se tiene que

∞
X
H(t) = Fi+1 (t; kµ) qi .
i=0

Derivando con respecto a t podemos obtener la densidad correspondiente

∞
X (µk)i+1 ti e−µkt
h(t) = (1 − ρ)ρi
i=0
i!
∞
µkt
X (µkρ)i
=e (1 − ρ)µk
i=0
i!
−µkt µktρ
= (1 − ρ)µke e
−µk(1−ρ)t
= (µk)(1 − ρ)e t ≥ 0.

Esta es la fdp de una exponencial de parámetro kµ(1 − ρ) y por lo tanto su fda correspondiente viene
dada por

H(t) = 1 − e−µk(1−ρ)t .

d. Halle EWq .
1 1
EWq = P (Wq > 0)E(Wq |Wq > 0) = C(k, r)
kµ 1 − r/k

Respuesta:
Del numeral b se sabe que:

P (Wq > 0) = C(k, r). (8)

De otro lado se sabe del numeral c se sabe que si hay espera esta se distribuye exponencialmente,
entonces:

1
E(Wq |Wq > 0) = , (9)
(kµ − λ)

3
 λ
además se tiene que r = µ, entonces de la ecuación (9) se tiene que:

1 1
E(Wq |Wq > 0) = , (10)
kµ (1 − kr )

reemplazando (8) y (10) en la ecuación del enunciado se tiene que:

1 1
EWq = C(k, r)
kµ 1 − r/k

e. Halle P (Wq ≤ t). Respuesta:

P (Wq ≤ t) = 1 − C(k, r)e−kµ(1−ρ)t t>0

Respuesta:

P (Wq ≤ t) = P (Wq ≤ t|Wq = 0)P (Wq = 0) + P (Wq ≤ t|Wq > 0)P (Wq > 0)
= 1(1 − C(k, r)) + (1 − e−kµ(1−ρ)t )C(k, r)
= 1 − C(k, r)e−kµ(1−ρ) .

f. Cierto call center abre 9 horas al dı́a de 8 a 5 pm y las tasa de llamadas en cada hora se pueden ver
en la siguiente tabla.
Horas Tasa
8:00 - 9:00 40
9:00 - 10:00 50
10:00 -11:00 70
11:00 - 12:00 110
12:00 - 1:00 120
1:00 - 2:00 30
2:00 - 3:00 20
3:00 - 4:00 10
4:00 - 5:00 10
Se ha observado que la duración de las llamadas se puede ajustar con una distribución exponencial
de media 3 minutos. Se quiere tener un nivel de servicio que garantice que el 95 % de los clientes
esperen menos de 20 segundos a ser atendidos. Determine el mı́nimo número de agentes que se deben
programar en cada hora para satisfacer este requerimiento de servicio. Suponga que en cada hora la tasa
es constante a lo largo de la hora y que se logra estado estable de modo que pueda usar las ecuaciones
anteriores. Ayuda: comience por determinar para cada intervalo el número de agentes necesarios para
que el sistema sea estable, y aumente esta cantidad hasta lograr el nivel de servicio requerido.
Respuesta:
Comenzamos por elaborar un pequeño código en VBA que implementa la fórmula Erlang-C. Refiérase al
apéndice ?? para verlo, en la función ErlangC_PWait. En esta función la expresión With WorksheetFunction
permite usar las funciones de excel con solo poner un punto. Fı́jese que la fórmula se calcula en términos

4
 de la acumulativa de la distribución Poisson como
k−1
! k−1
!
X rm X rm rk 1
C(k, r) = 1 − / +
m=0
m! m=0
m! k! 1 − r/k
rk 1
k! 1−r/k
= Pk−1 rm rk 1
m=0 m! + k! 1−r/k
r k e−r
= Pk−1
k!
r m e−r r k e−r
Mult. por (1 − ρ)e−r
(1 − ρ) m=0 m!+ k!
F (k; r) − F (k − 1; r)
=
F (k; r) − ρF (k − 1; r)

donde F (n; r) es la fda de la distribución Poisson con media r evaluada en n. En el código de vba
se usa la función PoissonCDF para calcular la acumulativa. Dicha función invoca la función de Excel,
pero si falla se aproxima usando la normal. Esto ocurre para parámetros r grandes pues exp−r se hace
muy pequeño, pero es precisamente para esos valores para los cuales
 
x + 0,5 − r
F (x; r) ' Φ √
r
. El 0,5 viene del hecho que estamos aproximando una distribución discreta con una continua. Usando
esta función se calcula la Tabla 1 (Ud encontrará en Sicua la hoja de Excel con los cálculos).

Horas λ µ r k-estab k ρ C(k, r) P (W q <= 20s)

8:00 - 9:00 40 20 2.00 3 5 0.400 0.0597 0.9572
9:00 - 10:00 50 20 2.50 3 6 0.417 0.0474 0.9678
10:00 -11:00 70 20 3.50 4 8 0.438 0.0299 0.9819
11:00 - 12:00 110 20 5.50 6 10 0.550 0.0628 0.9619
12:00 - 1:00 120 20 6.00 7 11 0.545 0.0492 0.9718
1:00 - 2:00 30 20 1.50 2 5 0.300 0.0201 0.9863
2:00 - 3:00 20 20 1.00 2 4 0.250 0.0204 0.9854
3:00 - 4:00 10 20 0.50 1 3 0.167 0.0152 0.9885
4:00 - 5:00 10 20 0.50 1 3 0.167 0.0152 0.9885

Tabla 1: Resultados para el modelo Erlang-C

La columna k-estab contiene el número de agentes necesarios para que el sistema sea estable. Incre-
mentamos k a partir de dichos valores hasta lograr el nivel de servicio deseado (95 %). Esto no es difı́cil
de hacer a mano, pero esta implementado en ErlangC_minAgentes en el Apéndice ??.
g. Los agentes son estudiantes que trabajan turnos de 4 horas contiguas. Determine el número de estu-
diantes que debe contratar y la asignación de horas. Use cualquier software de programación lineal
entera, o el solver de Excel.
Respuesta:
Construiremos un MIP con los siguientes parámetros
T = Número de periódos
L = Duración de los turnos (en nuestro caso 4)
Rt = Agentes requeridos en periodo t
Llamaremos xt el número de agentes que comienzan su turno en el perı́odo t. Dichos agentes estarán
activos en t, t + 1, . . . , t + L − 1. El último perı́odo en el cuál pueden comenzar es en t − L + 1. La
función objetivo es minimizar el número de agentes contratados:
T −L−1
X
xt
t=1

5
Debemos garantizar que el número de agentes en el periodo t sea mayor a los requeridos Rt . En un
periodo tı́pico t están trabajando aquellos contratados en ese periodo más los contratados en t − 1,
t − 2 t − 3 y t − 4. Es decir, el número de agentes en el periodo t se puede escribir como
Mt
X
xs ,
s=mt

donde m = mı́n(1, t − L + 1) y M = máx(t, T − L + 1). Para mayor claridad escribimos explı́citamente

las restricciones
x1 ≥ R1
x1 + x2 ≥ R2
x1 + x2 + x3 ≥ R3
x1 + x2 + x3 + x4 ≥ R4
x2 + x3 + x4 + x5 ≥ R5
x3 + x4 + x5 + x6 ≥ R6
x4 + x5 + x6 ≥ R7
x5 + x6 ≥ R8
x6 ≥ R9

El modelo se puede escribir ası́

T −L−1
X
Minimizar z= xt
t=1
Mt
X
sujeto a xs ≥ Rt t = 1, . . . , T Requerimento de agentes
s=mt

xt ∈ Z +

A continuación mostramos el modelo resuelto en Xpress-MP y el resultado arrojado

Archivo callcenter.mos
( ! ******************************************************

f i l e c a l l c e n t e r . mos
‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘
******************************************************* ! )

model ” C a l l c e n t e r ”
uses ”mmxprs”

parameters
i n p u t F i l e=” . / c a l l c e n t e r . dat ”
o u t p u t F i l e =” . / c a l l c e n t e r . t x t ”
end−parameters

forward function g e t P r o b l e m S t a t u s ( s t a t u s : integer ) : s t r i n g

declarations
! Conjuntos
PERIODOS : set of integer ! Rango de p e r i o d o s de tiempo
! Parámetros
MinAgentes : array (PERIODOS) of integer ! Minimo numero de a g e n t e s
L : integer ! Numero de t u r n o s c o n t i g u o s
! Var d e c i s i ó n
s t a r t s : array (PERIODOS) of mpvar ! a g e n t e s que comienzan en t

6
 end−declarations

i n i t i a l i z a t i o n s from i n p u t F i l e
PERIODOS MinAgentes L
end−i n i t i a l i z a t i o n s

! Numero de p e r i o d o s
T := g e t s i z e (PERIODOS ) ;

! Creamos l a v a r i a b l e s ó l o para l o s p r i m e r o s T−L p e r i o d o s

! p ue s no pueden comenzar más t a r d e
f o r a l l ( t i n PERIODOS | t <= T − L + 1 ) do
create ( starts ( t ) ) ;
! starts ( t ) is integer ;
end−do

! O b j e t i v o : minimizar numero de a g e n t e s
TotAgentes := sum( t i n PERIODOS | t <= T − L + 1 ) s t a r t s ( t )

! Minimos deben s e r s a t i s f e c h o s :
f o r a l l ( t i n PERIODOS) do
mn := m a x l i s t ( 1 , t−L+1);
mx := m i n l i s t ( t , T−L+1)
r e q ( t ):= sum( s i n mn . . mx) s t a r t s ( s ) >= MinAgentes ( t )
end−do

! R e s u e l v a e l problema
minimize ( TotAgentes )
! Genere e l r e p o r t e
i f ( o u t p u t F i l e <>” ” ) then
f o p e n ( o u t p u t F i l e ,F OUTPUT)
end−i f
writeln ( ” S t a t u s : ” , g e t P r o b l e m S t a t u s ( g e t p r o b s t a t ) ) ;
writeln ( ”Numero T o t a l de Agentes : ” , g e t o b j v a l ) ;
writeln ;
writeln ( ” P e r i o d o Comz Tot Req” )
f o r a l l ( t i n PERIODOS) do
write ( s t r f m t (PERIODOS( t ) , 6 ) )
write ( s t r f m t ( g e t s o l ( s t a r t s ( t ) ) , 8 ) )
write ( s t r f m t ( MinAgentes ( t )− g e t s l a c k ( r e q ( t ) ) , 8 ) )
writeln ( s t r f m t ( g e t s o l ( MinAgentes ( t ) ) , 8 ) )
end−do
f c l o s e (F OUTPUT)

! returns function status

function g e t P r o b l e m S t a t u s ( s t a t u s : integer ) : s t r i n g
case s t a t u s of
XPRS OPT : r e t u r n e d := ” S o l v e d t o o p t i m a l i t y . ”
XPRS UNF : r e t u r n e d := ” U n f i n i s h e d . ”
XPRS INF : r e t u r n e d := ” I n f e a s i b l e . ”
XPRS UNB : r e t u r n e d := ”Unbounded . ”
e l s e r e t u r n e d := ”Unknown s t a t u s . ”
end−case
end−function

end−model

7
 Archivo callcenter.txt
S t a t u s : S o l v e d to o p t i m a l i t y .
Numero T o t a l de Agentes : 19

Periodo Comz Tot Req

1 5 5 5
2 1 6 6
3 2 8 8
4 2 10 10
5 6 11 11
6 3 13 5
7 0 11 4
8 0 9 3
9 0 3 3

Podemos ver que la solución óptima usará 19 agentes. La columna Comz dice cuántos deben comenzar
por turno, mientras que la columna Tot contiene el número disponible en ese turno.
También solucionamos el problema usando el solver de Excel, y encontró una solución alterna también
con 19 agentes. El archivo está disponible en Sicua para consulta. La solución de excel está en la Tabla
2.

Horas #ope q comz 8-9 9 - 10 10 -11 11 - 12 12 - 1 1-2 2-3 3-4 4-5

8:00 - 9:00 5 5 5 5 5
9:00 - 10:00 5 5 5 5 5
10:00 -11:00 2 2 2 2 2
11:00 - 12:00 2 2 2 2 2
12:00 - 1:00 2 2 2 2 2
1:00 - 2:00 3 3 3 3 3
TOTAL 19 5 10 12 14 11 9 7 5 3
NECESARIOS 5 6 8 10 11 5 4 3 3

Tabla 2: Disposición de agentes óptima encontrada por Excel.

Aunque las dos soluciones usan el mismo número de agentes, vale la pena compararlas en cuanto a la
calidad de servicio que ofrecen para ver cuál es preferible. Al ver la Tabla 3 vemos que la de Excel
ofrece niveles de servicio ligeramente superiores.

Xpress Excel
Horas λ µ r k C(k, r) P (W q <= 20s) k C(k, r) P (W q <= 20s)
8:00 - 9:00 40 20 2.00 5 5.970 % 95.722 % 5 5.970 % 95.722 %
9:00 - 10:00 50 20 2.50 6 4.744 % 96.784 % 10 0.029 % 99.987 %
10:00 -11:00 70 20 3.50 8 2.989 % 98.187 % 12 0.030 % 99.988 %
11:00 - 12:00 110 20 5.50 10 6.279 % 96.192 % 14 0.179 % 99.930 %
12:00 - 1:00 120 20 6.00 11 4.922 % 97.176 % 11 4.922 % 97.176 %
1:00 - 2:00 30 20 1.50 13 0.000 % 100.000 % 9 0.003 % 99.999 %
2:00 - 3:00 20 20 1.00 11 0.000 % 100.000 % 7 0.009 % 99.996 %
3:00 - 4:00 10 20 0.50 9 0.000 % 100.000 % 5 0.018 % 99.989 %
4:00 - 5:00 10 20 0.50 3 1.515 % 98.852 % 3 1.515 % 98.852 %
PROM 4.308 % 97.330 % 1.888 % 98.846 %

Tabla 3: Comparación de los resultados de Excel y Xpress

8
h. Suponga ahora que los agentes se contratan por 4 horas diarias, pero no necesariamente contiguas,
pues puede haber una interrupción de hasta una hora. Genere un nuevo programa de turnos.
Respuesta:
Definimos las siguientes cantidades
i = periodos,i ∈ {1, . . . , T }
j = turnos, j ∈ {1, . . . , M }
Aij = 1(El turno j cubre el periodo i)
Ri = Numero requerido de agentes en periodo i
xj = número de agentes contratados para el turno j
La matriz A se arma buscando los posibles turnos que satisfacen el requerimiento de la interrupción.
Nosotros encontramos 21 turnos que se pueden ver en la Tabla 5:
El modelo a resolver es el siguiente.

T
X
Minimizar z= ci xi
i=1
M
X
sujeto a Aij xj ≥ Ri i = 1, . . . , T Requerimiento de agentes
j=1

xj ∈ Z +

A continuación mostramos la implementación en Xpress, ası́ como les resultados obtenidos. Podemos
ver que la solución usa 14 agentes, es decir una reducción de 5 agentes respecto a la solución original.

Archivo callcenter2.mos
( ! ******************************************************

f i l e c a l l c e n t e r 2 . mos
‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘
En e s t e modelo s e hace e l s c h e d u l i n g usando e l e n f o q u e
de s e t c o v e r i n g .
Germán Riaño . U n i v e r s i d a d de l o s Andes
******************************************************* ! )

model ” C a l l c e n t e r ”
uses ”mmxprs”

parameters
i n p u t F i l e=” . / c a l l c e n t e r 2 . dat ”
outputFile = ” ./ callce nte r2 . txt ”
end−parameters

forward function g e t P r o b l e m S t a t u s ( s t a t u s : integer ) : s t r i n g

declarations
! Conjuntos
PERIODOS : set of integer ! Rango de p e r i o d o s de tiempo
TURNOS: set of integer
! Parámetros
MinAgentes : array (PERIODOS) of integer ! Minimo numero de a g e n t e s
A: array (PERIODOS,TURNOS) of integer !A( i , j )=1 s i t u r r n o j c u b r e i
Costo : array (TURNOS) of r e a l
end−declarations

9
 i n i t i a l i z a t i o n s from i n p u t F i l e
PERIODOS TURNOS MinAgentes A Costo
end−i n i t i a l i z a t i o n s

! Var de d e c i s i o n
declarations
a g e n t e s : array (TURNOS) of mpvar ! a g e n t e s que comienzan en t
end−declarations

f o r a l l ( j i n TURNOS) a g e n t e s ( j ) i s i n t e g e r

! O b j e t i v o : minimizar C o s t o s
TotCosto := sum( j i n TURNOS) Costo ( j ) * a g e n t e s ( j )

! Minimos deben s e r s a t i s f e c h o s :
f o r a l l ( t i n PERIODOS) do
r e q ( t ):= sum( j i n TURNOS| A( t , j )=1) a g e n t e s ( j ) >= MinAgentes ( t )
end−do

! R e s u e l v a e l problema
minimize ( TotCosto )
! Genere e l r e p o r t e
i f ( o u t p u t F i l e <>” ” ) then
f o p e n ( o u t p u t F i l e ,F OUTPUT)
end−i f
writeln ( ” S t a t u s : ” , g e t P r o b l e m S t a t u s ( g e t p r o b s t a t ) ) ;
writeln ( ” Costo T o t a l : ” , g e t o b j v a l ) ;
writeln ( ”Numero T o t a l de Agentes : ” , sum( j i n TURNOS) g e t s o l ( a g e n t e s ( j ) ) ) ;
writeln ;
writeln ( ” P e r i o d o Total Req” )
f o r a l l ( t i n PERIODOS) do
write ( s t r f m t (PERIODOS( t ) , 6 ) )
write ( s t r f m t ( MinAgentes ( t )− g e t s l a c k ( r e q ( t ) ) , 8 ) )
writeln ( s t r f m t ( g e t s o l ( MinAgentes ( t ) ) , 8 ) )
end−do
writeln ;
writeln ( ”Turno Agentes ”)
! f o r a l l ( j i n TURNOS| g e t s o l ( a g e n t e s ( j )) >0) do
f o r a l l ( j i n TURNOS) do
write ( s t r f m t (TURNOS( j ) , 6 ) )
writeln ( s t r f m t ( g e t s o l ( a g e n t e s ( j ) ) , 8 ) )
end−do
f c l o s e (F OUTPUT)

! returns function status

function g e t P r o b l e m S t a t u s ( s t a t u s : integer ) : s t r i n g
case s t a t u s of
XPRS OPT : r e t u r n e d := ” S o l v e d t o o p t i m a l i t y . ”
XPRS UNF : r e t u r n e d := ” U n f i n i s h e d . ”
XPRS INF : r e t u r n e d := ” I n f e a s i b l e . ”
XPRS UNB : r e t u r n e d := ”Unbounded . ”
e l s e r e t u r n e d := ”Unknown s t a t u s . ”
end−case
end−function

end−model

10
 Archivo callcenter2.txt
S t a t u s : S o l v e d to o p t i m a l i t y .
Costo T o t a l : 14
Numero T o t a l de Agentes : 14

Periodo Total Req

1 5 5
2 6 6
3 8 8
4 10 10
5 11 11
6 5 5
7 4 4
8 4 3
9 3 3

Turno Agentes
1 2
2 2
7 2
11 2
12 1
13 1
14 1
20 2
21 1

Obtuvimos también la solución usando el Solver de Excel. La solución encontrada también tiene 14
agentes, pero es ligeramente diferente de la de Xpress, se puede ver en la Tabla 6. Las comparamos
ambas y se puede ver la comparación en la Tabla 4. De nuevo la de Excel es ligeramente superior en
su desempeño.

Xpress Excel
Horas λ µ r k C(k, r) P (W q <= 20s) k C(k, r) P (W q <= 20s)
8:00 - 9:00 40 20 2.00 5 5.970 % 95.722 % 6 1.869 % 98.802 %
9:00 - 10:00 50 20 2.50 6 4.744 % 96.784 % 6 4.744 % 96.784 %
10:00 -11:00 70 20 3.50 8 2.989 % 98.187 % 8 2.989 % 98.187 %
11:00 - 12:00 110 20 5.50 10 6.279 % 96.192 % 10 6.279 % 96.192 %
12:00 - 1:00 120 20 6.00 11 4.922 % 97.176 % 11 4.922 % 97.176 %
1:00 - 2:00 30 20 1.50 5 2.014 % 98.635 % 5 2.014 % 98.635 %
2:00 - 3:00 20 20 1.00 4 2.041 % 98.538 % 4 2.041 % 98.538 %
3:00 - 4:00 10 20 0.50 4 0.181 % 99.878 % 3 1.515 % 98.852 %
4:00 - 5:00 10 20 0.50 3 1.515 % 98.852 % 3 1.639 % 98.758 %
PROM 4.532 % 97.175 % 4.207 % 97.418 %

Tabla 4: Comparación entre la soluciones de Xpress y Excel para el problema con turnos flexibles

11
 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
8:00 - 9:00 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0
9:00 - 10:00 1 1 0 0 0 0 0 1 0 0 0 1 1 0 0 0 1 1 0 0 0
10:00 -11:00 1 1 1 0 0 0 1 0 1 0 0 0 1 1 0 0 1 1 1 0 0
11:00 - 12:00 1 1 1 1 0 0 1 1 0 1 0 1 0 1 1 0 0 1 1 1 0
12:00 - 1:00 0 1 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1
1:00 - 2:00 0 0 1 1 1 1 0 1 1 1 0 0 1 1 0 1 0 1 0 1 1
2:00 - 3:00 0 0 0 1 1 1 0 0 1 1 1 0 0 1 1 0 0 0 1 0 1
3:00 - 4:00 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 0
4:00 - 5:00 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1

Tabla 5: Posibles turnos con hasta una hora de interrupción

12
# Turno 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 TOT REQ
#ope en turno 3 0 2 1 - - 2 2 - 0 3 - - - - - 1 - - - - 14
8:00 - 9:00 3 - - - - - 2 - - - - - - - - - 1 - - - - 6 5
9:00 - 10:00 3 0 - - - - - 2 - - - - - - - - 1 - - - - 6 6
10:00 -11:00 3 0 2 - - - 2 - - - - - - - - - 1 - - - - 8 8
11:00 - 12:00 3 0 2 1 - - 2 2 - 0 - - - - - - - - - - - 10 10
12:00 - 1:00 - 0 2 1 - - 2 2 - - 3 - - - - - 1 - - - - 11 11
1:00 - 2:00 - - 2 1 - - - 2 - 0 - - - - - - - - - - - 5 5
2:00 - 3:00 - - - 1 - - - - - 0 3 - - - - - - - - - - 4 4
3:00 - 4:00 - - - - - - - - - 0 3 - - - - - - - - - - 3 3
4:00 - 5:00 - - - - - - - - - - 3 - - - - - - - - - - 3 3

Tabla 6: Solución para el problema de turnos flexibles encontrada con el solver de excel. Usa un total de 14 agentes
.
 i. Suponga ahora que se tiene en cuenta la impaciencia de los clientes. En particular suponga que la
impaciencia es exponencial con media de 1.5 minutos. Calcule el número agentes necesarios para que
el nivel de servicio se mantenga.
Respuesta:
De acuerdo con la información dada θ = 60/1,5 = 40 por hora. Implementamos las fórmulas de
Mandelbaum y Zeltyn para el modelo M/M/k + G, para el caso exponencial. En el Apéndice A se
puede ver el código usado. En la Tabla 7 se puede ver los resultados obtenidos. El nivel de servicio
acá se calcula como P {W < t}, es decir para todos los clientes (contando los que abandonan). Si Ud
usa el calculador Erlang-X disponible en http://www.math.vu.nl/∼koole/ccmath/ErlangX.php Ud.
obtendrá resultados ligeramente diferentes, pues allı́ calculan el nivel de servicio como P {V < t}, es
decir usando tiempo virtual. Si el porcentaje de abandonos no es muy alto estas dos cantidades no
diferirán mucho. Podemos concluir que al tener en cuenta los abandonos se necesita un agente menos
entre las 10 y las 3 de la tarde, lo cuál puede significar un ahorro.
Lo único en el código de VBA que amerita mención es el cálculo de la función gamma imcompleta
Z b
γ(a, b) = ta−1 e−t dt.
0
Excel no tiene una función para la gamma incompleta, pero tiene la función de distribución gamma
Z x α−1 −t/β
t e
F (x; α, β) = α Γ(α)
dt.
0 β
Es fácil ver que la gamma incompleta se puede calcular como
γ(a, b) = Γ(a) × F (b; a, 1).
Excel no tiene Γ(a), pero sı́ GammaLn, que calcula su logaritmo.

Horas λ µ θ r k-estab k ρ P {wait > 0} P {Abandon} P (W q <= 20s)

8:00 - 9:00 40 20 40 2.00 3 5 0.400 4.9354 % 1.6507 % 97.4084 %
9:00 - 10:00 50 20 40 2.50 3 6 0.417 3.9364 % 1.1877 % 98.0716 %
10:00 -11:00 70 20 40 3.50 4 7 0.500 6.0290 % 1.7220 % 97.1476 %
11:00 - 12:00 110 20 40 5.50 6 9 0.611 9.5657 % 2.4947 % 95.7534 %
12:00 - 1:00 120 20 40 6.00 7 10 0.600 7.6311 % 1.8536 % 96.8198 %
1:00 - 2:00 30 20 40 1.50 2 4 0.375 6.1677 % 2.3248 % 96.5220 %
2:00 - 3:00 20 20 40 1.00 2 3 0.333 7.5903 % 3.3014 % 95.3912 %
3:00 - 4:00 10 20 40 0.50 1 3 0.167 1.4001 % 0.5843 % 99.1730 %
4:00 - 5:00 10 20 40 0.50 1 3 0.167 1.4001 % 0.5843 % 99.1730 %

Tabla 7: Cálculos para el modelo Erlang A

j. Haga un estudio de simulación para corroborar sus resultados.

Respuesta:

Hicimos un modelo en Arena (archivo callcenter.doe) y corrimos optquest (archivo callcenter.opt)

variando el número de personas en cada hora. La Tabla 9 muestra las mejores soluciones encontradas
por OptQuest. La mejor solución usa 42 operarios-hora con un TSF de %95,31, mientras que la nuestra
recomendaba 55. En la Tabla 8 se pueden ver algunos de los resultados pertinentes. Nuestra hoja de
cálculo predice 92,2707 % para la configuración encontrada por Arena. La razón para la discrepancia
es que nuestro análisis usa ecuaciones de estado estable mientas que la simulación tiene en cuenta
que cuando la tasa sube al sistema le toma un tiempo saturarse. ¿Quiere esto decir que los resultados
analı́ticos deben desecharse? No. Por una lado los usamos de punto de partida para el OptQuest, lo
cuál ayudo a que la convergencia fuese más rápido. Pero además los resultados analı́ticos los obtuvimos
rápidamente en una hoja de cálculo, mientras que la simulación requirió mas tiempo para hacer el
modelo y para correr (ya usando software especializado que tiene un costo mayor).

13
 Output Average Half Width
Espera en Cola en min 2.7242 0.17
Numero Promedio en Cola 0.04128384 0
Porcentaje de Abandonos 5.8845 0.32
TSF 95.3471 0.32

Tabla 8: Resultados de la simulación

14
Simulation MinimizeTotal TSF Cap[9] Cap[8] Cap[7] Cap[6] Cap[5] Cap[4] Cap[3] Cap[2] Cap[1] Total
1 52 97.5591 3 3 3 4 10 9 9 6 5 52
12 48 97.079 3 1 3 2 10 9 9 6 5 48
21 46 95.815 3 1 3 2 9 9 10 4 5 46
38 43 95.3691 2 1 3 2 11 9 8 4 3 43
Best: 152 42 95.3196 2 1 3 2 9 9 8 5 3 42

Tabla 9: Resultados de la simulación con Arena + OptQuest. Las cantidades Cap[i] representan el número de servidores disponibles en el periodo i.
Para cada escenario se corren suficientes replicaciones que garanticen intervalos de confianza del 95 % no sean más anchos que el 2 % de la media (es
decir el intervalo a lo sumo del 4 % de la media)
A. Código de VBA

Archivo CallCenters.bas
A t t r i b u t e VB Name = ” C a l l C e n t e r s ”
Option E x p li c i t
’ UTILITY FUNCTIONS

’ I n c o m p l e t e gamma F u n c t i o n
Function gammaInc ( x , y )
With WorksheetFunction
gammaInc = . GammaDist ( y , x , 1 , True ) * Exp ( . GammaLn( x ) )
End With
End Function
’ F a i l −s a f e P o i s s o n CDF
Public Function PoissonCDF ( n , mean )
On Error GoTo UseNormal
PoissonCDF = WorksheetFunction . P o i s s o n ( n , mean , True )
Exit Function
UseNormal :
PoissonCDF = WorksheetFunction . NormDist ( n + 0 . 5 , mean , Sqr ( mean ) , True )
End Function

’ERLANG−C FUNCTIONS

’P(W>0) i n an E r l a n g C
Public Function ErlangC PWait ( k , r )
Dim numer , deno
With WorksheetFunction
numer = PoissonCDF ( k , r ) − PoissonCDF ( k − 1 , r )
deno = PoissonCDF ( k , r ) − ( r / k ) * PoissonCDF ( k − 1 , r )
End With
ErlangC PWait = numer / deno
End Function

’ Telephone s e r v i c e f a c t o r P(W<t )
Public Function ErlangC TSF ( k , r , mu, t )
Dim rho As Double
ErlangC TSF = 1# − ErlangC PWait ( k , r ) * Exp( −(k − r ) * mu * t )
End Function
’ Number o f a g e n t s needed f o r TSF
Public Function ErlangC minAgents ( r , mu, TSF , t a r g e t T i m e )
Dim k As Integer
With WorksheetFunction
k = . RoundUp ( r , 0 )
I f k = r Then k = k + 1
While ErlangC TSF ( k , r , mu, t a r g e t T i m e ) < TSF
k = k + 1
Wend
End With
ErlangC minAgents = k
End Function

’ASA= a v e r a g e s p e e d answer = Wating i n Q

Public Function ErlangC ASA ( r , mu, k )
Dim rho , Lq , Wq
rho = r / k
Lq = ErlangC PWait ( k , r ) * rho / ( 1 − rho )
Wq = Lq / (mu * rho )

15
ErlangC ASA = Wq
End Function

’ERLANG A FUNCTIONS
’ From Mandelbaum and Z e l t y n

Function ErlangA J ( lambda , mu, t h e t a , k )

Dim lambdaOtheta
lambdaOtheta = lambda / t h e t a
ErlangA J = Exp( lambdaOtheta ) / t h e t a *
WorksheetFunction . Power ( lambdaOtheta , −k * mu / t h e t a ) *
gammaInc ( k * mu / t h e t a , lambdaOtheta )
End Function
Function E r l a n g A J t ( lambda , mu, t h e t a , k , t )
Dim lambdaOtheta
lambdaOtheta = lambda / t h e t a
E r l a n g A J t = Exp( lambdaOtheta ) / t h e t a *
WorksheetFunction . Power ( lambdaOtheta , −k * mu / t h e t a ) *
gammaInc ( k * mu / t h e t a , lambdaOtheta * Exp(− t h e t a * t ) )
End Function
Function ErlangA JH ( lambda , mu, t h e t a , k , J )
Dim lambdaOtheta
lambdaOtheta = lambda / t h e t a
ErlangA JH = J / t h e t a −
Exp( lambdaOtheta ) / t h e t a / t h e t a *
WorksheetFunction . Power ( lambdaOtheta , −k * mu / t h e t a − 1 ) *
gammaInc ( k * mu / t h e t a + 1 , lambdaOtheta )
End Function
Function ErlangA JHt ( lambda , mu, t h e t a , k , Jt , t )
Dim lambdaOtheta
lambdaOtheta = lambda / t h e t a
ErlangA JHt = J t / t h e t a −
Exp( lambdaOtheta ) / t h e t a / t h e t a *
WorksheetFunction . Power ( lambdaOtheta , −k * mu / t h e t a − 1 ) *
gammaInc ( k * mu / t h e t a + 1 , lambdaOtheta * Exp(− t h e t a * t ) )
End Function

Function ErlangA E ( lambda , mu, k )

Dim Ei As Double , muOLambda As Double , i As Integer

muOLambda = mu / lambda
Ei = 1 ’ E s t e e s E0
For i = 1 To k − 1
Ei = 1 + i * muOLambda * Ei
Next i
ErlangA E = Ei
End Function

Public Function ErlangA PAbandon ( lambda , mu, k , t h e t a )

Dim J , E
J = ErlangA J ( lambda , mu, t h e t a , k )
E = ErlangA E ( lambda , mu, k )
ErlangA PAbandon = ( 1 + ( lambda − k * mu) * J ) / (E + lambda * J )
End Function

Public Function ErlangA TSF ( lambda , mu, t h e t a , k , time )

Dim J , E , Jt , Gbt
J = ErlangA J ( lambda , mu, t h e t a , k )
J t = E r l a n g A J t ( lambda , mu, t h e t a , k , time )

16
 E = ErlangA E ( lambda , mu, k )
Gbt = Exp(− t h e t a * time )
ErlangA TSF = 1 − lambda * Gbt * J t / (E + lambda * J )
End Function
Public Function ErlangA PWait ( lambda , mu, t h e t a , k )
Dim J , E
J = ErlangA J ( lambda , mu, t h e t a , k )
E = ErlangA E ( lambda , mu, k )
ErlangA PWait = lambda * J / (E + lambda * J )
End Function

’ Number o f a g e n t s needed f o r TSF

Public Function ErlangA minAgents ( lambda , mu, t h e t a , TSF , t a r g e t T i m e )
Dim k As Integer
With WorksheetFunction
k = 1
While ErlangA TSF ( lambda , mu, t h e t a , k , t a r g e t T i m e ) < TSF
k = k + 1
Wend
End With
ErlangA minAgents = k
End Function

17