Est la valeur de RAND_MAX toujours (2^n)-1?

Je suis intéressé pour le C++, bien que je soupçonne que, tout simplement, les importations C de définition standard. Je crois que la réponse est non pour ce que dit la norme, mais je suis plus intéressé par la pratique de la réponse.

Si RAND_MAX est toujours (2^n)-1, ce qui simplifie le traitement d'une question qui a tourné récemment le déplacement du code de MinGW GCC sous Linux GCC. RAND_MAX semble être plus grand (je n'ai pas vérifier, mais peut-être égale à INT_MAX ou quel que soit le symbole est), de sorte que certains vieux naïvement écrit RAND_MAX-n'est-ce pas-grand-assez-si-travail-autour-c'est le code retournée contre eux. Maintenant j'ai besoin de décider général j'ai besoin de cette bibliothèque, compte tenu de la fiddliness de l'écriture de code qui s'adapte correctement avec la possibilité de dépassement de capacité sans faire d'hypothèses concernant, par exemple, la largeur d'un int.

De toute façon, il y a aucune raisonnablement largement utilisé compilateurs C++ qui utilisent autre chose que (2^n)-1 pour RAND_MAX?

Aussi, ai-je raison que ((RAND_MAX | (RAND_MAX >> 1)) == RAND_MAX) est toujours et seulement vrai si RAND_MAX est égal à ((2^n)-1) pour un certain entier non signé n. Je crois que RAND_MAX est techniquement un int, mais il n'a pas de sens d'avoir un négatif ou de fractions de valeur, donc je pense que je peux remise de ceux-ci. Peu-manipulation ne fonctionne pas normalement me dérange pas, mais je continue à penser que l'expression ne semble pas être bien, et je ne peux pas comprendre pourquoi.

Enfin, bien que je ne vais pas être heureux jusqu'à ce que j'ai une solution de travail de mon propre, ce qui devrait - je utiliser pour les nombres aléatoires plutôt que de l'écrire moi-même? J'ai besoin de nombres aléatoires dans la plage de 0 <= x < paramètre, et surtout je veux qu'-égalité-comme-sainement possible probabilités pour tous les nombres. Par exemple, en prenant (rand() % upperbound) donne un biais en faveur des petites valeurs, en particulier lorsque le upperbound est grande, je veux l'éviter.

Est-il un coup de pouce ou de C++0x chose pour qui?

MODIFIER

Suite à quelque chose dans le "" peu sur le côté de la page montre qu'il existe en effet un moyen d'obtenir des nombres aléatoires avec donné les limites inférieure et supérieure de suralimentation.

OriginalL'auteur Steve314 | 2011-02-09

c++random

3

Je ne sais pas ce que les garanties sur RAND_MAX sont, mais vous feriez mieux de l'éviter si possible en raison du nombre de fractures de la implémentations autour et parce qu'il commence à vélo assez rapidement dans les applications d'aujourd'hui. Obtenir une distribution uniforme est décrit ici.

Je recommande Coup de pouce.Aléatoire à la place. Le Mersenne twister générateur représente un bon compromis entre la vitesse, l'utilisation de la mémoire et de la qualité.

J'ai déjà un nombre de Mersenne twister mise en œuvre - sans aucune raison valable, juste qu'il était couvert dans un livre. Une bonne version de bibliothèque serait plus pratique, bien sûr. Merci pour les conseils.
J'avais switch de Boost si j'étais vous,; il sépare PRNG les distributions de probabilité, et comprend une random_device classe pour un bon ensemencement (boost.org/doc/libs/release/doc/html/boost/random_device.html).
Accepté d'environ 80% à cause des idées fausses sur ce que rand lien - de Stimuler le point est plus pratique, mais ce lien est très intéressant.
BTW - bien prévu avec le random_device point. L'une des raisons je n'ai jamais réellement utilisé mon MT d'autres que de jouer a la "OK, alors comment puis-je semences correctement". J'ai pensé que si je n'étais pas en train de le faire, il n'y avait pas beaucoup de point de changer quoi que ce soit.
Je pense que Mersenne twister est un peu vieux maintenant, je voudrais utiliser le SMFT: math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html

