Institute of Information Science - University of Miskolc

User Tools

Site Tools

Trace: • information • junit5 • junit5_alapok • unit_tesztek_alapja • computerstud
tanszek:oktatas:infrendalapjai_architekturak:logika_alapjai:szamabrazolas

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

tanszek:oktatas:infrendalapjai_architekturak:logika_alapjai:szamabrazolas [2026/09/18 19:19] – created kneheztanszek:oktatas:infrendalapjai_architekturak:logika_alapjai:szamabrazolas [2026/10/03 18:17] (current) – knehez
Line 1: Line 1:
-===== Negatív és lebegőpontos számok ábrázolása kettes számrendszerben =====+===== Negatív és lebegőpontos számok ábrázolása =====
  
-A számítógép memóriája biteket tárol, ezért a pozitív egész számok mellett a negatív és a törtrészt tartalmazó számokat is 0-k és 1-ek sorozatával kell ábrázolni. Ehhez előre meg kell határozni, hogy az egyes biteknek mi a jelentésük.+Egy mérési eredmény lehet negatív, például −5 °C, és lehet tört érték, például 13,25 mm. A számítógép memóriájában azonban csak bitek, vagyis nullák és egyesek szerepelnek. Hogyan jelöljük ezekkel a mínuszjelet és a törtrészt?
  
-Fontos, hogy ugyanaz a bitsorozat önmagában még nem határozza meg a tárolt szám értékét. A ''11111111'' bitsorozat jelenthet például:+Ehhez meg kell állapodnunk a bitek értelmezésében. Először a negatív egész számok tárolását vizsgáljuk meg, majd a törtekből kiindulva eljutunk a lebegőpontos számábrázolásig és az **IEEE 754** szabvány szerinti tárolásig.
  
-  * előjel nélküli egész számként 255-öt; +==== 1. Kiindulás: mit jelent egy bitsorozat? ====
-  * 8 bites kettes komplemens előjeles számként −1-et; +
-  * egy hosszabb adat, karakter vagy utasítás részét.+
  
-Az értelmezéshez tehát ismernünk kell az adattípust és a felhasznált ábrázolási módot.+A kettes számrendszerben a helyi értékek jobbról balra kétszereződnek: 1, 2, 4, 8, 16 és így tovább. Egy bit helyén álló 1 azt jelenti, hogy az adott helyi értéket hozzáadjuk a számhoz; a 0 azt, hogy nem adjuk hozzá.
  
-==== 1. Előjel nélküli egész számok ====+Például a ''00001101'' bitsorozat értéke:
  
-Előjel nélküli ábrázolásnál minden bit a szám nagyságát adja meg. Egy 8 bites szám helyiértékei:+^ Helyi érték ^ 128 ^ 64 ^ 32 ^ 16 ^ 8 ^ 4 ^ 2 ^ 1 ^ 
 +| Bit | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 1 |
  
-^ Helyiérték ^ 2⁷ ^ 2⁶ ^ 2⁵ ^ 2⁴ ^ 2³ ^ 2² ^ 2¹ ^ 2⁰ ^ +A szám tehát **8 + 4 + 1 = 13**.
-| Érték | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |+
  
-Például:+Nyolc bit együtt egy **bájt**. Nyolc bitből 256 különböző bitsorozat készíthető. Ha mindegyiket nemnegatív egész számként értelmezzük, 0-tól 255-ig tudunk számokat ábrázolni. Ezt nevezzük **előjel nélküli egész számábrázolásnak**.
  
-<code> +Ha negatív számokat is szeretnénk tárolni, akkor ugyanezt a 256 bitsorozatot kell másképpen felosztanunk.
-00101101₂ = 32 + 8 + 4 + 1 = 45₁₀ +
-</code>+
  
-''n'' biten összesen ''2ⁿ'' különböző bitminta tárolható. Az előjel nélküli számok értéktartománya:+**A bitsorozat önmagában nem mondja meg, hogyan kell értelmezni.** Tudnunk kell, milyen számábrázolási szabály tartozik hozzá.
  
-<code> +==== 2. Első ötlet: külön bit jelölje az előjelet ====
-0 ... 2ⁿ − 1 +
-</code>+
  
-8 bit esetén ez:+Kézenfekvő megoldás, hogy az első bit az előjelet adja meg, a többi pedig a szám abszolút értékét, vagyis az előjel nélküli nagyságát.
  
-<code> +Állapodjunk meg abban, hogy az első bit 0 esetén pozitív, 1 esetén negatív előjelet jelent. Nyolc bitből így egy az előjelé, hét pedig a nagyságé:
-0 ... 255 +
-</code>+
  
-==== 2. Negatív egész számok ábrázolása ====+^ Szám ^ Előjelbit ^ A nagyság hét biten ^ Teljes bitsorozat ^ 
 +| +5 | 0 | ''0000101'' | ''00000101'' | 
 +| −5 | 1 | ''0000101'' | ''10000101'' |
  
-A negatív számok tárolására többféle módszert dolgoztak ki. A legismertebbek:+Ezt **előjeles abszolútértékes ábrázolásnak** nevezzük. Könnyű megérteni, de az egész számokkal végzett műveleteknél kényelmetlen:
  
-  * előjel–nagyságos ábrázolás; +  * A nullának két alakja van: ''00000000'' és ''10000000'', azaz +0 és −0. 
-  * egyes komplemens ábrázolás; +  * A bitsorozatok közönséges bináris összeadása önmagában nem adja meg helyesen az előjeles összeget.
-  * kettes komplemens ábrázolás.+
  
-A modern számítógépek szinte mindig a //kettes komplemens// ábrázolást használják az előjeles egész számok tárolására.+Például +5 és −5 matematikai összege 0. A fenti két bitsorozat szokásos bináris összeadása viszont ''10001010'', ami ebben az ábrázolásban −10 lenne.
  
-==== 2.1. Előjel–nagyságos ábrázolás ====+Az egész számokhoz ezért általában más megoldást használunk: a **kettes komplemens ábrázolást**.
  
-Ebben a módszerben a legmagasabb helyiértékű, bal szélső bit az előjelet jelöli:+==== 3. Kettes komplemens ====
  
-  * ''0'': pozitív szám; +Olyan bitsorozatot keresünk −5 számára, amelyet +5 bitsorozatához hozzáadva az alsó nyolc biten nullát kapunk.
-  * ''1'': negatív szám.+
  
-A többi bit a szám abszolút értékét tartalmazza.+Nyolc biten legfeljebb 255 ábrázolható előjel nélkül. A következő szám, 256, már kilenc bitet igényel: ''100000000''. Ha egy nyolcbites eredményből csak az alsó nyolc bitet tartjuk meg, ebből ''00000000'' marad.
  
-8 biten például:+Melyik nemnegatív számmal kell az 5-öt kiegészíteni 256-ra? A válasz: **256 − 5 = 251**.
  
-<code> +Ezért nyolcbites kettes komplemensben a −5 tárolt bitmintája megegyezik az előjel nélkül 251-et jelentő bitmintával: **11111011**.
-+5 = 00000101 +
-−5 = 10000101 +
-</code>+
  
-A módszer könnyen értelmezhető, de kétféle nulla tartozik hozzá:+=== Hogyan állítjuk elő a negatív szám bitmintáját? === 
 + 
 +Az eljárás két egyszerű lépésből áll, de **előtte rögzíteni kell a bitszámot**. Most nyolc bittel dolgozunk. 
 + 
 +  - Felírjuk a pozitív számot nyolc biten. 
 +  - Minden bitet megfordítunk: a 0-ból 1, az 1-ből 0 lesz. 
 +  - Az eredményhez hozzáadunk 1-et, és nyolc bitet tartunk meg. 
 + 
 +**Példa: −5 előállítása.**
  
 <code> <code>
-+0 = 00000000 ++5 nyolc biten:       00000101 
-−0 = 10000000+Bitek megfordítása:  11111010 
 +Egy hozzáadása:      11111011
 </code> </code>
  
-Az összeadás és kivonás végrehajtása is körülményes, mert az előjelet külön kell kezelni. Emiatt egész számok tárolására ma már ritkán használják.+Az eredmény tehát **−5 = 11111011** nyolcbites kettes komplemensben. 
 + 
 +Miért működik a megfordítás és az egy hozzáadása? A nyolc egyesből álló szám értéke 255. Egy pozitív x szám bitjeinek megfordítása 255 − x-et ad, az ezt követő +1 pedig 256 − x-et. Pontosan ezt kerestük. 
 + 
 +=== Hogyan olvassuk vissza a számot? === 
 + 
 +Nyolcbites kettes komplemensben az első bit helyi értéke **−128**, a többi bité változatlanul pozitív: 
 + 
 +^ Helyi érték ^ −128 ^ 64 ^ 32 ^ 16 ^ 8 ^ 4 ^ 2 ^ 1 ^ 
 +| −5 bitmintája | 1 | 1 | 1 | 1 | 1 | 0 | 1 | 1 | 
 + 
 +Az érték: **−128 + 64 + 32 + 16 + 8 + 2 + 1 = −5**. 
 + 
 +Ezért az első bit valóban jelzi az előjelet: 0 esetén nemnegatív, 1 esetén negatív a szám. De **nem egyszerűen külön mínuszjel a többi bit elé**. A maradék hét bit itt nem a negatív szám abszolút értékét tárolja. 
 + 
 +Másik visszaolvasási módszer: az ''11111011'' előjel nélkül 251. Mivel az első bit 1, kivonunk 256-ot: **251 − 256 = −5**. 
 + 
 +==== 4. Miért hasznos a kettes komplemens? ====
  
-==== 2.2. Egyes komplemens ábrázolás ====+A pozitív és negatív számok bitmintáit ugyanazzal a bináris összeadással kezelhetjük. Az összeadásban 1 + 1 eredménye 0 az adott helyen, és 1-et továbbviszünk a következő helyi értékre. Ezt **átvitelnek** nevezzük.
  
-Egy negatív szám egyes komplemensét úgy kapjuk meg, hogy a megfelelő pozitív szám minden bitjét megfordítjuk:+Vizsgáljuk meg az 5 + (−5) összeget:
  
 <code> <code>
-+5 = 00000101 +    00000101     +5 
-−5 = 11111010+  + 11111011     -5 
 +  ---------- 
 +  1 00000000
 </code> </code>
  
