Biaisée Générateur De Nombre Aléatoire

Je suis à la recherche d'un générateur de nombres aléatoires qui peuvent être biaisées. Par exemple, dire que je veux un nombre aléatoire entre 1 et 5, avec la probabilité d'être:

1: Vient en hausse de 20% du temps

2: Vient en hausse de 10% du temps

3: Vient jusqu'à 40% du temps

4: Vient en hausse de 25% du temps

5: Vient en hausse de 5% du temps

Est-il quelque chose dans la bibliothèque standard, ou d'autres bibliothèques qui ferait cela? Sinon, est-il un moyen efficace de faire moi-même?

J'espère que vous n'êtes pas à l'écriture de logiciels pour les casinos!
Haha non, j'en suis sûr, un casino, d'embaucher quelqu'un d'un peu plus intelligent.
D'hier: stackoverflow.com/questions/2772882/... et c'était un double de la pléthore de versions antérieures de la même question (que je suis trop paresseux pour trouver). Le mot que vous mai ont été portées disparues dans la recherche est "discret", ce qui est important car un certain nombre de réponses ci-dessous s'appliquent mieux à continue de distributions.
copiez et collez code testé pour c# ... stackoverflow.com/a/33991225/294884 ... fonctionne avec n'importe quel tableau trivialement

InformationsquelleAutor cmptrer | 2010-05-05

c++random

9

Le coup de pouce de nombre aléatoire bibliothèque offre la possibilité de spécifier différents en forme de distributions de votre groupe électrogène. C'est une grande bibliothèque - voir http://www.boost.org/doc/libs/1_42_0/libs/random/index.html.
- Oui, ne pas réinventer la roue!
- Un jour, je vais commencer à l'utiliser Boost. Un jour.
- Il lui manque juste une bonne documentation... serait bon de savoir ce que les concepts requis pour le moteur et la distribution de façon à être en mesure de concevoir son propre sans rétro-ingénierie de la bibliothèque 🙁
- Les bibliothèques sont bonnes, mais je pense qu'il est sûr de dire qu'il est un assez nouveau programmeur, dans ce cas, ils sont plus un obstacle que vous avez besoin de l'expérience dans un premier temps pour s'habituer à la logique.
- La rédaction de votre propre générateur de nombre aléatoire se heurte à des problèmes à l'aide d'un existant, testé l'une est un bien meilleur pari.
- Découvrez TR1 est de l'aléatoire de la bibliothèque. (Aléatoire lien de Google: johndcook.com/cpp_TR1_random.html.) Probablement fourni avec votre compilateur et probablement un cousin de Boost, avec un niveau plus élevé de la documentation.
InformationsquelleAutor
16

Pour votre problème, il suffit de choisir un élément au hasard dans cette liste de manière uniforme:
```
[1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5]
```
En général, cochez cette réponse: Pondérée des nombres aléatoires

Dans TR1 et C++0x, il est <random> de l'en-tête qui contient le discrete_distribution de la classe pour générer de tels numéros, entre autres.

Vous pouvez également vouloir vérifier GSL qui contient beaucoup plus de aléatoire des distributions (et des générateurs de nombres aléatoires) que la norme <random> de la bibliothèque. (Mais notez que la GSL utilise la GPLv3.)
- Je devrais peut-être l'ai expliqué ma situation est un peu mieux. Ce que j'ai vraiment besoin sera un nombre aléatoire entre 1 à 50,000 ish. Création d'une liste que long me semble inutile, et inutiles. Désolé pour la confusion.
- C'est pourquoi un bon de l'ingénierie nécessite un bon ensemble d'exigences. Vous avez demandé pour le cas simple et que vous avez la (correcte) de réponse simple.
InformationsquelleAutor kennytm
12

Meilleur moyen est sans doute de prendre le normal impartiale générateur aléatoire puis rendement basé sur l'intervalle de sa valeur tombe dans.

Juste une instruction if qui donne 1 pour 0:de 0,2, 2 0,2:de 0,3, 3 0,3:0.7, 4 pour de 0,7 0,95 et 5 pour 0.95:1. Le mieux à faire, soit la limite inférieure ou supérieure de l'intervalle inclusive et l'autre exclusif.
```
int biasedRandom(){
double i = randomNumber();
if(i<= 0.2){return 1;}
else if(i <= 0.3){return 2;}
else if(i <= 0.7){return 3;}
else if(i <= 0.95){return 4;}
else{return 5;}
}
```
Quelque chose comme ça.
- Si vous avez tout un tas d'intervalles à vérifier, ce que vous devez faire est de venir avec une distribution cumulée array (n'était pas sûr de ce que l'appeler) et faire une recherche binaire sur elle à chaque fois de trouver le numéro qui a été généré.
- Semble de ce générateur sera de retour 5 toujours. Double/flotteurs nécessaires et quelques autres mathématiques à moins que randomNumber() renvoie une valeur de 0-1.
- Ouais vous avez raison, il aurait donné 5 à chaque fois, ne signifie pas faire j'ai un int, c'était une erreur. Merci pour ça.
InformationsquelleAutor AaronM
5

