réels aléatoires (double ou long double)

Bonjour !
J'ai trouvé beaucoup d'informations sur la répartition aléatoire des entiers mais pas des réels.
J'ai besoin d'obtenir des réels aléatoirs entre des bornes précises.
Le problème est que je ne pense pas qu'utiliser la fonction rand() utilisée pour les entiers soit efficace car j'ai besoin d'une très grande précision pour mes réels (je prévoie d'utiliser les double voire long double).
Me ramener à des réels par des divisions à partir d'entiers fournis par rand() ne donnerait pas une bonne répartition, certains réels ne pouvant jamais être obtenus.

Je voudrais donc savoir si quelqu'un a la solution à ce problème : algorithme ou bibliothèque à utiliser.

Une solution pourrait être de construire le réel en donnant une valeur aléatoire à chaque bit mais je ne sais pas comment le faire, et ni ce sera réellement efficace.

Merci à qui pourra m'aider !

Citation:

---

Une solution pourrait être de construire le réel en donnant une valeur aléatoire à chaque bit mais je ne sais pas comment le faire, et ni ce sera réellement efficace.

---

Sans aller jusque là il existe de bonne bibliothèques qui travaillent sur les nombres à longueur et précision arbitraire et fournissent des utilitaires trés puissants.

On peut tout à fait concatener des nombres entiers aléatoires afin d'en obtenir un plus grand, ou alors des réels.
La qualité de répartition des nombres réels obtenus sera identique à celle des nombres entiers.

Par exemple, si on génére des entiers aléatoires entre 0 et 999 : 367, 903, 007, 812, ...

Alors, en les concatenant : 0,367903007812...

(Ensuite, on peut multiplier ce nombre entre 0 et 1 afin d'obtenir un réel enter 2 bornes quelconques a et b).

On peut tout aussi le faire digit par digit.

Oui mais cela risque d'obliger à faire des conversions entre string et nombre en faisant un formatage par flux:
http://c.developpez.com/faq/cpp/?pag...RINGS_strtonum

Non, pas forcément, car, par exemple :

0,123456 = 123/1000 + 456/1000000

Ou plus précisément:

Code:

---

1 2	0.123456=123.0/1000+456.0/1000000

---

car:

Code:

---

0,123456 = 123/1000 + 456/1000000

---

renvoie 0.

Oui, c'était juste pour expliquer le principe, après, on fait ce qu'on veut.

Pourrais-tu seriousme me donner le nom de bibliothèques que tu trouves efficaces ou l'endroit où je peux les trouver.

Sinon pour la concaténation il faudrait alors que je gère par exemple le type string en redéfinissant les opérations, ce qui n'est pas gênant mais je vais devoir appliquer à men réels des fonctions prédéfinies comme les fonctions cosinus et sinus par exemple.
Alors il faudrait convertir cette chaine de type string en un double qui lui est associé, en lisant la chaîne de caractères. Ton idée me semble pas mal.

Vous avez raison, on peut directement construire le réel avec les entiers.
Merci beaucoup, je n'ai donc pas besoin de bibliothèques!

Le problème est résolu !

Non, il n'y a pas besoin de string !!

On peut tout faire en restant avec des réels.

Il est vrai qu'on emploie le mot "concatener" pour des chaines de caractère en général, mais ce n'est pas pour cela que je l'ai utilisé ici ...

Citation:

---

Envoyé par koushkov

Le problème est résolu !

---

Alors pense à mettre : :resolu:

Citation:

---

Sinon pour la concaténation il faudrait alors que je gère par exemple le type string en redéfinissant les opérations

---

Non la concaténation est gérée par la classe string avec la redéfinition de l'opérateur "+".

Oui j'avais compris c'est parce que j'avais commencé mon message avant toutes vos réponses.
Par exemple pour un réel entre 0 et 1, j'initialise mon réel à 0
puis je le construis en lui additionnant des nombres jusqu'à ce que ma mantisse soit complétée, ce qui va dépendre de la position de mon premier chiffre non nul.

ex : si mon réel est construit par assemblage de nombres à 3 chiffres
alors si mon réel commencera par 0.002..., il me faudra deux chiffres de plus que s'il avait commencé par 0.894...

Merci encore !

boost.random propose des outils un peu plus puissants que la fonction rand() de la bibliothèque standard C.

Je plussoie loufoque ;)

Ok !
Je vais essayer d'utiliser boost car j'ai besoin d'un bon générateur (rapide) car j'ai besoin de générer des réels aléatoirs très souvent !
Faut que j'apprenne à utiliser la fonction uniform_real !
Rq : La fonction uniform_on_sphere à l'air pas mal pour les problèmes géométriques!

J'ai trouvé ça à propos de la fonction uniform_real :
"Note: The current implementation is buggy, because it may not fill all of the mantissa with random bits. "
Donc tant pis, je vais finalement réutiliser la première idée et donner ma répartition de réels à partir d'entiers même si les performances ne seront peut-être pas au rendez-vous !
Merci quand même!

Citation:

---

"Note: The current implementation is buggy, because it may not fill all of the mantissa with random bits. "

---

C'est probablement un problème qui n'existe que sur les plateformes non usuelles.
Le problème doit venir du fait qu'il n'est pas possible de savoir la taille de la mantisse de façon portable.

Ok merci !
Finalement, avec quelques difficultés (beaucoup), j'ai réussi à comprendre la bibliothèque random de boost et elle est vraiment bien avec des générateurs intéressants.
Le seul petit problème qui peut diminuer mes performances, est que, si dans une boucle, j'ai besoin, par exemple, de générer un nombre aléatoire de 0 à n, puis de 0 à n-1, ..., jusqu'à 0 à 1, il faut créer un générateur différent pour chaque étape, mais c'est sans doute un passage obligé (avant je programmais en Caml avec la fonction random__int(n) et je ne me rendais pas compte de ce problème).