Institute of Information Science - University of Miskolc

User Tools

Site Tools

Trace: • karakterkodolas
tanszek:oktatas:szamitastechnika:szamabrazolas

Differences

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

Link to this comparison view

Next revision		Previous revision
tanszek:oktatas:szamitastechnika:szamabrazolas [2026/10/01 20:08] – created kneheztanszek:oktatas:szamitastechnika:szamabrazolas [2026/10/01 20:34] (current) – knehez
Line 1: Line 1:
-===== Karakterkódolás =====+===== Negatív és lebegőpontos számok ábrázolása =====
  
-Amikor leírjuk azt, hogy ''motor'', betűket látunk a képernyőn. A számítógép azonban a szöveget is bitek formájában tárolja. Hogyan lehet betűket nullákkal és egyesekkel leírni? Ehhez először számokat rendelünk a betűkhöz, majd meghatározzuk e számok tárolásának módját.+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?
  
-Ebben a fejezetben megvizsgáljuk, hogyan működik ez a megfeleltetés, miért van többféle karakterkódolás, és mitől romolhatnak el az ékezetek egy fájl megnyitásakor.+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.
  
-==== 1. Hogyan lesz a betűből szám? ====+==== 1. Kiindulás: mit jelent egy bitsorozat? ====
  
-A szövegben szereplő betűket, számjegyeket, írásjeleket és egyéb jeleket összefoglalóan **karaktereknek** nevezzük. Az ''A'', a ''7'' és a ''?'' egyaránt karakter. A szóköz is karakter, bár nem rajzolódik ki látható jelként.+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á.
  
-Készítsünk egy nagyon egyszerű, **kitalált kódtáblázatot**! Állapodjunk meg abban, hogy három betűnek a következő számokat feleltetjük meg:+Például a ''00001101'' bitsorozat értéke:
  
-^ Betű ^ Hozzárendelt szám ^ +^ Helyi érték ^ 128 ^ 64 ^ 32 ^ 16 ^ 8 ^ 4 ^ 2 ^ 1 ^ 
-| A | 1 | +| Bit | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 1 |
-| B | 2 | +
-| C | 3 |+
  
-Ezzel a táblázattal az ''ABA'' szöveget az ''1, 2, 1'' számsorozattal írhatjuk le. Aki ismeri a táblázatot, a számsorozatból vissza tudja állítani az eredeti betűket.+A szám tehát **8 + 4 + 1 = 13**.
  
-Mi történne, ha a fogadó fél egy másik táblázatot használna, amelyben az 1 a B betűt, a 2 pedig az A betűt jelenti? Ugyanabból az ''1, 2, 1'' sorozatból a ''BAB'' szöveget olvasná ki.+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**.
  
-**Az adó és a fogadó félnek ugyanazokat a kódolási szabályokat kell használnia.** Ez a valódi szövegfájlok kezelésére is igaz.+Ha negatív számokat is szeretnénk tárolni, akkor ugyanezt a 256 bitsorozatot kell másképpen felosztanunk.
  
-==== 2. Hogyan tároljuk a hozzárendelt számokat? ====+**A bitsorozat önmagában nem mondja meg, hogyan kell értelmezni.** Tudnunk kell, milyen számábrázolási szabály tartozik hozzá.
  
-A számítógép a számokat kettes számrendszerben, nullák és egyesek sorozataként tárolja. Egy ilyen számjegy a **bit**. Nyolc bit együtt egy **bájt**.+==== 2. Első ötlet: külön bit jelölje az előjelet ====
  
-Nyolc biten 256 különböző érték különböztethető meg. Ha ezeket előjel nélküli egész számként értelmezzük, a lehetséges értékek 0-tól 255-ig terjednek.+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.
  
-Az előbbi kitalált példában tároljunk minden betűkódot egy bájton:+Á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é:
  
-^ Betű ^ Hozzárendelt szám ^ A szám nyolc biten ^ +^ Szám ^ Előjelbit ^ A nagyság hét biten ^ Teljes bitsorozat ^ 
-| A | 1 | ''00000001'' | +| +5 | 0 | ''0000101'' | ''00000101'' | 
-| B | 2 | ''00000010'' | +| −5 | 1 | ''0000101'' | ''10000101'' |
-| C | 3 | ''00000011'' |+
  
-Az ''ABA'' szöveg így három bájtot foglal: az első bájt az 1-et, a második a 2-t, a harmadik ismét az 1-et tárolja.+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:
  
-Ezzel már egy teljes tárolási szabályt adtunk meg: megmondtuk, melyik betűhöz milyen szám tartozik, és azt is, hogy egy számot hány biten tárolunk.+  * A nullának két alakja van: ''00000000'' és ''10000000'', azaz +0 és −0. 
 +  * A bitsorozatok közönséges bináris összeadása önmagában nem adja meg helyesen az előjeles összeget.
  
-A **karakterkódolás** meghatározza, hogyan alakítjuk a szöveg karaktereit tárolható bájtsorozattá. A visszaalakítást **dekódolásnak** nevezzük.+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.
  
-A saját táblázatunk csak szemléltetésre szolgál. A gyakorlatban közösen elfogadott, szabványos kódolásokat használunk, hogy a különböző programok és számítógépek értelmezni tudják egymás szövegeit.+Az egész számokhoz ezért általában más megoldást használunk: a **kettes komplemens ábrázolást**.
  
-==== 3. ASCII: egy közösen elfogadott kódtáblázat ====+==== 3. Kettes komplemens ====
  
-Az egyik ilyen szabvány az **ASCII**. Teljes neve American Standard Code for Information Interchange. Az ASCII meghatározza, hogy az általa kezelt karakterekhez mely számok tartoznak.+Olyan bitsorozatot keresünk −5 számára, amelyet +5 bitsorozatához hozzáadva az alsó nyolc biten nullát kapunk.
  
-Például a nagy ''A'' betűhöz a **65**, a nagy ''B'' betűhöz a **66** számot rendeli. Ezeket az értékeket megállapodás rögzíti: nem a betű alakjából számítjuk ki őket.+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.
  
