Newsgroup: it.comp.lang.c
Titolo: float:mantissa ed esponente

coem potrei fare a leggere e stampare mantissa ed esponente si un float???
ho provato a definire una struttura che vadi a combaciare con la struttura
cosi' come sotto:
#include <stdlib.h>
#include <stdio.h>
struct { int a:1;//bit significativo mantissa
	 int b:19;//bit della mantissa
	 int c:1;//bit significativo dell'esponente ???
	 int d:11;//esponente
	} jfloat;
int main(int argc, char *argv[]){
	float f=123.123;
	struct jfloat *F;
	F = &f;
	printf("%d, %d, %d, %d\n",\
	F->a ,F->b, F->c, F->d); //riga sbagliata ????
	return 1;
}
ma non mi funziona:dove sbaglio????
grazie per la possibile risposte e scusate la (forse ) cavolata
                   Jonathan

coem potrei fare a leggere e stampare mantissa ed esponente si un float???
Dipende da che formato viene implementato dal tuo compilatore.
--
Andrea Laforgia (ICQ 87230455)
http://www.geocities.com/AndreaLaforgia
"ci sono tre tipi di persone nel mondo : quelli che
 sono bravi in matematica e quelli che non lo sono."

 
gcc e' il mio compilatore
              Non sara' ne' il Fuoco ne' l'Acqua
                ne' l'Aria ne' la Terra
                 a fermarmi ma una Donna.
                   Jonathan

ma non mi funziona:dove sbaglio????
Il formato float prevede un bit di segno, 24 di mantissa e 8
di esponente.
Un programma che funziona sia sotto windows compilato con
BCC55 che sotto Linux con g++ e' il seguente:
  #include <stdio.h>
  #include <stdlib.h>
  typedef struct FLOAT_TAG
  {
    unsigned int mantissa:23;
    unsigned int exponent:8;
    unsigned int sign:1;
  } Float;
  int main(int argc,char *argv[])
  {
    int i;
    float f;
    Float *F = (Float *)&f;
    for (i=1; i<argc; i++)
    {
      f=atof(argv[i]);
      printf("%g: mantissa=0x%06x, exponent=%i, sign=%i\n",
             f,F->mantissa, F->exponent, F->sign);
    }
    return 0;
  }
Un esempio di run sotto linux e' il seguente:
  agriff@lx1:~/cpp/test > float 1 2 3 4 -5 0.5 -0.1
  1: mantissa=0x000000, exponent=127, sign=0
  2: mantissa=0x000000, exponent=128, sign=0
  3: mantissa=0x400000, exponent=128, sign=0
  4: mantissa=0x000000, exponent=129, sign=0
  -5: mantissa=0x200000, exponent=129, sign=1
  0.5: mantissa=0x000000, exponent=126, sign=0
  -0.1: mantissa=0x4ccccd, exponent=123, sign=1
Come noti il primo bit di mantissa e' sottointeso
essere 1 e l'esponente usa il formato XS128.
Nota che pero':
1) Le dichiarazioni di bitfield non sono portabili:
   in particolare non e' garantito quali bit vengano
   assegnati dal compilatore ai field.
   In K&R si raccomanda di usare bitfield solo come
   rappresentazioni interne e non per dati che
   vegono memorizzati oppure scambiati fra sistemi:
   anche diverse versioni di uno stesso compilatore
   potrebbero in teoria assegnare i bitfield in
   maniera diversa.
2) Il formato IEEE non prevede quale debba essere
   l'ordine dei byte che formano il float ma solo
   il loro contenuto. Su architettura hw diverse
   potrebbe essere necessaria una trasposizione.
Il codice che scrivi dipende quindi dalla particolare
accoppiata hw/compilatoe e deve essere verificato sul
campo.
HTH
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

di esponente.
1 + 24 + 8 = 33
I bit per la mantissa sono 23.


 coem potrei fare a leggere e stampare mantissa ed esponente si un float???
C'e' una funzione standard, per questo.  E' definita in math.h e si
chiama frexp.
MLO@cmssun2 2 $ man frexp
 Library Functions            SunOS 5.6                frexp(3C)
NAME
     frexp - extract mantissa and exponent from double  precision
     number
SYNOPSIS
     #include <math.h>
     double frexp(double num, int *exp);
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it
A C++ exception is when the code gets in trouble and says:
"Beam me up, Scotty!".

I bit per la mantissa sono 23.
Forse mi sono spiegato male. La mantissa e' formata da 24 bit
ma solo 23 sono effettivamente memorizzati in quanto il primo
bit si sottointende essere sempre 1.
Se ad esempio consideri la rappresentazione del numero 1 in
floating point noti come tutti i bit della mantissa siano a zero.
Zero e' rappresentato come caso speciale da 4 byte tutti a zero
e altri casi speciali vengono utilizzati per NaN INF etc.
Nel programma di stampa effettivamente sarebbe stato meglio che
avessi utilizzato (F->mantissa|0x800000) invece di F->mantissa.


bit si sottointende essere sempre 1.
Esatto, io mi riferivo a quelli effettivamente memorizzati.


 essere 1 e l'esponente usa il formato XS128.
                                ^^^^^^^^^^^^^^
come va letto cosi' questo formato????
                   Jonathan