Projet Stochastique - Hotline

Processus Stochastiques Classe 41-42 2012-2013

ESIEA – 74 Bis, avenue Maurice Thorez – 94200 Ivry-sur-Seine 1

Le groupe du projet est constitué de :

EN NAKDI Tarik

Projet informatique ESIEA

Sujet: Combien de personnes travaillent en moyenne au service

hotline d’un opérateur téléphonique



Sommaire

Problématique: ........................................................................................................................................ 3

1ère Modélisation de la Chaîne de Markov d’une Hotline ..................................................................... 4

Partie 1: CALCUL AVEC MATHEMATICA .................................................................................................. 5

2ème Modélisation de la Chaîne de Markov d’une Hotline .................................................................... 6

Partie 2: CALCUL AVEC MATHEMATICA .................................................................................................. 7

Conclusion: .............................................................................................................................................. 8

Annexes: .................................................................................................................................................. 9

Génération d’une chaîne de Markov en language C++: ...................................................................... 9

Génération d’une chaîne de Markov en language JAVA: .................................................................. 11

Webographie: ........................................................................................................................................ 13



Problématique:

Expliquer le but du projet

Notre idée : Construire un modèle général en prenant en compte la capacité des agents à traiter le

nombre d’appels par minute et le temps passer en file d’attente.

Markov + Matrice = Modèle poussée et général du projet Réponse au cahier des charges

Donner les moyens qui vont être utilisés pour répondre au cahier des charges

(

Mathematica

Création et génération d’une chaîne de Markov en C++ et en JAVA

)

Avant de commencer absolument dire que les événements d’arrivé des clients suit une loi de Poisson

avec λ le paramètre désignant le nombre d’appels par minute, c’est un taux d’arrivé des clients par

rapport au temps. Dans notre cas, si on se place sur H notre λ sera ϒH (gamma H).

Dire aussi que notre chaîne de Markov est ergodique, voir cours ou simplement dire que l’intensité

du trafic est inférieure à 1. Dans notre cas que p = (ϒA/ ϒH) <1 , ϒH pour le service et ϒA pour la file

d’attente.



1ère Modélisation de la Chaîne de Markov d’une Hotline

Légende: • M: Maison

• A: Attente

• H: Hotline

M A H

Nb/Nb = 1

(Nb – Na)/Nb

Na/Nb

0,3

0,7

Hypothèse 1: On prendra Na, le nombre d’agents tel qu’un 1 agent a la capacité de traiter 1 client par

minute. On fixera Nb à une valeur aléatoire de sorte que Na soit inférieur à Nb pour se rapprocher le plus possible de la réalité tout en donnant un modèle complet.



Partie 1: CALCUL AVEC MATHEMATICA

Mettre un bout de code servant à expliciter notre raisonnement.

Les moyennes E

Les variances V

La matrice pour le modèle général

Enfin le calcul du nombre d’agents optimal



2ème Modélisation de la Chaîne de Markov d’une Hotline

Légende: • M: Maison

• A: Attente

• H: Hotline

M A H

Nb/Nb = 1

Nb−(2Na+Na)/2

Nb

(Na + 2Na)/2Nb

0,3

0,7

Hypothèse 2: Il y aura 2 types d’agents dans la population Na. La moitié de Na sont les agents stagiaires

et ne sont capables de traiter qu’un client par minute, alors que l’autre moitié sont les agents qualifiés qui eux peuvent traiter deux clients par minute. On garde toujours cette hypothèse raisonnable : Na < Nb.



Partie 2: CALCUL AVEC MATHEMATICA

Mettre un bout de code servant à expliciter notre raisonnement.

Les moyennes E

Les variances V

La matrice pour le modèle général

Enfin le calcul du nombre d’agents optimal



Conclusion:

Modélisation générale réussie grâce à la formule de Lalitte, car notre modèle est ergodique ainsi qu’à

notre matrice donnée par la chaîne de Markov.

Réponse à la dernière question ainsi qu’en mettant le coût total du service de hotline en prenant Na

= 16 comme étant le nombre d’agent optimal.

Mettre les agents compétents pendant les heures de pointes lorsque la probabilité que Nb clients

appellent est très forte. Et donc placer le reste du personnel sur les autres plages horaires.



Annexes:

Génération d’une chaîne de Markov en language C++:

#include <time.h>

#include <iostream>

#include <string>

#include <deque>

#include <map>

#include <vector>

using namespace std;

const int NPREF = 2;

const char NONWORD[] = "\n"; // cannot appear as real line: we remove

newlines

const int MAXGEN = 3; // maximum words generated which are our 3 steps M,

A and H

typedef deque<string> Prefix;

map<Prefix, vector<string> > statetab; // prefix -> suffixes

void build(Prefix&, istream&);

void generate(int nwords);

void add(Prefix&, const string&);

// markov main: markov-chain random text generation

int main(void)

{

int nwords = MAXGEN;

Prefix prefix; // current input prefix

srand(time(NULL));

for (int i = 0; i < NPREF; i++)

add(prefix, NONWORD);

build(prefix, cin);


generate(nwords);

return 0;

}