-^ Karakter ^ ASCII-kód tízes számrendszerben ^ Tárolása egy bájton ^ +Melyik nemnegatív számmal kell az 5-öt kiegészíteni 256-ra? A válasz: **256 − 5 = 251**.
-| A | 65 | ''01000001'' | +
-| B | 66 | ''01000010'' | +
-| a | 97 | ''01100001'' | +
-| 0 | 48 | ''00110000'' | +
-| Szóköz | 32 | ''00100000'' |+
  
-Az ''ABBA'' szöveg ASCII szerint a 65, 66, 66, 65 értékű bájtokkal tárolható. A kisbetű és a nagybetű külön karakter: ezért az ''A'' és az ''a'' kódja eltér.+Ezért nyolcbites kettes komplemensben a −5 tárolt bitmintája megegyezik az előjel nélkül 251-et jelentő bitmintával: **11111011**.
  
-Az ASCII **128 kódértéket** használ, 0-tól 127-ig. Ennyi lehetőséghez 7 bit szükséges, mert 2 a hetediken 128. Ezért mondjuk, hogy az ASCII **7 bites kód**. A gyakorlatban rendszerint egy bájtot használunk egy ASCII-karakter tárolásához; ennek első, legnagyobb helyi értékű bitje 0.+=== Hogyan állítjuk elő a negatív szám bitmintáját? ===
  
-=== Mi fér bele az ASCII-ba? ===+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.
  
-Az ASCII tartalmazza az angol ábécé nagy- és kisbetűit, a számjegyeket, írásjeleket, a szóközt és úgynevezett **vezérlőkaraktereket**. A vezérlőkarakterek nem betűként jelennek meg: például a szöveg sorokra tagolásában vagy tabulátorral történő elrendezésében van szerepük.+  - 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.
  
-A magyar ékezetes betűk viszont nem szerepelnek benne. Az ''alma'' leírható ASCII-val, az ''árvíz'' már nem.+**Példa: −5 előállítása.**
  
-**Az ASCII korlátja tehát nem a számítógép sebessége, hanem a rendelkezésre álló jelek szűk köre.** A kódolás által kezelt karakterek összességét **karakterkészletnek** nevezzük.+<code> 
 ++5 nyolc biten:       00000101 
 +Bitek megfordítása:  11111010 
 +Egy hozzáadása:      11111011 
 +</code>
  
-==== 4. Hogyan kerültek be az ékezetes betűk? ====+Az eredmény tehát **−5 = 11111011** nyolcbites kettes komplemensben.
  
-Kézenfekvő megoldás volt a teljes bájt kihasználása: 7 bit helyett 8 bit használatával 128 helyett 256 kódérték áll rendelkezésre. A további helyekre ékezetes betűket és egyéb jeleket lehetett felvenni.+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.
  
-Az összes nyelv betűi azonban 256 helyre sem férnek el. Ezért különböző nyelvekhez és régiókhoz eltérő táblázatokat készítettek. Ezeket **kódlapoknak** nevezzük.+=== Hogyan olvassuk vissza a számot? ===
  
-Például a **Windows-1250** közép-európai karaktereket, köztük magyar ékezetes betűket tartalmaz. A **Windows-1252** elsősorban nyugat-európai nyelvekhez készült.+Nyolcbites kettes komplemensben az első bit helyi értéke **−128**, a többi bité változatlanul pozitív:
  
-Nézzünk egy valódi eltérést:+^ Helyi érték ^ −128 ^ 64 ^ 32 ^ 16 ^ 8 ^ 4 ^ 2 ^ 1 ^ 
 +| −5 bitmintája | 1 | 1 | 1 | 1 | 1 | 0 | 1 | 1 |
  
-^ A fájlban tárolt bájt értéke ^ Windows-1250 szerint ^ Windows-1252 szerint ^ +Az érték: **−128 + 64 + 32 + 16 + 8 + 2 + 1 = −5**.
-| 245 | ő | õ |+
  
-Ha egy Windows-1250 szerint mentett fájlt Windows-1252 szerint olvasunk, az ''ő'' helyén ''õ'' jelenhet meg. **A tárolt szám nem változott meg; a hozzá rendelt karakter változott meg.**+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.
  
-További régi kódlapnevekkel is találkozhatunk:+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**.
  
-^ Név ^ Hol találkozhatunk vele? ^ +==== 4. Miért hasznos a kettes komplemens? ====
-| IBM CP852 | Régi DOS-os, közép-európai szövegekben. | +
-| ISO-8859-1, más néven Latin-1 | Nyugat-európai szövegekben; az ''ő'' és az ''ű'' nincs benne. | +
-| ISO-8859-2, más néven Latin-2 | Közép- és kelet-európai szövegekben; a magyar ékezetes betűket is tartalmazza. |+
  
-Ezek nevét nem szükséges bemagolni. A lényeg az, hogy **a kódlap neve határozza meg, melyik táblázat szerint értelmezzük a bájtokat**.+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.
  
-Egyes programok az **ANSI** nevet használják egy régi Windowsos kódlap megjelölésére. Ez önmagában nem egyértelmű: a pontos kódlap környezettől függhet.+Vizsgáljuk meg az 5 + (−5) összeget:
  
-==== 5. Unicode: legyen közös azonosítójuk a karaktereknek! ====+<code> 
 +    00000101     +5 
 +  + 11111011     -5 
 +  ---------- 
 +  1 00000000 
 +</code>
  
-A kódlapokkal két probléma adódik. Egyrészt ugyanaz a szám különböző karaktereket jelenthet. Másrészt egyetlen ilyen kódlapba nem férnek bele a sokféle nyelv betűi és a műszaki jelek.+A bal oldali kilencedik bit nem fér bele a nyolcbites eredménybe. Az alsó nyolc bit ''00000000'', vagyis **0**, ahogyan vártuk.
  
-A **Unicode** olyan nemzetközi szabvány, amely közös rendszerben rendel számazonosítókat a karakterekhez. Tartalmazza számos mai és történeti írásrendszer betűit, valamint matematikai, műszaki és egyéb jeleket is.+A kivonás is összeadássá alakítható: **7 − 5 = 7 + (−5)**.
  
