Simuler l’al´eatoire Licence 1 MASS, parcours SEMS et ESD Introduction `a Java et `a l’algorithmique

Licence 1 MASS, parcours SEMS et ESD Introduction `a Java et `a l’algorithmique

S´ebastien Verel [email protected]

http://www.i3s.unice.fr/^∼verel

´Equipe ScoBi - Universit´e Nice Sophia Antipolis

15 mars 2013

Synth` ese

El`eves pour la synth`ese du jour ?

Objectifs de la s´ eance 6

Faire la diff´erence entre al´eatoire et pseudo-al´eatoire

Simuler un nombre pseudo-al´eatoire entier ou flottant entre 2 bornes donn´ees

Ecrire un algorithme utilisant un g´en´erateur pseudo-al´eatoire Ecrire un algorithme qui g´en`ere des s´eries temporelles du type u_t+1 =au_t+b+et u_t+1 = (a+)u_t+b

Question principale du jour :

Comment g´en´erer une s´erie de nombres qui ont l’air d’ˆetre al´eatoires ?

Plan

1 Introduction

2 G´en´erateurs pseudo-al´eatoire

3 Algorithmes stochastiques

Aiguille de Buffon

Exp´erience

Lancern fois une aiguille de longueur 2l sur parquet dont les lames sont de largeur 2a.

Soitp_nle nombre de fois que l’aiguille intercepte une lame de parquet.

La fr´equence ^p_nⁿ permet d’approximer le nombreπ.

limn→∞

p_n n = 2l

aπ

→`a partir d’´ev´enements al´eatoires, il est possible d’approximer une valeur

Besoin de nombres al´ eatoires

Simulation :

Mod`ele ´economique, sociologique, physique, m´edicale, ...

Cryptographie :

G´en´eration sˆure de cl´es de chiffrement Optimisation stochastique :

m´ethodes de MonteCarlo, recuit simul´e, algorithmes g´en´etiques, Paritcules Swarm Optimisation...

Jeux de hasard : Loto, suduko, ...

Besoin croissant de nombres al´eatoires en particulier en simulation et en cryptographie

Probl` eme de g´ en´ eration

M´ethodes principales de g´en´erateurs de nombres al´eatoires : A l’aide d’un syst`eme physique dont l’´etat est al´eatoire : Valeur pr´ecise d’une r´esistance, apparition des taches solaires, vibration de mati`ere...

→ bonne m´ethode mais lente A l’aide d’un ordinateur :

Mais un ordinateur est une machined´eterministe:

tout ´etat prochain est une fonction (image unique) des ´etats pr´ec`edents de la machine.

→ rapide, facile `a utiliser dans un ordinateur

→ mais PAS al´eatoire du tout...

Depuis peu : combinaison des deux

Technique de g´ en´ eration : le pseudo-al´ eatoire

2 ´etapes :

Initialisation d’un premier nombre appel´egraine : u0

G´en´eration d’une suite de nombres d´efinie par r´ecurrence : u_n+1 =f(u_n)

3402093,56,125672,10048,678089, ...

Limite des machines : le pseudo-al´ eatoire

Mais :

Taille de m´emoire limit´ee

Nombre de registres de calcul d’un processeur limit´e

→in´evitablep´eriodicit´edes nombres g´en´er´es pseudo-al´eatoirement par ordinateur

La suite des nombres doit avoir certaines propri´et´es de l’al´eatoire

→ g´en´erateur pseudo-al´eatoire

Petit historique

D´eveloppement essentiellement dˆu au besoin en simulation et cryptographie.

1946 : John Von Neumann, g´en´erateur Middle square 1948 : D. H. Lehmer, g´en´erateur congruenciel

1958 : G.T. Mitchell, et D.P. Moore, am´ealioration 1997 : Makoto Matsumoto et Takuji Nishimura : Mersenne-Twister

Algorithme de Von Neumann

Middle Square

Principe : pour calculer le nombre suivant, on ´el`eve au carr´e le nombre pr´ec`edent puis on conserve les chiffres du milieu.

Exemple :

Graine : 1111

1. 1111² = 1234321, premier nombre : 23432

2. 23432² = 549058624, deuxi`eme nombre : 4905862 3. ...

P´eriodicit´e faible

D´epend beaucoup de la graine

`

a fonctionnner sur l’ENIAC, mais tr`es vite limit´e.

M´ ethode 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;

}

M´ ethode 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());

}

M´ ethode de Fibonacci

Bas´e sur la suite de Fibonacci et l’arithm´etique modulaire.

