C++

générer une suite de bits aléatoire

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : générer une suite de bits aléatoire

lynz

bonjour ;
svp quelqu'un peut me dire pourquoi ce programme n'affiche pas des résultats correctes.

Je veux générer un tableau qui contient des suite aléatoires des 0 et 1, et autre tableau génère les positions aléatoires. A partir des positions du 2em tableau je veux accéder au 1er tableau et modifier les positions c'est à dire si le 1er tableau contient un zéro je le rend 1 et vise versa.

void Bruit(){
int tab4[100];
int tab3[100];
char tab2[100];
int m;
int h;
char w='x';
char v='+';
cout <<"\n \n les suites aléatoires générées : \n \n";
for(int m=0;m<1000;m++)
{

tab3[m]=rand()%2;
cout<<tab3[m];
}

cout <<"\n \n les positions bruitees: \n \n";
for(int m=0;m<100;m++){
tab4[m]=rand()%1000;
cout<<tab4[m]<<" ";}

cout <<"\n \n les suite des bits bruitees sont: \n \n";

for(int m=0;m<100;m++){
if(tab3[tab4[m]]==1)
{tab3[tab4[m]]=0;}
else
{tab3[tab4[m]]=1;}

cout<<tab3[m]<<" ";}

}

Publicité

gilou

Modérateur
Modzilla

Dans le code que tu as donné, il y avait deux emplois de 1000 à la place de 100, ce qui donnait des valeurs en dehors des bornes du tableau.
E corrigeant cela et reformatant le code, on obtient ceci qui compile:

Code :

#include <iostream>
#include <string>
#include <ctime>
#include <cstdlib>
using namespace std;
void Bruit() {
const int tsize = 100;
char tab2[tsize];
int tab3[tsize], tab4[tsize];
int m, h;
char w = 'x', v = '+';
string lspacing = "\n \n ", rspacing = " \n \n";
cout << lspacing << "les suites aleatoires generees:" << rspacing;
for (int m = 0; m < tsize; ++m) {
tab3[m] = rand() % 2;
cout << tab3[m];
}
cout << lspacing << "les positions bruitees:" << rspacing;
for (int m = 0; m < tsize; ++m) {
tab4[m] = rand() % tsize;
cout << tab4[m] << " ";
}
cout << lspacing << "les suite des bits bruitees sont:" << rspacing; ;
for (int m = 0; m < tsize; ++m) {
tab3[tab4[m]] = tab3[tab4[m]]?0:1;
cout << tab3[m] << " ";
}
}
int main() {
srand( unsigned(time(NULL)) );
Bruit();
return 0;
}

C:\clang>bruit.exe

les suites aleatoires generees:

0110101001101110001110101000001011001010101011110000011000001000011111001101010000011110010010100111

les positions bruitees:

99 91 71 23 29 40 42 16 28 98 50 41 71 85 35 10 44 8 13 71 55 59 85 78 93 39 92 60 4 81 44 8 45 24 91 69 49 57 50 64 40 80 62 6 63 92 83 60 61 99 21 99 29 83 31 36 30 81 72 89 42 60 0 37 39 8 15 98 3 35 25 68 11 35 41 40 6 94 91 98 87 66 88 23 92 49 64 11 40 92 59 10 32 86 23 3 25 63 41 14

les suite des bits bruitees sont:

0 1 1 0 1 0 1 0 0 1 1 0 1 1 1 0 1 0 1 1 1 0 1 1 1 0 0 0 1 1 1 0 1 1 0 1 1 0 1 1 1 1 0 0 1 0 1 1 0 1 0 0 0 1 1 1 0 1 0 1 1 1 1 1 1 1 1 1 1 0 0 1 0 1 0 1 0 1 1 0 1 0 0 1 1 1 1 1 1 0 0 1 1 1 0 0 0 1 0 0

A+,

Message édité par gilou le 08-05-2012 à 15:11:47

---------------
There's more than what can be linked! -- Iyashikei Anime Forever! -- AngularJS c'est un framework d'engulé! --

theshockwave

I work at a firm named Koslow

accessoirement, le modulo sur le random est à proscrire. sujet débattu à maintes reprises ici même.

Message cité 2 fois

---------------
last.fm

Profil supprimé

Pourquoi ne pas simplement lire les bits de la variable renvoyé par rand() ? il y en a log2(RAND_MAX) par appel de la fonction.

Pour les lire, faire un masque avec un ET logique, puis un bitshift.