-Az alapgondolat egy nagy közös jegyzékhez hasonlítható: az ''A'', az ''ő'' és a görög ''Ω'' is saját azonosítót kap benne. Nem kell nyelvenként más táblázatra áttérni.+<code> 
 +    00000111     +7 
 +  + 11111011     -5 
 +  ---------- 
 +  1 00000010 
 +</code>
  
-^ Karakter ^ Unicode-azonosító tízes számrendszerben ^ +Az alsó nyolc bit értéke **2**.
-| A | 65 | +
-| ó | 243 | +
-| ő | 337 | +
-| Ω | 937 | +
-| € | 8364 |+
  
-A karakterhez rendelt ilyen azonosítót **kódpontnak** nevezzük. Például az ''ő'' betű kódpontjának értéke 337. Ez egy azonosító, nem a betű mérete és nem a tárolásához szükséges bájtok száma.+//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 Unicode megtartotta az ASCII karaktereinek számértékeit: ezért az ''A'' kódja itt is 65.+==== 5. Mekkora számok férnek el? ====
  
-=== Miért látunk betűket is a kódpontok leírásában? ===+Nyolcbites kettes komplemensben:
  
-A szakmai leírások a kódpontokat rendszerint **tizenhatos, más néven hexadecimális számrendszerben** adják meg. Ez csupán a számok rövidebb leírásának módja.+  * a legnagyobb pozitív érték ''01111111'', vagyis **127**; 
 +  * a legkisebb érték ''10000000'', vagyis **−128**; 
 +  * a nulla egyetlen alakja ''00000000''.
  
-Ebben a számrendszerben a 0–9 számjegyeken kívül az A, B, C, D, E és F jelet is használjuk. Ezek rendre a 10, 11, 12, 13, 14 és 15 értéket jelentik. A helyi értékek jobbról balra 1, 16, 256 és így tovább.+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é.
  
-Például a hexadecimális ''F3'' értéke tízes számrendszerben: **15 × 16 + 3 = 243**.+^ Bitszám ^ Előjel nélküli egész ^ Kettes komplemens egész ^ 
 +| 8 | 0 … 255 | −128 … 127 | 
 +| 16 | 0 … 65 535 | −32 768 … 32 767 | 
 +| 32 | 0 … 4 294 967 295 | −2 147 483 648 … 2 147 483 647 |
  
-A Unicode-kódpontok szokásos jelölése ''U+'' előtaggal kezdődik, ezt követi a hexadecimális szám:+Á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.
  
-^ Karakter ^ Azonosító tízes számrendszerben ^ Ugyanaz a kódpont szokásos jelöléssel ^ +Ugyanaz a bitsorozat eltérő szabállyal mást jelent:
-| A | 65 | ''U+0041'' | +
-| ó | 243 | ''U+00F3'' | +
-| ő | 337 | ''U+0151'' |+
  
-A bevezető nullák a szám értékét nem változtatják meg. Az ''U+00F3'' tehát azt jelenti: **a 243 értékű Unicode-kódpont**. Az ''U+'' és az utána írt számjegyek magyarázó jelölések; nem ezeket a karaktereket mentjük el az ''ó'' helyett.+^ Bitsorozat ^ Előjel nélkül ^ Kettes komplemens szerint ^ 
 +| ''01111111'' | 127 | 127 | 
 +| ''10000000'' | 128 | −128 | 
 +| ''11111111'' | 255 | −1 |
  
-==== 6. UTF-8: hogyan tároljuk a Unicode-karaktereket? ====+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.
  
-A közös azonosítók bevezetésével még nem oldottunk meg mindent. Az ''ő'' azonosítója például 337, miközben egy bájtban csak 0 és 255 közötti egész szám tárolható. Meg kell tehát határoznunk, hogyan írjuk le a karaktereket egy vagy több bájttal.+=== Mi történik, ha több bitet használunk? ===
  
-Erre szolgál például az **UTF-8**. Ez egy pontosan meghatározott szabályrendszer, amely a Unicode-kódpontokhoz tárolható bájtsorozatokat rendel.+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.
  
-**A Unicode azt adja meg, melyik karakterről van szó. Az UTF-8 azt határozza meg, hogyan tároljuk azt bájtokkal.**+^ Szám ^ Nyolc biten ^ Tizenhat biten ^ 
 +| +5 | ''00000101'' | ''00000000 00000101'' | 
 +| −5 | ''11111011'' | ''11111111 11111011'' |
  
-Az UTF-8 egy kódolható kódponthoz 1, 2, 3 vagy 4 bájtot rendel. Az ASCII-karaktereket egy bájton, eredeti számértékükkel tárolja. A többi karakterhez több bájtot használ. Az alábbi példákban minden betűt egyetlen Unicode-kódponttal írunk le.+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.
  
-^ Karakter ^ Unicode-azonosító tízes számrendszerben ^ UTF-8-ban tárolt bájtok értékei, szintén tízes számrendszerben ^ Bájtok száma ^ +==== 6. Hogyan írunk fel törteket kettes számrendszerben? ====
-| A | 65 | 65 | 1 | +
-| ó | 243 | 195, 179 | 2 | +
-| ő | 337 | 197, 145 | 2 | +
-| € | 8364 | 226, 130, 172 | 3 |+
  
-A táblázatban a vesszők a külön bájtokat választják el; nem részei a tárolt adatnak. Például az ''ó'' helyére két bájt kerül: az első értéke 195, a másodiké 179. A program a két bájtot együtt értelmezve állítja vissza az ''ó'' betű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:
  
