Simuler l`aléatoire

Transcription

Simuler l`aléatoire

Simuler l’aléatoire
Licence 1 MASS, parcours SEMS et ESD
Introduction à Java et à l’algorithmique
Sébastien Verel
[email protected]
http://www.i3s.unice.fr/∼verel
Équipe ScoBi - Université Nice Sophia Antipolis
15 mars 2013
Introduction
Générateurs pseudo-aléatoire
Algorithmes stochastiques
Synthèse
Elèves pour la synthèse du jour ?
Sébastien Verel
Introduction
Objectifs de la séance 6
Faire la différence entre aléatoire et pseudo-aléatoire
Simuler un nombre pseudo-aléatoire entier ou flottant entre 2
bornes données
Ecrire un algorithme utilisant un générateur pseudo-aléatoire
Ecrire un algorithme qui génère des séries temporelles du type
ut+1 = aut + b + et ut+1 = (a + )ut + b
Question principale du jour :
Comment générer une série de nombres qui ont l’air d’être
aléatoires ?
Sébastien Verel
Introduction
Plan
1
Introduction
2
3
Sébastien Verel
Introduction
Aiguille de Buffon
Expérience
Lancer n fois une aiguille de longueur 2l sur parquet dont les lames
sont de largeur 2a.
Soit pn le nombre de fois que l’aiguille intercepte une lame de
parquet.
La fréquence
pn
n
permet d’approximer le nombre π.
limn→∞
2l
pn
=
n
aπ
→ à partir d’événements aléatoires, il est possible d’approximer
une valeur
Sébastien Verel
Introduction
Besoin de nombres aléatoires
Simulation :
Modèle économique, sociologique, physique, médicale, ...
Cryptographie :
Génération sûre de clés de chiffrement
Optimisation stochastique :
méthodes de MonteCarlo, recuit simulé, algorithmes
génétiques, Paritcules Swarm Optimisation...
Jeux de hasard :
Loto, suduko, ...
Besoin croissant de nombres aléatoires en particulier en simulation
et en cryptographie
Sébastien Verel
Introduction
Problème de génération
Méthodes principales de générateurs de nombres aléatoires :
A l’aide d’un système physique dont l’état est aléatoire :
Valeur précise d’une résistance, apparition des taches solaires,
vibration de matière...
→ bonne méthode mais lente
A l’aide d’un ordinateur :
Mais un ordinateur est une machine déterministe :
tout état prochain est une fonction (image unique) des états
précèdents de la machine.
→ rapide, facile à utiliser dans un ordinateur
→ mais PAS aléatoire du tout...
Depuis peu : combinaison des deux
Sébastien Verel
Introduction
Technique de génération : le pseudo-aléatoire
2 étapes :
Initialisation d’un premier nombre appelé graine :
u0
Génération d’une suite de nombres définie par récurrence :
un+1 = f (un )
3402093, 56, 125672, 10048, 678089, ...
Sébastien Verel
Introduction
Limite des machines : le pseudo-aléatoire
Mais :
Taille de mémoire limitée
Nombre de registres de calcul d’un processeur limité
→ inévitable périodicité des nombres générés pseudo-aléatoirement
par ordinateur
La suite des nombres doit avoir certaines propriétés de l’aléatoire
→ générateur pseudo-aléatoire
Sébastien Verel
Introduction
Petit historique
Développement essentiellement dû au besoin en simulation et
cryptographie.
1946 : John Von Neumann, générateur Middle square
1948 : D. H. Lehmer, générateur congruenciel
1958 : G.T. Mitchell, et D.P. Moore, améalioration
1997 : Makoto Matsumoto et Takuji Nishimura :
Mersenne-Twister
Sébastien Verel
Introduction
Algorithme de Von Neumann
Middle Square
Principe : pour calculer le nombre suivant, on élève au carré le
nombre précèdent puis on conserve les chiffres du milieu.
Exemple :
Graine : 1111
1. 11112 = 1234321, premier nombre : 23432
2. 234322 = 549058624, deuxième nombre : 4905862
3. ...
Périodicité faible
Dépend beaucoup de la graine
à fonctionnner sur l’ENIAC, mais très vite limité.
Sébastien Verel
Introduction
Méthode de Von Neumann
// nombre courant pseud-aleatiore
int n = 1111;
/********************************
* initialisation generateur pseudo-aleatoire de Von Neumann
*
* entree :
*
graine du generateur aleatoire
*
* sortie :
*
aucune
*******************************/
void randSeed(int k) {
n = k;
}
Sébastien Verel
Introduction
Méthode de Von Neumann
/********************************
* generateur pseudo-aleatoire de Von Neumann
*
* entree :
*
aucune
*
* sortie :
*
nombre non attendu suivant
*******************************/
int rand() {
int nbChiffre = int(log(n * n) / log(10));
n = (n * n) % int(exp(nbChiffre * log(10))) / 10;
return n;
}
void setup() {
randSeed(1111);
println(rand());
println(rand());
}
Sébastien Verel
Introduction
Méthode de Fibonacci
Basé sur la suite de Fibonacci et l’arithmétique modulaire.
xn = (xn−1 + xn−2 ) mod M
avec x0 et x1 comme graines
Ou une variante avec k un entier.
xn = (xn−1 + xn−k ) mod M
avec x0 ... xk−1 comme graines
Qualité : dépend de k et des nombres utilisés pour graines
Peu de consommation de ressources
Simple à implémenter....
Sébastien Verel
Introduction
Méthode Fibonacci
// nombres courants pseudo-aleatoires
int n0 ;
int n1 ;
// congruence
int M = 1000;
/********************************
* generateur pseudo-aleatoire : Methode de Fibonacci
*
* entree :
*
*
* sortie :
*
aucune
*******************************/
void randSeed(int _n0, int _n1) {
n0 = _n0;
n1 = _n1;
}
Sébastien Verel
Introduction
Méthode Fibonacci
/********************************
* generateur pseudo-aleatoire Fibonacci
*
* entree :
*
aucune
*
* sortie :
*
*******************************/
int rand() {
int suiv = (n0 + n1) % M;
n0 = n1;
n1 = suiv;
return suiv;
}
void setup() {
randSeed(23456, 9726);
println(rand());
println(rand());
}
Sébastien Verel
Introduction
Générateurs congruentiels linéaires
Basé sur les suites arithmétiquo-géométriques et l’arithmétique
modulaire.
xn = axn−1 + c mod m
avec x0 une graine.
Période au maximum m.
m choisit de la taille des nombres en machine 232 .
Simple à implémenter....
Sébastien Verel
Introduction
Methode par congruence linéaire
// nombres courants pseudo-aleatoires
int n ;
// congruence
int M = 1000;
int a = 53;
int c = 97;
/********************************
* generateur pseudo-aleatoire basee sur la congruence
*
* entree :
*
*
* sortie :
*
aucune
*******************************/
void randSeed(int _n) {
n = _n;
}
Sébastien Verel
Introduction
Méthode par congruence linéaire
/********************************
* generateur pseudo-aleatoire base sur la congruence
*
* entree :
*
aucune
*
* sortie :
*
*******************************/
int rand() {
n = (a * n + c) % M;
return n;
}
void setup() {
randSeed(23456);
println(rand());
println(rand());
}
Sébastien Verel
Introduction
Mersenne-twister (Makoto Matsumoto et Takuji Nishimura
1997)
Basé sur les nombres de Mersenne 2p − 1
Période 219937 − 1
distribution uniforme sur 623 dimensions
N’est pas un générateur adapté à la cryptographie, mais très
utile en simulation et optimisation.
Sébastien Verel
Introduction
Propriétés statistiques du pseudo-aléatoire
Les générateurs pseudo-aléatoires sont conçus pour générer des
nombres selon une loi ”proche” d’une loi uniforme
U(0, maxValue − 1).
Certaines propriétés statistiques attendues
Propriété de la distribution des nombres : moments, fréquence
d’apparition des nombres, comparaison à la loi uniforme
Entropie maximale
Indépendance statistique des nombres de la série :
autocorrélation, test spectral
Sébastien Verel
Introduction
Générateur pseudo-aléatoires de nombres flottants
Initialisation de la graine aléatoire
randomSeed(n)
Nombre aléatoire (float) entre 0 et b (b exclu)
random(b)
Nombre aléatoire (float) entre a et b (b exclu)
random(a, b)
Sébastien Verel
Introduction
Générateur pseudo-aléatoires de nombres entiers
Nombre aléatoire (int) entre 0 et b − 1
int(random(b))
Nombre aléatoire (int) entre a et b − 1
int(random(a, b))
Sébastien Verel
Introduction
Jeu où l’on doit deviner un nombre entre 0 et 100
/**************************************
* Organise le jeu qui consiste a deviner un nombre
*
* entree :
*
- n : nombre a deviner
*
* sortie :
*
- aucune
***************************************/
void deviner() {
int rep;
int n = int(random(101));
rep = n - 1;
while (rep != n) {
rep = lire("Proposer un nombre entier");
if (rep < n)
println("trop petit");
else
if (rep > n)
println("trop grand");
}
println("Winner is back !");
}
Sébastien Verel
Introduction
Simulation de lancer de fléchettes
/********************************
* lancer de n flechettes
*
* entree :
*
n : entier, nombre de lancer
*
* sortie :
*
nombre points sur n lancers
*******************************/
int lancer(int n) {
int pts = 0;
float rho, theta ;
for(int i = 0; i < n; i++) {
rho
= random(10);
theta = random(-3.14159265358, 3.14159265358);
point(width / 2 + 10 * rho * cos(theta), height / 2 + 10 * rho * sin(theta));
pts += nbPoints(rho);
}
return pts;
}
Sébastien Verel
Introduction
Simulation de lancer de fléchettes
/********************************
* compte le nombre de point en fonction de la distance au centre
*
* entree :
*
rho : distance au centre
*
* sortie :
*
nombre de point
*******************************/
int nbPoints(float rho) {
if (rho > 10)
return 0;
else
if (rho > 5)
return 3;
else
if (rho > 2)
return 5;
else
if (rho > 1)
return 10;
else
return 20;
}
Sébastien Verel
Introduction
Simulation de marche aléatoire
Simulation une marche aléatoire de n pas sur l’ensemble des
entiers (positifs ou négatif) en partant du point central.
// variable globale
int x, y;
/********************************
* marche aleatoire sur Z^2
*
* entree :
*
aucune
*
* sortie :
*
aucune
*******************************/
void marche() {
if (int(random(2)) == 0)
y++;
else
y--;
if (int(random(2)) == 0)
x++;
else
x--;
}
Sébastien Verel
Introduction
Simulation de marche aleatoire
void draw() {
// efface
stroke(0);
point(x, y);
marche();
// affiche
stroke(255);
point(x, y);
}
void setup() {
size(200, 200);
background(0);
strokeWeight(20);
// position initiale
y = height / 2;
x = width / 2;
frameRate(20);
}
Sébastien Verel
Introduction
Objectifs de la séance 6
Faire la différence entre aléatoire et pseudo-aléatoire
Simuler un nombre pseudo-aléatoire entier ou flottant entre 2
bornes données
Ecrire un algorithme utilisant un générateur pseudo-aléatoire
Ecrire un algorithme qui génère des séries temporelles du type
ut+1 = aut + b + et ut+1 = (a + )ut + b
Question principale du jour :
Comment générer une série de nombres qui ont l’air d’être
aléatoires ?
Sébastien Verel

Simuler l`aléatoire

Transcription

Documents pareils

a l`issue de ce jeu le gain algebrique (gain ou perte

1 Année-Diplôme d`ingénieur TD Tribus et Variables aléatoires

Devoir surveillé sur les probabilités en première S

Jeu de Boggle Projet de programmation Modalités pratiques

Télécharger l`article au format PDF - ALE 08

Un exemple de marche aléatoire - préparation à l`agrégation de

Introduction au pricing d`option en finance

2004 - MATH III - EM LYON ECE - Annale corrigée

03 Siska Gaeremyn

1 Simulation de la loi normale centrée réduite