-A bitenkénti megfordítás során minden 0-ból 1, minden 1-ből 0 lesz.+A bal oldali kilencedik bit nem fér bele a nyolcbites eredménybe. Az alsó nyolc bit ''00000000'', vagyis **0**, ahogyan vártuk.
  
-Ennél a módszernél is kétféle nulla létezik:+A kivonás is összeadássá alakítható: **7 − 5 = 7 + (−5)**.
  
 <code> <code>
-+0 = 00000000 +    00000111     +7 
-−0 = 11111111+  + 11111011     -5 
 +  ---------- 
 +  1 00000010
 </code> </code>
  
-Ez a tulajdonság, valamint az aritmetikai műveletek bonyolultsága miatt az egyes komplemenst a mai általános célú számítógépek egész számok tárolására jellemzően nem használják.+Az alsó nyolc bit értéke **2**.
  
-==== 2.3. Kettes komplemens ábrázolás ====+//Fontos:// A helyes előjeles eredményhez az is szükséges, hogy a matematikai eredmény beleférjen az adott bitszám értéktartományába. A kilencedik bit elhagyása önmagában nem oldja meg a túl nagy eredmények problémáját.
  
-A kettes komplemens ábrázolás előnye, hogy csak egyetlen nullaérték létezik, és ugyanaz az összeadó áramkör használható pozitív és negatív számok összeadására.+==== 5. Mekkora számok férnek el? ====
  
-Egy negatív szám kettes komplemens alakjának előállítása:+Nyolcbites kettes komplemensben:
  
-  - Írjuk fel a szám pozitív abszolút értékét a megadott bitszámon. +  * a legnagyobb pozitív érték ''01111111'', vagyis **127**; 
-  - Fordítsuk meg az összes bitet. +  * a legkisebb érték ''10000000'', vagyis **−128**; 
-  - Adjunk az eredményhez 1-et.+  * a nulla egyetlen alakja ''00000000''.
  
-Például a −5 előállítása 8 biten:+A tartomány azért nem szimmetrikus, mert az első bit 0-val kezdődő 128 lehetősége közé a nulla is beletartozik: 0–127. Az 1-gyel kezdődő 128 lehetőség a −128 és −1 közötti számoké.
  
-<code> +^ Bitszám ^ Előjel nélküli egész ^ Kettes komplemens egész ^ 
-  00000101   +5 bináris alakja +| 8 | 0 … 255 | −128 … 127 | 
-  11111010   a bitek megfordítása +| 16 | 0 … 65 535 | −32 768 … 32 767 | 
-+        1 +| 32 | 0 … 4 294 967 295 | −2 147 483 648 … 2 147 483 647 |
----------- +
-  11111011   −5 kettes komplemens alakja +
-</code>+
  
-Tehát:+Általánosan n bit esetén a kettes komplemens tartománya **−2<sup>n−1</sup> … 2<sup>n−1</sup> − 1**. A felső index hatványozást jelent.
  
-<code> +Ugyanaz a bitsorozat eltérő szabállyal mást jelent:
-+5 = 00000101 +
-−5 = 11111011 +
-</code>+
  
-=== Negatív kettes komplemens szám visszaalakítása ===+^ Bitsorozat ^ Előjel nélkül ^ Kettes komplemens szerint ^ 
 +| ''01111111'' | 127 | 127 | 
 +| ''10000000'' | 128 | −128 | 
 +| ''11111111'' | 255 | −1 |
  
-Ha egy kettes komplemens számban a bal szélső bit 1, akkor a szám negatív. Az abszolút érték meghatározásához:+A −128 pozitív párja, +128 nem fér el nyolcbites kettes komplemensben. Ezért a legkisebb negatív érték előjelének megfordítása is túlcsordulhat.
  
-  - fordítsuk meg az összes bitet; +=== Mi történik, ha több bitet használunk? ===
-  - adjunk hozzá 1-et; +
-  - az eredményt lássuk el negatív előjellel.+
  
-Például:+Ha egy kettes komplemens számot változatlan értékkel több bitre bővítünk, az új bal oldali biteket a régi első bit értékével töltjük ki. Ezt **előjelkiterjesztésnek** nevezzük.
  
-<code> +^ Szám ^ Nyolc biten ^ Tizenhat biten ^ 
-  11110110   ismeretlen negatív szám +| +5 | ''00000101'' | ''00000000 00000101'' | 
-  00001001   a bitek megfordítása +| −5 | ''11111011'' | ''11111111 11111011'' |
-+        1 +
----------- +
-  00001010   10 +
-</code>+
  
-Ezért:+A szóköz csak az olvashatóságot segíti. Negatív szám elé tehát nem nullákat írunk, mert az megváltoztatná az értékét.
  
-<code> +==== 6. Hogyan írunk fel törteket kettes számrendszerben? ====
-11110110₂ = −10₁₀ +
-</code>+
  
-Egy másik gyors módszer szerint a 8 bites negatív szám bitsorozatát először előjel nélküli számként értelmezzük, majd kivonjuk belőle ''2⁸ = 256'' értékét:+Tízes számrendszerben a vessző utáni helyi értékek: egy tized, egy század, egy ezred. Kettes számrendszerben ugyanígy folytatódik a helyiérték-rendszer, de minden új helyen kettővel osztunk:
  
-<code> +^ Hely ^ A vessző előtt ^ Első törtjegy ^ Második törtjegy ^ Harmadik törtjegy ^ Negyedik törtjegy ^ 
-11110110₂ = 246 előjel nélküli számként +| Helyi érték | 1 | 1/2 | 1/4 | 1/8 | 1/16 | 
-246 − 256 = −10 +| Tízes számrendszerben | 1 | 0,5 | 0,25 | 0,125 | 0,0625 |
-</code>+
  
-=== A kettes komplemens értéktartománya ===+Például a bináris **0,101** értéke:
  
-''n'' bites kettes komplemens szám értéktartománya:+**1 × 1/2 + 0 × 1/4 + 1 × 1/8 = 0,625**.
  
-<code> +A következőkben a szám mögötti alsó 2 a kettes, az alsó 10 a tízes számrendszert jelöli. Így az előző összefüggés:
-−2ⁿ⁻¹ ... 2ⁿ⁻¹ − 1 +
-</code>+
  
-Néhány gyakori eset:+**0,101<sub>2</sub> = 0,625<sub>10</sub>**.
  
-^ Bitszám ^ Legkisebb érték ^ Legnagyobb érték ^ +Ez nem azonos a tízes számrendszerbeli 0,101-gyel. A vessző mindkét esetben az egész és a tört részt választja el, de a helyi értékek különböznek.
-| 8 bit | −128 | 127 | +
-| 16 bit | −32 768 | 32 767 | +
-| 32 bit | −2 147 483 648 | 2 147 483 647 | +
-| 64 bit | −2⁶³ | 2⁶³ − 1 |+
  
-A tartomány azért nem szimmetrikus, mert a nulla is a nemnegatív bitminták egyikét foglalja el. 8 biten például:+=== Példa: 13,25 felírása binárisan ===
  
-<code> +Az egész részt és a tört részt külön vizsgáljuk:
-01111111 =  127 +
-00000000 =    0 +
-11111111 =   −1 +
-10000000 = −128 +
-</code>+
  
-==== 2.4. Összeadás kettes komplemens számokkal ====+  * 13 = 8 + 4 + 1, ezért az egész rész ''1101''. 
 +  * 0,25 = 1/4, ezért a tört rész ''01''.
  
-Kettes komplemens ábrázolásnál a pozitív és negatív számok a szokásos bináris összeadással összeadhatók.+Tehát **13,25<sub>10</sub> = 1101,01<sub>2</sub>**.
  
-Számítsuk ki 8 biten az ''5 + (−3)'' műveletet:+Ellenőrzés: 8 + 4 + 1 + 1/4 = 13,25.
  
-<code> +=== Általános módszer: a törtrész szorzása kettővel ===
-  00000101    +5 +
-+ 11111101    −3 +
----------- +
-1 00000010 +
-</code>+
  
-A kilencedik bitre kerülő átvitelt elhagyjuk, mert a számábrázolás csak 8 bites. Az eredmény:+A törtjegyeket ismételt kettővel szorzással is meghatározhatjuk. Minden lépésben felírjuk a szorzat egész részét, majd a következő lépésben csak a megmaradt törtrésszel dolgozunk.
  
-<code> +Például 0,625 esetén:
-00000010 = 2 +
-</code>+
  
-Valóban:+^ Lépés ^ Szorzás ^ Következő bináris jegy ^ Továbbvitt törtrész ^ 
 +| 1. | 0,625 × 2 = 1,25 | 1 | 0,25 | 
 +| 2. | 0,25 × 2 = 0,5 | 0 | 0,5 | 
 +| 3. | 0,5 × 2 = 1,0 | 1 | 0 |
  
-<code> +A jegyeket keletkezésük sorrendjében olvassuk: **0,101<sub>2</sub>**. A maradék nulla lett, ezért a felírás véget ért.
-5 + (−3) = 2 +
-</code>+
  
-=== Kivonás összeadással ===+==== 7. Hol tároljuk a vesszőt? ====
  
-Az ''A − B'' kivonás elvégezhető úgy, hogy ''A'' értékéhez hozzáadjuk ''B'' kettes komplemensét:+A memóriában nincs a bitek közé rajzolt vessző. A helyét is értelmezési szabállyal kell megadnunk.
  
-<code> +Az egyik lehetőség, hogy előre rögzítjük, hány bit tartozik a törtrészhez. Ezt **fixpontos számábrázolásnak** nevezzük.
-A − B = A + (−B) +
-</code>+
  
-Például ''7 − 5'':+Például használjunk nyolc előjel nélküli bitet, és állapodjunk meg abban, hogy az utolsó négy bit a törtrész. A tárolt ''00110100'' bitmintát ilyenkor ''0011,0100'' alakban értelmezzük:
  
-<code> +**2 + 1 + 1/4 = 3,25**.
-  00000111    +7 +
-+ 11111011    −5 +
----------- +
-1 00000010     2 +
-</code>+
  
-==== 2.5. Túlcsordulás ====+Ugyanez megfogalmazható úgy is, hogy a tárolt egész szám 52, és annak értékét 16-tal osztjuk: **52/16 = 3,25**.
  