-**Miért kell két bájt az ó betűhöz, ha a 243 még elférne egy bájtban?** Mert az UTF-8 nem egyszerűen a kódpont számértékét írja egy bájtba. Az egybájtos alakot a 0–127 közötti ASCII-kódoknak tartja fenn; a többi karakter tárolására külön szabályt alkalmaz. Ennek bitenkénti működését később, kiegészítésként vezetjük le.+^ Hely ^ A vessző előtt ^ Első törtjegy ^ Második törtjegy ^ Harmadik törtjegy ^ Negyedik törtjegy ^ 
 +| Helyi érték | 1 | 1/2 | 1/4 | 1/8 | 1/16 | 
 +| Tízes számrendszerben | 1 | 0,5 | 0,25 | 0,125 | 0,0625 |
  
-=== Hány bájt egy szó? ===+Például a bináris **0,101** értéke:
  
-Nézzük a ''mérő'' szót! Az ''m'' és az ''r'' ASCII-karakter, ezért egy-egy bájtot foglal. Az ''é'' és az ''ő'' két-két bájtot igényel.+**1 × 1/2 + 0 × 1/4 + 1 × 1/8 = 0,625**.
  
-^ Betű ^ UTF-8-ban szükséges hely ^ +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:
-| m | 1 bájt | +
-| é | 2 bájt | +
-| r | 1 bájt | +
-| ő | 2 bájt | +
-| **Összesen** | **6 bájt** |+
  
-A szó tehát **4 betűből áll, de 6 bájtot foglal**. Itt csak a négy betű tárolási helyét számoltuk; nem adtunk hozzá sortörést vagy fájleleji jelzést.+**0,101<sub>2</sub> = 0,625<sub>10</sub>**.
  
-//Kiegészítés:// A Unicode egyes ékezetes betűket alapbetű és külön ékezet egymás utáni megadásával is képes leírni. A képernyőn ez egyetlen betűként jelenhet meg, miközben két kódpont tartozik hozzá. A fejezet számítási példáiban az ékezetes betűk önálló kódpontos alakját használjuk.+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.
  
-==== 7. Mit jelent mindez a gyakorlatban? ====+=== Példa: 13,25 felírása binárisan ===
  
-=== Miért jelenik meg hibás szöveg? ===+Az egész részt és a tört részt külön vizsgáljuk:
  
-Korábban láttuk, hogy két régi kódlap eltérően értelmezheti ugyanazt a bájtot. Hasonló hiba történhet akkor is, ha egy UTF-8-fájlt egy régi kódlap szerint nyitunk meg.+  * 13 = 8 + 4 + 1, ezért az egész rész ''1101''. 
 +  * 0,25 = 1/4, ezért a tört rész ''01''.
  
-Az ''ó'' UTF-8-bájtjai tízes számrendszerben 195 és 179. Ha a program Windows-1252 szerint olvassa ezeket, két külön karakternek tekinti őket: a 195 értékhez az ''Ã'', a 179 értékhez a ''³'' jelet rendeli. Így jelenik meg az ''ó'' helyén az ''ó'' szöveg.+Tehát **13,25<sub>10</sub> = 1101,01<sub>2</sub>**.
  
-**A fájl adatai még lehetnek helyesek; a program rossz szabály szerint olvassa őket.**+Ellenőrzés: 8 + 4 + 1 + 1/4 = 13,25.
  
-A ''.txt'' és a ''.csv'' fájlnév-végződés önmagában nem árulja el a kódolást. A program néha megpróbálja felismerni azt, de a felismerés nem mindig biztos.+=== Általános módszer: a törtrész szorzása kettővel ===
  
-=== Megnyitás és átkódolás ===+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.
  
-Hibás ékezetek esetén először őrizzük meg az eredeti fájlt, és próbáljuk meg a készítésekor használt kódolással megnyitni.+Például 0,625 esetén:
  
-  * **Más kódolással történő megnyitáskor** ugyanazokat a bájtokat értelmezzük más szabály szerint. A fájl tartalmát ettől még nem írjuk át. +^ Lépés ^ Szorzás ^ Következő bináris jegy ^ Továbbvitt törtrész ^ 
-  * **Átkódoláskor** a már helyesen felismert szövegből más kódolású bájtsorozatot hozunk létre és mentünk el.+| 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 |
  
-Például egy Windows-1250-fájl UTF-8-ra alakításakor az ''ő'' egyetlen, 245 értékű bájtja helyett két bájt, 197 és 145 kerül az új fájlba. A betű ugyanaz marad, csak a tárolása változik.+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.
  
-Ha a helytelenül megjelenített szöveget mentjük újra, a hibát is elmenthetjük. Ha pedig olyan kódlapot választunk, amelyből egy szükséges karakter hiányzik, a program például kérdőjellel helyettesítheti azt. Ez már információvesztést okozhat.+==== 7. Hol tároljuk a vesszőt? ====
  
-=== Mérési adatok megnyitása ===+A memóriában nincs a bitek közé rajzolt vessző. A helyét is értelmezési szabállyal kell megadnunk.
  
-A **CSV** olyan szöveges fájlformátum, amely táblázatos adatokat tárol: a sorokon belüli mezőket például vessző vagy pontosvessző választja el. Egy mérési eredményeket tartalmazó fájlban ilyen oszlopnév is szerepelhet: ''Hőmérséklet [°C]''.+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 fájl beolvasásakor három külön beállításra lehet szükség:+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:
  
-  * **Karakterkódolás:** hogyan értelmezze a program a betűket és egyéb jeleket? +**2 + 1 + 1/4 = 3,25**.
-  * **Mezőelválasztó:** melyik jel választja szét az oszlopok adatait? +
-  * **Tizedesjel:** pont vagy vessző választja el a szám egész és tört részét?+
  
-A hibás ékezet és az egy oszlopba összecsúszott táblázat tehát nem ugyanaz a probléma.+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**.
  
-=== A betűtípus szerepe ===+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.
  
-A karakterkódolás mellett a megjelenítésnek is helyesen kell működnie. A **betűtípus** adja meg a jelek kirajzolható alakját. Előfordulhat, hogy a program helyesen azonosít egy karaktert, de a választott betűtípusban nincs hozzá rajzolat. Ekkor például üres négyzet jelenhet meg.+**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?
  
-Az értelmetlen ékezetes betűsor gyakran kódolási problémára, a hiányzó jel helyén álló négyzet pedig megjelenítési problémára utalhat.+==== 8. A lebegőpontos ábrázolás alapötlete ====
  
