la création d'un nombre aléatoire entre 0 à 1 en permanence

Je suis en train de modéliser un prix de l'action du mouvement en C++. J'ai besoin de créer un nombre aléatoire entre 0 et 1.

Mais il semble que le générateur de nombre aléatoire de la valeur ne cesse d'augmenter et n'est pas vraiment aléatoire.

Le code ressemble à ceci:

#include<iostream>
#include<ctime>
#include<cstdlib>
#include<time.h>

using namespace std;

int main()
{
    double stockPrice = 25;
    int start = 0, end = 0;
    start = clock();

    srand (time(NULL));
    cout << (double) rand() / (double) (RAND_MAX) << endl;
    system("pause");

    while(stockPrice > 18)
    {
        if(stockPrice == 20)
        {
            double probability = (rand()/(double)RAND_MAX);
            if(probability <= (1/10))
            {
                stockPrice = stockPrice-1;
            }
            else
            {
                stockPrice = stockPrice +1;
            }
        }
        else if (stockPrice < 20)
        {
            double probability = (rand()/(double)RAND_MAX);
            if(probability <= (1/3))
            {
                stockPrice = stockPrice -1;
            }
            else
            {
                stockPrice = stockPrice +1;
            }
        }
        else 
        {
            double probability = (rand()/(double)RAND_MAX);
            if(probability <= (2/3))
            {
                stockPrice = stockPrice -1;
            }
            else
            {
                stockPrice = stockPrice +1;
            }
        }
        cout << stockPrice << endl;
    }

    end = clock();

    double t = (double)(start-end)/CLOCKS_PER_SEC;
    cout << t << endl;
    system("pause");
}

Vous ne savez pas comment résoudre ce.. Besoin de quelques conseils...

"le générateur de nombre aléatoire de la valeur ne cesse d'augmenter et n'est pas vraiment aléatoire." - non!
si cela se produit à chaque ré-exécuter le programme, here est l'explication.
Puisque c'est le c++, pourquoi n'utilisez-vous pas tout de la moderne générateurs de nombres aléatoires sont fournis? random_device
Jetez un oeil à la bibliothèque standard uniform_real_distribution.
"mieux" comme à résister mieux (statistique) des tests lorsque par rapport aux propriétés d'un "true" générateur aléatoire, voir par exemple ici: en.wikipedia.org/wiki/Pseudorandom_number_generator

OriginalL'auteur lakesh | 2013-09-30

algorithm c++math random

8

Besoin de quelques conseils...

orientation 1:

corriger les comparaisons, vous devez utiliser
```
double probability = (rand()/(double)(RAND_MAX + 1));
                                               ^
                                        for better scaling
```
car actuellement en ligne if(probability <= (1/10)) vous êtes en comparant avec 0 en raison de la conversion 1/10 1/3 et 2/3 entier

orientation 2:

après tout, vous pouvez utiliser le générateur avec une meilleure propriétés statistiques
```
#include <random>
#include <iostream>

    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> dis(0, 1);
    double uniformOn01 = dis(gen);
```
Le générateur de nombre aléatoire est pas le problème. Le problème est de comparer les probabilités dont les valeurs sont comprises entre 0 et 1 avec les fractions comme 1/3; les valeurs de ces fractions sont toujours à 0.
Je pense que vous devriez utiliser rand()/((double)RAND_MAX + 1) pour éviter les problème de dépassement d'entier.

OriginalL'auteur 4pie0
1
```
if(probability <= (1/3))
    {
    stockPrice = stockPrice -1;
    }
else
    {
    stockPrice = stockPrice +1;
    }
```
Depuis probabililty n'est jamais négatif, ce code presque toujours incrémenter la valeur de stockPrice. Le seul moment où il ne sera pas, c'est quand probability est de 0. C'est parce que 1/3 est entier division, et sa valeur est de 0. Modifier l'ensemble de ces fraction de quelque chose comme 1.0/3 et les choses seront beaucoup mieux. Et cela a rien à voir avec la qualité du générateur de nombre aléatoire. Certaines personnes se exercé quand ils voient rand qu'ils ne voient pas autre chose.

Cependant, il y est une faille dans la mise à l'échelle dans le code. Au lieu de
```
double probability = (rand()/(double)RAND_MAX);
```
utilisation
```
double probability = (rand()/(double)(RAND_MAX + 1));
```
Comme écrit à l'origine, la valeur de probability sera de 1 à chaque fois que rand() produit la valeur RAND_MAX, et il va produire d'autres valeurs beaucoup plus souvent.

OriginalL'auteur Pete Becker
0

Dans tous vos cas où vous comparer la probabilité que vous avez de division entière, qui aboutissent à 0... au lieu de (2/3) vous vouliez (2/(double)3) ou 2/3.0.

Si cela est vrai, il ne répond pas à la question posée. xD
euh, oui, il fait répondre à la question. La façon dont le code est écrit, il sera presque toujours incrémenter le prix des actions.
Je pense que la question est en relation avec les valeurs du nombre aléatoire lui-même, et non pas le prix des actions.
malgré le bruit de l'anti-rand les gens, il n'y a pas de mise en œuvre sur la planète qui fait ce que la question décrit. Le code lui-même est mauvais, et il va augmenter le prix des actions. Si il y a encore des problèmes après avoir fixé, il être approprié d'examiner la qualité de la génératrice. Cependant, pour un programme simple comme cela, rand est assez bon, et tous les problèmes sont dans le code lui-même.
vous êtes de droite. Merci pour cette idée.

OriginalL'auteur Michael

Vous devez vous connecter pour publier un commentaire.