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

générer une suite de bits aléatoire - C++ - Programmation

Marsh Posté le 08-05-2012 à 01:01:34    

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]<<" ";}
 
 
}

Reply

Marsh Posté le 08-05-2012 à 01:01:34   

Reply

Marsh Posté le 08-05-2012 à 11:58:50    

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 :
  1. #include <iostream>
  2. #include <string>
  3. #include <ctime>
  4. #include <cstdlib>
  5. using namespace std;
  7. void Bruit() {
  8.     const int tsize = 100;
  9.     char tab2[tsize];
  10.     int tab3[tsize], tab4[tsize];
  11.     int m, h;
  12.     char w = 'x', v = '+';
  13.     string lspacing = "\n \n ", rspacing = " \n \n";
  15.     cout << lspacing << "les suites aleatoires generees:" << rspacing;
  16.     for (int m = 0; m < tsize; ++m) {
  17.         tab3[m] = rand() % 2;
  18.         cout << tab3[m];
  19.     }
  21.     cout << lspacing << "les positions bruitees:" << rspacing;
  22.     for (int m = 0; m < tsize; ++m) {
  23.         tab4[m] = rand() % tsize;
  24.         cout << tab4[m] << " ";
  25.     }
  27.     cout << lspacing << "les suite des bits bruitees sont:" << rspacing; ;
  29.     for (int m = 0; m < tsize; ++m) {
  30.         tab3[tab4[m]] = tab3[tab4[m]]?0:1;
  31.         cout << tab3[m] << " ";
  32.     }
  33. }
  36. int main() {
  37.     srand( unsigned(time(NULL)) );
  38.     Bruit();
  39.     return 0;
  40. }


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é!  --
Reply

Marsh Posté le 08-05-2012 à 12:51:06    

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

Message cité 2 fois

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

Marsh Posté le 07-06-2012 à 22:28:24    

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
Reply

Marsh Posté le 08-06-2012 à 11:43:09    

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
Reply

Marsh Posté le 08-06-2012 à 16:06:57    

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 :o

Message cité 1 fois

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

Marsh Posté le 08-06-2012 à 16:12:53    

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

 
Code :
  1. 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
Reply

Marsh Posté le 08-06-2012 à 16:20:00    

Terminapor a écrit :

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

Code :
  1. 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
Reply

Marsh Posté le 08-06-2012 à 16:29:03    

Terminapor a écrit :

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

 
Code :
  1. 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)
Reply

Marsh Posté le 08-06-2012 à 20:49:56    

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

Code :
  1. #include <cmath>
  2. #include <ctime>
  3. #include <cstdlib>
  4. #include <iostream>
  5. using namespace std;
  7. static const double TWOPI(atan(1.0)*2);
  9. class BitGen {
  10. private:
  11.     double X1, Y1, X2, Y2;
  12.     const double K1, K2;
  14. public:
  15.     BitGen(double x1, double y1, double x2, double y2, double k1 = 150.72, double k2 = 210.37) :
  16.         X1(x1), Y1(y1), X2(x2), Y2(y2), K1(k1), K2(k2) {}
  18.     int nextBit() {
  19.         X1 = fmod(X1 + K1 * sin(Y1), TWOPI);
  20.         Y1 = fmod(Y1 + X1, TWOPI);
  21.         X2 = fmod(X2 + K2 * sin(Y2), TWOPI);
  22.         Y2 = fmod(Y2 + X2, TWOPI);
  23.         return (X2 > Y1? 1 : 0);
  24.     }
  26. };
  29. int main() {
  30.     srand( unsigned(time(NULL)) );
  31.     BitGen generator(fmod(rand(), TWOPI), fmod(rand(), TWOPI), fmod(rand(), TWOPI), fmod(rand(), TWOPI));
  32.     for (int i = 0; i < 4000; ) {
  33.         ++i;
  34.         cout << generator.nextBit();
  35.         if (!(i%75)) {
  36.             cout << endl;
  37.         }
  38.     }
  39.     return 0;
  40. }


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é!  --
Reply

Marsh Posté le 08-06-2012 à 20:49:56   

Reply

Marsh Posté le 11-06-2012 à 14:34:08    

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 :o


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

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

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

Marsh Posté le 11-06-2012 à 21:12:05    

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 :o


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

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed