[C] Genrazione casuale 64 bit double

[dad_89]

Devo generare casualmente i 64 bit di una variabile double, ora la prima cosa che ho fatto è stata quella di generare un valore random, compreso fra 0 e RAND_MAX, dopodichè lo divido per 2, se è pari il bit sarà 0 se è dispari il bit generato sarà 1, ora i vari bit vengono inseriti in un array di 64 elementi, alla fine avrò un array contenente la mia configurazione di bit generati in modo casuale.

void rand_bit64(int *a){
int i, n;
for(i = 0; i < 63; i++){
n = ((rand() % RAND_MAX) / 2);
if(n & 1) a[i] = 1;
else a[i] = 0;
}
}

Ora però il problema sta nel convertire la configurazione dell'array in un valore double, cioè se ho la mio array formato da

0100101010001010 101001000111100 111011100100000 11000010011000110
dovrò convertire questa cifra in un valore decimale a virgola mobile.
Ho pensato di procedere in questo modo, prendo i primi 32 bit dell'array e li converto in decimale dopodichè prendo gli altri 32 e li converto anch'essi in decimale facendo attenzione che il valore non sia negativo ed inserisco questa parte dopo la virgola, in questo modo avrei entrambi i valori del double finale.

Non so se possa funzionare ma sinceramente mi sembra troppo macchinoso e grezzo come metodo credo che ci siano altre alternative più veloci per fare questo tipo di cose, ma non mi viene in mente nulla :(

Piccola Nota, sono contretto ad utilizzare un array di interi per la configurazione dei 64 bit, quindi non venitemi a dirmi di prendere il puntatore di un double e generare a caso i bit al suo interno con char ed int vari :ciapet:

[gugoXX]

Ma non puoi fare il contrario, ovvero generare prima il double random, riempiendo un array di 8byte,
e poi, se proprio ti serve la rappresentazione a bit un un array di interi, la ottieni successivamente?

[dad_89]

Ma non puoi fare il contrario, ovvero generare prima il double random, riempiendo un array di 8byte,
e poi, se proprio ti serve la rappresentazione a bit un un array di interi, la ottieni successivamente?
Eh no l'esercizio dice proprio che devo avere generare i 64 bit casuali per poi risalire al numero double e non viceversa, cmq ho preso come spunto lo standard IEEE ed ho trovato le due parti del double, cioè i primi 12 bit li ho presi per l'esponente (senza considerare il segno per ora), i succesivi 54 per la parte frazionaria, ed effetivamente mi trovo con i duce valori, però non riesco ad unirli nell'unico double ... cioè ho l'esp che è uguale a 1002 ad esempio e la parte dopo la virgola uguale a 89754, non riesco a generare il double 1002.89754 :doh:

[gugoXX]

Beh, se prima generi 8 byte casuali e poi li usi come numero double secondo me non hai fatto qualcosa di sbagliato.
hai sempre generato 64bit in modo casuale (se non li vuoi generare 8 o 16 alla volta puoi sempre generarne uno alla volta) e hai considerato il numero come numero double.

se non e' proprio C standard scusami

byte a[8];
for (int t=0;t<8;t++) a[t]=(random qualcosa per un byte)
double* ret=(double*)a;


Se invece appunto non vuoi/puoi generare i bit 8 alla volta puoi sempre andare a maschere di bit.

byte risultato[8];
for (int b=0;b<8;b++)
{
for (int bit=0;bit<8;bit++)
{
bool questo=(random per un bit)
risultato[b] |= (questo<<bit);
}
}
double* ret=(double*)risultato;


Comunque io non costruirei in modo indipendente mantissa ed esponente (e segno). Lascerei proprio l'interpretazione dei bit casuali cosi' come sono.

[dad_89]

:what:
Scusa la mia ignoranza gugoXX ma non riesco a capire perchè nel tuo codice hai scritto "byte a[8]", cioè 64 bit sono 4 byte quindi perchè dovrei calcolarmene 8? :eek:

[gugoXX]

:what:
Scusa la mia ignoranza gugoXX ma non riesco a capire perchè nel tuo codice hai scritto "byte a[8]", cioè 64 bit sono 4 byte quindi perchè dovrei calcolarmene 8? :eek:

E' solo una tua svista. I byte sono da 8bit.
4 byte sono 32bit...

E' solo una svista, ma non farla all'esame senno' ti bocciano :D

[dad_89]

Ops ... è vero però l'esercizio dice proprio di generare i 64 bit di un double è per quello che mi sono confuso :doh:

Cmq sono arrivato a produrre questo scempio fino adesso, (seguendo sempre la questione, segno, mantissa e esponente):

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

int mypow(int value){
int ris = 1, i;
if(value >= 1)
for (i = 1; i <= value; i++) ris *= 2;
return ris;
}

void rand_bit64(int *a){
int i, n;
for(i = 0; i < 63; i++){
n = ((rand() % RAND_MAX) / 2);
if(n & 1) a[i] = 1;
else a[i] = 0;
}
}

void generate_double_value(int *a, int *sign, double *_esp, double *_manta){
int esp[11], manta[54];
int i;
double ris;

*sign = a[0];

for(i = 1; i < 64; i++){
if(i < 11) esp[i] = a[i];
else if(i > 11) manta[i] = a[i];
}

for(i = 1; i < 64; i++){
if(i < 11 && esp[i] == 1) *_esp += mypow(11 - i - 1);
else if(i > 11 && manta[i] == 1) *_manta += mypow(53 - i - 1);
}

if(*_manta < 0) *_manta = abs(*_manta);
}

int main(void){
int i, b[64] = {0}, sign;
double esp = 0.0, manta = 0.0;
srand(time(NULL));
rand_bit64(b);
for(i = 0; i < 64; i++){ printf("%d", b[i]); if(!(i % 31)) printf(" "); }
convert(b, &sign, &esp, &manta);
printf ("\nSegno = %s Esponente = %d Mantissa = %d", ((sign > 0) ? "neg" : "pos"), (int) esp, (int) manta);
return 0;
}
Funziona, però non sono riuscito ancora a comporre tutto il double con i miei valori generati :cry:

[cdimauro]

Eh no l'esercizio dice proprio che devo avere generare i 64 bit casuali per poi risalire al numero double e non viceversa, cmq ho preso come spunto lo standard IEEE ed ho trovato le due parti del double, cioè i primi 12 bit li ho presi per l'esponente (senza considerare il segno per ora), i succesivi 54 per la parte frazionaria, ed effetivamente mi trovo con i duce valori, però non riesco ad unirli nell'unico double ... cioè ho l'esp che è uguale a 1002 ad esempio e la parte dopo la virgola uguale a 89754, non riesco a generare il double 1002.89754 :doh:
Occhio che il tuo codice non sarà assolutamente portabile se non consideri l'endianess quando accedi ai singoli bit della "struttura" che compone il double.

Molto meglio che generi 2 valori a 32 bit che "impacchetti" in un intero a 64 bit, e dopo provvedi a dividere il tutto per 2^64-1, in modo da garantire che 0 <= numero <= 1 (se vuoi escludere l'uno ti basta dividere per 2^64).