BARBIER Jérôme RICM4
simul(N,lambda, mu)
mu –> nombre de taches que le serveur peut traiter par seconde
lambda : nombre de taches qui arrive par seconde
T1(1)=0
Tn(n)=Tn(n-1)+An
Tn(n)=max(T1(n),T2(n-1)) +Sn
R(n)=T2(n)-T1(n)
4 lois différentes : exp, unif, det, erlang (rgamma) 3 serveurs : vus de l'extérieur –> 1 seul
intervale de confiance : centré sur la variance, puis = sigma/RACINE(n)
Je n'ai pas réussit à mettre toutes mes courbes sur le même graphique… j'en ai donc fait un pour chaque fonction, au plaisir d'apprendre comment réaliser cette exploit, veuillez m'excuser pour cette gène occasionné :
Fonction de création de la dataFrame :
dataFrame <- function(N, lambda, mu, nameFunction) {
if (nameFunction == "exponentielle") {
a <- rexp(N, lambda)
s <- rexp(N, mu)
}
if (nameFunction == "uniforme") {
a <- rexp(N, lambda)
s <- runif(N, 0, mu)
}
if (nameFunction == "deterministe") {
a <- rexp(N, lambda)
s <- array(1, N)
}
if (nameFunction == "erlang") {
a <- rexp(N, lambda)
s <- rgamma(N, mu, 1, 1)
}
T1 <- c()
T2 <- c()
R <- c()
T1[1] = 0
T2[1] = 0
S = 0
R = 0
for (i in 2:N) {
T1[i] = T1[i - 1] + a[i]
T2[i] = max(T1[i], T2[i - 1]) + s[i]
R[i] = T2[i] - T1[i]
}
df = data.frame(A = a, S = s, t1 = T1, t2 = T2, r = R, myLambda = lambda)
df
}
On va maintenant chercher a compresser toutes nos valeurs :
concact <- function(pas, n, i, nameFunction) {
df <- dataFrame(n, i, 1, nameFunction)
i <- i + pas
while (i <= 1) {
df <- rbind(df, dataFrame(n, i, 1, nameFunction))
i <- i + pas
}
df
}
On va prendre toutes nos valeurs, on le concatene selon la colonne “lambda”, c'est à dire que pour une valeur lambda donnée, nous allons récupérer toutes la valeurs similaire, on en affiche le temps moyen et on fait le calcul des intervales de confiances : cela ne nous donne plus 1000 données, mais seulement 10 (une pour chaque pas de lambda).
Pour les valeurs choisies : un pas de 0.05 afin d'obtenir des mesures précise (voir à partir de quand il y aurait un phénomène particulier) et obtenir plusieurs valeurs. La valeur de n fixé à 1000 afin de répéter 1000 fois l'opération. Valeur de i à 0.1 que l'on fait varié de 0.1 pour faire 10 valeurs. Enfin, mu fixé à 1 pour toutes les fonctions afin d'avoir des valeurs comparables.
Construction de nos valeurs pour la fonction exponentielle :
dfexpo <- concact(0.05, 1000, 0.1, "exponentielle")
library(plyr)
dfexpo2 <- ddply(dfexpo, c("myLambda"), summarize, Time = mean(r), InterConfi = sd(r)/sqrt(length(r)))
dfexpo2
## myLambda Time InterConfi
## 1 0.10 1.112 0.03515
## 2 0.15 1.113 0.03457
## 3 0.20 1.201 0.03887
## 4 0.25 1.415 0.04641
## 5 0.30 1.381 0.04517
## 6 0.35 1.668 0.05572
## 7 0.40 1.497 0.04607
## 8 0.45 2.084 0.06712
## 9 0.50 1.891 0.05589
## 10 0.55 2.066 0.06584
## 11 0.60 2.256 0.07181
## 12 0.65 3.321 0.12120
## 13 0.70 2.880 0.08186
## 14 0.75 3.666 0.11220
## 15 0.80 4.787 0.13535
## 16 0.85 7.938 0.28113
## 17 0.90 7.447 0.18568
## 18 0.95 6.307 0.16263
Construction de nos valeurs pour la fonction Uniforme :
dfunif <- concact(0.05, 1000, 0.1, "uniforme")
library(plyr)
dfunif2 <- ddply(dfunif, c("myLambda"), summarize, Time = mean(r), InterConfi = sd(r)/sqrt(length(r)))
dfunif2
## myLambda Time InterConfi
## 1 0.10 0.5270 0.009517
## 2 0.15 0.5289 0.009945
## 3 0.20 0.5386 0.009758
## 4 0.25 0.5471 0.010218
## 5 0.30 0.5440 0.010676
## 6 0.35 0.5819 0.011197
## 7 0.40 0.5679 0.010972
## 8 0.45 0.6150 0.013429
## 9 0.50 0.5745 0.011262
## 10 0.55 0.6444 0.013603
## 11 0.60 0.6374 0.012918
## 12 0.65 0.6814 0.014480
## 13 0.70 0.6822 0.014521
## 14 0.75 0.6938 0.014260
## 15 0.80 0.6940 0.014176
## 16 0.85 0.7326 0.015733
## 17 0.90 0.7491 0.016740
## 18 0.95 0.7482 0.014803
Construction de nos valeurs pour la fonction deterministe :
dfdet <- concact(0.05, 1000, 0.1, "deterministe")
library(plyr)
dfdet2 <- ddply(dfdet, c("myLambda"), summarize, Time = mean(r), InterConfi = sd(r)/sqrt(length(r)))
dfdet2
## myLambda Time InterConfi
## 1 0.10 1.076 0.007479
## 2 0.15 1.075 0.007847
## 3 0.20 1.122 0.009366
## 4 0.25 1.166 0.011689
## 5 0.30 1.211 0.015486
## 6 0.35 1.198 0.012991
## 7 0.40 1.325 0.016994
## 8 0.45 1.412 0.020998
## 9 0.50 1.524 0.026345
## 10 0.55 1.518 0.024461
## 11 0.60 1.778 0.032180
## 12 0.65 1.766 0.032403
## 13 0.70 2.767 0.068345
## 14 0.75 3.118 0.075003
## 15 0.80 2.500 0.055408
## 16 0.85 3.256 0.078724
## 17 0.90 3.619 0.075159
## 18 0.95 4.932 0.110271
Construction de nos valeurs pour la fonction Erlang :
dferl <- concact(0.05, 1000, 0.1, "erlang")
library(plyr)
dferl2 <- ddply(dferl, c("myLambda"), summarize, Time = mean(r), InterConfi = sd(r)/sqrt(length(r)))
dferl2
## myLambda Time InterConfi
## 1 0.10 1.103 0.03350
## 2 0.15 1.191 0.03834
## 3 0.20 1.279 0.04243
## 4 0.25 1.219 0.03742
## 5 0.30 1.364 0.04220
## 6 0.35 1.530 0.05195
## 7 0.40 1.468 0.04590
## 8 0.45 1.916 0.05989
## 9 0.50 1.833 0.05844
## 10 0.55 2.139 0.07180
## 11 0.60 2.368 0.07583
## 12 0.65 2.784 0.08669
## 13 0.70 3.362 0.09875
## 14 0.75 4.163 0.12289
## 15 0.80 3.615 0.11116
## 16 0.85 4.796 0.13268
## 17 0.90 4.662 0.11991
## 18 0.95 15.438 0.29791
J'ai décidé de ne pas forcer l'affichage sur 0(en x et y) car cela n'apporte rien(tout les points son présent) et que nous observons moins bien les intervalles de confiances.
Graphe de la fonction exponentielle :
library(ggplot2)
ggplot(dfexpo2,aes(x=myLambda, y= Time, ymin= Time-InterConfi, ymax= Time+InterConfi,colour=InterConfi))+geom_pointrange(); #+xlim(0,1)+ylim(0,15);
Nous pouvons clairement voir ici que si lambda est petit, l'intervalle de confiance est faible alors que plus il augmente plus cet intervalle de confiance augmente également (variance de 0.3 environ) : pouvons nous dire qu'un tel intervalle de confiance est assez précis? –> Etant donnée que le lambda (nombre de taches par seconde) est grand, le dernier client va rester longtemps dans le buffer, mais l'intervalle de confiance étant grand montre que se temps d'attente peut être très variable : cela dépend des clients précédent.
Nous pouvons également constater que la progression est relativement lente : l'inclinaison de la courbe augmente légèrement avant “d'exploser”.Cette explosion se présente toujours dans les dernières mesures. Des “pics” de valeurs au niveau du temps apparaissent.
Nous retrouvons bien ici la courbe de la function exponentielle.
Graphe de la fonction uniforme :
library(ggplot2)
ggplot(dfunif2, aes(x = myLambda, y = Time, ymin = Time - InterConfi, ymax = Time +
InterConfi, colour = InterConfi)) + geom_pointrange()
# +xlim(0,1)+ylim(0,1);
Contrairement au graphe précédent, nous pouvons voir que la différence de Temps est bien moindre. En effet, la différence est nettement plus faible. De plus l'intervalle de confiance quand à lui ne varie pas beaucoup également! contrairement à la courbe précédente, il reste plus ou moins constant (une légère différence) : cela signifie que le temps de traitement est plus constantes meme si la valeur de lambda est grande. Le serveur à donc “le temps” de traiter tous ses clients sans arriver à des temps faramineux.
Graphe de la fonction deterministe :
library(ggplot2)
ggplot(dfdet2, aes(x = myLambda, y = Time, ymin = Time - InterConfi, ymax = Time +
InterConfi, colour = InterConfi)) + geom_pointrange()
# +xlim(0,1)+ylim(0,1);
Ressemble énormement à la loi exponentielle
Graphe de la fonction erlang :
library(ggplot2)
ggplot(dferl2, aes(x = myLambda, y = Time, ymin = Time - InterConfi, ymax = Time +
InterConfi, colour = InterConfi)) + geom_pointrange()
# +xlim(0,1)+ylim(0,1);
La fonction erlang peut être simplifié en la loi exponentielle d'ou la ressemblance flagrante des courbes.
Pour conclure, la loi exponentielle, deterministe et erlang se ressemble énormement. Seul la loi uniforme est différente des autres. C'est pourquoi il est dommage que les courbes ne soit pas sur le même graphique car nous aurions pu aisement comparer les courbes qui se ressemble énormément.