Random distribution gaussienne avec minimum

0.16*25*25 = 100
Si je voulais répartir équitablement ces 100 éléments dans les 25*25 cases, j'en aurais 0.16 par case. Mais je veux pas que ça soit équitable, je veux que ça soit aléatoire.

Il faut donc une distribution en cloche, parce que si je tire en équiprobabilité des nombres entre 0 et 100, mon tableau risque d'être rempli en quelques cases et toutes les suivantes seraient vide.

C'est plus clair ou pas ?

Merci pour ton aide.
Cependant cette solution ne peut pas convenir parce que la moyenne est de max-min, donc 50, alors que je la veux de 0.16.
En fait, la gaussienne n'est pas adaptée parce que la loi que je veux est asymétrique, contrairement à la loi normale.

"la moyenne est de max-min, donc 50, alors que je la veux de 0.16"
Je ne sais pas comment tu as fait pour obtenir 50 avec max-min, mais dans le cas général la moyenne est (min+max)/2. Alors je ne sais pas ce que tu veux faire avec ton 0.16, mais quoi que tu fasses, si tu mets 100 éléments dans 250 cases tu auras toujours 40% de cases remplies, peu importe la distribution que tu utilises.

Avec une distribution gaussienne tu règles surtout le problème "si je tire en équiprobabilité des nombres entre 0 et 100, mon tableau risque d'être rempli en quelques cases et toutes les suivantes seraient vide." même si là encore je me demande pourquoi tu veux tirer entre 0 et 100 alors que tes cases vont jusqu'à 250 !

Exemple :

Random random = new Random();
boolean[] tab = new boolean[250];
for (int i=0; i<100; i++) { // on remplit 100 cases
    int pos;
    do { // on cherche un nombre entre 0 et 250
        pos = (int) Math.floor(nextGaussian(random, 0, 250));
    }
    while (tab[pos]); // tant que la position du tableau est déjà remplie
    tab[pos] = true;
}

// affichage
for (int i=0; i<250; i++)
    System.out.println(i+"\t"+tab[i]);

Ce qui donne bien 100 cases remplies entre 0 sur les 250 que contient le tableau, avec une distribution gaussienne qui favorise bien davantage le milieu du tableau que les bords.
Exemple avec la valeur 1 pour les cases remplies et 0 pour celles restées vides.

Je dois mal m'exprimer, tu n'as pas du tout compris ce que je veux.
Le tableau que je veux remplir est en deux dimensions, avec 25 indices pour chaque dimension. Ensuite, ce tableau ne contient pas des booléens, mais des entiers (ou des réels, ça change pas grand chose). Le total des valeurs de toutes les cases du tableau doit être égal à 100.

Voilà le code :

int[][] tableau = new int[25][25];
for(int i=0; i<25; i++)
  for(int j=0; j<25; j++){
    double alea = generer_aleatoire();
    tableau[i][j] = Math.round(alea);
  }

Je veux une fonction generer_aleatoire() qui envoie des nombres de manière aléatoire tels que si je fais la somme de toutes les cases du tableau, je vais trouver (environ) 100.

J'ai proposé deux possibilités dans mon message ci-dessous. Mais c'est empirique, je trouve pas comment calculer la valeur exacte du 0.58 que j'ai mis.

Alors, je ne sais toujours pas à quoi correspondent les valeurs 0.16 ou 0.58 que tu cherches à obtenir, mais si je comprends bien ce que tu veux faire c'est ça :
width=25, height=25, objective=100, precision=0.001

Si on fait une coupe sur une ligne, une colonne, ou une diagonale, on obtiendras toujours une gaussienne (de plus en plus déformé quand on s'éloigne du centre).

Voici le code, en reprenant la méthode nextGaussian que je t'ai proposé hier :

// initialisation
Random random = new Random();
int width = 25, height = 25;
double objective = 100;
double precision = 0.001;
double[][] tab = new double[width][height];

// remplissage
for (int i = 0, n = (int) (objective / precision); i < n; i++) {
    int posX = (int) Math.floor(nextGaussian(random, 0, width - 1));
    int posY = (int) Math.floor(nextGaussian(random, 0, height - 1));
    tab[posX][posY] += precision;
}

// affichage
for (int y = 0; y < height; y++) {
    for (int x = 0; x < width; x++)
        System.out.print(tab[x][y] + "\t");
    System.out.println();
}

Je passe en résoluj, mais si quelqu'un a une meilleure solution, je suis preneur ! :)

Ton problème est compliqué à comprendre parce que je ne vois pas du tout l'intérêt que tu as à faire un tel code... Mais cela dit j'ai encore plein de propositions :-)