-==== 8. Kiegészítés: hogyan készül az UTF-8-bájtsorozat? ====+A mérnöki gyakorlatban gyakran használunk hatványalakot. Például:
  
-Az UTF-8 bájtjai nemcsak a kódpont bitjeit tartalmazzák. Bizonyos bitek azt jelzik, hogy egyetlen bájtról, több bájtból álló sorozat kezdetéről vagy annak folytatásáról van-e szó.+  * 13 250 = 1,325 × 10<sup>4</sup>; 
 +  * 0,001325 = 1,325 × 10<sup>−3</sup>.
  
-A következő táblázatban a leírt 0-k és 1-ek rögzített **jelzőbitek**. Az ''x'' helyekre a kódpont számértékének bitjei kerülnek:+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.
  
-^ Teljes hossz ^ Bitminta ^ +A negatív kitevő osztást jelent: 10<sup>−3</sup> = 1/1000. Ugyanígy 2<sup>−3</sup> = 1/8.
-| 1 bájt | ''0xxxxxxx'' | +
-| 2 bájt | ''110xxxxx 10xxxxxx'' | +
-| 3 bájt | ''1110xxxx 10xxxxxx 10xxxxxx'' | +
-| 4 bájt | ''11110xxx 10xxxxxx 10xxxxxx 10xxxxxx'' |+
  
-Például a ''110'' kezdet azt jelzi, hogy összesen két bájt tartozik össze. A második bájt ''10'' kezdete azt mutatja, hogy ez egy sorozat folytatása. Ezt nevezzük **folytató bájtnak**.+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”.
  
-=== Az ó betű levezetése ===+A bináris lebegőpontos számoknál a hatvány alapja **2**, nem 10.
  
-Az ''ó'' kódpontja tízes számrendszerben 243. Kettes számrendszerben ez ''11110011'', mert 128 + 64 + 32 + 16 + 2 + 1 = 243.+=== A szám rendezése egységes alakba ===
  
-A 243 nagyobb 127-nél, ezért nem használhatjuk az egybájtos alakot. A kétbájtos mintában viszont 5 + 6 = 11 adatbitnek van helye, ami elegendő. A nyolc bit elé ezért három nullát írunk, majd az eredményt 5 és 6 bites részre bontjuk:+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:
  
-<code> +**1101,01<sub>2</sub> = 1,10101<sub>2</sub> × 2<sup>3</sup>**.
-243 kettes számrendszerben: 11110011 +
-11 bitre kiegészítve:      00011110011 +
-Felbontás:                00011 110011 +
-</code>+
  
-Ezután az első öt bit elé ''110'', a következő hat bit elé ''10'' kerül:+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.
  
-<code> +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.
-Első bájt:    110 + 00011  = 11000011 +
-Második bájt: 10  + 110011 = 10110011 +
-</code>+
  
-Az első bájt értéke 195, a másodiké 179. Így kaptuk meg a korábbi táblázatban szereplő két számot.+Egy egynél kisebb számnál negatív kitevőt kapunk:
  
-Hexadecimálisan 195 = ''C3'', 179 = ''B3'', ezért ugyanez a bájtsorozat röviden **C3 B3** alakban írható. Egy bájtot két hexadecimális számjeggyel tudunk megadni.+**0,00101<sub>2</sub> = 1,01<sub>2</sub> × 2<sup>−3</sup> = 0,15625<sub>10</sub>**.
  
-**A U+00F3 és a C3 B3 két különböző dolgot jelöl:** az első az ''ó'' Unicode-azonosítója, a második az UTF-8-ban tárolandó két bájt értéke.+Itt a vesszőt jobbra mozdítottuk három hellyel, ezért az érték megtartásához nyolccal osztunk.
  
-//Megjegyzés:// A táblázat a szerkezetet mutatja. Az UTF-8 további érvényességi szabályokat is meghatároz; például minden kódpontot a legrövidebb megengedett alakjával kell kódolni.+==== 9. IEEE 754: pontosan melyik bit mit tároljon? ====
  
-==== 9. Kiegészítés: UTF-16 és a fájl eleji jelzés ====+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.
  
-Ugyanazokat a Unicode-karaktereket az UTF-8-tól eltérő módon is lehet tárolni. Ilyen kódolás az **UTF-16**, amely egy kódolható kódponthoz 2 vagy 4 bájtot használ.+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.
  
-Az ''A'' betű UTF-16-ban két bájtot foglal. Az egyik bájt értéke 0, a másiké 65. A két bájt sorrendjében azonban meg kell állapodni:+A 32 bitet három egymás utáni részre osztjuk. Az ilyen, meghatározott szerepű bitcsoportot **mezőnek** nevezzük.
  
-^ Sorrend neve ^ Az A tárolt bájtjai tízes számrendszerben ^ Magyarázat ^ +^ Mező ^ Méret ^ Feladat ^ 
-| Big-endian | 0, 65 | A nagyobb helyi értékű bájt kerül előre. | +| Előjel | 1 bit | 0: pozitív, 1: negatív előjel | 
-| Little-endian | 65, 0 | A kisebb helyi értékű bájt kerül előre. |+| 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 két változat neve **UTF-16BE**, illetve **UTF-16LE**. A bájtsorrend itt a két bájt sorrendjét jelenti, nem az egy bájton belüli bitek megfordítását.+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.
  
-A fájl elejére speciális jelzés is kerülhet, amely segít a bájtsorrend felismerésében. Ezt **BOM**-nak (Byte Order Mark, bájtsorrendjelző) nevezzük. A BOM nem a szöveg részeként olvasandó betű vagy szó.+=== Miért csak a vessző utáni biteket tároljuk? ===
  
-A BOM használata nem minden esetben kötelező: a kódolást és a sorrendet más módon is megadhatják. UTF-8-fájl elején is előfordulhat BOM, de ott csak a kódolásra utaló jelzés, mert UTF-8-nál nincs választható bájtsorrend.+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.
  