-Túlcsordulás akkor történik, ha a matematikai eredmény nem fér el a rendelkezésre álló bitszámon.+Ebben az egyszerű formátumban két szomszédos szám távolsága mindig 1/16 = 0,0625. A legnagyobb szám 255/16 = 15,9375. Több törtbit finomabb felbontást adna, de ugyanennyi összes bit mellett kisebb egész rész férne el.
  
-8 bites előjeles szám esetén a legnagyobb tárolható érték 127. Ha ehhez 1-et adunk:+**A fixpontos ábrázolás állandó lépésközt használ.** Ez hasznos lehet, ha a mérési tartomány és a szükséges felbontás előre ismert. Mi történjen azonban, ha nagyon kicsi és nagyon nagy számokkal is szeretnénk dolgozni?
  
-<code> +==== 8. A lebegőpontos ábrázolás alapötlete ====
-  01111111    127 +
-+ 00000001      1 +
----------- +
-  10000000   −128-ként értelmezhető bitminta +
-</code>+
  
-A matematikai eredmény 128 lenne, de ez 8 bites előjeles számban nem ábrázolható.+A mérnöki gyakorlatban gyakran használunk hatványalakot. Például:
  
-Előjeles összeadásnál túlcsordulás történt, ha:+  * 13 250 = 1,325 × 10<sup>4</sup>; 
 +  * 0,001325 = 1,325 × 10<sup>−3</sup>.
  
-  * két pozitív szám összege negatívnak látszik; vagy +Mindkét számban az 1,325 hordozza az értékes számjegyeket. A tíz hatványa mondja meg, mekkora legyen a szám. A **kitevő** az a szám, amelyet a hatvány alapjának felső indexébe írunk: itt 4, illetve −3.
-  * két negatív szám összege pozitívnak látszik.+
  
-Különböző előjelű számok összeadásakor nem keletkezhet előjeles túlcsordulás. Az utolsó bitről kilépő átvitel önmagában nem azonos az előjeles túlcsordulással.+A negatív kitevő osztást jelent: 10<sup>−3</sup> = 1/1000. Ugyanígy 2<sup>−3</sup> = 1/8.
  
-==== 2.6. Előjelkiterjesztés ====+A **lebegőpontos számábrázolás** ezt az ötletet használja: külön tárolja a szám előjelét, értékes jegyeit és a nagyságrendet meghatározó kitevőt. A vessző helye a kitevőtől függ, ezért mondjuk, hogy „lebeg”.
  
-Ha egy előjeles számot több biten szeretnénk tárolni, a bal szélső előjelbitet kell megismételni.+A bináris lebegőpontos számoknál a hatvány alapja **2**, nem 10.
  
-Például a −5 átalakítása 8 bitesről 16 bitesre:+=== A szám rendezése egységes alakba ===
  
-<code> +A 13,25 korábban kapott bináris alakja ''1101,01''. A vesszőt három hellyel balra helyezve ''1,10101''-et kapunk. Ez nyolcadakkora szám, ezért 2<sup>3</sup>-nal, azaz nyolccal kell szoroznunk:
-8 biten:  11111011 +
-16 biten: 11111111 11111011 +
-</code>+
  
-Pozitív szám esetén balról 0-kat írunk hozzá:+**1101,01<sub>2</sub> = 1,10101<sub>2</sub> × 2<sup>3</sup>**.
  
-<code> +A nem nulla szám abszolút értékét úgy rendezzük át, hogy a vessző előtt pontosan egy 1-es maradjon. Ezt az alakot **normalizált alaknak**, az átrendezést **normalizálásnak** nevezzük.
-8 biten:  00000101 +
-16 biten: 00000000 00000101 +
-</code>+
  
-Ez az //előjelkiterjesztés// megőrzi a szám eredeti értékét.+Az ''1,10101'' részt **szignifikansnak** nevezzük; sok tananyag a **mantissza** elnevezést használja rá. Ez hordozza a szám értékes bináris jegyeit. Értéke normalizált alakban legalább 1, de kisebb 2-nél.
  
-==== 3. Törtszámok kettes számrendszerben ====+Egy egynél kisebb számnál negatív kitevőt kapunk:
  
-A bináris törtek a tízes számrendszer törtrészeihez hasonlóan helyiértékeket használnak, de a tizedesvesszőtől jobbra 2 negatív kitevőjű hatványai állnak.+**0,00101<sub>2</sub> = 1,01<sub>2</sub> × 2<sup>−3</sup> = 0,15625<sub>10</sub>**.
  
-^ Bináris helyiérték ^ 2⁻¹ ^ 2⁻² ^ 2⁻³ ^ 2⁻⁴ ^ +Itt a vesszőt jobbra mozdítottuk három hellyel, ezért az érték megtartásához nyolccal osztunk.
-| Tízes számrendszerben | 1/2 | 1/4 | 1/8 | 1/16 | +
-| Érték | 0,5 | 0,25 | 0,125 | 0,0625 |+
  
-Például:+==== 9. IEEE 754: pontosan melyik bit mit tároljon? ====
  
-<code> +Az alapötlet még nem határozza meg, hány bitet kapjon az előjel, a kitevő és a szignifikáns. Ha különböző számítógépek ugyanúgy szeretnék értelmezni az adatot, közös szabályokra van szükségük.
-0,101₂ = 1 · 2⁻¹ + 0 · 2⁻² + 1 · 2⁻³ +
-       = 0,5 + 0 + 0,125 +
-       = 0,625₁₀ +
-</code>+
  
-Egy egész- és törtrészt egyaránt tartalmazó szám:+Az **IEEE 754** a lebegőpontos számábrázolás és aritmetika szabványa. Többek között tárolási formátumokat, kerekítési szabályokat és különleges értékeket határoz meg. Itt a **binary32** nevű, 32 bites bináris formátumot vezetjük le részletesen. Ezt egyszeres pontosságú ábrázolásnak is nevezik.
  
-<code> +A 32 bitet három egymás utáni részre osztjuk. Az ilyen, meghatározott szerepű bitcsoportot **mezőnek** nevezzük.
-1101,01₂ = 8 + 4 + 1 + 0,25 = 13,25₁₀ +
-</code>+
  
-=== Tízes tört átalakítása binárissá ===+^ Mező ^ Méret ^ Feladat ^ 
 +| Előjel | 1 bit | 0: pozitív, 1: negatív előjel | 
 +| Eltolt kitevő | 8 bit | A kettes hatvány kitevőjének tárolása, az alább megadott eltolással | 
 +| Törtrész | 23 bit | A normalizált szignifikáns vessző utáni bitjei |
  
-A törtrészt ismételten megszorozzuk 2-vel. Minden lépésben az eredmény egész része adja a következő bináris számjegyet.+Ez összesen **1 + 8 + 23 = 32 bit**, vagyis négy bájt. A következő levezetések a normál, véges, nem nulla számokra vonatkoznak. A nulla és más különleges esetek szabályait később külön tárgyaljuk.
  
-Alakítsuk át a 0,625 értéket:+=== Miért csak a vessző utáni biteket tároljuk? ===
  
-^ Művelet ^ Egész rész ^ Megmaradó törtrész ^ +A normalizált bináris alak mindig ''1,''-gyel kezdődik. Ezt az első 1-est ezért nem szükséges külön eltárolni: visszaolvasáskor automatikusan eléírjuk a tárolt törtbiteknek.
-| 0,625 · 2 = 1,25 | 1 | 0,25 | +
-| 0,25 · 2 = 0,5 | 0 | 0,5 | +
-| 0,5 · 2 = 1,0 | 1 | 0 |+
  
-Az egész részeket felülről lefelé összeolvasva:+Például az ''1,10101'' szignifikansból csak az ''10101'' rész kerül a törtrészmezőbe. A hiányzó helyeket jobbról nullákkal töltjük ki.
  
-<code> +Az elhagyott első 1-est **rejtett vezető bitnek** nevezik. Emiatt a 23 tárolt törtbit a normál számoknál **24 értékes bináris jegyet** biztosít. A szignifikans és a tárolt törtrészmező tehát nem pontosan ugyanaz.
-0,625₁₀ = 0,101₂ +
-</code>+
  
-Nem minden tízes számrendszerbeli tört írható fel véges bináris törtként. A 0,1 például végtelen, ismétlődő bináris tört:+=== Hogyan tárolunk negatív kitevőt? ===
  
-<code> +A kitevő lehet pozitív és negatív is. A binary32 kitevőmezőjét azonban **nem kettes komplemens szerint** értelmezzük. Ehelyett a valódi kitevőhöz hozzáadunk **127-et**, és ezt a nemnegatív értéket tároljuk.
-0,1₁₀ = 0,00011001100110011...₂ +
-</code>+
  
-Emiatt a számítógép a 0,1 értéknek csak egy közeli közelítését tudja eltárolni.+Ezt az állandó hozzáadást **eltolásnak** nevezzük; angol neve bias.
  
-==== 4. Fixpontos és lebegőpontos ábrázolás ====+  * **Tárolás:** tárolt kitevő = valódi kitevő + 127. 
 +  * **Visszaolvasás:** valódi kitevő = tárolt kitevő − 127.
  
-Törtszámok tárolására többféle megoldás használható.+^ Valódi kitevő ^ Tárolt érték ^ A tárolt érték nyolc biten ^ 
 +| −3 | 124 | ''01111100'' | 
 +| 0 | 127 | ''01111111'' | 
 +| +3 | 130 | ''10000010'' |
  
-//Fixpontos ábrázolásnál// előre meghatározzuk, hogy a bitsorozatban hol található a bináris pont. Például egy 8 bites formátumban kijelölhetünk 4 bitet az egészrész és 4 bitet a törtrész számára. A ''00110100'' bitsorozat ekkor így értelmezhető:+A normál számok tárolt kitevője 1 és 254 közötti lehet, ami −126 és +127 közötti valódi kitevőt jelent. A 0 és a 255 mezőérték különleges esetek számára van fenntartva.
  
-<code> +==== 10. Teljes példa: −13,25 tárolása binary32 formátumban ====
-0011,0100₂ = 3,25₁₀ +
-</code>+
  
-A fixpontos számok egyszerűek és kiszámítható pontosságúak, de az ábrázolható tartományuk korlátozott.+=== 1. lépés: az előjel ===
  
-//Lebegőpontos ábrázolásnál// a bináris pont helye nem rögzített. A számot a tudományos számábrázoláshoz hasonló alakban tároljuk:+A szám negatív, ezért az **előjelbit 1**. A továbbiakban a 13,25 abszolút értékével dolgozunk.
  