// build: read input words, build state table

void build(Prefix& prefix, istream& in)

{

string buf;

while (in >> buf)

add(prefix, buf);

}

// add: add word to suffix deque, update prefix

void add(Prefix& prefix, const string& s)

{

if (prefix.size() == NPREF) {

statetab[prefix].push_back(s);

prefix.pop_front();

}

prefix.push_back(s);



}

// generate: produce output, one word per line

void generate(int nwords)

{

Prefix prefix;

int i;

for (i = 0; i < NPREF; i++)


for (i = 0; i < nwords; i++) {

vector<string>& suf = statetab[prefix];

const string& w = suf[rand() % suf.size()];

if (w == NONWORD)

break;

cout << w << "\n";

prefix.pop_front(); // advance

prefix.push_back(w);

}

}



Génération d’une chaîne de Markov en language JAVA:

/*Java classes of Markov chain algorithm

Class Prefix

Class Chain

Class Markov*/

import java.io.*;

import java.util.StringTokenizer;

import java.util.Vector;

import java.util.Hashtable;

import java.util.Random;

//Prefix Class

class Prefix {

public Vector pref;

// NPREF adjacent words from input

static final int MULTIPLIER = 31; // for hashCode() // Prefix

constructor: duplicate existing prefix

Prefix(Prefix p){

pref = (Vector) p.pref.clone();

} // Prefix constructor: n copies of str

Prefix(int n, String str){

pref = new Vector();

for (int i = 0; i < n; i++)

pref.addElement(str);

} // Prefix hashCode: generate hash from all prefix words

public int hashCode(){

int h = 0;

for (int i = 0; i < pref.size(); i++)

h = MULTIPLIER * h + pref.elementAt(i).hashCode();

return h;

} // Prefix equals: compare two prefixes for equal words

public boolean equals(Object o){

Prefix p = (Prefix) o;

for (int i = 0; i < pref.size(); i++)

if (!pref.elementAt(i).equals(p.pref.elementAt(i)))

return false;

return true;

}

}

//Chain Class

class Chain {

static final int NPREF = 2; // size of prefix

static final String NONWORD = "\n"; // "word" that can't appear

Hashtable statetab = new Hashtable(); // key = Prefix, value = suffix

Vector

Prefix prefix = new Prefix(NPREF, NONWORD); // initial prefix

Random rand = new Random(); // Chain build: build State table from

input stream



void build(InputStream in) throws IOException{

StreamTokenizer st = new StreamTokenizer(in);

st.resetSyntax(); // remove default rules

st.wordChars(0, Character.MAX_VALUE); // turn on all chars

st.whitespaceChars(0, ' '); // except up to blank

while (st.nextToken() != st.TT_EOF)

add(st.sval);

add(NONWORD);

} // Chain add: add word to suffix list, update prefix

void add(String word){

Vector suf = (Vector) statetab.get(prefix);

if (suf == null) {

suf = new Vector();

statetab.put(new Prefix(prefix), suf);

}

suf.addElement(word);

prefix.pref.removeElementAt(0);

prefix.pref.addElement(word);

} // Chain generate: generate output words

void generate(int nwords){

prefix = new Prefix(NPREF, NONWORD);

for (int i = 0; i < nwords; i++) {

Vector s = (Vector) statetab.get(prefix);

if (s == null) {

System.err.println("Markov: internal error: no state");

System.exit(1);

}

int r = Math.abs(rand.nextInt()) % s.size();

String suf = (String) s.elementAt(r);

if (suf.equals(NONWORD))break;

System.out.println(suf);

prefix.pref.removeElementAt(0);

prefix.pref.addElement(suf);

}

}

}

//Markov Class

class Markov {

static final int MAXGEN = 3; // maximum words generated which are our

3 steps M, A and H

public static void main(String[] args) throws IOException{

Chain chain = new Chain();

int nwords = MAXGEN;

chain.build(System.in);

chain.generate(nwords);

}

}



Webographie:

http://www.lokad.com/fr.accueil.ashx

http://fr.wikipedia.org/wiki/Th%C3%A9orie_des_files_d'attente

http://www.developpez.net

http://www.wolfram.com/mathematica/

http://web.univ-pau.fr/~cpham/ENSEIGNEMENT/UEPERF/FILE.pdf

http://www.loria.fr/~sur/enseignement/RO/Files1_FSur.pdf

http://www.stephan-robert.ch/attachments/File/MSE-Stochastique/transp-files-attente.pdf

http://www.lokad.com/fr.accueil.ashx

http://fr.wikipedia.org/wiki/Th%C3%A9orie_des_files_d'attente

http://www.developpez.net/

http://www.wolfram.com/mathematica/

http://web.univ-pau.fr/~cpham/ENSEIGNEMENT/UEPERF/FILE.pdf

http://www.loria.fr/~sur/enseignement/RO/Files1_FSur.pdf

http://www.stephan-robert.ch/attachments/File/MSE-Stochastique/transp-files-attente.pdf

Projet Stochastique - Hotline

Documents

Transcript of Projet Stochastique - Hotline