-==== 10. Base64: hogyan legyen egy fájlból továbbítható szöveg? ====+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.
  
-Eddig szövegek tárolásáról volt szó. Most más feladatot vizsgálunk: van egy tetszőleges fájlunk, például egy képünk, és annak bájtjait olyan mezőben szeretnénk továbbítani, amely szöveget vár.+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.
  
-A fájl bájtjait nem kezelhetjük egyszerűen betűkként. Tetszőleges értékeik lehetnek, köztük olyanok, amelyeket a fogadó program vezérlőjelként értelmezne. Célszerű ezért az adatot egy szűk, előre rögzített készletből választott, nyomtatható jelekkel leírni.+=== Hogyan tárolunk negatív kitevőt? ===
  
-Erre szolgál a **Base64**. Tetszőleges bemeneti bájtokat alakít át betűkből, számjegyekből és néhány további jelből álló szöveggé. Ilyen megoldást használnak például számos e-mail-melléklet átvitelekor.+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.
  
-**Az UTF-8 szöveges karaktereket alakít bájtokká. A Base64 tetszőleges bájtokat alakít szöveges jelekké.**+Ezt az állandó hozzáadást **eltolásnak** nevezzük; angol neve bias.
  
-A Base64 nem titkosítás: aki ismeri a szabályt, kulcs nélkül vissza tudja állítani az eredeti adatot.+  * **Tárolás:** tárolt kitevő = valódi kitevő + 127. 
 +  * **Visszaolvasás:** valódi kitevő = tárolt kitevő − 127.
  
-=== Miért éppen 64? ===+^ Valódi kitevő ^ Tárolt érték ^ A tárolt érték nyolc biten ^ 
 +| −3 | 124 | ''01111100'' | 
 +| 0 | 127 | ''01111111'' | 
 +| +3 | 130 | ''10000010'' |
  
-A Base64 a bemeneti biteket **hatos csoportokba** rendezi. Hat bit 64 különböző értéket adhat, 0-tól 63-ig. Mindegyik értékhez egy nyomtatható jelet rendel:+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.
  
-^ A hat bit értéke ^ Hozzárendelt jel ^ +==== 10. Teljes példa: −13,25 tárolása binary32 formátumban ====
-| 0–25 | ''A''–''Z'' | +
-| 26–51 | ''a''–''z'' | +
-| 52–61 | ''0''–''9'' | +
-| 62 | ''+'' | +
-| 63 | ''/'' |+
  
-Az értékek sorrendben követik egymást: 0 jelentése ''A'', 1 jelentése ''B'', 2 jelentése ''C'', és így tovább.+=== 1. lépés: az előjel ===
  
-**Ez a Base64 saját táblázata, nem az ASCII-táblázat.** Például a ''T'' itt a 19 értékű hatbites csoportot jelöli. Amikor magát a kimeneti ''T'' betűt ASCII-szövegként tároljuk, annak bájtértéke 84.+A szám negatív, ezért az **előjelbit 1**. A továbbiakban a 13,25 abszolút értékével dolgozunk.
  
-=== Példa: Man ===+=== 2. lépés: bináris alak és normalizálás ===
  
-Használjuk bemenetként a ''Man'' szöveg három ASCII-bájtját! Az ASCII-táblázat szerint az ''M'' értéke 77, az ''a'' értéke 97, az ''n'' értéke 110. Először ezeket írjuk fel nyolc biten:+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>**. 
-M: 77  = 01001101 + 
-a: 97  = 01100001 +A valódi kitevő tehát **3**, a szignifikáns **1,10101**. 
-n: 110 = 01101110 + 
-</code>+=== 3. lépés: a kitevőmező === 
 + 
 +A 3-hoz hozzáadjuk az eltolást: **3 + 127 = 130**. 
 + 
 +Mivel 130 = 128 + 2, a kitevőmező nyolc bitje **10000010**. 
 + 
 +=== 4. lépés: a törtrészmező === 
 + 
 +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: 
 + 
 +**10101000000000000000000**. 
 + 
 +Itt nincs szükség kerekítésre, mert az összes értékes jegy elfér. 
 + 
 +=== 5. lépés: a mezők összeillesztése === 
 + 
 +^ Előjel: 1 bit ^ Kitevő: 8 bit ^ Törtrész: 23 bit ^ 
 +| ''1'' | ''10000010'' | ''10101000000000000000000'' |
  
-Ez összesen 24 bit. A bitek sorrendjén nem változtatunk, csak a csoporthatárokat helyezzük át: három nyolcbites csoport helyett négy hatbites csoportot készítünk.+A teljes 32 bites minta:
  
 <code> <code>
-Három bájt:         01001101 01100001 01101110 +1 10000010 10101000000000000000000
-Négy hatos csoport: 010011 010110 000101 101110+
 </code> </code>
  
-A hatbites csoportokat számként értelmezzük, majd megkeressük a hozzájuk tartozó Base64-jelet:+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.
  
-^ Hat bit ^ Értéke tízes számrendszerben ^ Base64-jel ^ +**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.
-| ''010011'' | 19 | T | +
-| ''010110'' | 22 | W | +
-| ''000101'' | 5 | F | +
-| ''101110'' | 46 | u |+
  
-Például ''010011'' = 16 + 2 + 1 = 19, a táblázatban pedig a 19-hez a ''T'' tartozik. Az eredmény tehát **TWFu**.+=== Visszaellenőrzés: mit jelent ez a 32 bit? ===
  
-Dekódoláskor ugyanezt végezzük fordítva: a négy jelből négy hatbites csoportot kapunk, majd a 24 bitet három nyolcbites bájtra bontjuk vissza.+  - 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**.
  
-=== Miért jelenik meg egyenlőségjel a végén? ===+=== A szabály tömör képlettel ===
  
-Nem minden fájl bájtszáma osztható hárommal. Ha a végén csak egy vagy két bájt marad, az utolsó hatbites csoporthoz nulla biteket kell hozzáadnunk. A négykarakteres kimeneti csoport hiányzó helyeit ''='' jelekkel töltjük ki.+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:
  