-<code> +=== 2. lépés: bináris alak és normalizálás ===
-előjel · mantissza · 2kitevő +
-</code>+
  
-Például:+A korábbi levezetés szerint:
  
-<code> +**13,25<sub>10</sub> = 1101,01<sub>2</sub> = 1,10101<sub>2</sub> × 2<sup>3</sup>**.
-1101,01₂ = 1,10101₂ · 2³ +
-</code>+
  
-A bináris pontot három hellyel mozgattuk balra, ezért a kitevő értéke 3.+A valódi kitevő tehát **3**, a szignifikáns **1,10101**.
  
-==== 5. Az IEEE 754 lebegőpontos szabvány ====+=== 3. lépés: a kitevőmező ===
  
-A legtöbb mai számítógép az IEEE 754 szabvány szerint tárolja a lebegőpontos számokat. A bitsorozat három mezőből áll:+A 3-hoz hozzáadjuk az eltolást: **3 + 127 = 130**.
  
-  * ''S'' – előjelbit (sign); +Mivel 130 = 128 + 2, a kitevőmező nyolc bitje **10000010**.
-  * ''E'' – eltolt kitevő (exponent); +
-  * ''F'' – törtrészmező (fraction), amelyet gyakran mantisszának is neveznek.+
  
-A két leggyakoribb formátum:+=== 4. lépés: a törtrészmező ===
  
-^ Formátum ^ Teljes méret ^ Előjel ^ Kitevő ^ Törtrész ^ Kitevő eltolása ^ Közelítő decimális pontosság ^ +Az ''1,10101'' elejéről elhagyjuk a rejtett 1-est. A maradó ''10101'' öt bit hosszú; jobbról 18 nullával egészítjük ki 23 bitre:
-| Egyszeres pontosság (float) | 32 bit | 1 bit | 8 bit | 23 bit | 127 | kb. 7 számjegy | +
-| Kétszeres pontosság (double) | 64 bit | 1 bit | 11 bit | 52 bit | 1023 | kb. 15–16 számjegy |+
  
-Egy normál, 32 bites lebegőpontos szám értéke:+**10101000000000000000000**.
  
-<code> +Itt nincs szükség kerekítésre, mert az összes értékes jegy elfér.
-(−1)^S · 1,F₂ · 2^(E − 127) +
-</code>+
  
-ahol:+=== 5. lépés: a mezők összeillesztése ===
  
-  * ''S'' az előjelbit; +^ Előjel: 1 bit ^ Kitevő: 8 bit ^ Törtrész: 23 bit ^ 
-  * ''E'' a kitevőmező előjel nélküli értéke; +| ''1'' | ''10000010'' | ''10101000000000000000000'' |
-  * ''F'' a törtrészmező; +
-  * 127 a kitevő eltolási értéke, más néven //bias//.+
  
-Az előjelbit értelmezése:+A teljes 32 bites minta:
  
 <code> <code>
-S = 0: pozitív szám +1 10000010 10101000000000000000000
-S = 1: negatív szám+
 </code> </code>
  
-A kitevőt eltolva tároljuk, ezért negatív kitevőhöz sincs szükség külön előjelbitre. Például a 3 kitevőt 32 bites formátumban így tároljuk:+A szóközök csak a mezőhatárokat mutatják, nem tárolt jelek. A bitmintát a legfelső előjelbittől a legalsó törtbit felé írtuk fel; a memóriabeli bájtsorrend külön kérdés.
  
-<code> +**Fontos különbség:** itt a negatív előjelet egy külön bit tárolja. A −13,25 előállításához nem fordítjuk meg a +13,25 teljes bitmintáját, és nem adunk hozzá 1-et. A kettes komplemens az egész számoknál tanult másik ábrázolás.
-3 + 127 = 130 = 10000010₂ +
-</code>+
  
-Normál számok esetében a mantissza mindig ''1,'' kezdetű. A kezdő 1-est nem kell eltárolni, mert annak értéke ismert. Ezt //rejtett egyesnek// nevezzük. Így 23 tárolt törtrészbit valójában 24 bites bináris pontosságot biztosít.+=== Visszaellenőrzés: mit jelent ez a 32 bit? ===
  
-==== 5.1. A 13,25 ábrázolása 32 bites IEEE 754 formátumban ====+  - Az előjelbit 1, ezért az eredmény negatív. 
 +  - A kitevőmező ''10000010'', vagyis 130. A valódi kitevő 130 − 127 = 3. 
 +  - A törtmező elé visszaírjuk a rejtett 1-est: ''1,10101''. 
 +  - A szignifikáns értéke 1 + 1/2 + 1/8 + 1/32 = 1,65625. 
 +  - Megszorozzuk 2<sup>3</sup>-nal: 1,65625 × 8 = 13,25. 
 +  - Alkalmazzuk a negatív előjelet: **−13,25**.
  
-=== 1. Átalakítás kettes számrendszerbe ===+=== A szabály tömör képlettel ===
  
-<code> +Jelöljük az előjelbitet s-sel, a kitevőmező előjel nélküli egész értékét E-vel, a 23 bites törtrészmező előjel nélküli egész értékét pedig F-fel. Normál binary32 számnál:
-13,25₁₀ = 1101,01₂ +
-</code>+
  
-=== 2. Normalizálás ===+**érték = (−1)<sup>s</sup> × (1 + F / 2<sup>23</sup>) × 2<sup>E−127</sup>**.
  
-<code> +A képlet ugyanazokat a lépéseket foglalja össze, amelyeket az előbb külön elvégeztünk. Csak akkor alkalmazható ebben az alakban, ha **1 ≤ E ≤ 254**.
-1101,01₂ = 1,10101₂ · 2³ +
-</code>+
  
-=== 3. Az előjelbit meghatározása ===+==== 11. Második példa: egy kicsi pozitív szám ====
  
-A szám pozitív:+Ábrázoljuk a **0,15625** számot! Mivel 0,15625 = 1/8 + 1/32, bináris alakja ''0,00101''.
  
-<code> +Normalizálva: **1,01<sub>2</sub> × 2<sup>−3</sup>**.
-S = 0 +
-</code>+
  
-=== 4. A kitevő tárolása ===+  * Az előjelbit **0**, mert a szám pozitív. 
 +  * A valódi kitevő **−3**, így a tárolt kitevő −3 + 127 = **124**, azaz ''01111100''. 
 +  * A rejtett 1-es utáni törtbitek ''01'', amelyeket 23 bitre egészítünk ki.
  
-<code> +^ Előjel ^ Kitevő ^ Törtrész ^ 
-kitevő = 3 +| ''0'' | ''01111100'' | ''01000000000000000000000'' |
-eltolt kitevő = 3 + 127 = 130 = 10000010₂ +
-</code>+
  
-=== 5. A törtrész tárolása ===+Visszaolvasva a szignifikáns 1,25, a kettes hatvány 1/8, ezért az eredmény **1,25 / 8 = 0,15625**.
  
-A normalizált alak kezdő 1-esét nem tároljuk. Az utána következő bitek:+==== 12. Miért nem minden szám tárolható pontosan? ====
  
-<code> +A tízes számrendszerben az 1/3 felírása végtelen: 0,3333… Kettes számrendszerben is vannak végtelen felírású törtek, de nem pontosan ugyanazok.
-10101000000000000000000 +
-</code>+
  
-=== 6. A mezők összeállítása ===+Például a **0,1<sub>10</sub> bináris alakja 0,0001100110011…<sub>2</sub>**. A ''0011'' rész az első törtjegy után ismétlődik.
  
-<code> +Az ismételt kettővel szorzásnál is látszik az ismétlődés:
-S |    E     |           F +
-0 | 10000010 | 10101000000000000000000 +
-</code>+
  
-Egybefüggően:+^ Lépés ^ Szorzás ^ Kiírt bit ^ Maradó törtrész ^ 
 +| 1. | 0,1 × 2 = 0,2 | 0 | 0,2 | 
 +| 2. | 0,2 × 2 = 0,4 | 0 | 0,4 | 
 +| 3. | 0,4 × 2 = 0,8 | 0 | 0,8 | 
 +| 4. | 0,8 × 2 = 1,6 | 1 | 0,6 | 
 +| 5. | 0,6 × 2 = 1,2 | 1 | 0,2 |
  
-<code> +Az ötödik lépésben újra 0,2 maradt, ezért innentől ugyanaz a folyamat ismétlődik. A szám felírása nem ér véget.
-01000001010101000000000000000000 +
-</code>+
  
-Hexadecimális alakban:+Véges számú biten csak véges számú jegyet tárolhatunk, ezért **közelítő értéket** választunk. A binary32 formátumban a 0,1 legközelebbi tárolható értéke körülbelül **0,10000000149**.
  
-<code> +Ez nem meghibásodás. Hasonló ahhoz, amikor az 1/3 helyett csak 0,333-at írunk le.
-0x41540000 +
-</code>+
  
-A −13,25 ábrázolásánál csak az előjelbit változik 1-re:+=== A kerekítés alapelve ===
  
-<code> +Az IEEE 754 alapértelmezett bináris kerekítése a **legközelebbi ábrázolható értéket** választja. Pontos félútnál azt az értéket részesíti előnyben, amelynek utolsó megtartott bináris jegye 0. Ezt „legközelebbire, döntetlennél párosra” kerekítésnek nevezik.
-11000001010101000000000000000000 = 0xC1540000 +
-</code>+
  
-==== 5.2. IEEE 754 bitsorozat visszaalakítása ====+Ezért a tárolás nem minden esetben puszta levágás: a megtartott utolsó jegyek a kerekítés hatására megváltozhatnak.
  
-Határozzuk meg a következő 32 bites lebegőpontos szám értékét:+=== A pontosság nem a tizedesjegyek állandó számát jelenti ===
  
-<code> +A binary32 normál számoknak 24 értékes bináris jegyük van. Amikor a kitevő nő, ugyanezek a jegyek nagyobb helyi értékeket jelölnek. Ezért a nagyobb számok között általában nagyobb a távolság.
-1 | 10000001 | 01100000000000000000000 +
-</code>+
  
-Az előjelbit:+Például binary32 esetén:
  