Un truc du genre (j'ai pas essayé) :

int e = rand();
for (j=0; j < log2(RAND_MAX); j++) cout << (e & (1 >> j)) << j;

remplacer ensuite j par ta "position bruitée"

Message édité par Profil supprimé le 07-06-2012 à 22:34:48

Terminapor

I'll see you rise.

theshockwave a écrit :

accessoirement, le modulo sur le random est à proscrire. sujet débattu à maintes reprises ici même.

On utilise quoi dans ce cas pour garder l'uniformité ?

Message cité 1 fois

---------------
Perhaps you don't deserve to breathe

WiiDS

20 titres en GC, 0 abandon, 0 DQ

theshockwave a écrit :

accessoirement, le modulo sur le random est à proscrire. sujet débattu à maintes reprises ici même.

Terminapor a écrit :

On utilise quoi dans ce cas pour garder l'uniformité ?

+1, je veux pas être méchant mais claquer une phrase juste comme ça sans explication ça a aucun intérêt

Message cité 1 fois

---------------
"I can cry like Roger. It's just a shame I can't play like him" - Andy Murray, 2010

Terminapor

I'll see you rise.

Apparemment, le mieux c'est de mettre sur un interval 0-1 et ensuite de régler le résultat :

Code :

int n = (int)(((((double)std::rand()) / RAND_MAX) * 14620) + 1);

(La je crois que c'est pour un nombre entre 1 et 14621)

source : http://stackoverflow.com/questions [...] enerator-c

Message cité 2 fois
Message édité par Terminapor le 08-06-2012 à 16:13:23

---------------
Perhaps you don't deserve to breathe

WiiDS

20 titres en GC, 0 abandon, 0 DQ

Terminapor a écrit :

Apparemment, le mieux c'est de mettre sur un interval 0-1 et ensuite de régler le résultat :

Code :

int n = (int)(((((double)std::rand()) / RAND_MAX) * 14620) + 1);

(La je crois que c'est pour un nombre entre 1 et 14621)

source : http://stackoverflow.com/questions [...] enerator-c

:jap:

Bon à savoir

---------------
"I can cry like Roger. It's just a shame I can't play like him" - Andy Murray, 2010

Un Programmeur

Terminapor a écrit :

Apparemment, le mieux c'est de mettre sur un interval 0-1 et ensuite de régler le résultat :

Code :

int n = (int)(((((double)std::rand()) / RAND_MAX) * 14620) + 1);

(La je crois que c'est pour un nombre entre 1 et 14621)

source : http://stackoverflow.com/questions [...] enerator-c

Une autre methode et une explication plus complete des problemes (y compris ceux de la methode ci-dessus): http://www.bourguet.org/v2/clang/random/

Message édité par Un Programmeur le 08-06-2012 à 16:34:14

---------------
The truth is rarely pure and never simple (Oscar Wilde)

gilou

Modérateur
Modzilla

En prenant celle de ce papier et l'adaptant vite fait:

Code :

#include <cmath>
#include <ctime>
#include <cstdlib>
#include <iostream>
using namespace std;
static const double TWOPI(atan(1.0)*2);
class BitGen {
private:
double X1, Y1, X2, Y2;
const double K1, K2;
public:
BitGen(double x1, double y1, double x2, double y2, double k1 = 150.72, double k2 = 210.37) :
X1(x1), Y1(y1), X2(x2), Y2(y2), K1(k1), K2(k2) {}
int nextBit() {
X1 = fmod(X1 + K1 * sin(Y1), TWOPI);
Y1 = fmod(Y1 + X1, TWOPI);
X2 = fmod(X2 + K2 * sin(Y2), TWOPI);
Y2 = fmod(Y2 + X2, TWOPI);
return (X2 > Y1? 1 : 0);
}
};
int main() {
srand( unsigned(time(NULL)) );
BitGen generator(fmod(rand(), TWOPI), fmod(rand(), TWOPI), fmod(rand(), TWOPI), fmod(rand(), TWOPI));
for (int i = 0; i < 4000; ) {
++i;
cout << generator.nextBit();
if (!(i%75)) {
cout << endl;
}
}
return 0;
}

Un exemple de sortie:

101010100100010111001000110100001011000110100101001111101101100110011101010
010001101111100000011111110001001000111011011011000001110000011010100011001
001000010110000110011111100000001100110101101000100110010001001010111011010
000110101000110110010010111111010100000000101111100110110100011000001001011
100101100110110011011010001000001101111111001001110110010000011001010000011
011010011010000100111111101001011000101010111000001000000011010111100000110
111001100111100110010111111000110001101011011110010101011100001101001000101
010000000001111001010010110011111000111110001010111111111001101110101010010
110110100010101110100110001001000110111111000101101010110101001111011001110
010000000000000011001100010010111011101011111110101000010100001011000101000
101111111011101100111100110111100110110100101100111111000010000000000100000
010011101100110100111010110101100111010001100001101111100011110001100100111
101101001111100110111010101101011011110010101000111110100110000000000110100
111011011110001000111111110010000100101011100001010001011100100110010000110
001000100110100111111001001110101001110101010000010111010011111111011000111
111010010101010111010111110101100000100010101101111010100100110011111001100
001111101000101111100010100011001001111100011001100101100100011110000101011
000100000000110011011011101111110101110010001111111100101101111011111010010
001101010010101011100111011110110010011000101100010000100110100001010111100
101101100100000010101111110101110010101101010000101000100111100011100001101
001010100111101100101101101011010110001010101010010110001011000101000010100
111101000111100100111110110010101111011101011000111111011111011100010010001
111111111100010000101110000000000100010000001110111010000111001101001000000
110110110111111000011011000111110101010010111111001111110001100101010100001
110101110010000010100111001100100011001101001101100111101101011110111110110
011010111011001001010010010100000110001110101000111111001110010111111011101
111110100111011000101001010001010010100100110111110111111010111000110110011
001010011101101110011010111011000000001001110001011010010100111001101000100
110011011111000001010100110111010110100100001000101000100101101000111111001
111011101101111010111101101010101000110010000011111000000100101011100011101
110111000111000001010101101110100101101001110110100001000001100010110111000
010010000101010111101100111110011100001100000001110001111111011000110010010
100110000001100111000001011010100000010000110110001101001111000000100101101
100010001111111000111111010110110100001011010111100010110001000110111001101
101100100001001001100100000110001111011100100010010100011111011110101111110
011010010000010000110011111101010011101001001100111100011001101010101101110
000010001111110100001111110011101000010111001000011101111011010110111100111
111010111000111010011110001000100011100001101000100010000101000111001000100
011010010000101111101001100000000111010011101001011011111011011101100000100
010010100010100000101001011001101100100100101101010100110001001111000101011
010111010011000001111001110100111111000001001000000010001011111000010001101
111010000001101101010010011110100110011000111111010001100001101110110110001
010101001110111111000110110100100111001000101001001010001000110000001110000
011011000100011011010100110001100101001111100010001111000011011010011001100
101111010010100111111110111110001100100110111011010101100111011101001111011
111110001100111111111100101101011010110100000010010111101001011001101101101
101010100110000110011010000111001000000011000001111001110001110110101001001
101001111101000001110101011111101100011001101000111010110100100110110011011
101110001001000010101010000010010110110101000000100010111101001111100010001
111001100001001100100110010101101101011011011111000001111110110001011011010
011011010001011101000110001010111110011100110111110111001001000010100100010
001011110101001000011001110100000101010011001001101001100000101110101001111
110111010011111101011110011101001110110101101011000001010101101000100011001
0001011011011001111110111

A+,

Message édité par gilou le 08-06-2012 à 20:51:30

---------------
There's more than what can be linked! -- Iyashikei Anime Forever! -- AngularJS c'est un framework d'engulé! --

Publicité

theshockwave

I work at a firm named Koslow

WiiDS a écrit :

+1, je veux pas être méchant mais claquer une phrase juste comme ça sans explication ça a aucun intérêt

Edit : du coup c'est ce qui explique l'utilite de passer sur l'intervalle 0-1 comme dit plus haut oui. Apres on n'a pas toujours envie de passer par des floats. Il faut juste retenir qu'il faut utiliser les bits de poids fort

Message cité 1 fois
Message édité par theshockwave le 11-06-2012 à 14:36:31

---------------
last.fm

WiiDS

20 titres en GC, 0 abandon, 0 DQ

theshockwave a écrit :

Roh les boulets qui prennent pas le temps de chercher 30 secondes ...
La fonction rand a une meilleure qualite d'aleatoire sur les bits de poids fort. Prendre les bits de poids faible, c'est mal utiliser la fonction. Si tu veux des 0 ou des 1 tu fais des shift et pas juste et masque ou un modulo qui va te pourrir ta repartition.
Maintenant tu es content, ton repas tombe tout cuit dans ton assiette ?

Edit : du coup c'est ce qui explique l'utilite de passer sur l'intervalle 0-1 comme dit plus haut oui. Apres on n'a pas toujours envie de passer par des floats. Il faut juste retenir qu'il faut utiliser les bits de poids fort

Hého, hein [:dakans]

Si je demande des détails, c'est parce que la plupart des sites internet (même sérieux) proposent l'implémentation classique avec modulo. Même cplusplus.com propose d'utiliser rand de cette manière ( http://www.cplusplus.com/reference [...] dlib/rand/ ) bien qu'il y ait effectivement un petit avertissement sur la répartition des nombres générés.

Bref merci quand même pour ta bonne humeur et ton savoir

---------------
"I can cry like Roger. It's just a shame I can't play like him" - Andy Murray, 2010

FORUM HardWare.fr

Programmation

C++

générer une suite de bits aléatoire

Sujets relatifs
générer un diagramme de collaboration dans StarUML	Générer une image à partir d'un fichier html
[C# / LINQ to XML] Générer des balises contenant des ':'	génération des nombres long aleatoire
ecrire un programme qui lit une suite de valeur à partir d'un entier n	little endian vers big endian pour un 40 bits
[RESOLU] Plusieurs "like" de suite + probleme jointure	compiler wkhtmltopdf pour une debian 64 bits
Element aléatoire parmi différents types	générer une suite de bits aléatoire
Plus de sujets relatifs à : générer une suite de bits aléatoire

Page générée en 0.118 secondes