-A ''='' **kitöltő jel**, nem tartozik a 64 adatjelhez, és nem jelent egy újabb hatbites adatcsoportot.+**érték = (−1)<sup>s</sup> × (1 + F / 2<sup>23</sup>) × 2<sup>E−127</sup>**.
  
-^ Az utolsó csoportban maradt adat ^ Base64-adatjelek ^ Kitöltés ^ +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**.
-| 3 bájt | 4 jel | Nincs | +
-| 2 bájt | 3 jel | Egy ''='' | +
-| 1 bájt | 2 jel | Két ''='' |+
  
-**Példa egyetlen bájttal:** legyen a bemenet az 1 értékű bájt, vagyis ''00000001''.+==== 11. Második példa: egy kicsi pozitív szám ====
  
-  - Hat bit után elvágjuk: ''000000'' és ''01''. +Ábrázoljuk a **0,15625** számot! Mivel 0,15625 = 1/8 + 1/32, bináris alakja ''0,00101''.
-  - A második csoportot négy nullával egészítjük ki: ''010000''. +
-  - A két csoport értéke 0 és 16. A Base64-táblázat szerint ezek jele ''A'' és ''Q''. +
-  - Két adatjelünk van, ezért még két ''='' kitöltő jelet írunk utánuk.+
  
-Az eredmény **AQ==**. Visszaalakításkor a két egyenlőségjel mutatja, hogy az utolsó csoport csak egy eredeti bájtot tartalmazott. A két adatjelből visszakapott 12 bit utolsó négy nullája kitöltés, ezt elhagyjuk.+Normalizálva: **1,01<sub>2</sub> × 2<sup>−3</sup>**.
  
-=== Mennyivel nő az adat mérete? ===+  * 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.
  
-A Base64 három bemeneti bájtból négy kimeneti karaktert állít elő. Ha ezeket ASCII-val vagy UTF-8-cal tároljuk, négy bájtot foglalnak.+^ Előjel ^ Kitevő ^ Törtrész ^ 
 +| ''0'' | ''01111100'' | ''01000000000000000000000'' |
  
-Például **300 bájt adatból 400 bájt** lesz, a sortöréseket és egyéb kiegészítéseket nem számítva. Ez körülbelül **33% méretnövekedés**. Kis bemenetnél a kitöltés miatt az arány nagyobb is lehet.+Visszaolvasva a szignifikáns 1,25, a kettes hatvány 1/8, ezért az eredmény **1,25 / 8 = 0,15625**.
  
-A Base64 tehát **nem tömörítés**. Előnye az, hogy a bináris adat szöveges környezetben is továbbítható. Azt, hogy a kódolt szöveg tartalmazhat-e sortörést, az adott alkalmazás szabályai határozzák meg.+==== 12. Miért nem minden szám tárolható pontosan? ====
  
-==== Ellenőrző kérdések ====+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.
  
-  - Miért kell ugyanazt a kódtáblázatot használnia az írónak és az olvasónak? +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. 
-  - Miért nem írható le az ''árvíz'' szó ASCII-val? + 
-  - Mit jelent a Unicode-kódpont? Hogyan kapcsolódik hozzá az UTF-8? +Az ismételt kettővel szorzásnál is látszik az ismétlődés: 
-  - Mit jelöl az ''U+00F3'', és mit jelöl a ''C3 B3''? + 
-  - Hány bájtot foglal a ''mérő'' négy betűje UTF-8-ban a példában használt alakokkal? +^ Lépés ^ Szorzás ^ Kiírt bit ^ Maradó törtrész ^ 
-  - Mi a különbség a más kódolással történő megnyitás és az átkódolás között? +| 1. | 0,1 × 2 = 0,2 | 0 | 0,2 | 
-  - Miért nem szabad titkosításként használni a Base64-et? +| 2. | 0,2 × 2 = 0,4 | 0 | 0,4 | 
-  - Miért lesz három bájtból négy Base64-jel?+| 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 | 
 + 
 +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. 
 + 
 +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**. 
 + 
 +Ez nem meghibásodás. Hasonló ahhoz, amikor az 1/3 helyett csak 0,333-at írunk le. 
 + 
 +=== A kerekítés alapelve === 
 + 
 +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. 
 + 
 +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. 
 + 
 +=== A pontosság nem a tizedesjegyek állandó számát jelenti === 
 + 
 +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. 
 + 
 +Például binary32 esetén: 
 + 
 +  * 1 és 2 között a szomszédos számok távolsága 2<sup>−23</sup>, körülbelül 0,0000001192. 
 +  * 2<sup>24</sup> = 16 777 216 és 2<sup>25</sup> között a lépésköz már **2**. 
 + 
 +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. 
 + 
 +**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. 
 + 
 +==== 13. Nulla, nagyon kicsi számok és különleges értékek ==== 
 + 
 +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. 
 + 
 +A következő táblázatban E a kitevőmező egész értéke, F pedig a törtrészmezőé: 
 + 
 +^ Tárolt kitevő, E ^ Törtrész, F ^ Jelentés ^ 
 +| 1–254 | Tetszőleges | Normál, véges, nem nulla szám; rejtett vezető bitje 1. | 
 +| 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. | 
 + 
 +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>. 
 + 
 +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. 
 + 
 +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. 
 + 
 +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. 
 + 
 +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. 
 + 
 +==== 14. Mi változik 64 bites lebegőpontos ábrázolásnál? ==== 
 + 
 +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. 
 + 
 +^ 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> | 
 + 
 +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. 
 + 
 +A binary64 lényegesen pontosabb, de **a 0,1-et ez sem tárolja pontosan**, mert annak bináris felírása végtelen. 
 + 
 +==== 15. Mire figyeljünk mérnöki számításoknál? ==== 
 + 
 +  * **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. 
 + 
 +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. 
 + 
 +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. 
 + 
 +==== Ellenőrző kérdések és feladatok ==== 
 + 
 +  - Í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?
  
 === Megoldások === === Megoldások ===
  