-<code> +  * 1 és 2 között a szomszédos számok távolsága 2<sup>−23</sup>, körülbelül 0,0000001192. 
-S = 1, ezért a szám negatív. +  * 2<sup>24</sup> = 16 777 216 és 2<sup>25</sup> között a lépésköz már **2**.
-</code>+
  
-A kitevőmező:+A **16 777 217** egész szám ezért nem tárolható pontosan binary32-ben, pedig nem közelíti meg a formátum legnagyobb értékét. A szomszédai 16 777 216 és 16 777 218. Az alapértelmezett kerekítés itt a 16 777 216-ot választja.
  
-<code> +**Az ábrázolható tartomány és az ábrázolás pontossága külön tulajdonság.** Attól, hogy egy érték a tartományon belül van, még nem feltétlenül tárolható pontosan.
-10000001₂ = 129 +
-valódi kitevő = 129 − 127 = 2 +
-</code>+
  
-A rejtett 1-essel kiegészített mantissza:+==== 13. Nulla, nagyon kicsi számok és különleges értékek ====
  
-<code> +A normál alak mindig rejtett 1-essel kezdődik, ezért ezzel a szabállyal a nullát nem tudnánk leírni. A szabvány ezért bizonyos kitevőmintákhoz külön értelmezést rendel.
-1,011₂ = 1 + 1/4 + 1/8 = 1,375 +
-</code>+
  
-A szám értéke:+A következő táblázatban E a kitevőmező egész értéke, F pedig a törtrészmezőé:
  
-<code> +^ Tárolt kitevő, E ^ Törtrész, F ^ Jelentés ^ 
-(−1) · 1,375 · 2² = −1,375 · 4 = −5,5 +| 1–254 | Tetszőleges | Normál, véges, nem nulla szám; rejtett vezető bitje 1. | 
-</code>+| 0 | 0 | Nulla; az előjelbittől függően +0 vagy −0. | 
 +| 0 | Nem nulla | Szubnormális, azaz a normál tartománynál kisebb abszolút értékű, nem nulla szám. | 
 +| 255 | 0 | Pozitív vagy negatív végtelen az előjelbit szerint. | 
 +| 255 | Nem nulla | NaN: különleges „nem szám” érték. |
  
-==== 5.3. Különleges értékek ====+A **szubnormális számoknál** a vezető bit 0, a kettes hatvány kitevője pedig rögzítetten −126. Így a normál tartomány alatt is tárolhatók nullától különböző értékek, de kevesebb értékes jeggyel. A legkisebb pozitív binary32 érték 2<sup>−149</sup>, körülbelül 1,4 × 10<sup>−45</sup>.
  
-Az IEEE 754 szabvány bizonyos kitevőmintákat különleges értékek jelölésére tart fenn.+A szubnormális érték képlete: **(−1)<sup>s</sup> × (F / 2<sup>23</sup>) × 2<sup>−126</sup>**. Itt nem írunk vissza rejtett 1-est.
  
-^ Kitevőmező ^ Törtrészmező ^ Jelentés ^ +A **végtelen** jelölés például túl nagy eredménynél jelenhet meg. Nem egy rendkívül nagy véges számot jelent, hanem különleges érték.
-| minden bit 0 | minden bit 0 | +0 vagy −0 | +
-| minden bit 0 | nem minden bit 0 | szubnormális szám | +
-| 1 és 254 között | tetszőleges | normál szám | +
-| minden bit 1 | minden bit 0 | +végtelen vagy −végtelen | +
-| minden bit 1 | nem minden bit 0 | NaN |+
  
-=== Pozitív és negatív nulla ===+A **NaN** az angol Not a Number rövidítése. Olyan eredményt jelölhet, amelyhez nem rendelhető szokásos számérték, például a 0/0 műveletnél. A program konkrét szabályai szerint ilyen helyzetben különleges érték vagy hibajelzés is keletkezhet.
  
-Az IEEE 754 formátumban a nullának két előjeles változata van:+A +0 és −0 a szokásos numerikus egyenlőségvizsgálatban egyenlő, de bitmintájuk eltér, és egyes műveletek különbséget tesznek közöttük. Ez az egész számok kettes komplemens ábrázolásának egyetlen nullájától eltérő szabály.
  
-<code> +==== 14. Mi változik 64 bites lebegőpontos ábrázolásnál? ====
-+0: S = 0 +
-−0: S = 1 +
-</code>+
  
-A legtöbb műveletben egyenlőnek számítanak, de bizonyos műveleteknél az előjelüknek lehet jelentősége.+Az IEEE 754 másik gyakori formátuma a **binary64**, más néven kétszeres pontosságú ábrázolás. Ugyanarra az elvre épül, de több bitet használ a kitevőhöz és a törtrészhez is.
  
-=== Szubnormális számok ===+^ Tulajdonság ^ binary32 ^ binary64 ^ 
 +| Teljes méret | 32 bit, 4 bájt | 64 bit, 8 bájt | 
 +| Előjel | 1 bit | 1 bit | 
 +| Kitevőmező | 8 bit | 11 bit | 
 +| Tárolt törtbitek | 23 bit | 52 bit | 
 +| Értékes bináris jegyek normál számnál | 24 | 53 | 
 +| Kitevő eltolása | 127 | 1023 | 
 +| Tájékoztató pontosság tízes számrendszerben | Körülbelül 7 értékes jegy | Körülbelül 16 értékes jegy | 
 +| Legnagyobb pozitív véges érték, közelítőleg | 3,4 × 10<sup>38</sup> | 1,8 × 10<sup>308</sup> |
  
-A szubnormális számok segítségével a nullához nagyon közeli értékek is ábrázolhatók. Ezeknél nincs rejtett kezdő 1-es, ezért az értékük:+Az „értékes jegy” nem ugyanaz, mint a „vessző utáni jegy”. Például az 1,234567 és az 1 234 567 egyaránt hét értékes decimális jegyet tartalmaz. A táblázat kerekített tájékoztatást ad, nem minden decimális számra érvényes pontos tárolási garanciát.
  
-<code> +A binary64 lényegesen pontosabb, de **a 0,1-et ez sem tárolja pontosan**, mert annak bináris felírása végtelen.
-(−1)^S · 0,F₂ · 2^(1 − bias) +
-</code>+
  
-Pontosságuk kisebb, mint a normál számoké, de fokozatos átmenetet biztosítanak a legkisebb normál szám és a nulla között.+==== 15. Mire figyeljünk mérnöki számításoknál? ====
  
-=== Végtelen ===+  * **Egész számoknál ellenőrizzük a tartományt.** Például egy számláló tárolásakor fontos, elfér-e benne a legnagyobb várható érték. 
 +  * **A lebegőpontos eredményben lehet kerekítési eltérés.** Ez nem azonos a műszer mérési hibájával, bár a számítás során mindkettő jelentős lehet. 
 +  * **Nagy érték mellett egy kis változás elveszhet.** Ha a változás kisebb a helyi lépésköznél, kerekítés után ugyanaz a szám maradhat. 
 +  * **A számítás sorrendje is számíthat.** A részeredmények kerekítése miatt az összeadások átcsoportosítása eltérő eredményt adhat. 
 +  * **Számított vagy mért értékek egyezését gyakran tűréssel vizsgáljuk.** A tűrést a mértékegységhez, a nagyságrendhez és a feladat pontossági követelményéhez kell választani.
  
-Pozitív vagy negatív végtelen keletkezhet például túl nagy eredmény vagy nem nulla érték nullával történő lebegőpontos osztása esetén:+Például ha két hosszúságeredmény eltérését legfeljebb 0,001 mm-ig tekintjük elfogadhatónak, azt vizsgáljuk, hogy különbségük abszolút értéke legfeljebb 0,001 mm-e. Más nagyságrendű feladatnál relatív, az érték nagyságához viszonyított tűrésre is szükség lehet.
  
-<code> +A több megjelenített tizedesjegy nem teszi pontosabbá sem az eredeti mérést, sem a már elvégzett számítást.
-1,0 / 0,0 = +végtelen +
-−1,0 / 0,0 = −végtelen +
-</code>+
  
-=== NaN ===+==== Ellenőrző kérdések és feladatok ====
  
-A ''NaN'' jelentése //Not a Number//, vagyis „nem szám”. Matematikailag nem értelmezett lebegőpontos műveletek eredménye lehet, például:+  - Írja fel a −6 értéket nyolcbites kettes komplemens ábrázolással! 
 +  - Mit jelent az ''11110110'' nyolcbites kettes komplemens szerint? 
 +  - Miért okoz problémát a 100 + 40 művelet nyolcbites kettes komplemensben? 
 +  - Írja fel a 0,375 számot bináris tört alakban! 
 +  - Írja fel a 6,5 számot normalizált bináris alakban! 
 +  - Adja meg a +6,5 három mezőjét IEEE 754 binary32 formátumban! 
 +  - Az előző bitmintában mely bitek változnak meg, ha +6,5 helyett −6,5-et tárolunk? 
 +  - Miért nem tárolható pontosan a 0,1 sem binary32, sem binary64 formátumban? 
 +  - Hogyan lehetséges, hogy egy tartományon belüli egész szám sem tárolható pontosan lebegőpontos formában?
  
-<code> +=== Megoldások ===
-0,0 / 0,0 +
-négyzetgyök(−1,0) a valós számok között +
-végtelen − végtelen +
-</code>+
  
-A NaN különleges tulajdonsága, hogy még önmagával sem tekinthető egyenlőnek:+  - +6: ''00000110''; megfordítva: ''11111001''; egyet hozzáadva: **11111010**. 
 +  - Előjel nélkül 246, ezért kettes komplemens szerint 246 − 256 = **−10**. 
 +  - A matematikai eredmény 140, de a legnagyobb ábrázolható érték 127. Túlcsordulás történik. 
 +  - 0,375 = 1/4 + 1/8, ezért **0,011<sub>2</sub>**. 
 +  - 6,5 = 110,1<sub>2</sub> = **1,101<sub>2</sub> × 2<sup>2</sup>**. 
 +  - Előjel: ''0''; kitevő: 2 + 127 = 129, azaz ''10000001''; törtrész: ''10100000000000000000000''. 
 +  - Csak az előjelbit változik 0-ról 1-re. 
 +  - A 0,1 bináris alakja végtelen szakaszos tört, a tárolható bitek száma pedig véges. 
 +  - A tartomány a nagyságrendet korlátozza, a szignifikáns hossza pedig a pontosságot. Nagy értékeknél a szomszédos tárolható számok között egynél nagyobb távolság is lehet.
  
