Yksittäinen tarkkuusnumero

Kokeneet kirjoittajat eivät ole vielä tarkistaneet sivun nykyistä versiota, ja se voi poiketa merkittävästi 14. maaliskuuta 2016 tarkistetusta versiosta . tarkastukset vaativat 33 muokkausta .

Yksittäisen tarkkuuden numero ( eng.  single precision , single ) on laajalle levinnyt tietokonemuoto reaalilukujen esittämiseen, ja se vie muistissa 32 bittiä (4 tavua ) . Yleensä se ymmärretään IEEE 754 -standardin liukulukumuotona .

Yksittäisen tarkkuuden liukulukuluvut vastaavat tarkkuudellaan lukuja, joissa on 7–8 merkitsevää desimaalinumeroa (keskiarvo 7,6) välillä noin .

Nykyaikaisissa tietokoneissa liukulukulaskutoimituksia tukee laitteisto-apuprosessori ( FPU  - englanti  floating p oint u nit ) . Useissa laskenta-arkkitehtuureissa ei kuitenkaan ole laitteistotukea liukulukuille, ja sitten niiden kanssa työskennellään ohjelmistossa.

Merkki
Tilaus Mantissa
0 0 yksi yksi yksi yksi yksi 0 0 0 yksi 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0  = 0,15625
31 24 23 16 viisitoista kahdeksan 7 0

Eksponentin laskemiseksi eksponentin poikkeama, joka on 12710 = 7F16 = 011111112 ( eli 011111002 - 011111112 = 12410 - 12710 = -310 ) , vähennetään kahdeksanbittisestä eksponenttikentästä . Koska kokonaislukuosa on aina yhtä suuri kuin yksi normalisoidussa binäärimantissassa, vain sen murto-osa kirjoitetaan mantissakenttään, ts. yksittäisen tarkkuusluvun mantissan todellinen koko on 24 bittiä. Mantissan laskemiseksi mantissan murto-osa mantissan murto-osan 1,0100000000000000000000000 23-bittisen kentän kentästä lisätään yhteen . Luku on yhtä suuri kuin etumerkillisen mantissan tulo kertaa kaksi kertaluvun potenssilla = 1,01 2 *2 10 -3 10 = 101 2 *2 10 -5 10 = 5 10 *2 10 -5 10 = 0,15625 10 .

Yleinen malli bittikohtaiselle pääsylle

liitto { float fl ; uint32_t dw ; } f ; int s = ( f . dw >> 31 ) ? -1 : 1 ; /* Merkki */ int e = ( f . dw >> 23 ) & 0xFF ; /* Tilaus */ int m = /* Mantissa */ e ? ( f . dw & 0x7FFFFF ) | 0x800000 : ( f . dw & 0x7FFFFF ) << 1 ;

Tuloksena oleva laskentakaava (yksi tarkkuusluku) on s * (m * 2 ^ -23) * (2 ^(e-127)).

Käyttöesimerkkejä

Python

Muuntaa luvun yhden tarkkuuden kokonaislukuesityksen (neljänä tavuna, alhainen kertaluku alussa) Pythonin sisäänrakennetuksi reaalilukutyypiksi.

def dw2float ( dw_array ): assert ( len ( dw_array ) == 4 ) dw = int . from_bytes ( dw_array , byteorder = 'pieni' , signed = False ) s = - 1 if ( dw >> 31 ) == 1 \ else 1 # Merkki e = ( dw >> 23 ) & 0xFF ; # Järjestys m = (( dw & 0x7FFFFF ) | 0x800000 ) jos e != 0 \ else (( dw & 0x7FFFFF ) << 1 ) # Mantissa m1 = m * ( 2 ** ( - 23 )) # Mantissa kelluvassa paluussa s * m1 * ( 2 ** ( e - 127 ))

0.15625 10 kelluvassa muodossa kirjoitetaan 3E20000016 :ksi, mikä vastaa neljää tavua: [0x00,0x00,0x20,0x3E]. Ohjelman tulos:

In[1]: dw2float([0x00,0x00,0x20,0x3E]) Out[1]: 0,15625 In[2]: dw2float([0x00,0x00,0x20,0xBE]) Out[2]: -0,15625

Esimerkkejä yksittäisistä tarkkuusluvuista

Nämä esimerkit esitetään heksadesimaalilukuina liukulukuina. Ne sisältävät merkkibitin, eksponentin ja mantissan.

3f80 0000 = 1 c000 0000 = −2 7f7f ffff ≈ 3,40282346639 × 10 38 (maksimi yksittäinen tarkkuus) 0000 0001 = 2 -149 ≈ 1,40129846432 × 10 -45 (Pienin positiivinen yksittäinen tarkkuusluku - denormalisoitu ) 0080 0000 = 2 -126 ≈ 1,17549435082 × 10 -38 (Pienin normalisoitu positiivinen yksittäinen tarkkuusluku) 0000 0000 = 0 8000 0000 = -0 7f80 0000 = ääretön ff80 0000 = −ääretön 3eaa aaab ≈ 1/3

Yleensä kun numeerisia vakioita muunnetaan kelluvaksi, pyöristetään. Esimerkiksi luku 1/3 pyöristetään ylöspäin.

Katso myös

Linkit