Donc si je comprends mieux (tu me diras), le 0.58 tu peux l'obtenir rétroactivement, c'est à dire que tu peux remplir aléatoirement toutes tes cases, calculer la somme que ça fait et ce qui te manque (ou ce que tu as en trop) pour atteindre ton 100 attendu, et repasser sur chaque case pour ajouter la différence.

Random random = new Random();
double[][] tableau = new double[25][25];
double objective = 100;

double total = 0;
for (int i = 0; i < 25; i++) {
    for (int j = 0; j < 25; j++) {
        double val = random.nextGaussian();
        tableau[i][j] = val;
        total += val;
    }
}

double delta = (objective - total) / (25 * 25);
System.out.println("delta=" + delta);

for (int i = 0; i < 25; i++) {
    for (int j = 0; j < 25; j++) {
        tableau[i][j] += delta;
        System.out.print(tableau[i][j] + "\t");
    }
    System.out.println();
}

Remarque : la valeur delta suit également une gaussienne et je tombe bien sur 0.16 comme valeur moyenne, mais c'est trop peu probable pour utiliser systématiquement cette valeur, il vaut mieux un delta calculé dynamiquement.

Courbe obtenue pour 10 millions de calculs de delta arrondis à trois décimales.pour un objectif de 100 sur une grille 25x25.

Si tu ne veux jamais de valeurs négatives alors il faut reprendre la méthode que j'ai mis plus haut qui te permet d'avoir un nombre aléatoire entre les valeurs min et max (par exemple 0 et 1), sauf que pour normaliser ta somme il vaudrait mieux multiplier plutôt qu'ajouter.

Random random = new Random();
double[][] tableau = new double[25][25];
double objective = 100;

double total = 0;
for (int i = 0; i < 25; i++) {
    for (int j = 0; j < 25; j++) {
        double val = nextGaussian(random,0,1);
        tableau[i][j] = val;
        total += val;
    }
}

double delta = objective/total;
System.out.println("delta=" + delta);

for (int i = 0; i < 25; i++) {
    for (int j = 0; j < 25; j++) {
        tableau[i][j] *= delta;
        System.out.println(tableau[i][j]);
    }
}

"Dans la grille, il y a 100€ répartis aléatoirement. Chaque case peut contenir jusqu'à 100€, mais c'est très peu probable. En pratique, il est très rare de trouver plus de 3€ derrière une case."

Il est impossible d'avoir une case avec 100€. Il faudrait pour ça avoir un tirage entre 0 et 1 qui soit égal à 1 (ce qui est quasiment impossible) et qu'en plus les 624 autres tirages soient exactement à 0... Même 3€ est improbable.

J'ai fait les tests sur 100 000 grilles (chacune totalise 100€ réparties sur 625 cases), et si on arrondis les tirages aléatoires aux centimes en moyenne on obtient une répartition comme ceci :

Remarque : la forme de ces résultats dépend des paramètres

EMPIRICAL_MIN = -6

et

EMPIRICAL_MAX = +6

que j'ai utilisé dans ma méthode nextGaussian, mais on pourrait jouer sur ces valeurs pour que la probabilité d'avoir 0 ou 1 quand on tire un nombre entre 0 et 1 soit beaucoup plus probable, par exemple avec 0 et +3 on ne se servirait que d'une partie de la courbe, la probabilité d'avoir 0 serait maximale et celle d'avoir 1 serait faible mais non nulle


Remarque : même si la probabilité de tirer 1 entre 0 et 1 serait plus importante, ça ne veut toujours pas dire que cela correspond à la probabilité d'avoir 100€. Si tu veux que l'on puisse avoir 100€ alors il faut augmenter le total de la grille.

Si je reprends un peu la discussion, le but du programme était de repartir 100 € sur 625 cases soit environ 0.16€ par case, en pratique ça dépassait rarement 0.25€.
Alors comment veux tu mettre des entiers là dessus ?

Remarque : sans information supplémentaire de ta part, je considérerai que tu utilises ces deux codes là (ce sont les dernières versions dans la discussion) :
https://forums.commentcamarche.net/forum/affich-32823135-random-distribution-gaussienne-avec-minimum#3
https://forums.commentcamarche.net/forum/affich-32823135-random-distribution-gaussienne-avec-minimum#13