-<code c> +==== Források és további olvasnivaló ====
-if (x != x) +
-{ +
-    /* x értéke NaN */ +
-} +
-</code>+
  
-A gyakorlatban azonban erre a célra a programozási nyelvek beépített ''isnan'' függvényét célszerű használni.+  * [[https://docs.oracle.com/cd/E77782_01/html/E77791/z4000ac019878.html|Oracle Numerical Computation Guide: IEEE-formátumok és különleges értékek]] 
 +  * [[https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html|David Goldberg: What Every Computer Scientist Should Know About Floating-Point Arithmetic]]
  
-==== 6. A lebegőpontos ábrázolás pontatlansága ==== 
  
-A lebegőpontos számok véges számú bitből állnak, ezért a valós számoknak csak egy véges részhalmazát tudják pontosan tárolni. A többi értéket a legközelebbi ábrázolható számra kell kerekíteni.+<html> 
 +<div id="szam-demo"> 
 +  <style> 
 +    #szam-demo { 
 +      max-width: 1000px; 
 +      margin: 20px auto; 
 +      padding: 22px; 
 +      box-sizing: border-box; 
 +      border: 1px solid #cbd5e1; 
 +      border-radius: 14px; 
 +      background: #f8fafc; 
 +      color: #172033; 
 +      font: 16px/1.6 Arial, sans-serif; 
 +    } 
 +    #szam-demo * { box-sizing: border-box; } 
 +    #szam-demo h3 { margin: 0 0 12px; color: #172033; } 
 +    #szam-demo p { margin: 10px 0; } 
 +    #szam-demo button, 
 +    #szam-demo input { 
 +      font: inherit; 
 +    } 
 +    #szam-demo button { 
 +      padding: 8px 13px; 
 +      border: 1px solid #94a3b8; 
 +      border-radius: 7px; 
 +      background: white; 
 +      color: #172033; 
 +      cursor: pointer; 
 +    } 
 +    #szam-demo button:hover { background: #e2e8f0; } 
 +    #szam-demo button:focus-visible, 
 +    #szam-demo input:focus-visible { 
 +      outline: 3px solid #2563eb; 
 +      outline-offset: 2px; 
 +    } 
 +    #szam-demo .navigation, 
 +    #szam-demo .controls, 
 +    #szam-demo .presets { 
 +      display: flex; 
 +      flex-wrap: wrap; 
 +      gap: 8px; 
 +      align-items: center; 
 +      margin-bottom: 15px; 
 +    } 
 +    #szam-demo .navigation button[aria-pressed="true"] { 
 +      background: #1e40af; 
 +      border-color: #1e40af; 
 +      color: white; 
 +    } 
 +    #szam-demo input[type="text"], 
 +    #szam-demo input[type="number"] { 
 +      width: 180px; 
 +      max-width: 100%; 
 +      padding: 8px; 
 +      border: 1px solid #94a3b8; 
 +      border-radius: 6px; 
 +      background: white; 
 +      color: #172033; 
 +    } 
 +    #szam-demo input[type="range"] { 
 +      display: block; 
 +      width: 100%; 
 +      margin: 18px 0; 
 +      accent-color: #1e40af; 
 +    } 
 +    #szam-demo .bits { 
 +      display: flex; 
 +      flex-wrap: wrap; 
 +      gap: 5px; 
 +      margin: 10px 0; 
 +    } 
 +    #szam-demo .bit { 
 +      width: 44px; 
 +      min-height: 48px; 
 +      padding: 5px; 
 +      font: bold 20px monospace; 
 +    } 
 +    #szam-demo .bit[aria-pressed="true"] { 
 +      background: #1e40af; 
 +      color: white; 
 +      border-color: #1e40af; 
 +    } 
 +    #szam-demo .bit small { 
 +      display: block; 
 +      font: 11px Arial, sans-serif; 
 +    } 
 +    #szam-demo .result { 
 +      margin: 14px 0; 
 +      padding: 14px; 
 +      border-left: 4px solid #2563eb; 
 +      border-radius: 5px; 
 +      background: #eaf1ff; 
 +      overflow-wrap: anywhere; 
 +    } 
 +    #szam-demo .mono { 
 +      font-family: Consolas, monospace; 
 +      overflow-wrap: anywhere; 
 +    } 
 +    #szam-demo .error { 
 +      color: #a61b1b; 
 +      font-weight: bold; 
 +    } 
 +    #szam-demo .hint { 
 +      color: #475569; 
 +      font-size: 14px; 
 +    } 
 +    #szam-demo .field { 
 +      margin-top: 16px; 
 +      padding: 12px; 
 +      border-radius: 8px; 
 +      background: white; 
 +      border: 1px solid #dbe3ed; 
 +    } 
 +    #szam-demo .field-title { font-weight: bold; } 
 +    #szam-demo [hidden] { display: none !important; } 
 +    @media (max-width: 500px) { 
 +      #szam-demo { padding: 12px; } 
 +      #szam-demo .bit { width: 38px; } 
 +    } 
 +  </style>
  
-Mivel a 0,1 és a 0,2 nem írható fel véges bináris törtként, a következő összehasonlítás egyes programozási nyelvekben meglepő eredményt adhat:+  <div class="navigation" aria-label="Demonstráció kiválasztása"> 
 +    <button type="button" data-panel="integer" aria-pressed="true"> 
 +      Negatív egész számok 
 +    </button> 
 +    <button type="button" data-panel="float" aria-pressed="false"> 
 +      IEEE 754 lebegőpontos számok 
 +    </button> 
 +  </div>
  
-<code c> +  <section data-section="integer"> 
-double a = 0.1; +    <h3>Nyolc bit – kétféle értelmezés</h3> 
-double b = 0.2;+    <p> 
 +      Kattints a bitekre! Ugyanazt a bitsorozatot előjel nélküli 
 +      egészként és kettes komplemens szerint is értelmezzük. 
 +    </p>
  
-if (a + b == 0.3) +    <div class="controls"> 
-{ +      <label for="szam-int-input">Előjeles érték:</label> 
-    printf("Egyenlo"); +      <input id="szam-int-input" type="number" 
-} +             min="-128" max="127" step="1" value="-5"> 
-else +      <button type="button" data-action="set-integer">Beállítás</button> 
-{ +    </div>
-    printf("Nem egyenlo"); +
-} +
-</code>+
  
-Az eredmény rendszerint ''Nem egyenlo'', mert a tárolt közelítő értékek összege nem pontosan egyezik meg a 0,3 tárolt közelítésével.+    <input data-role="int-slider" type="range" 
 +           min="-128" max="127" step="1" value="-5" 
 +           aria-label="Előjeles egész szám">
  
-Lebegőpontos értékeket ezért általában egy kis hibahatár, úgynevezett //epsilon// segítségével hasonlítunk össze:+    <div class="presets"> 
 +      <button type="button" data-int="-128">−128</button> 
 +      <button type="button" data-int="-5">−5</button> 
 +      <button type="button" data-int="-1">−1</button> 
 +      <button type="button" data-int="0">0</button> 
 +      <button type="button" data-int="5">+5</button> 
 +      <button type="button" data-int="127">+127</button> 
 +    </div>
  
-<code c> +    <div data-role="int-bits" class="bits" 
-#include <math.h>+         aria-label="Nyolcbites bitminta"></div>
  
-double epsilon = 1e-9;+    <div class="result" aria-live="polite"> 
 +      <div>Előjel nélkül: <strong data-role="unsigned"></strong></div> 
 +      <div>Kettes komplemens szerint: 
 +        <strong data-role="signed"></strong> 
 +      </div> 
 +      <div data-role="int-equation" class="mono"></div> 
 +    </div>
  
-if (fabs((a + b) - 0.3) < epsilon) +    <p data-role="int-explanation"></p>
-{ +
-    printf("A ket ertek a megadott pontossagon belul egyenlo"); +
-} +
-</code>+
  
-Az epsilon megfelelő értéke a számok nagyságrendjétől és az alkalmazás pontossági követelményeitől függ; nem minden feladathoz jó ugyanaz az állandó.+    <div class="controls"> 
 +      <button type="button" data-action="increment"> 
 +        Adjunk hozzá 1-et! 
 +      </button> 
 +      <button type="button" data-action="negate"> 
 +        Bitek megfordítása és +1 
 +      </button> 
 +    </div>
  
-==== 6.1. Pontosság és nagyságrend ====+    <p data-role="int-message" aria-live="polite"></p>
  
-A lebegőpontos számábrázolás relatív pontosságú. Minél nagyobb számokat tárolunk, annál nagyobb távolság lehet két egymást követő ábrázolható érték között.+    <p class="hint"> 
 +      Próbáld ki: állíts be 127-et, majd adj hozzá 1-et! 
 +      A demonstráció nyolc bitet tart meg. 
 +    </p> 
 +  </section>
  
-A 32 bites ''float'' 24 bites bináris pontossága miatt minden egész számot pontosan képes ábrázolni ''2²⁴ = 16 777 216'' értékig. E fölött már nem minden egymást követő egész szám tárolható.+  <section data-section="float" hidden> 
 +    <h3>Hogyan lesz egy számból 32 bit?</h3> 
 +    <p> 
 +      Írj be egy számot, vagy válassz példát! 
 +      A program IEEE 754 binary32 formátumra alakítja. 
 +      A kapott biteket külön is átkapcsolhatod. 
 +    </p>
  
-Például 32 bites float esetén:+    <div class="controls"> 
 +      <label for="szam-float-input">Szám:</label> 
 +      <input id="szam-float-input" type="text" 
 +             value="-13,25" spellcheck="false"> 
 +      <button type="button" data-action="set-float">Átalakítás</button> 
 +    </div>
  