OriginalL'auteur Fred Foo
5
- Je ne sais pas tout en œuvre pour laquelle RAND_MAX est pas un de moins qu'une puissance de deux, mais ce n'est pas mandaté par la norme;
- ((RAND_MAX | (RAND_MAX >> 1)) == RAND_MAX) est en effet une façon de tester si RAND_MAX est une de moins qu'une puissance de deux.
- Je suis en utilisant
```
int alea(int n){ 
  assert (0 < n && n <= RAND_MAX); 
  int partSize = 
    n == RAND_MAX ? 1 : 1 + (RAND_MAX-n)/(n+1); 
  int maxUsefull = partSize * n + (partSize-1); 
  int draw; 
  do { 
    draw = rand(); 
  } while (draw > maxUsefull); 
  return draw/partSize; 
}
```
pour faire comme répartie uniformément que possible des nombres aléatoires à partir de rand().

Je n'arrive pas à utiliser cette fonction, parce que le RAND_MAX est trop petit problème existe encore sur Windows. Cela dit, je pourrais juste conditionnellement compiler à choisir entre ça et l'utilisation de deux randoms-pour-faire-une version (le code existant n'est que combiné avec quelque chose de très similaire à votre code). C'est ce que j'ai fait un arrêt de l'erreur pour le moment de toute façon - il semble juste comme de la tricherie, c'est tout.

OriginalL'auteur AProgrammer
4

Pour les implémentations de rand qui utilisent une (variante a) Générateur Linéaire à Congruence (la plupart d'entre eux), puis RAND_MAX sera un nombre premier, et pas nécessairement de la forme 2^n - 1 ("un nombre de Mersenne premier").

Aussi, 2^31-1 est un nombre premier, mais si n n'est pas premier, 2^n - 1 n'est pas premier.

(En effet, si n = ab, alors 2^n - 1 = (2^a - 1)(1 + 2^b + 2^(2b) + ...) )

Autour de 2^64, le seul nombre de Mersenne premier est de 2^61 - 1.

Et vous devriez vraiment éviter linéaire générateurs à congruence si vous avez tout à moitié sérieux exigence sur la génération de nombre aléatoire. En fait, je dirais que, à l'exception d'un jeu de tetris, vous devriez éviter de rand() de la bibliothèque C.

Intéressant. Otoh, que - "tetris" n'est pas vraiment loin de la marque - et pour beaucoup de gens, pas seulement moi. Le nombre de personnes qui développent une critique de sécurité des bibliothèques de chiffrement, ou d'autres applications dans lesquelles vous vous souciez vraiment de façon aléatoire ce générateur est vraiment, est probablement assez faible en comparaison avec, par exemple, le nombre de personnes qui veulent compléter leurs tests de régression avec certains randomish-test-les données en fonction des tests ou le nombre de gens qui écrivent des jeux simples.
Linéaire cong. les générateurs de graves défauts, ce qui rend impossible, même pour le plus simple des applications mathématiques. Voir, par exemple. javamex.com/tutorials/random_numbers/lcg_planes.shtml pour voir ce que je veux dire.
mots clés: "mathématiques et applications", et je ne peux accepter que, même pour certains très simples, vous pouvez avoir besoin d'une plus forte générateur. Je vais ajouter "de l'ingénierie à la simulation, qui vient probablement sous mon "autres applications dans lesquelles vous vous souciez vraiment de couverture. Mais sérieusement, pour de nombreux programmeurs, les nombres aléatoires sont quelque chose que nous avons rarement besoin, et quand nous le faisons rand est presque toujours assez bon. Parfois, même "ajouter au dernier numéro de" est suffisante pour générer des données arbitraires, de sauver les mineurs tracas de semis et de la recherche jusqu'à la droite de l'en-tête à inclure.
cela dit, le monde sera probablement un meilleur endroit lorsque plus de gens commencent à utiliser le C++0x bibliothèque standard de nombre aléatoire de soutien. Le plus fort (par défaut?) générateur de nombre aléatoire est de plus en plus un bonus supplémentaire, bien que, étant donné le soutien pour différentes distributions et probablement d'autres bonnes choses.

OriginalL'auteur Alexandre C.
1

De GCC (4.6) RAND_MAX = 0x7FFFFFFF (31bit)
En MS Visual Studio (2012) RAND_MAX = 0x7FFF (15bit)

OriginalL'auteur Tomas Kubes

Dans Embacadero C++ Builder, il y a deux variables définies dans stdlib.h:

/* Maximum value returned by "rand" function*/
#define RAND_MAX  0x7FFFU

/* Maximum value returned by "_lrand" function (also used by random() macro)*/
#define LRAND_MAX 0x7FFFFFFFU

OriginalL'auteur Bhaskar

1

Dans le standard GNU fichier d'en-tête stdlib.h, il existe une définition de RAND_MAX qui devrait être la seule définition dans votre système:
```
#define RAND_MAX    2147483647
```
La valeur de 2 147 483 647 = 0x7fffffff est le plus grand entier 32 bits non signé.

La rand fonctions, définies dans stdlib.h, sont fiables dans la norme GNU environnements avec un bémol: le multi-threading (pthread) environnements aurez besoin pthread code pour synchroniser afin de protéger le rand(), srand(), et rand_r() appelle car ils ne sont pas réentrant. Voir la page de man pour srand pour une explication.

RAND_MAX ne devrait pas être définie n'importe où ailleurs dans votre système. Si vous voyez une valeur différente pour RAND_MAX ou de voir une définition de RAND_MAX ailleurs stdlib.h, alors ce doit être un non-standard, non-portable de l'environnement. Windows est bien connu pour la fabrication de la normalisation et de la portabilité difficile (E. g. mise en œuvre des sockets et de l'Api).

Ceci est incorrect "valeur 2147483647 = 0x7fffffff est le plus grand entier 32 bits non signé". Valeur 4294967295 = 0xffffffff est le plus grand entier 32 bits non signé. Peut-être que vous avez voulu dire "... plus connecté entier de 32 bits".

OriginalL'auteur texadactyl
1

Selon ISO C (C99 à C17 au moins) et POSIX (Question 7, 2016 Édition), RAND_MAX doit être d'au moins 32767, c'est à dire 2^15-1, et il n'y a pas d'autres restrictions.

Sous GNU/Linux, RAND_MAX est garanti d'être exactement 2147483647 = 2^31-1 sur toutes les architectures pour des raisons de cohérence avec POSIX concernant la random() fonction: POSIX spécifie que la valeur de retour est dans la gamme de 0 à 2^31-1, et Linux random(3) page de manuel documente la gamme de 0 à RAND_MAX.

La question d'origine est assez hors de propos aujourd'hui - il a été demandé en 2011 et s'est concentré sur le C++, mais le C++ a acquis de nouvelles bibliothèques pour les nombres aléatoires dans la 2011 standard (basé sur l'amplification aléatoire de la bibliothèque de l'IIRC). De cours C++ importe encore plus de la norme, et c'est l'information pertinente provenant de C. Et rand est toujours inclus avec qui, même si son utilisation est fortement déconseillée - par exemple std::random_shuffle (qui rand derrière les scènes) a été dépréciée en C++14 et remplacé par std::shuffle (ce qui est un argument supplémentaire pour un "générateur aléatoire uniforme").
Cependant, la question est toujours d'actualité pour C si l'on ne veut pas utiliser une bibliothèque externe.

OriginalL'auteur vinc17

Vous devez vous connecter pour publier un commentaire.