-  - Eltérő táblázattal ugyanazokból a számokból más karaktereket állíthatnak vissza. +  - +6: ''00000110''; megfordítva: ''11111001''; egyet hozzáadva: **11111010**. 
-  - Az ASCII nem tartalmazza az ''á'' és az ''í'' betűt. +  - Előjel nélkül 246, ezért kettes komplemens szerint 246 − 256 = **−10**. 
-  - A kódpont a karakter számazonosítója. Az UTF-8 meghatározza az ehhez tartozó tárolandó bájtsorozatot. +  - A matematikai eredmény 140, de a legnagyobb ábrázolható érték 127. Túlcsordulás történik. 
-  - Az ''U+00F3'' az ''ó'' Unicode-kódpontja. A ''C3 B3'' a két UTF-8-bájtjának hexadecimális értéke. +  - 0,375 = 1/4 + 1/8, ezért **0,011<sub>2</sub>**. 
-  - Hat bájtot: 1 + 2 + 1 + 2. +  - 6,5 = 110,1<sub>2</sub> = **1,101<sub>2</sub> × 2<sup>2</sup>**. 
-  - Megnyitáskor a meglévő bájtokat értelmezzük; átkódoláskor a felismert karakterekhez más kódolású bájtsorozatot hozunk létre. +  - Előjel: ''0''; kitevő: 2 + 127 = 129, azaz ''10000001''; törtrész: ''10100000000000000000000''. 
-  - Mert a kódolt adat kulcs nélkül visszaállítható. +  - Csak az előjelbit változik 0-ról 1-re. 
-  - Három bájt 24 bit; ebből négy hatbites csoport készül, és minden csoporthoz egy jel tartozik.+  - 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. 
 + 
 +==== Források és további olvasnivaló ==== 
 + 
 +  * [[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]] 
 + 
 + 
 +<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> 
 + 
 +  <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> 
 + 
 +  <section data-section="integer"> 
 +    <h3>Nyolc bit – kétféle értelmezés</h3> 
 +    <p> 
 +      Kattints a bitekre! Ugyanazt a bitsorozatot előjel nélküli 
 +      egészként és kettes komplemens szerint is értelmezzük. 
 +    </p> 
 + 
 +    <div class="controls"> 
 +      <label for="szam-int-input">Előjeles érték:</label> 
 +      <input id="szam-int-input" type="number" 
 +             min="-128" max="127" step="1" value="-5"> 
 +      <button type="button" data-action="set-integer">Beállítás</button> 
 +    </div> 
 + 
 +    <input data-role="int-slider" type="range" 
 +           min="-128" max="127" step="1" value="-5" 
 +           aria-label="Előjeles egész szám"> 
 + 
 +    <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> 
 + 
 +    <div data-role="int-bits" class="bits" 
 +         aria-label="Nyolcbites bitminta"></div> 
 + 
 +    <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> 
 + 
 +    <p data-role="int-explanation"></p> 
 + 
 +    <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> 
 + 
 +    <p data-role="int-message" aria-live="polite"></p> 
 + 
 +    <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> 
 + 
 +  <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> 
 + 
 +    <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> 
 + 
 +    <div class="presets"> 
 +      <button type="button" data-float="-13.25">−13,25</button> 
 +      <button type="button" data-float="0.15625">0,15625</button> 
 +      <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"; 
 + 
 +      const digit = document.createElement("span"); 
 +      button.appendChild(digit); 
 + 
 +      if (weight !== undefined) { 
 +        const label = document.createElement("small"); 
 +        label.textContent = weight; 
 +        button.appendChild(label); 
 +      } 
 + 
 +      button.addEventListener("click", handler); 
 +      container.appendChild(button); 
 + 
 +      return {button, digit, position}; 
 +    } 
 + 
 +    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) 
 +      )); 
 +    } 
 + 
 +    function clearIntegerMessage() { 
 +      el("int-message").textContent = ""; 
 +      el("int-message").className = ""; 
 +    } 
 + 
 +    function renderInteger() { 
 +      const value = signedValue(); 
 + 
 +      intInput.value = value; 
 +      el("int-slider").value = value; 
 + 
 +      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; 
 + 
 +      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; 
 +      } 
 + 
 +      view.setFloat32(0, value, false); 
 +      word = view.getUint32(0, false); 
 +      const stored = view.getFloat32(0, false); 
 + 
 +      el("float-message").className = ""; 
 +      if (Number.isFinite(value) && !Number.isFinite(stored)) { 
 +        el("float-message").textContent = 
 +          "Binary32-túlcsordulás: a véges bemenetből végtelen lett."; 
 +        el("float-message").className = "error"; 
 +      } else if (value !== 0 && stored === 0) { 
 +        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."; 
 +      } 
 + 
 +      if (!Number.isFinite(value)) { 
 +        el("float-message").textContent = "Különleges érték beállítva."; 
 +      } 
 + 
 +      renderFloat(false); 
 +    } 
 + 
 +    root.querySelector('[data-action="set-float"]') 
 +      .addEventListener("click", convertFloat); 
 + 
 +    floatInput.addEventListener("keydown", event => { 
 +      if (event.key === "Enter") convertFloat(); 
 +    }); 
 + 
 +    root.querySelectorAll("[data-float]").forEach(button => { 
 +      button.addEventListener("click", () => { 
 +        floatInput.value = button.dataset.float; 
 +        convertFloat(); 
 +      }); 
 +    }); 
 + 
 +    root.querySelectorAll("[data-panel]").forEach(button => { 
 +      button.addEventListener("click", () => { 
 +        root.querySelectorAll("[data-panel]").forEach(tab => { 
 +          tab.setAttribute("aria-pressed", String(tab === button)); 
 +        }); 
 +        root.querySelectorAll("[data-section]").forEach(section => { 
 +          section.hidden = section.dataset.section !== button.dataset.panel; 
 +        }); 
 +      }); 
 +    });
  
 +    renderInteger();
 +    convertFloat();
 +  })();
 +  </script>
 +</div>
 +</html>
tanszek/oktatas/szamitastechnika/szamabrazolas.1790885320.txt.gz · Last modified: by knehez