-<code> +    <div class="presets"> 
-16 777 216 még pontosan ábrázolható. +      <button type="button" data-float="-13.25">−13,25</button> 
-16 777 217 már nem ábrázolható pontosan. +      <button type="button" data-float="0.15625">0,15625</button> 
-</code>+      <button type="button" data-float="0.1">0,1</button> 
 +      <button type="button" data-float="16777217">16 777 217</button> 
 +      <button type="button" data-float="0">+0</button> 
 +      <button type="button" data-float="-0">−0</button> 
 +      <button type="button" data-float="Infinity">+∞</button> 
 +      <button type="button" data-float="NaN">NaN</button> 
 +    </div> 
 + 
 +    <p data-role="float-message" aria-live="polite"></p> 
 + 
 +    <div class="field"> 
 +      <div class="field-title">1. Előjel – 1 bit</div> 
 +      <div data-role="sign-bits" class="bits"></div> 
 +      <div data-role="sign-description"></div> 
 +    </div> 
 + 
 +    <div class="field"> 
 +      <div class="field-title">2. Kitevő – 8 bit</div> 
 +      <div data-role="exponent-bits" class="bits"></div> 
 +      <div data-role="exponent-description"></div> 
 +    </div> 
 + 
 +    <div class="field"> 
 +      <div class="field-title">3. Törtrész – 23 bit</div> 
 +      <div data-role="fraction-bits" class="bits"></div> 
 +      <div data-role="fraction-description"></div> 
 +    </div> 
 + 
 +    <div class="result" aria-live="polite"> 
 +      <div>Típus: <strong data-role="float-class"></strong></div> 
 +      <div data-role="float-formula" class="mono"></div> 
 +      <div> 
 +        Tárolt érték: 
 +        <strong data-role="float-value" class="mono"></strong> 
 +      </div> 
 +      <div class="hint"> 
 +        A véges, nem nulla értéket 17 értékes decimális jegyre írjuk ki. 
 +      </div> 
 +    </div> 
 + 
 +    <p class="hint"> 
 +      A 0,1 példán figyeld meg a kerekítést! 
 +      Normál számnál a tárolt törtbitek elé egy rejtett 1-es kerül. 
 +      Nulla és szubnormális szám esetén a vezető bit 0. 
 +    </p> 
 +  </section> 
 + 
 +  <noscript>A demonstráció használatához engedélyezett JavaScript szükséges.</noscript> 
 + 
 +  <script> 
 +  (function () { 
 +    "use strict"; 
 + 
 +    const root = document.getElementById("szam-demo"); 
 +    if (!root || root.dataset.initialized) return; 
 +    root.dataset.initialized = "true"; 
 + 
 +    const el = name => root.querySelector('[data-role="' + name + '"]'); 
 +    const intInput = root.querySelector("#szam-int-input"); 
 +    const floatInput = root.querySelector("#szam-float-input"); 
 + 
 +    let byte = 251; 
 +    let word = 0; 
 + 
 +    const buffer = new ArrayBuffer(4); 
 +    const view = new DataView(buffer); 
 + 
 +    function signedValue() { 
 +      return byte < 128 ? byte : byte - 256; 
 +    } 
 + 
 +    function numberText(value) { 
 +      if (Number.isNaN(value)) return "NaN"; 
 +      if (value === Infinity) return "+∞"; 
 +      if (value === -Infinity) return "−∞"; 
 +      if (Object.is(value, -0)) return "−0"; 
 +      return String(value).replace(".", ","); 
 +    } 
 + 
 +    function preciseText(value) { 
 +      if (!Number.isFinite(value) || value === 0) { 
 +        return numberText(value); 
 +      } 
 +      return value.toPrecision(17).replace(".", ","); 
 +    } 
 + 
 +    function makeBit(container, position, handler, weight) { 
 +      const button = document.createElement("button"); 
 +      button.type = "button"; 
 +      button.className = "bit";
  
-Ezért lebegőpontos típust nem célszerű például nagy azonosítók vagy pénzösszegek pontos tárolására használni.+      const digit = document.createElement("span"); 
 +      button.appendChild(digit);
  
-==== 6.2. Túlcsordulás és alulcsordulás ====+      if (weight !== undefined) { 
 +        const label = document.createElement("small"); 
 +        label.textContent = weight; 
 +        button.appendChild(label); 
 +      }
  
-//Túlcsordulás// akkor történik, ha az eredmény abszolút értéke nagyobb a formátumban tárolható legnagyobb véges számnál. Az eredmény ilyenkor gyakran pozitív vagy negatív végtelen lesz.+      button.addEventListener("click", handler); 
 +      container.appendChild(button);
  
-//Alulcsordulás// akkor történik, ha egy nem nulla eredmény abszolút értéke túl közel kerül a nullához. Az eredmény először szubnormális számmá, végül nullává kerekedhet.+      return {button, digit, position}; 
 +    }
  
-==== 6.3. Kerekítési hibák felhalmozódása ====+    const intBits = []; 
 +    for (let p = 7; p >= 0; p--) { 
 +      intBits.push(makeBit( 
 +        el("int-bits"), 
 +        p, 
 +        function () { 
 +          byte ^= 1 << p; 
 +          clearIntegerMessage(); 
 +          renderInteger(); 
 +        }, 
 +        p === 7 ? "−128" : String(2 ** p) 
 +      )); 
 +    }
  
-Egyetlen lebegőpontos művelet hibája rendszerint nagyon kicsi, de sok egymás utáni művelet során a hibák felhalmozódhatnak. A műveletek sorrendje is befolyásolhatja az eredményt.+    function clearIntegerMessage() { 
 +      el("int-message").textContent = ""; 
 +      el("int-message").className = ""; 
 +    }
  
-Például nagyon nagy és nagyon kicsi szám összeadásakor a kis szám hatása elveszhet:+    function renderInteger() { 
 +      const value = signedValue();
  
-<code> +      intInput.value = value; 
-nagy_szam + kis_szam = nagy_szam +      el("int-slider").value = value; 
-</code>+ 
 +      intBits.forEach(item => { 
 +        const bit = (byte >>> item.position) & 1; 
 +        item.digit.textContent = bit; 
 +        item.button.setAttribute("aria-pressed", String(bit === 1)); 
 +        item.button.setAttribute( 
 +          "aria-label", 
 +          item.position + ". bit: " + bit + ", átkapcsolás" 
 +        ); 
 +      }); 
 + 
 +      el("unsigned").textContent = byte; 
 +      el("signed").textContent = value; 
 + 
 +      const terms = []; 
 +      for (let p = 7; p >= 0; p--) { 
 +        if ((byte >>> p) & 1) { 
 +          terms.push(p === 7 ? "−128" : String(2 ** p)); 
 +        } 
 +      } 
 +      el("int-equation").textContent = 
 +        (terms.length ? terms.join(" + ") : "0") + " = " + value; 
 + 
 +      el("int-explanation").textContent = value < 0 
 +        ? "Az első bit 1. Előjel nélküli értékéből 256-ot kivonva: " + 
 +          byte + " − 256 = " + value + 
 +          ". Az első bit itt −128 súlyú, nem külön mínuszjel." 
 +        : "Az első bit 0. A két értelmezés ugyanazt a nemnegatív számot adja."; 
 +    } 
 + 
 +    function setInteger(value) { 
 +      if (!Number.isInteger(value) || value < -128 || value > 127) { 
 +        el("int-message").textContent = 
 +          "−128 és 127 közötti egész számot adj meg!"; 
 +        el("int-message").className = "error"; 
 +        return; 
 +      } 
 +      byte = value & 255; 
 +      clearIntegerMessage(); 
 +      renderInteger(); 
 +    } 
 + 
 +    root.querySelector('[data-action="set-integer"]') 
 +      .addEventListener("click", () => setInteger(intInput.valueAsNumber)); 
 + 
 +    intInput.addEventListener("keydown", event => { 
 +      if (event.key === "Enter") setInteger(intInput.valueAsNumber); 
 +    }); 
 + 
 +    el("int-slider").addEventListener("input", event => { 
 +      setInteger(Number(event.target.value)); 
 +    }); 
 + 
 +    root.querySelectorAll("[data-int]").forEach(button => { 
 +      button.addEventListener("click", () => { 
 +        setInteger(Number(button.dataset.int)); 
 +      }); 
 +    }); 
 + 
 +    root.querySelector('[data-action="increment"]') 
 +      .addEventListener("click", () => { 
 +        const before = signedValue(); 
 +        byte = (byte + 1) & 255; 
 +        renderInteger(); 
 + 
 +        el("int-message").className = before === 127 ? "error" : ""; 
 +        el("int-message").textContent = before === 127 
 +          ? "Túlcsordulás! 127 + 1 = 128, de ez nem fér el. " + 
 +            "A megtartott 10000000 bitminta előjelesen −128." 
 +          : before + " + 1 = " + signedValue() + 
 +            ". Az eredmény belefér a nyolcbites előjeles tartományba."; 
 +      }); 
 + 
 +    root.querySelector('[data-action="negate"]') 
 +      .addEventListener("click", () => { 
 +        const before = signedValue(); 
 +        const original = byte.toString(2).padStart(8, "0"); 
 +        const inverted = ((~byte) & 255).toString(2).padStart(8, "0"); 
 + 
 +        byte = ((~byte) + 1) & 255; 
 +        renderInteger(); 
 + 
 +        el("int-message").className = before === -128 ? "error" : ""; 
 +        el("int-message").textContent = 
 +          original + " → megfordítva: " + inverted + 
 +          " → +1: " + byte.toString(2).padStart(8, "0") + 
 +          (before === -128 
 +            ? ". Túlcsordulás: +128 nem ábrázolható ezen a nyolc biten." 
 +            : ". Az új előjeles érték: " + signedValue() + "."); 
 +      }); 
 + 
 +    const floatBits = []; 
 + 
 +    function addFloatBits(container, high, low) { 
 +      for (let p = high; p >= low; p--) { 
 +        floatBits.push(makeBit(container, p, function () { 
 +          word = (word ^ (1 << p)) >>> 0; 
 +          el("float-message").textContent = 
 +            "Kézzel módosított bitminta; az értéket most ebből olvassuk vissza."; 
 +          el("float-message").className = ""; 
 +          renderFloat(true); 
 +        })); 
 +      } 
 +    } 
 + 
 +    addFloatBits(el("sign-bits"), 31, 31); 
 +    addFloatBits(el("exponent-bits"), 30, 23); 
 +    addFloatBits(el("fraction-bits"), 22, 0); 
 + 
 +    function renderFloat(updateInput) { 
 +      view.setUint32(0, word, false); 
 +      const value = view.getFloat32(0, false); 
 + 
 +      const sign = word >>> 31; 
 +      const exponent = (word >>> 23) & 255; 
 +      const fraction = word & 0x7fffff; 
 +      const fractionBits = fraction.toString(2).padStart(23, "0"); 
 + 
 +      floatBits.forEach(item => { 
 +        const bit = (word >>> item.position) & 1; 
 +        item.digit.textContent = bit; 
 +        item.button.setAttribute("aria-pressed", String(bit === 1)); 
 +        item.button.setAttribute( 
 +          "aria-label", 
 +          item.position + ". bit: " + bit + ", átkapcsolás" 
 +        ); 
 +      }); 
 + 
 +      el("sign-description").textContent = sign 
 +        ? "s = 1: negatív előjel. NaN esetén ez nem számszerű előjel." 
 +        : "s = 0: pozitív előjel. NaN esetén ez nem számszerű előjel."; 
 + 
 +      el("fraction-description").textContent = 
 +        "A 23 bit előjel nélküli egész értéke: F = " + fraction + "."; 
 + 
 +      let classification; 
 +      let formula; 
 + 
 +      if (exponent === 255) { 
 +        el("exponent-description").textContent = 
 +          "E = 255: különleges érték; nem alkalmazzuk az E − 127 szabályt."; 
 + 
 +        classification = fraction === 0 ? "Végtelen" : "NaN – nem szám"; 
 +        formula = fraction === 0 
 +          ? "Csupa 1-es kitevő és nulla törtrész: " + numberText(value) 
 +          : "Csupa 1-es kitevő és nem nulla törtrész: NaN."; 
 +      } else if (exponent === 0) { 
 +        el("exponent-description").textContent = 
 +          "E = 0: nulla vagy szubnormális szám. A skálázás 2⁻¹²⁶, " + 
 +          "a vezető bit 0."; 
 + 
 +        classification = fraction === 0 ? "Előjeles nulla" : "Szubnormális szám"; 
 +        formula = fraction === 0 
 +          ? "Nulla kitevő és nulla törtrész: " + numberText(value) 
 +          : (sign ? "−" : "+") + "0," + fractionBits + 
 +            "₂ × 2^(−126)"; 
 +      } else { 
 +        const actualExponent = exponent - 127; 
 +        classification = "Normál szám"; 
 + 
 +        el("exponent-description").textContent = 
 +          "E = " + exponent + "; valódi kitevő: " + 
 +          exponent + " − 127 = " + actualExponent + "."; 
 + 
 +        formula = (sign ? "−" : "+") + "1," + fractionBits + 
 +          "₂ × 2^(" + actualExponent + ")"; 
 + 
 +        el("fraction-description").textContent += 
 +          " A rejtett 1-essel a szignifikáns: " + 
 +          numberText(1 + fraction / 8388608) + "."; 
 +      } 
 + 
 +      el("float-class").textContent = classification; 
 +      el("float-formula").textContent = formula; 
 +      el("float-value").textContent = preciseText(value); 
 + 
 +      if (updateInput) { 
 +        floatInput.value = Number.isNaN(value) 
 +          ? "NaN" 
 +          : Object.is(value, -0) ? "-0" : String(value); 
 +      } 
 +    } 
 + 
 +    function convertFloat() { 
 +      const text = floatInput.value.trim().replace("−", "-").replace(",", "."); 
 +      let value;
  
-Ez nem matematikai azonosság, hanem a véges pontosság következménye.+      if (/^[+-]?nan$/i.test(text)) { 
 +        value = NaN; 
 +      } else if (/^\+?(infinity|∞)$/i.test(text)) { 
 +        value = Infinity; 
 +      } else if (/^-(infinity|∞)$/i.test(text)) { 
 +        value = -Infinity; 
 +      } else if (/^[+-]?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i.test(text)) { 
 +        value = Number(text); 
 +        if (!Number.isFinite(value)) { 
 +          el("float-message").textContent = 
 +            "A bemenet a böngésző számkezelési tartományán kívül esik."; 
 +          el("float-message").className = "error"; 
 +          return; 
 +        } 
 +      } else { 
 +        el("float-message").textContent = 
 +          "Számot adj meg, például −13,25 vagy 1e-40! Infinity és NaN is megadható."; 
 +        el("float-message").className = "error"; 
 +        return; 
 +      }
  
-==== 7. Egész és lebegőpontos számábrázolás összehasonlítása ====+      view.setFloat32(0, value, false); 
 +      word = view.getUint32(0, false); 
 +      const stored = view.getFloat32(0, false);
  
-^ Tulajdonság ^ Kettes komplemens egész szám ^ IEEE 754 lebegőpontos szám ^ +      el("float-message").className = ""; 
-| Tárolható értékek | egészek | törtrészes és nagyon kis vagy nagy számok | +      if (Number.isFinite(value) && !Number.isFinite(stored)) { 
-| Pontosság | a tartományon belül pontos | gyakran közelítő | +        el("float-message").textContent = 
-| Előjel kezelése | a legmagasabb bit helyiértékének része | külön előjelbit | +          "Binary32-túlcsordulás: a véges bemenetből végtelen lett."; 
-| Túlcsordulás | a bitsorozat hibás előjelű értékké fordulhat vagy a nyelv hibát jelezhet | gyakran végtelen keletkezik | +        el("float-message").className = "error"; 
-| Különleges értékek | általában nincsenek | ±0, ±végtelen, NaN, szubnormális számok | +      } else if (value !== 0 && stored === 0) { 
-| Jellemző alkalmazás | számlálók, indexek, darabszámok | mérések, geometriai és tudományos számítások |+        el("float-message").textContent = 
 +          "A szám túl kicsi: binary32-re kerekítve nulla lett."; 
 +      } else if (Number.isFinite(value) && stored !== value) { 
 +        el("float-message").textContent = 
 +          "Kerekítés történt a böngésző által beolvasott szám binary32-re alakításakor."; 
 +      } else { 
 +        el("float-message").textContent = 
 +          "A beolvasott érték binary32-re alakításakor nem történt további kerekítés."; 
 +      }
  
-==== 8. Összefoglalás ====+      if (!Number.isFinite(value)) { 
 +        el("float-message").textContent = "Különleges érték beállítva."; 
 +      }
  
-  * Az előjel nélküli ''n'' bites egész számok tartománya ''0 ... 2ⁿ − 1''. +      renderFloat(false); 
-  * Az előjeles egész számokat a modern számítógépek jellemzően kettes komplemens alakban tárolják. +    }
-  * Egy negatív kettes komplemens számot a pozitív alak bitjeinek megfordításával, majd 1 hozzáadásával kapunk meg. +
-  * Az ''n'' bites kettes komplemens számok tartománya ''−2ⁿ⁻¹ ... 2ⁿ⁻¹ − 1''. +
-  * A bináris törtrész helyiértékei ''2⁻¹, 2⁻², 2⁻³, ...'' értékek. +
-  * Az IEEE 754 lebegőpontos szám előjelből, eltolt kitevőből és törtrészből áll. +
-  * Sok tízes tört, például a 0,1, binárisan csak közelítőleg tárolható. +
-  * Lebegőpontos számokat általában nem közvetlen egyenlőségvizsgálattal, hanem megfelelő hibahatár figyelembevételével hasonlítunk össze. +
-  * Pénzügyi és más, pontos tizedes számítást igénylő feladatokhoz célszerű decimális vagy skálázott egész számábrázolást használni.+
  
-==== 9. Ellenőrző kérdések és feladatok ====+    root.querySelector('[data-action="set-float"]') 
 +      .addEventListener("click", convertFloat);
  
-  - Miért nem határozható meg egy bitsorozat értéke az adattípus ismerete nélkül? +    floatInput.addEventListener("keydown", event => { 
-  - Mi a 45 előjel nélküli 8 bites bináris alakja? +      if (event.key === "Enter") convertFloat(); 
-  - Ábrázolja a −18 számot 8 bites kettes komplemens formában! +    });
-  - Milyen értéket jelent a ''11101100'' bitsorozat 8 bites kettes komplemens számként? +
-  - Mi a 8 bites előjeles egészek legkisebb és legnagyobb értéke? +
-  - Végezze el 8 biten a ''12 + (−7)'' összeadást! +
-  - Miért okoz túlcsordulást 8 biten a ''100 + 40'' összeadás? +
-  - Alakítsa át a ''101,101₂'' számot tízes számrendszerbe! +
-  - Alakítsa át a ''10,625₁₀'' számot kettes számrendszerbe! +
-  - Milyen három fő mezőből áll egy IEEE 754 lebegőpontos szám? +
-  - Miért nem tárolható pontosan a 0,1 a szokásos bináris lebegőpontos formátumokban? +
-  - Mit jelent a NaN érték?+
  
-==== 10. A feladatok rövid megoldása ====+    root.querySelectorAll("[data-float]").forEach(button => { 
 +      button.addEventListener("click", () => { 
 +        floatInput.value = button.dataset.float; 
 +        convertFloat(); 
 +      }); 
 +    });
  
-  - A bitsorozat jelentése az ábrázolási módtól és az adattípustól függ. +    root.querySelectorAll("[data-panel]").forEach(button => { 
-  - ''45₁₀ = 00101101₂''. +      button.addEventListener("click", () => { 
-  - ''+18 = 00010010'', bitfordítás után ''11101101'', majd 1 hozzáadásával ''−18 = 11101110''. +        root.querySelectorAll("[data-panel]").forEach(tab => { 
-  - ''11101100₂ = −20₁₀''. +          tab.setAttribute("aria-pressed", String(tab === button)); 
-  - A tartomány −128-tól 127-ig tart. +        }); 
-  - ''00001100 + 11111001 = 00000101'', tehát az eredmény 5. +        root.querySelectorAll("[data-section]").forEach(section => { 
-  - Az eredmény 140 lenne, amely nagyobb a legnagyobb 8 bites előjeles értéknél, vagyis 127-nél. +          section.hidden = section.dataset.section !== button.dataset.panel; 
-  - ''101,101₂ = 5,625₁₀''. +        }); 
-  - ''10,625₁₀ = 1010,101₂''. +      }); 
-  - Előjelbitből, kitevőmezőből és törtrészmezőből. +    });
-  - Mert a 0,1 bináris alakja végtelen, ismétlődő tört, miközben a tárolásra véges számú bit áll rendelkezésre. +
-  - A NaN matematikailag nem értelmezhető lebegőpontos művelet eredményét jelöli.+
  
 +    renderInteger();
 +    convertFloat();
 +  })();
 +  </script>
 +</div>
 +</html>
tanszek/oktatas/infrendalapjai_architekturak/logika_alapjai/szamabrazolas.txt · Last modified: by knehez