rand Générateur de nombres pseudo-aléatoires

## Séquence d'appel

                r = rand()
                r = rand(m1,m2,...)
                r = rand(m1,m2,...,key)
                r = rand(x)
                r = rand(x,key)

                s = rand("seed")
                rand("seed",s)

                rand(key)
                key = rand("info")

## Paramètres

mi

  entiers

key

  chaîne de caractères, `"uniform"` ou `"normal"` (par défaut: `key="uniform"`)

x

  tableau (vecteur, matrice, hypermatrice) de booléens, nombres, ou polynomes, dont uniquement les dimensions et le caractère réel ou complexes sont pris en compte.

r

  tableau de nombres décimaux ou complexes, de taille m1-par-m2-par-... avec des valeurs aléatoires.

s

  un entier positif, la graine (par défaut: `s=0`).

## Description

Le but de cette fonction est de retourner un tableau de nombres dont les valeurs sont des nombres aléatoires réels ou complexes. En fonction des arguments d'entrée, la fonction peut renvoyer une matrice de doubles aléatoires or peut configurer ou récupérer la distribution des nombres aléatoires ou peut configurer ou récupérer la graine du générateur aléatoire.

## Générer des nombres aléatoires

Sans l'argument `key` la syntaxe ci-dessous produit une matrice aléatoire dont chaque élément est la réalisation d'une variable aléatoire suivant une loi donnée (par défaut uniforme sur [0,1]).

r=rand()

  renvoit un scalaire aléatoire.

r=rand(m1,m2)

  est une matrice aléatoire de dimensions `m1` x `m2`.

r=rand(m1,m2,..,mn)

  est une matrice aléatoire de dimensions `m1` x `m2`,.. x `mn`.

r=rand(a)

  est une matrice aléatoire de mêmes dimensions que a. `rand(a)` est complexe si `a` est une matrice complexe.

## Changer la distribution des nombres aléatoires

S'il est présent, l'argument `key` permet de spécifier la loi suivie par défaut par la variable aléatoire.

rand("uniform")

  La loi par défaut est uniforme sur l'intervalle [0,1].

rand("normal")

  La loi par défaut est une loi normale centrée réduite (moyenne 0, variance 1).

key=rand("info")

  renvoie la distribution courante, c'est à dire "uniform" ou "normal".

## Récupérer ou changer la graine

Il est possible de réinitialiser l'état interne du générateur aléatoire (spécifié par un entier de l'intervalle [0,2^31-1]) ):

s=rand("seed")

  Renvoie la valeur courante de la graine.

rand("seed",s)

  Configure la valeur `s` de la graine (par défaut la graine est initialisée à `s=0` au premier appel).

## Exemples

Dans l'exemple suivant, nous générons des doubles associés à différentes distributions.

    // Récupère un double aléatoire (sur la distribution courante)
    r=rand()
    // Récupère une matrice de doubles de taille 4-par-6 (sur la distribution courante)
    r=rand(4,6)
    // Récupère une matrice de doubles de taille 4-par-6 de distribution uniforme
    r=rand(4,6,"uniform")
    // Génère une matrice de doubles aléatoires normaux centrés réduits de même taille que x
    x=rand(4,4);
    r=rand(x,"normal")
    // Génère un tableau de taille 2-par-2-par-2 de doubles aléatoires
    r=rand(2,2,2)

Dans l'exemple suivant, nous changeons la distribution des nombres générés par `rand`. Nous produisons d'abord des nombres normaux centrés réduits, puis des nombres uniformes dans [0,1[.

        // Configure le générateur sur la loi normale
        rand("normal")
        r=rand(4,6)
        // Récupère la distribution courante
        key=rand("info")
        // Configure le générateur sur la loi uniforme
        rand("uniform")
        r=rand(4,6)
        key=rand("info")

Dans l'exemple suivant, nous générons une matrice complexe de doubles de taille 2-par-3, avec une distribution normale centrée réduite.

        // Génère une matrice complex de doubles aléatoires de taille 2-par-3
        x=rand(2,3)+%i*rand(2,3)
        // Génère une matrice complexe de doubles normaux centrés réduits
        // de la même taille que x
        r=rand(x,"normal")

Dans l'exemple suivant, nous dessinons la distribution de 1000 nombres uniformes produits par `rand`.

        r=rand(1000,1,"uniform");
        scf();
        histplot(10,r);
        xtitle("Nombres uniformes par rand","X","Fréquence")

Dans l'exemple suivant, nous dessinons la distribution de nombres normaux centrés réduits produits par `rand`.

        r=rand(1000,1,"normal");
        scf();
        histplot(10,r);
        xtitle("Nombres normaux centrés réduits par rand","X","Fréquence")

## Obtenir des nombres aléatoires prévisibles ou moins prévisibles

Le générateur pseudo-aléatoire "uniform" est une séquence déterministe dont le but est de reproduire une séquence de nombres aléatoire, indépendents et identiquement distribués dans l'intervalle [0,1[.

Dans le but de pouvoir obtenir des simulations reproductibles, la graine initiale du générateur est zéro, de telle sorte que la séquence est la même d'une session à l'autre. En d'autres termes, les premiers nombres produits par `rand` sont toujours : 0.2113249, 0.7560439, ...

Dans certains cas, nous pourrions vouloir initialiser la graine du générateur dans le but de produire des séquences moins prévisibles. Dans cette situation, nous pouvons initialiser la graine avec la sortie de la fonction `getdate`, comme dans l'exemple suivant:

    n=getdate("s");
    rand("seed",n);

## Le générateur

Le générateur de nombres aléatoires `"uniform"` est décrit dans "Urand, A Universal Random Number Generator" par Michael A. Malcolm, Cleve B. Moler, Stan-Cs-73-334, January 1973, Computer Science Department, School Of Humanities And Sciences, Stanford University.

C'est un générateur linéaire à congruence de la forme :

x = (a x + c) mod M

pour lequel les constantes sont :

a = 843314861
c = 453816693
M = 231

D'après les auteurs, ce générateur est de longueur complète, c'est à dire que sa période est M = 231 = 2147483648.

Le générateur de nombres aléatoires `"normal"` est fondés sur la méthode de Box-Muller, pour lequel la source de nombres uniformes est Urand.

## Qualité statistique du générateur

La fonction grand dispose de générateurs aléatoires produisant des séquences de nombres qui possèdent de meilleures qualités statistiques. Par conséquent, dans les situations où la qualité statistique des séquences de nombres aléatoires est importante, nous devrions plutôt utiliser la fonction `grand`. De plus, la fonction `grand` fournit davantage de fonctionnalités.

## Voir aussi

- grand
- ssrand
- sprand