Miért a leggyakoribb egész szám 32 bit, de a legelterjedtebb lebegőpontos szám 64 bit?

Tartomány vs. pontosság

Egy dolog, hogy vitatnám azt az elképzelést, hogy a legelterjedtebb lebegőpontos szám 64 bites DPFP (kettős pontosságú lebegőpontos) ábrázolást használ.

Legalábbis teljesítménykritikus valós időmezők, például játékok, az SPFP (egypontos lebegőpontos) még mindig sokkal gyakoribb, mivel a közelítés és a sebesség előnyben részesítendő a legnagyobb pontosság mellett.

Ennek azonban talán az egyik módja, hogy egy 32 -bit int az 2^32 egész számok tartományát jelenti (~ 4,3 milliárd). Az egész számok leggyakoribb használata valószínűleg az elemek indexeként fog megjelenni, és “ez az elemek elég egészséges tartománya, amelyet nehéz lenne túllépni anélkül, hogy meghaladná a mai hardverrel elérhető memóriát *.

_{* Ne feledje, hogy memóriahibák fordulhatnak elő egyetlen, összefüggő 4 gigabájtos blokk kiosztásakor / elérésekor, még 30 gigabájt szabadon is, pl. a folytonosság miatt A blokk követelményei.}

A 32 bites egész szám nem mindig hatékonyabb az utasítás szintjén, de általában hatékonyabb, ha tömbbe összesítjük, például mivel a memória fele kell (pl. több index, amely elfér egy oldal / gyorsítótár sorában, pl.).

Ne feledje, hogy mint Lightness Races in Orbit rámutat, tágabb perspektívából nem is feltétlenül igaz, hogy a 32 bites egész számokat használják gyakrabban. Szűk látószögem egy olyan területről származik, ahol a 32 bites ints indexeket százezrektől milliókig gyakran más struktúrába összesítik – ott a méret felére csökkentése segíthet tétel.

Mostantól a 64 bites DPFP előfordulhat, hogy egyes kontextusokban sokkal több, mint 64 bites egész számok használhatók. Ott az extra bitek a tartomány helyett a pontosságot adják. Sok alkalmazás igényelhet pontosságot, vagy legalábbis sokkal könnyebb programozást igényel, extra pontossággal. Tehát valószínűleg ez az oka annak, hogy a 64 bites DPFP-k előfordulhatnak gyakoribbak egyes területeken, mint a 64 bites egészek, és miért

Nos, az int és a dupla Java dolog. Például az Objective-C és a Swift programban az NSInteger vagy az Int programot használja, amely 32 bites 32 bites gépen és 64 bites 64 bites gépen. Elég nagy ahhoz, hogy bármilyen elemet megszámolhasson a memóriában. Ami mindenképpen hasznos, hogy szinte mindenhol ugyanazt a típust használja, hacsak nem egy adott helyzetben van szüksége valamire.

A Java megpróbál olyan kódot használni, amely minden végrehajtáskor azonos módon fut, ezért úgy gondolják, hogy ugyanazt a típust kell használnia a használt géptől függetlenül, és hogy a típusnak ugyanannyi bitnek kell lennie, függetlenül attól, hogy a gép. Az Objective-C és a Swift (és C, C ++ is) eltérő nézőpontot képvisel.

Az egész számokat többnyire a dolgok számlálására használják, és általában nem kell annyi dolgot megszámolni. A lebegőpontos aritmetikának pontosságra van szüksége, és a 32 bites lebegőpont gyakran nem ad elég pontosságot. A 64 bites dupla mindenhol használatával harci esély adódik arra, hogy mindig kellő pontosságot kapj, anélkül, hogy a lebegőpontos számtan specialistája lennél. úszó nem “t.

De milyen következetességet adna a hosszú és dupla használata? Az egész számok és a lebegőpontos számok nem ugyanazok. Nincs szükség arra, hogy állandó bitmérettel rendelkezzenek. 2D pontokat használok és sok téglalap. Tehát a konzisztencia érdekében 64 bitesek is legyenek? Pontok, amelyek összetevőnként 32 bitesek, és téglalapok 16-os? Természetesen nem. Nincs szükség konzisztenciára.

Megjegyzések

• Ez egy nagyon szép válasz, amely elmagyarázza annak JVM oldalát, hogy az egyes típusok mérete a platformtól függetlenül azonos marad.

A rövid, az int, az egy és a dupla azonos méretűek a java-ban, mint a 32 bites és 64 bites platformok leggyakoribb C fordítóiban és a C-ben, mint a java egyértelműen az int-et tartja a fő egész típusú típusnak, és a double-t a fő lebegőpontos típusnak. Szerintem ésszerű azt mondani, hogy a Java ezt az egyezményt annak idején a közös C fordítóktól örökölte.

Az egészek általában használt c cuccok számlálása vagy indexelése. Elég ritka (bár nem ismeretlen), hogy 2 milliárdnál többet kellene számolnia vagy indexelnie valamiből. Valójában a C99 előtt szállítóspecifikus típusokat kellett használnia, ha 64 bites egész számot akart.

A lebegőpontos számokat általában a valós számok közelítésére használják. Az egyetlen pontosság az idő nagy részében elég jó, de nem nehéz olyan problémákat találni, amelyek elfogadhatatlan mennyiségű kerekítési hibát okoznak. Azt remélem, hogy a tudományos számítástechnika iránti kereslet az, ami a kettős pontosságú lebegőpontos támogatást jóval a 64 bites előtti mindenütt jelen volt Az egész szám támogatás volt.

Amit furcsának találok, az az, hogy a C a kettős, míg a fortran az egy pontosság használatát ösztönzi.