Objectif : créer et travailler sur une file
Première partie : Création de la fonction renvoyant la dataframe pour la file
library(ggplot2)
library(plyr)
set.seed(1)
# Création de la fonction pour la simulation de files L => type de loi : -
# EXP => exponentielle - ERL => erlang - UNIF => unifmorme - DET =>
# deterministe
simulation_file <- function(N, l, m, L) {
# temps d'attente entre deux arrivees
a <- rexp(N, rate = l)
# temps de traitement du serveur
s <- c()
if (L == "EXP") {
s <- rexp(N, m)
} else if (L == "ERL") {
s <- rgamma(N, shape = 1, rate = 1)
} else if (L == "UNIF") {
s <- runif(N, 0, m)
} else if (L == "DET") {
for (i in 1:N) {
s[i] <- 1
}
}
t1 <- c()
t2 <- c()
t1[1] <- 0
t2[1] <- t1[1] + s[1]
for (i in 2:N) {
# le moment d'arrivee du client
t1[i] <- t1[i - 1] + a[i]
# le moment de sortie, soit le serveur est pres, soit on doit attendre
t2[i] <- max(t2[i - 1], t1[i]) + s[i]
}
df <- data.frame(ENTREE = t1, SORTIE = t2, TEMPST = (t2 - t1), LAMBDA = l,
LOI = L)
df
}
J'effectue plusieurs tests de lois pour la fonction créée précédemment. Des doutes persistent cependant sur les lois d'erlang et déterministe, notamment sur leur utilisation. Pour les choix “techniques”, j'ai décidé d'augmenter le nombre de valeurs lorsque ma courbe commence à avoir une forte fluctuation, pour mieux voir l'évolution de celle-ci.
Pour la loi uniforme, j'ai fixé N à 100, car j'obtenais un petit intervalle de confiance, cela ne me semblait pas nécessaire d'augmenter la valeur.
Pour les autres lois en revanche, j'ai coupé la courbe en deux, car celle-ci s'apparente à une courbe exponentielle. De 0 à 0.6 pour lambda, j'ai utilisé un N de 400 avec un pas de 0.05 pour lambda, car j'obtiens des résultats corrects (un petit intervalle de confiance) et je ne remarque pas d'augmentation rapide de la courbe de la pente. En revanche, aux alentours de lambda = 0.6, la courbe grimpe rapidement. J'ai augmenté N ainsi que le pas de lambda pour mieux voir l'évolution de la courbe.
mon_res <- data.frame()
# Loi exponentielle
lambda_values = seq(from = 0.1, to = 0.6, by = 0.05)
for (i in 1:length(lambda_values)) {
mon_res <- rbind(mon_res, simulation_file(400, lambda_values[i], 1, "EXP"))
}
lambda_values = seq(from = 0.6, to = 1, by = 0.01)
for (i in 1:length(lambda_values)) {
mon_res <- rbind(mon_res, simulation_file(1000, lambda_values[i], 1, "EXP"))
}
# Loi uniforme
lambda_values = seq(from = 0.1, to = 1, by = 0.05)
for (i in 1:length(lambda_values)) {
mon_res <- rbind(mon_res, simulation_file(100, lambda_values[i], 1, "UNIF"))
}
# Loi Erlang
lambda_values = seq(from = 0.1, to = 0.7, by = 0.05)
for (i in 1:length(lambda_values)) {
mon_res <- rbind(mon_res, simulation_file(400, lambda_values[i], 1, "ERL"))
}
lambda_values = seq(from = 0.7, to = 1, by = 0.01)
for (i in 1:length(lambda_values)) {
mon_res <- rbind(mon_res, simulation_file(1000, lambda_values[i], 1, "ERL"))
}
# loi deterministe
lambda_values = seq(from = 0.1, to = 0.7, by = 0.05)
for (i in 1:length(lambda_values)) {
mon_res <- rbind(mon_res, simulation_file(400, lambda_values[i], 1, "DET"))
}
lambda_values = seq(from = 0.7, to = 1, by = 0.01)
for (i in 1:length(lambda_values)) {
mon_res <- rbind(mon_res, simulation_file(1000, lambda_values[i], 1, "DET"))
}
# calcul final
mon_res2 <- ddply(mon_res, c("LAMBDA", "LOI"), summarize, TempsMoyen = mean(TEMPST),
vari = var(TEMPST), espint = (sd(TEMPST)/sqrt(length(TEMPST))))
ggplot(data = mon_res2, aes(x = LAMBDA, y = TempsMoyen, ymin = TempsMoyen -
espint, ymax = TempsMoyen + espint, color = factor(LOI))) + geom_point() +
geom_errorbar()
Pour les résultats, la loi uniforme n'est pas du tout une bonne représentation, pour moi si du retard de temps de traitement arrive, celui-ci s'accumule de plus en plus. Une fois qu'un retard survient (un client arrive mais n'est pas immédiatement servi), il y a plus de chance que le client suivant ne soit également pas servi dans l'immédiat par le serveur, comme dans une autoroute : si on attend au péage, on risque généralement de faire attendre ceux de derrière, puis l'accumulation de l'arrivé de voiture provoque finalement un bouchon quand plus de voitures arrivent par rapport à celles qui partent.
La loi exponentielle provoque une forte fluctuation et une véritable explosion du temps moyen d'attente, ce qui me parait peu probable.
L'utilisation de la loi d'Erlang me parait être la plus correcte, car le temps explose de manière beaucoup plus visible que la loi exponentielle.
A l'inverse, pour la loi déterministe, le temps moyen d'attente n'augmente pas fortement, ce qui ne me parait pas être une bonne représentation. Cela voudrait dire que finalement, le temps d'arrivé entre deux clients n'influence pas énormément sur le temps moyen d'attente.