Ce que vous décrivez est la mise en œuvre d'un générateur de nombre aléatoire qui dessine à partir d'une distribution de probabilité. Par exemple, des numéros de dessin à partir d'une distribution Gaussienne devrait tirer des nombres aléatoires tels que la probabilité d'un tirage, x est proportionnelle à

_{(source: wikimedia.org)}

.

En général, l'approche est de dessiner à partir d'une distribution aléatoire uniforme, puis choisissez la valeur de la distribution désirée de la fonction de répartition cumulative (CDF) à celui établi emplacement. Dans le cas Normal d'une Gaussienne, de tirer un nombre au hasard, x à partir d'une distribution uniforme (c'est ce que la norme des générateurs de nombres aléatoires devraient donner) et ensuite choisissez que l'aléatoire Gaussien distribué valeur. Pour votre cas, le CDF que vous décrivez est une pièce sage continue d'escalier qui pourrait être mis en œuvre à l'aide de l'une des nombreuses (bonnes) réponses que vous avez déjà reçues.

Bien sûr, ce n'est que baliverne. Ce que vous devrait faire, c'est à l'aide d'une bibliothèque qui prend en charge pour vous. Les statistiques et la génération de nombres aléatoires ne sont pas négligeables et il n'y a pas besoin de ré-inventer la roue. Voir Neil réponse (et de vérifier le Boost nombre aléatoire de la bibliothèque).

InformationsquelleAutor Barry Wark

Arrivé en retard à la partie sur celui-ci. Ici, c'est le C++0x réponse:

#include <iostream>
#include <random>
#include <iterator>

int main()
{
    //Set up distribution
    double interval[] = {1,   2,   3,   4,   5,   6};
    double weights[] = {  .2,   .1,  .4,  .25, .05};
    std::piecewise_constant_distribution<> dist(std::begin(interval),
                                                std::end(interval),
                                                std::begin(weights));
    //Choose generator
    std::mt19937 gen;  //seed as wanted
    //Demonstrate by pouring into avg[rand-1]
    const unsigned N = 1000000;
    double avg[sizeof(weights) / sizeof(weights[0])] = {0};
    for (unsigned i = 0; i < N; ++i)
        avg[static_cast<unsigned>(dist(gen)) - 1]++;
    //Comute averages
    for (double* i = std::begin(avg); i < std::end(avg); ++i)
        *i /= N;
    //Display
    for (unsigned i = 1; i <= sizeof(avg)/sizeof(avg[0]); ++i)
        std::cout << "avg[" << i << "] = " << avg[i-1] << '\n';
}

Qui, pour moi, les résultats:

avg[1] = 0.199779
avg[2] = 0.100002
avg[3] = 0.400111
avg[4] = 0.250257
avg[5] = 0.049851

+1 Excellente réponse!

InformationsquelleAutor Howard Hinnant

0

Pourquoi ne pas simplement utiliser un générateur de nombre aléatoire que le numéro de retour compris entre 0.0 et 1.0, et l'envelopper avec une autre fonction qui renvoie un nombre en fonction de vos exigences?

comme
```
double biased (double seed) {
if (seed >= 0.0 && seed <0.2) return 1;
else if  ...
}
```
- Je ne voudrais pas utiliser seed comme identificateur pour un numéro généré de façon aléatoire, c'est déroutant...
- Pourquoi pas? Le C fonction rand prend également une graine, dans la plupart des cas, le système de temps. Donc biaisée est une fonction qui génère un nombre aléatoire basé sur une graine.
InformationsquelleAutor DaClown
0

Jeter de façon aléatoire un nombre réel x dans [0,1], if 0< x<0.2 return 1, if 0.2<x <0.3 return 2, etc.

Voir ici pour le problème général.

InformationsquelleAutor leonbloy
0

Kenny a donné une réponse appropriée adapté selon votre fréquence de distribution.

Le plus de réponse générale travaille avec un CDF - la Fonction de Distribution Cumulée pour les données, et utilise un nombre aléatoire uniforme de sélectionner une valeur dans la distribution.

InformationsquelleAutor Jonathan Leffler
0

Je suis en train de faire pour faire la même chose et j'ai trouvé ceci:
http://eli.thegreenplace.net/2010/01/22/weighted-random-generation-in-python/

Semble assez bon pour le but que vous avez déclaré.

InformationsquelleAutor Animesh Agarwal

#include <boost/random/discrete_distribution.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/variate_generator.hpp>

#include <iostream>

int main()
{

  unsigned int seed = 42;
  boost::mt19937 generator(seed);

  //return 0 with probability 10%
  //       1                  40%
  //       2                  50%
  boost::random::discrete_distribution<int> custom_dist{1,4,5};

  boost::variate_generator<boost::mt19937&,
  boost::random::discrete_distribution<int> > rndn(generator, custom_dist);

  for (unsigned int i = 0; i<10000; i++) {
    std::cout << rndn() << std::endl;
  }

  return 0;

}

Et voici une représentation graphique de la suite:

Biaisée Générateur De Nombre Aléatoire

InformationsquelleAutor sbalian

Vous devez vous connecter pour publier un commentaire.