x_n= (xn−1+xn−2) modM avecx₀ et x₁ comme graines

Ou une variante aveck un entier.

xn= (xn−1+xn−k) modM avecx₀...xk−1 comme graines

Qualit´e : d´epend dek et des nombres utilis´es pour graines Peu de consommation de ressources

M´ ethode Fibonacci

// nombres courants pseudo-aleatoires int n0 ;

int n1 ; // congruence int M = 1000;

/********************************

* generateur pseudo-aleatoire : Methode de Fibonacci

*

* entree :

* graine du generateur aleatoire

*

* sortie :

* aucune

*******************************/

void randSeed(int _n0, int _n1) { n0 = _n0;

n1 = _n1;

}

M´ ethode Fibonacci

/********************************

* generateur pseudo-aleatoire Fibonacci

*

* entree :

* aucune

*

* sortie :

* nombre non attendu suivant

*******************************/

int rand() {

int suiv = (n0 + n1) % M;

n0 = n1;

n1 = suiv;

return suiv;

}

void setup() { randSeed(23456, 9726);

println(rand());

println(rand());

}

G´ en´ erateurs congruentiels lin´ eaires

Bas´e sur les suites arithm´etiquo-g´eom´etriques et l’arithm´etique modulaire.

x_n=axn−1+c modm avecx0 une graine.

P´eriode au maximumm.

m choisit de la taille des nombres en machine 2³². Simple `a impl´ementer....

Methode par congruence lin´ eaire

// nombres courants pseudo-aleatoires int n ;

// congruence int M = 1000;

int a = 53;

int c = 97;

/********************************

* generateur pseudo-aleatoire basee sur la congruence

*

* entree :

* graine du generateur aleatoire

*

* sortie :

* aucune

*******************************/

void randSeed(int _n) { n = _n;

}

M´ ethode par congruence lin´ eaire

/********************************

* generateur pseudo-aleatoire base sur la congruence

*

* entree :

* aucune

*

* sortie :

* nombre non attendu suivant

*******************************/

int rand() { n = (a * n + c) % M;

return n;

}

void setup() { randSeed(23456);

println(rand());

println(rand());

}

Mersenne-twister (Makoto Matsumoto et Takuji Nishimura 1997)

Bas´e sur les nombres de Mersenne 2^p−1 P´eriode 2¹⁹⁹³⁷−1

distribution uniforme sur 623 dimensions

N’est pas un g´en´erateur adapt´e `a la cryptographie, mais tr`es utile en simulation et optimisation.

Propri´ et´ es statistiques du pseudo-al´ eatoire

Les g´en´erateurs pseudo-al´eatoires sont con¸cus pour g´en´erer des nombres selon une loi ”proche” d’une loi uniforme

U(0,maxValue−1).

Certaines propri´et´es statistiques attendues

Propri´et´e de la distribution des nombres : moments, fr´equence d’apparition des nombres, comparaison `a la loi uniforme Entropie maximale

Ind´ependance statistique des nombres de la s´erie : autocorr´elation, test spectral

G´ en´ erateur pseudo-al´ eatoires de nombres flottants

Initialisation de la graine al´eatoire randomSeed(n)

Nombre al´eatoire (float) entre 0 et b (b exclu) random(b)

Nombre al´eatoire (float) entre aet b (b exclu) random(a, b)

G´ en´ erateur pseudo-al´ eatoires de nombres entiers

Nombre al´eatoire (int) entre 0 et b−1 int(random(b))

Nombre al´eatoire (int) entre a etb−1 int(random(a, b))

Jeu o` u 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");

}

Simulation de lancer de fl´ echettes

/********************************

* 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;

}

Simulation de lancer de fl´ echettes

/********************************

* 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;

Simulation de marche al´ eatoire

Simulation une marche al´eatoire den pas sur l’ensemble des entiers (positifs ou n´egatif) 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--;

}

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);

}

Objectifs de la s´ eance 6

Faire la diff´erence entre al´eatoire et pseudo-al´eatoire

Simuler un nombre pseudo-al´eatoire entier ou flottant entre 2 bornes donn´ees

Ecrire un algorithme utilisant un g´en´erateur pseudo-al´eatoire Ecrire un algorithme qui g´en`ere des s´eries temporelles du type u_t+1 =au_t+b+et u_t+1 = (a+)u_t+b

Question principale du jour :

Comment g´en´erer une s´erie de nombres qui ont l’air d’ˆetre al´eatoires ?